Skip to content
Projects
Groups
Snippets
Help
Loading...
Help
Support
Keyboard shortcuts
?
Submit feedback
Contribute to GitLab
Sign in / Register
Toggle navigation
F
folly
Project overview
Project overview
Details
Activity
Releases
Repository
Repository
Files
Commits
Branches
Tags
Contributors
Graph
Compare
Issues
0
Issues
0
List
Boards
Labels
Milestones
Merge Requests
0
Merge Requests
0
CI / CD
CI / CD
Pipelines
Jobs
Schedules
Analytics
Analytics
CI / CD
Repository
Value Stream
Wiki
Wiki
Snippets
Snippets
Members
Members
Collapse sidebar
Close sidebar
Activity
Graph
Create a new issue
Jobs
Commits
Issue Boards
Open sidebar
Libraries
folly
Commits
e1af1682
Commit
e1af1682
authored
Oct 16, 2018
by
Eric Niebler
Committed by
Facebook Github Bot
Oct 17, 2018
Browse files
Options
Browse Files
Download
Email Patches
Plain Diff
flow_single works with concepts emulation
fbshipit-source-id: 73b62ddd46201b81ea7f69c83f7f498ab45f6d13
parent
97d89ff6
Changes
3
Hide whitespace changes
Inline
Side-by-side
Showing
3 changed files
with
187 additions
and
277 deletions
+187
-277
folly/experimental/pushmi/benchmarks/PushmiBenchmarks.cpp
folly/experimental/pushmi/benchmarks/PushmiBenchmarks.cpp
+9
-5
folly/experimental/pushmi/include/pushmi.h
folly/experimental/pushmi/include/pushmi.h
+89
-136
folly/experimental/pushmi/include/pushmi/flow_single.h
folly/experimental/pushmi/include/pushmi/flow_single.h
+89
-136
No files found.
folly/experimental/pushmi/benchmarks/PushmiBenchmarks.cpp
View file @
e1af1682
...
@@ -20,13 +20,17 @@ struct countdownsingle {
...
@@ -20,13 +20,17 @@ struct countdownsingle {
int
*
counter
;
int
*
counter
;
template
<
class
ExecutorRef
>
template
<
class
ExecutorRef
>
void
operator
()(
ExecutorRef
exec
)
{
void
operator
()(
ExecutorRef
exec
)
const
;
if
(
--*
counter
>
0
)
{
exec
|
op
::
submit
(
mi
::
make_single
(
*
this
));
}
}
};
};
template
<
class
ExecutorRef
>
void
countdownsingle
::
operator
()(
ExecutorRef
exec
)
const
{
if
(
--*
counter
>
0
)
{
//exec | op::submit(mi::make_single(*this));
exec
|
op
::
submit
(
mi
::
single
<
countdownsingle
,
mi
::
abortEF
,
mi
::
ignoreDF
>
{
*
this
});
}
}
struct
inline_executor
{
struct
inline_executor
{
using
properties
=
mi
::
property_set
<
mi
::
is_sender
<>
,
mi
::
is_single
<>>
;
using
properties
=
mi
::
property_set
<
mi
::
is_sender
<>
,
mi
::
is_single
<>>
;
template
<
class
Out
>
template
<
class
Out
>
...
...
folly/experimental/pushmi/include/pushmi.h
View file @
e1af1682
...
@@ -4293,8 +4293,7 @@ PUSHMI_INLINE_VAR constexpr struct make_flow_single_fn {
...
@@ -4293,8 +4293,7 @@ PUSHMI_INLINE_VAR constexpr struct make_flow_single_fn {
return
flow_single
<>
{};
return
flow_single
<>
{};
}
}
PUSHMI_TEMPLATE
(
class
VF
)
PUSHMI_TEMPLATE
(
class
VF
)
(
requires
not
Receiver
<
VF
>
&&
!
detail
::
is_v
<
VF
,
on_error_fn
>
&&
(
requires
PUSHMI_EXP
(
defer
::
True
<>
PUSHMI_BROKEN_SUBSUMPTION
(
PUSHMI_AND
not
defer
::
Receiver
<
VF
>
PUSHMI_AND
not
defer
::
Invocable
<
VF
&>
)))
!
detail
::
is_v
<
VF
,
on_done_fn
>
)
auto
operator
()(
VF
vf
)
const
{
auto
operator
()(
VF
vf
)
const
{
return
flow_single
<
VF
,
abortEF
,
ignoreDF
,
ignoreStpF
,
ignoreStrtF
>
{
return
flow_single
<
VF
,
abortEF
,
ignoreDF
,
ignoreStpF
,
ignoreStrtF
>
{
std
::
move
(
vf
)};
std
::
move
(
vf
)};
...
@@ -4304,99 +4303,89 @@ PUSHMI_INLINE_VAR constexpr struct make_flow_single_fn {
...
@@ -4304,99 +4303,89 @@ PUSHMI_INLINE_VAR constexpr struct make_flow_single_fn {
return
flow_single
<
ignoreVF
,
on_error_fn
<
EFN
...
>
,
ignoreDF
,
ignoreStpF
,
ignoreStrtF
>
{
return
flow_single
<
ignoreVF
,
on_error_fn
<
EFN
...
>
,
ignoreDF
,
ignoreStpF
,
ignoreStrtF
>
{
std
::
move
(
ef
)};
std
::
move
(
ef
)};
}
}
template
<
class
DF
>
PUSHMI_TEMPLATE
(
class
DF
)
auto
operator
()(
on_done_fn
<
DF
>
df
)
const
{
(
requires
PUSHMI_EXP
(
defer
::
True
<>
PUSHMI_AND
defer
::
Invocable
<
DF
&>
PUSHMI_BROKEN_SUBSUMPTION
(
PUSHMI_AND
not
defer
::
Receiver
<
DF
>
)))
return
flow_single
<
ignoreVF
,
abortEF
,
on_done_fn
<
DF
>
,
ignoreStpF
,
ignoreStrtF
>
{
auto
operator
()(
DF
df
)
const
{
std
::
move
(
df
)};
return
flow_single
<
ignoreVF
,
abortEF
,
DF
,
ignoreStpF
,
ignoreStrtF
>
{
std
::
move
(
df
)};
}
PUSHMI_TEMPLATE
(
class
V
,
class
PE
,
class
E
,
class
Wrapped
)
(
requires
FlowSingleReceiver
<
Wrapped
,
V
,
PE
,
E
>
&&
!
detail
::
is_v
<
Wrapped
,
none
>
)
auto
operator
()(
Wrapped
w
)
const
{
return
flow_single
<
V
,
PE
,
E
>
{
std
::
move
(
w
)};
}
}
PUSHMI_TEMPLATE
(
class
VF
,
class
EF
)
PUSHMI_TEMPLATE
(
class
VF
,
class
EF
)
(
requires
not
Receiver
<
VF
>
&&
!
detail
::
is_v
<
VF
,
on_error_fn
>
&&
(
requires
PUSHMI_EXP
(
defer
::
True
<>
PUSHMI_BROKEN_SUBSUMPTION
(
PUSHMI_AND
not
defer
::
Receiver
<
VF
>
PUSHMI_AND
not
defer
::
Invocable
<
EF
&>
)))
!
detail
::
is_v
<
VF
,
on_done_fn
>
&&
!
detail
::
is_v
<
EF
,
on_value_fn
>
&&
!
detail
::
is_v
<
EF
,
on_done_fn
>
)
auto
operator
()(
VF
vf
,
EF
ef
)
const
{
auto
operator
()(
VF
vf
,
EF
ef
)
const
{
return
flow_single
<
VF
,
EF
,
ignoreDF
,
ignoreStpF
,
ignoreStrtF
>
{
std
::
move
(
vf
),
return
flow_single
<
VF
,
EF
,
ignoreDF
,
ignoreStpF
,
ignoreStrtF
>
{
std
::
move
(
vf
),
std
::
move
(
ef
)};
std
::
move
(
ef
)};
}
}
template
<
class
...
EFN
,
class
DF
>
PUSHMI_TEMPLATE
(
class
EF
,
class
DF
)
auto
operator
()(
on_error_fn
<
EFN
...
>
ef
,
on_done_fn
<
DF
>
df
)
const
{
(
requires
PUSHMI_EXP
(
defer
::
True
<>
PUSHMI_AND
defer
::
Invocable
<
DF
&>
PUSHMI_BROKEN_SUBSUMPTION
(
PUSHMI_AND
not
defer
::
Receiver
<
EF
>
)))
return
flow_single
<
ignoreVF
,
on_error_fn
<
EFN
...
>
,
on_done_fn
<
DF
>
,
ignoreStpF
,
ignoreStrtF
>
{
auto
operator
()(
EF
ef
,
DF
df
)
const
{
std
::
move
(
ef
),
std
::
move
(
df
)};
return
flow_single
<
ignoreVF
,
EF
,
DF
,
ignoreStpF
,
ignoreStrtF
>
{
std
::
move
(
ef
),
std
::
move
(
df
)};
}
}
PUSHMI_TEMPLATE
(
class
VF
,
class
EF
,
class
DF
)
PUSHMI_TEMPLATE
(
class
VF
,
class
EF
,
class
DF
)
(
requires
Invocable
<
DF
&>
)
(
requires
PUSHMI_EXP
(
defer
::
Invocable
<
DF
&>
PUSHMI_BROKEN_SUBSUMPTION
(
PUSHMI_AND
not
defer
::
Receiver
<
VF
>
))
)
auto
operator
()(
VF
vf
,
EF
ef
,
DF
df
)
const
{
auto
operator
()(
VF
vf
,
EF
ef
,
DF
df
)
const
{
return
flow_single
<
VF
,
EF
,
DF
,
ignoreStpF
,
ignoreStrtF
>
{
std
::
move
(
vf
),
return
flow_single
<
VF
,
EF
,
DF
,
ignoreStpF
,
ignoreStrtF
>
{
std
::
move
(
vf
),
std
::
move
(
ef
),
std
::
move
(
df
)};
std
::
move
(
ef
),
std
::
move
(
df
)};
}
}
PUSHMI_TEMPLATE
(
class
VF
,
class
EF
,
class
DF
,
class
StpF
)
PUSHMI_TEMPLATE
(
class
VF
,
class
EF
,
class
DF
,
class
StpF
)
(
requires
Invocable
<
DF
&>
&&
Invocable
<
StpF
&>
)
(
requires
PUSHMI_EXP
(
defer
::
Invocable
<
DF
&>
PUSHMI_AND
defer
::
Invocable
<
StpF
&>
PUSHMI_BROKEN_SUBSUMPTION
(
PUSHMI_AND
not
defer
::
Receiver
<
VF
>
))
)
auto
operator
()(
VF
vf
,
EF
ef
,
DF
df
,
StpF
stpf
)
const
{
auto
operator
()(
VF
vf
,
EF
ef
,
DF
df
,
StpF
stpf
)
const
{
return
flow_single
<
VF
,
EF
,
DF
,
StpF
,
ignoreStrtF
>
{
std
::
move
(
vf
),
return
flow_single
<
VF
,
EF
,
DF
,
StpF
,
ignoreStrtF
>
{
std
::
move
(
vf
),
std
::
move
(
ef
),
std
::
move
(
df
),
std
::
move
(
stpf
)};
std
::
move
(
ef
),
std
::
move
(
df
),
std
::
move
(
stpf
)};
}
}
PUSHMI_TEMPLATE
(
class
VF
,
class
EF
,
class
DF
,
class
StpF
,
class
StrtF
)
PUSHMI_TEMPLATE
(
class
VF
,
class
EF
,
class
DF
,
class
StpF
,
class
StrtF
)
(
requires
Invocable
<
DF
&>
&&
Invocable
<
StpF
&>
)
(
requires
PUSHMI_EXP
(
defer
::
Invocable
<
DF
&>
PUSHMI_AND
defer
::
Invocable
<
StpF
&>
PUSHMI_BROKEN_SUBSUMPTION
(
PUSHMI_AND
not
defer
::
Receiver
<
VF
>
))
)
auto
operator
()(
VF
vf
,
EF
ef
,
DF
df
,
StpF
stpf
,
StrtF
strtf
)
const
{
auto
operator
()(
VF
vf
,
EF
ef
,
DF
df
,
StpF
stpf
,
StrtF
strtf
)
const
{
return
flow_single
<
VF
,
EF
,
DF
,
StpF
,
StrtF
>
{
std
::
move
(
vf
),
std
::
move
(
ef
),
return
flow_single
<
VF
,
EF
,
DF
,
StpF
,
StrtF
>
{
std
::
move
(
vf
),
std
::
move
(
ef
),
std
::
move
(
df
),
std
::
move
(
stpf
),
std
::
move
(
strtf
)};
std
::
move
(
df
),
std
::
move
(
stpf
),
std
::
move
(
strtf
)};
}
}
PUSHMI_TEMPLATE
(
class
Data
)
PUSHMI_TEMPLATE
(
class
Data
)
(
requires
Receiver
<
Data
>
)
(
requires
PUSHMI_EXP
(
defer
::
True
<>
PUSHMI_AND
defer
::
Receiver
<
Data
>
)
)
auto
operator
()(
Data
d
)
const
{
auto
operator
()(
Data
d
)
const
{
return
flow_single
<
Data
,
passDVF
,
passDEF
,
passDDF
,
passDStpF
,
passDStrtF
>
{
return
flow_single
<
Data
,
passDVF
,
passDEF
,
passDDF
,
passDStpF
,
passDStrtF
>
{
std
::
move
(
d
)};
std
::
move
(
d
)};
}
}
PUSHMI_TEMPLATE
(
class
Data
,
class
DVF
)
PUSHMI_TEMPLATE
(
class
Data
,
class
DVF
)
(
requires
Receiver
<
Data
>
&&
!
detail
::
is_v
<
DVF
,
on_error_fn
>
&&
(
requires
PUSHMI_EXP
(
defer
::
True
<>
PUSHMI_AND
defer
::
Receiver
<
Data
>
PUSHMI_BROKEN_SUBSUMPTION
(
PUSHMI_AND
not
defer
::
Invocable
<
DVF
&
,
Data
&>
)))
!
detail
::
is_v
<
DVF
,
on_done_fn
>
)
auto
operator
()(
Data
d
,
DVF
vf
)
const
{
auto
operator
()(
Data
d
,
DVF
vf
)
const
{
return
flow_single
<
Data
,
DVF
,
passDEF
,
passDDF
,
passDStpF
,
passDStrtF
>
{
return
flow_single
<
Data
,
DVF
,
passDEF
,
passDDF
,
passDStpF
,
passDStrtF
>
{
std
::
move
(
d
),
std
::
move
(
vf
)};
std
::
move
(
d
),
std
::
move
(
vf
)};
}
}
PUSHMI_TEMPLATE
(
class
Data
,
class
...
DEFN
)
PUSHMI_TEMPLATE
(
class
Data
,
class
...
DEFN
)
(
requires
Receiver
<
Data
>
)
(
requires
PUSHMI_EXP
(
defer
::
Receiver
<
Data
>
)
)
auto
operator
()(
Data
d
,
on_error_fn
<
DEFN
...
>
ef
)
const
{
auto
operator
()(
Data
d
,
on_error_fn
<
DEFN
...
>
ef
)
const
{
return
flow_single
<
Data
,
passDVF
,
on_error_fn
<
DEFN
...
>
,
passDDF
,
passDStpF
,
passDStrtF
>
{
return
flow_single
<
Data
,
passDVF
,
on_error_fn
<
DEFN
...
>
,
passDDF
,
passDStpF
,
passDStrtF
>
{
std
::
move
(
d
),
std
::
move
(
ef
)};
std
::
move
(
d
),
std
::
move
(
ef
)};
}
}
PUSHMI_TEMPLATE
(
class
Data
,
class
DDF
)
(
requires
PUSHMI_EXP
(
defer
::
True
<>
PUSHMI_AND
defer
::
Receiver
<
Data
>
PUSHMI_AND
defer
::
Invocable
<
DDF
&
,
Data
&>
))
auto
operator
()(
Data
d
,
DDF
df
)
const
{
return
flow_single
<
Data
,
passDVF
,
passDEF
,
DDF
,
passDStpF
,
passDStrtF
>
{
std
::
move
(
d
),
std
::
move
(
df
)};
}
PUSHMI_TEMPLATE
(
class
Data
,
class
DVF
,
class
DEF
)
PUSHMI_TEMPLATE
(
class
Data
,
class
DVF
,
class
DEF
)
(
requires
Receiver
<
Data
>
&&
!
detail
::
is_v
<
DVF
,
on_error_fn
>
&&
(
requires
PUSHMI_EXP
(
defer
::
Receiver
<
Data
>
PUSHMI_BROKEN_SUBSUMPTION
(
PUSHMI_AND
not
defer
::
Invocable
<
DEF
&
,
Data
&>
)))
!
detail
::
is_v
<
DVF
,
on_done_fn
>
&&
!
detail
::
is_v
<
DEF
,
on_done_fn
>
)
auto
operator
()(
Data
d
,
DVF
vf
,
DEF
ef
)
const
{
auto
operator
()(
Data
d
,
DVF
vf
,
DEF
ef
)
const
{
return
flow_single
<
Data
,
DVF
,
DEF
,
passDDF
,
passDStpF
,
passDStrtF
>
{
std
::
move
(
d
),
std
::
move
(
vf
),
std
::
move
(
ef
)};
return
flow_single
<
Data
,
DVF
,
DEF
,
passDDF
,
passDStpF
,
passDStrtF
>
{
std
::
move
(
d
),
std
::
move
(
vf
),
std
::
move
(
ef
)};
}
}
PUSHMI_TEMPLATE
(
class
Data
,
class
...
DEFN
,
class
DDF
)
PUSHMI_TEMPLATE
(
class
Data
,
class
DEF
,
class
DDF
)
(
requires
Receiver
<
Data
>
)
(
requires
PUSHMI_EXP
(
defer
::
Receiver
<
Data
>
PUSHMI_AND
defer
::
Invocable
<
DDF
&
,
Data
&>
)
)
auto
operator
()(
Data
d
,
on_error_fn
<
DEFN
...
>
ef
,
on_done_fn
<
DDF
>
df
)
const
{
auto
operator
()(
Data
d
,
DEF
ef
,
DDF
df
)
const
{
return
flow_single
<
Data
,
passDVF
,
on_error_fn
<
DEFN
...
>
,
on_done_fn
<
DDF
>
,
passDStpF
,
passDStrtF
>
{
return
flow_single
<
Data
,
passDVF
,
DEF
,
DDF
,
passDStpF
,
passDStrtF
>
{
std
::
move
(
d
),
std
::
move
(
ef
),
std
::
move
(
df
)};
std
::
move
(
d
),
std
::
move
(
ef
),
std
::
move
(
df
)};
}
}
PUSHMI_TEMPLATE
(
class
Data
,
class
DDF
)
(
requires
Receiver
<
Data
>
)
auto
operator
()(
Data
d
,
on_done_fn
<
DDF
>
df
)
const
{
return
flow_single
<
Data
,
passDVF
,
passDEF
,
on_done_fn
<
DDF
>
,
passDStpF
,
passDStrtF
>
{
std
::
move
(
d
),
std
::
move
(
df
)};
}
PUSHMI_TEMPLATE
(
class
Data
,
class
DVF
,
class
DEF
,
class
DDF
)
PUSHMI_TEMPLATE
(
class
Data
,
class
DVF
,
class
DEF
,
class
DDF
)
(
requires
Receiver
<
Data
>
&&
Invocable
<
DDF
&
,
Data
&>
)
(
requires
PUSHMI_EXP
(
defer
::
Receiver
<
Data
>
PUSHMI_AND
defer
::
Invocable
<
DDF
&
,
Data
&>
)
)
auto
operator
()(
Data
d
,
DVF
vf
,
DEF
ef
,
DDF
df
)
const
{
auto
operator
()(
Data
d
,
DVF
vf
,
DEF
ef
,
DDF
df
)
const
{
return
flow_single
<
Data
,
DVF
,
DEF
,
DDF
,
passDStpF
,
passDStrtF
>
{
std
::
move
(
d
),
return
flow_single
<
Data
,
DVF
,
DEF
,
DDF
,
passDStpF
,
passDStrtF
>
{
std
::
move
(
d
),
std
::
move
(
vf
),
std
::
move
(
ef
),
std
::
move
(
df
)};
std
::
move
(
vf
),
std
::
move
(
ef
),
std
::
move
(
df
)};
}
}
PUSHMI_TEMPLATE
(
class
Data
,
class
DVF
,
class
DEF
,
class
DDF
,
class
DStpF
)
PUSHMI_TEMPLATE
(
class
Data
,
class
DVF
,
class
DEF
,
class
DDF
,
class
DStpF
)
(
requires
Receiver
<
Data
>
&&
Invocable
<
DDF
&
,
Data
&>
&&
Invocable
<
DStpF
&
,
Data
&>
)
(
requires
PUSHMI_EXP
(
defer
::
Receiver
<
Data
>
PUSHMI_AND
defer
::
Invocable
<
DDF
&
,
Data
&>
PUSHMI_AND
defer
::
Invocable
<
DStpF
&
,
Data
&>
)
)
auto
operator
()(
Data
d
,
DVF
vf
,
DEF
ef
,
DDF
df
,
DStpF
stpf
)
const
{
auto
operator
()(
Data
d
,
DVF
vf
,
DEF
ef
,
DDF
df
,
DStpF
stpf
)
const
{
return
flow_single
<
Data
,
DVF
,
DEF
,
DDF
,
DStpF
,
passDStrtF
>
{
std
::
move
(
d
),
return
flow_single
<
Data
,
DVF
,
DEF
,
DDF
,
DStpF
,
passDStrtF
>
{
std
::
move
(
d
),
std
::
move
(
vf
),
std
::
move
(
ef
),
std
::
move
(
df
),
std
::
move
(
stpf
)};
std
::
move
(
vf
),
std
::
move
(
ef
),
std
::
move
(
df
),
std
::
move
(
stpf
)};
}
}
PUSHMI_TEMPLATE
(
class
Data
,
class
DVF
,
class
DEF
,
class
DDF
,
class
DStpF
,
class
DStrtF
)
PUSHMI_TEMPLATE
(
class
Data
,
class
DVF
,
class
DEF
,
class
DDF
,
class
DStpF
,
class
DStrtF
)
(
requires
Receiver
<
Data
>
&&
Invocable
<
DDF
&
,
Data
&>
&&
Invocable
<
DStpF
&
,
Data
&>
)
(
requires
PUSHMI_EXP
(
defer
::
Receiver
<
Data
>
PUSHMI_AND
defer
::
Invocable
<
DDF
&
,
Data
&>
PUSHMI_AND
defer
::
Invocable
<
DStpF
&
,
Data
&>
)
)
auto
operator
()(
Data
d
,
DVF
vf
,
DEF
ef
,
DDF
df
,
DStpF
stpf
,
DStrtF
strtf
)
const
{
auto
operator
()(
Data
d
,
DVF
vf
,
DEF
ef
,
DDF
df
,
DStpF
stpf
,
DStrtF
strtf
)
const
{
return
flow_single
<
Data
,
DVF
,
DEF
,
DDF
,
DStpF
,
DStrtF
>
{
std
::
move
(
d
),
return
flow_single
<
Data
,
DVF
,
DEF
,
DDF
,
DStpF
,
DStrtF
>
{
std
::
move
(
d
),
std
::
move
(
vf
),
std
::
move
(
ef
),
std
::
move
(
df
),
std
::
move
(
stpf
),
std
::
move
(
strtf
)};
std
::
move
(
vf
),
std
::
move
(
ef
),
std
::
move
(
df
),
std
::
move
(
stpf
),
std
::
move
(
strtf
)};
...
@@ -4409,124 +4398,88 @@ PUSHMI_INLINE_VAR constexpr struct make_flow_single_fn {
...
@@ -4409,124 +4398,88 @@ PUSHMI_INLINE_VAR constexpr struct make_flow_single_fn {
flow_single
()
->
flow_single
<>
;
flow_single
()
->
flow_single
<>
;
PUSHMI_TEMPLATE
(
class
VF
)
PUSHMI_TEMPLATE
(
class
VF
)
(
requires
not
Receiver
<
VF
>
&&
!
detail
::
is_v
<
VF
,
on_error_fn
>
&&
(
requires
PUSHMI_EXP
(
defer
::
True
<>
PUSHMI_BROKEN_SUBSUMPTION
(
PUSHMI_AND
not
defer
::
Receiver
<
VF
>
PUSHMI_AND
not
defer
::
Invocable
<
VF
&>
)))
!
detail
::
is_v
<
VF
,
on_done_fn
>
)
flow_single
(
VF
)
->
flow_single
(
VF
)
flow_single
<
VF
,
abortEF
,
ignoreDF
,
ignoreStpF
,
ignoreStrtF
>
;
->
flow_single
<
VF
,
abortEF
,
ignoreDF
,
ignoreStpF
,
ignoreStrtF
>
;
template
<
class
...
EFN
>
template
<
class
...
EFN
>
flow_single
(
on_error_fn
<
EFN
...
>
)
flow_single
(
on_error_fn
<
EFN
...
>
)
->
->
flow_single
<
flow_single
<
ignoreVF
,
on_error_fn
<
EFN
...
>
,
ignoreDF
,
ignoreStpF
,
ignoreStrtF
>
;
ignoreVF
,
on_error_fn
<
EFN
...
>
,
PUSHMI_TEMPLATE
(
class
DF
)
ignoreDF
,
(
requires
PUSHMI_EXP
(
defer
::
True
<>
PUSHMI_AND
defer
::
Invocable
<
DF
&>
PUSHMI_BROKEN_SUBSUMPTION
(
PUSHMI_AND
not
defer
::
Receiver
<
DF
>
)))
ignoreStpF
,
flow_single
(
DF
)
->
ignoreStrtF
>
;
flow_single
<
ignoreVF
,
abortEF
,
DF
,
ignoreStpF
,
ignoreStrtF
>
;
template
<
class
DF
>
flow_single
(
on_done_fn
<
DF
>
)
->
flow_single
<
ignoreVF
,
abortEF
,
on_done_fn
<
DF
>
,
ignoreStpF
,
ignoreStrtF
>
;
PUSHMI_TEMPLATE
(
class
V
,
class
PE
,
class
E
,
class
Wrapped
)
(
requires
FlowSingleReceiver
<
Wrapped
,
V
,
PE
,
E
>
&&
!
detail
::
is_v
<
Wrapped
,
none
>
)
flow_single
(
Wrapped
)
->
flow_single
<
V
,
PE
,
E
>
;
PUSHMI_TEMPLATE
(
class
VF
,
class
EF
)
PUSHMI_TEMPLATE
(
class
VF
,
class
EF
)
(
requires
not
Receiver
<
VF
>
&&
!
detail
::
is_v
<
VF
,
on_error_fn
>
&&
(
requires
PUSHMI_EXP
(
defer
::
True
<>
PUSHMI_BROKEN_SUBSUMPTION
(
PUSHMI_AND
not
defer
::
Receiver
<
VF
>
PUSHMI_AND
not
defer
::
Invocable
<
EF
&>
)))
!
detail
::
is_v
<
VF
,
on_done_fn
>
&&
!
detail
::
is_v
<
EF
,
on_value_fn
>
&&
flow_single
(
VF
,
EF
)
->
!
detail
::
is_v
<
EF
,
on_done_fn
>
)
flow_single
<
VF
,
EF
,
ignoreDF
,
ignoreStpF
,
ignoreStrtF
>
;
flow_single
(
VF
,
EF
)
->
flow_single
<
VF
,
EF
,
ignoreDF
,
ignoreStpF
,
ignoreStrtF
>
;
PUSHMI_TEMPLATE
(
class
EF
,
class
DF
)
(
requires
PUSHMI_EXP
(
defer
::
True
<>
PUSHMI_AND
defer
::
Invocable
<
DF
&>
PUSHMI_BROKEN_SUBSUMPTION
(
PUSHMI_AND
not
defer
::
Receiver
<
EF
>
)))
template
<
class
...
EFN
,
class
DF
>
flow_single
(
EF
,
DF
)
->
flow_single
(
on_error_fn
<
EFN
...
>
,
on_done_fn
<
DF
>
)
flow_single
<
ignoreVF
,
EF
,
DF
,
ignoreStpF
,
ignoreStrtF
>
;
->
flow_single
<
ignoreVF
,
on_error_fn
<
EFN
...
>
,
on_done_fn
<
DF
>
,
ignoreStpF
,
ignoreStrtF
>
;
PUSHMI_TEMPLATE
(
class
VF
,
class
EF
,
class
DF
)
PUSHMI_TEMPLATE
(
class
VF
,
class
EF
,
class
DF
)
(
requires
Invocable
<
DF
&>
)
(
requires
PUSHMI_EXP
(
defer
::
Invocable
<
DF
&>
PUSHMI_BROKEN_SUBSUMPTION
(
PUSHMI_AND
not
defer
::
Receiver
<
VF
>
))
)
flow_single
(
VF
,
EF
,
DF
)
flow_single
(
VF
,
EF
,
DF
)
->
->
flow_single
<
VF
,
EF
,
DF
,
ignoreStpF
,
ignoreStrtF
>
;
flow_single
<
VF
,
EF
,
DF
,
ignoreStpF
,
ignoreStrtF
>
;
PUSHMI_TEMPLATE
(
class
VF
,
class
EF
,
class
DF
,
class
StpF
)
PUSHMI_TEMPLATE
(
class
VF
,
class
EF
,
class
DF
,
class
StpF
)
(
requires
Invocable
<
DF
&>
&&
Invocable
<
StpF
&>
)
(
requires
PUSHMI_EXP
(
defer
::
Invocable
<
DF
&>
PUSHMI_AND
defer
::
Invocable
<
StpF
&>
PUSHMI_BROKEN_SUBSUMPTION
(
PUSHMI_AND
not
defer
::
Receiver
<
VF
>
))
)
flow_single
(
VF
,
EF
,
DF
,
StpF
)
flow_single
(
VF
,
EF
,
DF
,
StpF
)
->
->
flow_single
<
VF
,
EF
,
DF
,
StpF
,
ignoreStrtF
>
;
flow_single
<
VF
,
EF
,
DF
,
StpF
,
ignoreStrtF
>
;
PUSHMI_TEMPLATE
(
class
VF
,
class
EF
,
class
DF
,
class
StpF
,
class
StrtF
)
PUSHMI_TEMPLATE
(
class
VF
,
class
EF
,
class
DF
,
class
StpF
,
class
StrtF
)
(
requires
Invocable
<
DF
&>
&&
Invocable
<
StpF
&>
)
(
requires
PUSHMI_EXP
(
defer
::
Invocable
<
DF
&>
PUSHMI_AND
defer
::
Invocable
<
StpF
&>
PUSHMI_BROKEN_SUBSUMPTION
(
PUSHMI_AND
not
defer
::
Receiver
<
VF
>
))
)
flow_single
(
VF
,
EF
,
DF
,
StpF
,
StrtF
)
flow_single
(
VF
,
EF
,
DF
,
StpF
,
StrtF
)
->
->
flow_single
<
VF
,
EF
,
DF
,
StpF
,
StrtF
>
;
flow_single
<
VF
,
EF
,
DF
,
StpF
,
StrtF
>
;
PUSHMI_TEMPLATE
(
class
Data
)
PUSHMI_TEMPLATE
(
class
Data
)
(
requires
Receiver
<
Data
>
)
(
requires
PUSHMI_EXP
(
defer
::
True
<>
PUSHMI_AND
defer
::
Receiver
<
Data
>
)
)
flow_single
(
Data
d
)
flow_single
(
Data
d
)
->
->
flow_single
<
Data
,
passDVF
,
passDEF
,
passDDF
,
passDStpF
,
passDStrtF
>
;
flow_single
<
Data
,
passDVF
,
passDEF
,
passDDF
,
passDStpF
,
passDStrtF
>
;
PUSHMI_TEMPLATE
(
class
Data
,
class
DVF
)
PUSHMI_TEMPLATE
(
class
Data
,
class
DVF
)
(
requires
Receiver
<
Data
>
&&
!
detail
::
is_v
<
DVF
,
on_error_fn
>
&&
(
requires
PUSHMI_EXP
(
defer
::
True
<>
PUSHMI_AND
defer
::
Receiver
<
Data
>
PUSHMI_BROKEN_SUBSUMPTION
(
PUSHMI_AND
not
defer
::
Invocable
<
DVF
&
,
Data
&>
)))
!
detail
::
is_v
<
DVF
,
on_done_fn
>
)
flow_single
(
Data
d
,
DVF
vf
)
->
flow_single
(
Data
d
,
DVF
vf
)
flow_single
<
Data
,
DVF
,
passDEF
,
passDDF
,
passDStpF
,
passDStrtF
>
;
->
flow_single
<
Data
,
DVF
,
passDEF
,
passDDF
,
passDStpF
,
passDStrtF
>
;
PUSHMI_TEMPLATE
(
class
Data
,
class
...
DEFN
)
PUSHMI_TEMPLATE
(
class
Data
,
class
...
DEFN
)
(
requires
Receiver
<
Data
>
)
(
requires
PUSHMI_EXP
(
defer
::
Receiver
<
Data
>
))
flow_single
(
Data
d
,
on_error_fn
<
DEFN
...
>
)
flow_single
(
Data
d
,
on_error_fn
<
DEFN
...
>
)
->
->
flow_single
<
flow_single
<
Data
,
passDVF
,
on_error_fn
<
DEFN
...
>
,
passDDF
,
passDStpF
,
passDStrtF
>
;
Data
,
passDVF
,
PUSHMI_TEMPLATE
(
class
Data
,
class
DDF
)
on_error_fn
<
DEFN
...
>
,
(
requires
PUSHMI_EXP
(
defer
::
True
<>
PUSHMI_AND
defer
::
Receiver
<
Data
>
PUSHMI_AND
defer
::
Invocable
<
DDF
&
,
Data
&>
))
passDDF
,
flow_single
(
Data
d
,
DDF
)
->
passDStpF
,
flow_single
<
Data
,
passDVF
,
passDEF
,
DDF
,
passDStpF
,
passDStrtF
>
;
passDStrtF
>
;
PUSHMI_TEMPLATE
(
class
Data
,
class
DVF
,
class
DEF
)
PUSHMI_TEMPLATE
(
class
Data
,
class
DVF
,
class
DEF
)
(
requires
Receiver
<
Data
>
&&
!
detail
::
is_v
<
DVF
,
on_error_fn
>
&&
(
requires
PUSHMI_EXP
(
defer
::
Receiver
<
Data
>
PUSHMI_BROKEN_SUBSUMPTION
(
PUSHMI_AND
not
defer
::
Invocable
<
DEF
&
,
Data
&>
)))
!
detail
::
is_v
<
DVF
,
on_done_fn
>
&&
!
detail
::
is_v
<
DEF
,
on_done_fn
>
)
flow_single
(
Data
d
,
DVF
vf
,
DEF
ef
)
->
flow_single
(
Data
d
,
DVF
vf
,
DEF
ef
)
flow_single
<
Data
,
DVF
,
DEF
,
passDDF
,
passDStpF
,
passDStrtF
>
;
->
flow_single
<
Data
,
DVF
,
DEF
,
passDDF
,
passDStpF
,
passDStrtF
>
;
PUSHMI_TEMPLATE
(
class
Data
,
class
...
DEFN
,
class
DDF
)
(
requires
Receiver
<
Data
>
)
flow_single
(
Data
d
,
on_error_fn
<
DEFN
...
>
,
on_done_fn
<
DDF
>
)
->
flow_single
<
Data
,
passDVF
,
on_error_fn
<
DEFN
...
>
,
on_done_fn
<
DDF
>
,
passDStpF
,
passDStrtF
>
;
PUSHMI_TEMPLATE
(
class
Data
,
class
DDF
)
PUSHMI_TEMPLATE
(
class
Data
,
class
D
EF
,
class
D
DF
)
(
requires
Receiver
<
Data
>
)
(
requires
PUSHMI_EXP
(
defer
::
Receiver
<
Data
>
PUSHMI_AND
defer
::
Invocable
<
DDF
&
,
Data
&>
)
)
flow_single
(
Data
d
,
on_done_fn
<
DDF
>
)
flow_single
(
Data
d
,
DEF
,
DDF
)
->
->
flow_single
<
Data
,
passDVF
,
passDEF
,
on_done_fn
<
DDF
>
,
passDStpF
,
passDStrtF
>
;
flow_single
<
Data
,
passDVF
,
DEF
,
DDF
,
passDStpF
,
passDStrtF
>
;
PUSHMI_TEMPLATE
(
class
Data
,
class
DVF
,
class
DEF
,
class
DDF
)
PUSHMI_TEMPLATE
(
class
Data
,
class
DVF
,
class
DEF
,
class
DDF
)
(
requires
Receiver
<
Data
>
&&
Invocable
<
DDF
&
,
Data
&>
)
(
requires
PUSHMI_EXP
(
defer
::
Receiver
<
Data
>
PUSHMI_AND
defer
::
Invocable
<
DDF
&
,
Data
&>
)
)
flow_single
(
Data
d
,
DVF
vf
,
DEF
ef
,
DDF
df
)
flow_single
(
Data
d
,
DVF
vf
,
DEF
ef
,
DDF
df
)
->
->
flow_single
<
Data
,
DVF
,
DEF
,
DDF
,
passDStpF
,
passDStrtF
>
;
flow_single
<
Data
,
DVF
,
DEF
,
DDF
,
passDStpF
,
passDStrtF
>
;
PUSHMI_TEMPLATE
(
class
Data
,
class
DVF
,
class
DEF
,
class
DDF
,
class
DStpF
)
PUSHMI_TEMPLATE
(
class
Data
,
class
DVF
,
class
DEF
,
class
DDF
,
class
DStpF
)
(
requires
Receiver
<
Data
>
&&
Invocable
<
DDF
&
,
Data
&>
&&
Invocable
<
DStpF
&
,
Data
&>
)
(
requires
PUSHMI_EXP
(
defer
::
Receiver
<
Data
>
PUSHMI_AND
defer
::
Invocable
<
DDF
&
,
Data
&>
PUSHMI_AND
defer
::
Invocable
<
DStpF
&
,
Data
&>
))
flow_single
(
Data
d
,
DVF
vf
,
DEF
ef
,
DDF
df
,
DStpF
stpf
)
flow_single
(
Data
d
,
DVF
vf
,
DEF
ef
,
DDF
df
,
DStpF
stpf
)
->
->
flow_single
<
Data
,
DVF
,
DEF
,
DDF
,
DStpF
,
passDStrtF
>
;
flow_single
<
Data
,
DVF
,
DEF
,
DDF
,
DStpF
,
passDStrtF
>
;
PUSHMI_TEMPLATE
(
PUSHMI_TEMPLATE
(
class
Data
,
class
DVF
,
class
DEF
,
class
DDF
,
class
DStpF
,
class
DStrtF
)
class
Data
,
(
requires
PUSHMI_EXP
(
defer
::
Receiver
<
Data
>
PUSHMI_AND
defer
::
Invocable
<
DDF
&
,
Data
&>
PUSHMI_AND
defer
::
Invocable
<
DStpF
&
,
Data
&>
))
class
DVF
,
flow_single
(
Data
d
,
DVF
vf
,
DEF
ef
,
DDF
df
,
DStpF
stpf
,
DStrtF
strtf
)
->
class
DEF
,
flow_single
<
Data
,
DVF
,
DEF
,
DDF
,
DStpF
,
DStrtF
>
;
class
DDF
,
class
DStpF
,
class
DStrtF
)
(
requires
Receiver
<
Data
>
&&
Invocable
<
DDF
&
,
Data
&>
&&
Invocable
<
DStpF
&
,
Data
&>
)
flow_single
(
Data
d
,
DVF
vf
,
DEF
ef
,
DDF
df
,
DStpF
stpf
,
DStrtF
strtf
)
->
flow_single
<
Data
,
DVF
,
DEF
,
DDF
,
DStpF
,
DStrtF
>
;
#endif
#endif
template
<
class
V
,
class
PE
=
std
::
exception_ptr
,
class
E
=
PE
>
template
<
class
V
,
class
PE
=
std
::
exception_ptr
,
class
E
=
PE
>
...
...
folly/experimental/pushmi/include/pushmi/flow_single.h
View file @
e1af1682
...
@@ -292,8 +292,7 @@ PUSHMI_INLINE_VAR constexpr struct make_flow_single_fn {
...
@@ -292,8 +292,7 @@ PUSHMI_INLINE_VAR constexpr struct make_flow_single_fn {
return
flow_single
<>
{};
return
flow_single
<>
{};
}
}
PUSHMI_TEMPLATE
(
class
VF
)
PUSHMI_TEMPLATE
(
class
VF
)
(
requires
not
Receiver
<
VF
>
&&
!
detail
::
is_v
<
VF
,
on_error_fn
>
&&
(
requires
PUSHMI_EXP
(
defer
::
True
<>
PUSHMI_BROKEN_SUBSUMPTION
(
PUSHMI_AND
not
defer
::
Receiver
<
VF
>
PUSHMI_AND
not
defer
::
Invocable
<
VF
&>
)))
!
detail
::
is_v
<
VF
,
on_done_fn
>
)
auto
operator
()(
VF
vf
)
const
{
auto
operator
()(
VF
vf
)
const
{
return
flow_single
<
VF
,
abortEF
,
ignoreDF
,
ignoreStpF
,
ignoreStrtF
>
{
return
flow_single
<
VF
,
abortEF
,
ignoreDF
,
ignoreStpF
,
ignoreStrtF
>
{
std
::
move
(
vf
)};
std
::
move
(
vf
)};
...
@@ -303,99 +302,89 @@ PUSHMI_INLINE_VAR constexpr struct make_flow_single_fn {
...
@@ -303,99 +302,89 @@ PUSHMI_INLINE_VAR constexpr struct make_flow_single_fn {
return
flow_single
<
ignoreVF
,
on_error_fn
<
EFN
...
>
,
ignoreDF
,
ignoreStpF
,
ignoreStrtF
>
{
return
flow_single
<
ignoreVF
,
on_error_fn
<
EFN
...
>
,
ignoreDF
,
ignoreStpF
,
ignoreStrtF
>
{
std
::
move
(
ef
)};
std
::
move
(
ef
)};
}
}
template
<
class
DF
>
PUSHMI_TEMPLATE
(
class
DF
)
auto
operator
()(
on_done_fn
<
DF
>
df
)
const
{
(
requires
PUSHMI_EXP
(
defer
::
True
<>
PUSHMI_AND
defer
::
Invocable
<
DF
&>
PUSHMI_BROKEN_SUBSUMPTION
(
PUSHMI_AND
not
defer
::
Receiver
<
DF
>
)))
return
flow_single
<
ignoreVF
,
abortEF
,
on_done_fn
<
DF
>
,
ignoreStpF
,
ignoreStrtF
>
{
auto
operator
()(
DF
df
)
const
{
std
::
move
(
df
)};
return
flow_single
<
ignoreVF
,
abortEF
,
DF
,
ignoreStpF
,
ignoreStrtF
>
{
std
::
move
(
df
)};
}
PUSHMI_TEMPLATE
(
class
V
,
class
PE
,
class
E
,
class
Wrapped
)
(
requires
FlowSingleReceiver
<
Wrapped
,
V
,
PE
,
E
>
&&
!
detail
::
is_v
<
Wrapped
,
none
>
)
auto
operator
()(
Wrapped
w
)
const
{
return
flow_single
<
V
,
PE
,
E
>
{
std
::
move
(
w
)};
}
}
PUSHMI_TEMPLATE
(
class
VF
,
class
EF
)
PUSHMI_TEMPLATE
(
class
VF
,
class
EF
)
(
requires
not
Receiver
<
VF
>
&&
!
detail
::
is_v
<
VF
,
on_error_fn
>
&&
(
requires
PUSHMI_EXP
(
defer
::
True
<>
PUSHMI_BROKEN_SUBSUMPTION
(
PUSHMI_AND
not
defer
::
Receiver
<
VF
>
PUSHMI_AND
not
defer
::
Invocable
<
EF
&>
)))
!
detail
::
is_v
<
VF
,
on_done_fn
>
&&
!
detail
::
is_v
<
EF
,
on_value_fn
>
&&
!
detail
::
is_v
<
EF
,
on_done_fn
>
)
auto
operator
()(
VF
vf
,
EF
ef
)
const
{
auto
operator
()(
VF
vf
,
EF
ef
)
const
{
return
flow_single
<
VF
,
EF
,
ignoreDF
,
ignoreStpF
,
ignoreStrtF
>
{
std
::
move
(
vf
),
return
flow_single
<
VF
,
EF
,
ignoreDF
,
ignoreStpF
,
ignoreStrtF
>
{
std
::
move
(
vf
),
std
::
move
(
ef
)};
std
::
move
(
ef
)};
}
}
template
<
class
...
EFN
,
class
DF
>
PUSHMI_TEMPLATE
(
class
EF
,
class
DF
)
auto
operator
()(
on_error_fn
<
EFN
...
>
ef
,
on_done_fn
<
DF
>
df
)
const
{
(
requires
PUSHMI_EXP
(
defer
::
True
<>
PUSHMI_AND
defer
::
Invocable
<
DF
&>
PUSHMI_BROKEN_SUBSUMPTION
(
PUSHMI_AND
not
defer
::
Receiver
<
EF
>
)))
return
flow_single
<
ignoreVF
,
on_error_fn
<
EFN
...
>
,
on_done_fn
<
DF
>
,
ignoreStpF
,
ignoreStrtF
>
{
auto
operator
()(
EF
ef
,
DF
df
)
const
{
std
::
move
(
ef
),
std
::
move
(
df
)};
return
flow_single
<
ignoreVF
,
EF
,
DF
,
ignoreStpF
,
ignoreStrtF
>
{
std
::
move
(
ef
),
std
::
move
(
df
)};
}
}
PUSHMI_TEMPLATE
(
class
VF
,
class
EF
,
class
DF
)
PUSHMI_TEMPLATE
(
class
VF
,
class
EF
,
class
DF
)
(
requires
Invocable
<
DF
&>
)
(
requires
PUSHMI_EXP
(
defer
::
Invocable
<
DF
&>
PUSHMI_BROKEN_SUBSUMPTION
(
PUSHMI_AND
not
defer
::
Receiver
<
VF
>
))
)
auto
operator
()(
VF
vf
,
EF
ef
,
DF
df
)
const
{
auto
operator
()(
VF
vf
,
EF
ef
,
DF
df
)
const
{
return
flow_single
<
VF
,
EF
,
DF
,
ignoreStpF
,
ignoreStrtF
>
{
std
::
move
(
vf
),
return
flow_single
<
VF
,
EF
,
DF
,
ignoreStpF
,
ignoreStrtF
>
{
std
::
move
(
vf
),
std
::
move
(
ef
),
std
::
move
(
df
)};
std
::
move
(
ef
),
std
::
move
(
df
)};
}
}
PUSHMI_TEMPLATE
(
class
VF
,
class
EF
,
class
DF
,
class
StpF
)
PUSHMI_TEMPLATE
(
class
VF
,
class
EF
,
class
DF
,
class
StpF
)
(
requires
Invocable
<
DF
&>
&&
Invocable
<
StpF
&>
)
(
requires
PUSHMI_EXP
(
defer
::
Invocable
<
DF
&>
PUSHMI_AND
defer
::
Invocable
<
StpF
&>
PUSHMI_BROKEN_SUBSUMPTION
(
PUSHMI_AND
not
defer
::
Receiver
<
VF
>
))
)
auto
operator
()(
VF
vf
,
EF
ef
,
DF
df
,
StpF
stpf
)
const
{
auto
operator
()(
VF
vf
,
EF
ef
,
DF
df
,
StpF
stpf
)
const
{
return
flow_single
<
VF
,
EF
,
DF
,
StpF
,
ignoreStrtF
>
{
std
::
move
(
vf
),
return
flow_single
<
VF
,
EF
,
DF
,
StpF
,
ignoreStrtF
>
{
std
::
move
(
vf
),
std
::
move
(
ef
),
std
::
move
(
df
),
std
::
move
(
stpf
)};
std
::
move
(
ef
),
std
::
move
(
df
),
std
::
move
(
stpf
)};
}
}
PUSHMI_TEMPLATE
(
class
VF
,
class
EF
,
class
DF
,
class
StpF
,
class
StrtF
)
PUSHMI_TEMPLATE
(
class
VF
,
class
EF
,
class
DF
,
class
StpF
,
class
StrtF
)
(
requires
Invocable
<
DF
&>
&&
Invocable
<
StpF
&>
)
(
requires
PUSHMI_EXP
(
defer
::
Invocable
<
DF
&>
PUSHMI_AND
defer
::
Invocable
<
StpF
&>
PUSHMI_BROKEN_SUBSUMPTION
(
PUSHMI_AND
not
defer
::
Receiver
<
VF
>
))
)
auto
operator
()(
VF
vf
,
EF
ef
,
DF
df
,
StpF
stpf
,
StrtF
strtf
)
const
{
auto
operator
()(
VF
vf
,
EF
ef
,
DF
df
,
StpF
stpf
,
StrtF
strtf
)
const
{
return
flow_single
<
VF
,
EF
,
DF
,
StpF
,
StrtF
>
{
std
::
move
(
vf
),
std
::
move
(
ef
),
return
flow_single
<
VF
,
EF
,
DF
,
StpF
,
StrtF
>
{
std
::
move
(
vf
),
std
::
move
(
ef
),
std
::
move
(
df
),
std
::
move
(
stpf
),
std
::
move
(
strtf
)};
std
::
move
(
df
),
std
::
move
(
stpf
),
std
::
move
(
strtf
)};
}
}
PUSHMI_TEMPLATE
(
class
Data
)
PUSHMI_TEMPLATE
(
class
Data
)
(
requires
Receiver
<
Data
>
)
(
requires
PUSHMI_EXP
(
defer
::
True
<>
PUSHMI_AND
defer
::
Receiver
<
Data
>
)
)
auto
operator
()(
Data
d
)
const
{
auto
operator
()(
Data
d
)
const
{
return
flow_single
<
Data
,
passDVF
,
passDEF
,
passDDF
,
passDStpF
,
passDStrtF
>
{
return
flow_single
<
Data
,
passDVF
,
passDEF
,
passDDF
,
passDStpF
,
passDStrtF
>
{
std
::
move
(
d
)};
std
::
move
(
d
)};
}
}
PUSHMI_TEMPLATE
(
class
Data
,
class
DVF
)
PUSHMI_TEMPLATE
(
class
Data
,
class
DVF
)
(
requires
Receiver
<
Data
>
&&
!
detail
::
is_v
<
DVF
,
on_error_fn
>
&&
(
requires
PUSHMI_EXP
(
defer
::
True
<>
PUSHMI_AND
defer
::
Receiver
<
Data
>
PUSHMI_BROKEN_SUBSUMPTION
(
PUSHMI_AND
not
defer
::
Invocable
<
DVF
&
,
Data
&>
)))
!
detail
::
is_v
<
DVF
,
on_done_fn
>
)
auto
operator
()(
Data
d
,
DVF
vf
)
const
{
auto
operator
()(
Data
d
,
DVF
vf
)
const
{
return
flow_single
<
Data
,
DVF
,
passDEF
,
passDDF
,
passDStpF
,
passDStrtF
>
{
return
flow_single
<
Data
,
DVF
,
passDEF
,
passDDF
,
passDStpF
,
passDStrtF
>
{
std
::
move
(
d
),
std
::
move
(
vf
)};
std
::
move
(
d
),
std
::
move
(
vf
)};
}
}
PUSHMI_TEMPLATE
(
class
Data
,
class
...
DEFN
)
PUSHMI_TEMPLATE
(
class
Data
,
class
...
DEFN
)
(
requires
Receiver
<
Data
>
)
(
requires
PUSHMI_EXP
(
defer
::
Receiver
<
Data
>
)
)
auto
operator
()(
Data
d
,
on_error_fn
<
DEFN
...
>
ef
)
const
{
auto
operator
()(
Data
d
,
on_error_fn
<
DEFN
...
>
ef
)
const
{
return
flow_single
<
Data
,
passDVF
,
on_error_fn
<
DEFN
...
>
,
passDDF
,
passDStpF
,
passDStrtF
>
{
return
flow_single
<
Data
,
passDVF
,
on_error_fn
<
DEFN
...
>
,
passDDF
,
passDStpF
,
passDStrtF
>
{
std
::
move
(
d
),
std
::
move
(
ef
)};
std
::
move
(
d
),
std
::
move
(
ef
)};
}
}
PUSHMI_TEMPLATE
(
class
Data
,
class
DDF
)
(
requires
PUSHMI_EXP
(
defer
::
True
<>
PUSHMI_AND
defer
::
Receiver
<
Data
>
PUSHMI_AND
defer
::
Invocable
<
DDF
&
,
Data
&>
))
auto
operator
()(
Data
d
,
DDF
df
)
const
{
return
flow_single
<
Data
,
passDVF
,
passDEF
,
DDF
,
passDStpF
,
passDStrtF
>
{
std
::
move
(
d
),
std
::
move
(
df
)};
}
PUSHMI_TEMPLATE
(
class
Data
,
class
DVF
,
class
DEF
)
PUSHMI_TEMPLATE
(
class
Data
,
class
DVF
,
class
DEF
)
(
requires
Receiver
<
Data
>
&&
!
detail
::
is_v
<
DVF
,
on_error_fn
>
&&
(
requires
PUSHMI_EXP
(
defer
::
Receiver
<
Data
>
PUSHMI_BROKEN_SUBSUMPTION
(
PUSHMI_AND
not
defer
::
Invocable
<
DEF
&
,
Data
&>
)))
!
detail
::
is_v
<
DVF
,
on_done_fn
>
&&
!
detail
::
is_v
<
DEF
,
on_done_fn
>
)
auto
operator
()(
Data
d
,
DVF
vf
,
DEF
ef
)
const
{
auto
operator
()(
Data
d
,
DVF
vf
,
DEF
ef
)
const
{
return
flow_single
<
Data
,
DVF
,
DEF
,
passDDF
,
passDStpF
,
passDStrtF
>
{
std
::
move
(
d
),
std
::
move
(
vf
),
std
::
move
(
ef
)};
return
flow_single
<
Data
,
DVF
,
DEF
,
passDDF
,
passDStpF
,
passDStrtF
>
{
std
::
move
(
d
),
std
::
move
(
vf
),
std
::
move
(
ef
)};
}
}
PUSHMI_TEMPLATE
(
class
Data
,
class
...
DEFN
,
class
DDF
)
PUSHMI_TEMPLATE
(
class
Data
,
class
DEF
,
class
DDF
)
(
requires
Receiver
<
Data
>
)
(
requires
PUSHMI_EXP
(
defer
::
Receiver
<
Data
>
PUSHMI_AND
defer
::
Invocable
<
DDF
&
,
Data
&>
)
)
auto
operator
()(
Data
d
,
on_error_fn
<
DEFN
...
>
ef
,
on_done_fn
<
DDF
>
df
)
const
{
auto
operator
()(
Data
d
,
DEF
ef
,
DDF
df
)
const
{
return
flow_single
<
Data
,
passDVF
,
on_error_fn
<
DEFN
...
>
,
on_done_fn
<
DDF
>
,
passDStpF
,
passDStrtF
>
{
return
flow_single
<
Data
,
passDVF
,
DEF
,
DDF
,
passDStpF
,
passDStrtF
>
{
std
::
move
(
d
),
std
::
move
(
ef
),
std
::
move
(
df
)};
std
::
move
(
d
),
std
::
move
(
ef
),
std
::
move
(
df
)};
}
}
PUSHMI_TEMPLATE
(
class
Data
,
class
DDF
)
(
requires
Receiver
<
Data
>
)
auto
operator
()(
Data
d
,
on_done_fn
<
DDF
>
df
)
const
{
return
flow_single
<
Data
,
passDVF
,
passDEF
,
on_done_fn
<
DDF
>
,
passDStpF
,
passDStrtF
>
{
std
::
move
(
d
),
std
::
move
(
df
)};
}
PUSHMI_TEMPLATE
(
class
Data
,
class
DVF
,
class
DEF
,
class
DDF
)
PUSHMI_TEMPLATE
(
class
Data
,
class
DVF
,
class
DEF
,
class
DDF
)
(
requires
Receiver
<
Data
>
&&
Invocable
<
DDF
&
,
Data
&>
)
(
requires
PUSHMI_EXP
(
defer
::
Receiver
<
Data
>
PUSHMI_AND
defer
::
Invocable
<
DDF
&
,
Data
&>
)
)
auto
operator
()(
Data
d
,
DVF
vf
,
DEF
ef
,
DDF
df
)
const
{
auto
operator
()(
Data
d
,
DVF
vf
,
DEF
ef
,
DDF
df
)
const
{
return
flow_single
<
Data
,
DVF
,
DEF
,
DDF
,
passDStpF
,
passDStrtF
>
{
std
::
move
(
d
),
return
flow_single
<
Data
,
DVF
,
DEF
,
DDF
,
passDStpF
,
passDStrtF
>
{
std
::
move
(
d
),
std
::
move
(
vf
),
std
::
move
(
ef
),
std
::
move
(
df
)};
std
::
move
(
vf
),
std
::
move
(
ef
),
std
::
move
(
df
)};
}
}
PUSHMI_TEMPLATE
(
class
Data
,
class
DVF
,
class
DEF
,
class
DDF
,
class
DStpF
)
PUSHMI_TEMPLATE
(
class
Data
,
class
DVF
,
class
DEF
,
class
DDF
,
class
DStpF
)
(
requires
Receiver
<
Data
>
&&
Invocable
<
DDF
&
,
Data
&>
&&
Invocable
<
DStpF
&
,
Data
&>
)
(
requires
PUSHMI_EXP
(
defer
::
Receiver
<
Data
>
PUSHMI_AND
defer
::
Invocable
<
DDF
&
,
Data
&>
PUSHMI_AND
defer
::
Invocable
<
DStpF
&
,
Data
&>
)
)
auto
operator
()(
Data
d
,
DVF
vf
,
DEF
ef
,
DDF
df
,
DStpF
stpf
)
const
{
auto
operator
()(
Data
d
,
DVF
vf
,
DEF
ef
,
DDF
df
,
DStpF
stpf
)
const
{
return
flow_single
<
Data
,
DVF
,
DEF
,
DDF
,
DStpF
,
passDStrtF
>
{
std
::
move
(
d
),
return
flow_single
<
Data
,
DVF
,
DEF
,
DDF
,
DStpF
,
passDStrtF
>
{
std
::
move
(
d
),
std
::
move
(
vf
),
std
::
move
(
ef
),
std
::
move
(
df
),
std
::
move
(
stpf
)};
std
::
move
(
vf
),
std
::
move
(
ef
),
std
::
move
(
df
),
std
::
move
(
stpf
)};
}
}
PUSHMI_TEMPLATE
(
class
Data
,
class
DVF
,
class
DEF
,
class
DDF
,
class
DStpF
,
class
DStrtF
)
PUSHMI_TEMPLATE
(
class
Data
,
class
DVF
,
class
DEF
,
class
DDF
,
class
DStpF
,
class
DStrtF
)
(
requires
Receiver
<
Data
>
&&
Invocable
<
DDF
&
,
Data
&>
&&
Invocable
<
DStpF
&
,
Data
&>
)
(
requires
PUSHMI_EXP
(
defer
::
Receiver
<
Data
>
PUSHMI_AND
defer
::
Invocable
<
DDF
&
,
Data
&>
PUSHMI_AND
defer
::
Invocable
<
DStpF
&
,
Data
&>
)
)
auto
operator
()(
Data
d
,
DVF
vf
,
DEF
ef
,
DDF
df
,
DStpF
stpf
,
DStrtF
strtf
)
const
{
auto
operator
()(
Data
d
,
DVF
vf
,
DEF
ef
,
DDF
df
,
DStpF
stpf
,
DStrtF
strtf
)
const
{
return
flow_single
<
Data
,
DVF
,
DEF
,
DDF
,
DStpF
,
DStrtF
>
{
std
::
move
(
d
),
return
flow_single
<
Data
,
DVF
,
DEF
,
DDF
,
DStpF
,
DStrtF
>
{
std
::
move
(
d
),
std
::
move
(
vf
),
std
::
move
(
ef
),
std
::
move
(
df
),
std
::
move
(
stpf
),
std
::
move
(
strtf
)};
std
::
move
(
vf
),
std
::
move
(
ef
),
std
::
move
(
df
),
std
::
move
(
stpf
),
std
::
move
(
strtf
)};
...
@@ -408,124 +397,88 @@ PUSHMI_INLINE_VAR constexpr struct make_flow_single_fn {
...
@@ -408,124 +397,88 @@ PUSHMI_INLINE_VAR constexpr struct make_flow_single_fn {
flow_single
()
->
flow_single
<>
;
flow_single
()
->
flow_single
<>
;
PUSHMI_TEMPLATE
(
class
VF
)
PUSHMI_TEMPLATE
(
class
VF
)
(
requires
not
Receiver
<
VF
>
&&
!
detail
::
is_v
<
VF
,
on_error_fn
>
&&
(
requires
PUSHMI_EXP
(
defer
::
True
<>
PUSHMI_BROKEN_SUBSUMPTION
(
PUSHMI_AND
not
defer
::
Receiver
<
VF
>
PUSHMI_AND
not
defer
::
Invocable
<
VF
&>
)))
!
detail
::
is_v
<
VF
,
on_done_fn
>
)
flow_single
(
VF
)
->
flow_single
(
VF
)
flow_single
<
VF
,
abortEF
,
ignoreDF
,
ignoreStpF
,
ignoreStrtF
>
;
->
flow_single
<
VF
,
abortEF
,
ignoreDF
,
ignoreStpF
,
ignoreStrtF
>
;
template
<
class
...
EFN
>
template
<
class
...
EFN
>
flow_single
(
on_error_fn
<
EFN
...
>
)
flow_single
(
on_error_fn
<
EFN
...
>
)
->
->
flow_single
<
flow_single
<
ignoreVF
,
on_error_fn
<
EFN
...
>
,
ignoreDF
,
ignoreStpF
,
ignoreStrtF
>
;
ignoreVF
,
on_error_fn
<
EFN
...
>
,
PUSHMI_TEMPLATE
(
class
DF
)
ignoreDF
,
(
requires
PUSHMI_EXP
(
defer
::
True
<>
PUSHMI_AND
defer
::
Invocable
<
DF
&>
PUSHMI_BROKEN_SUBSUMPTION
(
PUSHMI_AND
not
defer
::
Receiver
<
DF
>
)))
ignoreStpF
,
flow_single
(
DF
)
->
ignoreStrtF
>
;
flow_single
<
ignoreVF
,
abortEF
,
DF
,
ignoreStpF
,
ignoreStrtF
>
;
template
<
class
DF
>
flow_single
(
on_done_fn
<
DF
>
)
->
flow_single
<
ignoreVF
,
abortEF
,
on_done_fn
<
DF
>
,
ignoreStpF
,
ignoreStrtF
>
;
PUSHMI_TEMPLATE
(
class
V
,
class
PE
,
class
E
,
class
Wrapped
)
(
requires
FlowSingleReceiver
<
Wrapped
,
V
,
PE
,
E
>
&&
!
detail
::
is_v
<
Wrapped
,
none
>
)
flow_single
(
Wrapped
)
->
flow_single
<
V
,
PE
,
E
>
;
PUSHMI_TEMPLATE
(
class
VF
,
class
EF
)
PUSHMI_TEMPLATE
(
class
VF
,
class
EF
)
(
requires
not
Receiver
<
VF
>
&&
!
detail
::
is_v
<
VF
,
on_error_fn
>
&&
(
requires
PUSHMI_EXP
(
defer
::
True
<>
PUSHMI_BROKEN_SUBSUMPTION
(
PUSHMI_AND
not
defer
::
Receiver
<
VF
>
PUSHMI_AND
not
defer
::
Invocable
<
EF
&>
)))
!
detail
::
is_v
<
VF
,
on_done_fn
>
&&
!
detail
::
is_v
<
EF
,
on_value_fn
>
&&
flow_single
(
VF
,
EF
)
->
!
detail
::
is_v
<
EF
,
on_done_fn
>
)
flow_single
<
VF
,
EF
,
ignoreDF
,
ignoreStpF
,
ignoreStrtF
>
;
flow_single
(
VF
,
EF
)
->
flow_single
<
VF
,
EF
,
ignoreDF
,
ignoreStpF
,
ignoreStrtF
>
;
PUSHMI_TEMPLATE
(
class
EF
,
class
DF
)
(
requires
PUSHMI_EXP
(
defer
::
True
<>
PUSHMI_AND
defer
::
Invocable
<
DF
&>
PUSHMI_BROKEN_SUBSUMPTION
(
PUSHMI_AND
not
defer
::
Receiver
<
EF
>
)))
template
<
class
...
EFN
,
class
DF
>
flow_single
(
EF
,
DF
)
->
flow_single
(
on_error_fn
<
EFN
...
>
,
on_done_fn
<
DF
>
)
flow_single
<
ignoreVF
,
EF
,
DF
,
ignoreStpF
,
ignoreStrtF
>
;
->
flow_single
<
ignoreVF
,
on_error_fn
<
EFN
...
>
,
on_done_fn
<
DF
>
,
ignoreStpF
,
ignoreStrtF
>
;
PUSHMI_TEMPLATE
(
class
VF
,
class
EF
,
class
DF
)
PUSHMI_TEMPLATE
(
class
VF
,
class
EF
,
class
DF
)
(
requires
Invocable
<
DF
&>
)
(
requires
PUSHMI_EXP
(
defer
::
Invocable
<
DF
&>
PUSHMI_BROKEN_SUBSUMPTION
(
PUSHMI_AND
not
defer
::
Receiver
<
VF
>
))
)
flow_single
(
VF
,
EF
,
DF
)
flow_single
(
VF
,
EF
,
DF
)
->
->
flow_single
<
VF
,
EF
,
DF
,
ignoreStpF
,
ignoreStrtF
>
;
flow_single
<
VF
,
EF
,
DF
,
ignoreStpF
,
ignoreStrtF
>
;
PUSHMI_TEMPLATE
(
class
VF
,
class
EF
,
class
DF
,
class
StpF
)
PUSHMI_TEMPLATE
(
class
VF
,
class
EF
,
class
DF
,
class
StpF
)
(
requires
Invocable
<
DF
&>
&&
Invocable
<
StpF
&>
)
(
requires
PUSHMI_EXP
(
defer
::
Invocable
<
DF
&>
PUSHMI_AND
defer
::
Invocable
<
StpF
&>
PUSHMI_BROKEN_SUBSUMPTION
(
PUSHMI_AND
not
defer
::
Receiver
<
VF
>
))
)
flow_single
(
VF
,
EF
,
DF
,
StpF
)
flow_single
(
VF
,
EF
,
DF
,
StpF
)
->
->
flow_single
<
VF
,
EF
,
DF
,
StpF
,
ignoreStrtF
>
;
flow_single
<
VF
,
EF
,
DF
,
StpF
,
ignoreStrtF
>
;
PUSHMI_TEMPLATE
(
class
VF
,
class
EF
,
class
DF
,
class
StpF
,
class
StrtF
)
PUSHMI_TEMPLATE
(
class
VF
,
class
EF
,
class
DF
,
class
StpF
,
class
StrtF
)
(
requires
Invocable
<
DF
&>
&&
Invocable
<
StpF
&>
)
(
requires
PUSHMI_EXP
(
defer
::
Invocable
<
DF
&>
PUSHMI_AND
defer
::
Invocable
<
StpF
&>
PUSHMI_BROKEN_SUBSUMPTION
(
PUSHMI_AND
not
defer
::
Receiver
<
VF
>
))
)
flow_single
(
VF
,
EF
,
DF
,
StpF
,
StrtF
)
flow_single
(
VF
,
EF
,
DF
,
StpF
,
StrtF
)
->
->
flow_single
<
VF
,
EF
,
DF
,
StpF
,
StrtF
>
;
flow_single
<
VF
,
EF
,
DF
,
StpF
,
StrtF
>
;
PUSHMI_TEMPLATE
(
class
Data
)
PUSHMI_TEMPLATE
(
class
Data
)
(
requires
Receiver
<
Data
>
)
(
requires
PUSHMI_EXP
(
defer
::
True
<>
PUSHMI_AND
defer
::
Receiver
<
Data
>
)
)
flow_single
(
Data
d
)
flow_single
(
Data
d
)
->
->
flow_single
<
Data
,
passDVF
,
passDEF
,
passDDF
,
passDStpF
,
passDStrtF
>
;
flow_single
<
Data
,
passDVF
,
passDEF
,
passDDF
,
passDStpF
,
passDStrtF
>
;
PUSHMI_TEMPLATE
(
class
Data
,
class
DVF
)
PUSHMI_TEMPLATE
(
class
Data
,
class
DVF
)
(
requires
Receiver
<
Data
>
&&
!
detail
::
is_v
<
DVF
,
on_error_fn
>
&&
(
requires
PUSHMI_EXP
(
defer
::
True
<>
PUSHMI_AND
defer
::
Receiver
<
Data
>
PUSHMI_BROKEN_SUBSUMPTION
(
PUSHMI_AND
not
defer
::
Invocable
<
DVF
&
,
Data
&>
)))
!
detail
::
is_v
<
DVF
,
on_done_fn
>
)
flow_single
(
Data
d
,
DVF
vf
)
->
flow_single
(
Data
d
,
DVF
vf
)
flow_single
<
Data
,
DVF
,
passDEF
,
passDDF
,
passDStpF
,
passDStrtF
>
;
->
flow_single
<
Data
,
DVF
,
passDEF
,
passDDF
,
passDStpF
,
passDStrtF
>
;
PUSHMI_TEMPLATE
(
class
Data
,
class
...
DEFN
)
PUSHMI_TEMPLATE
(
class
Data
,
class
...
DEFN
)
(
requires
Receiver
<
Data
>
)
(
requires
PUSHMI_EXP
(
defer
::
Receiver
<
Data
>
))
flow_single
(
Data
d
,
on_error_fn
<
DEFN
...
>
)
flow_single
(
Data
d
,
on_error_fn
<
DEFN
...
>
)
->
->
flow_single
<
flow_single
<
Data
,
passDVF
,
on_error_fn
<
DEFN
...
>
,
passDDF
,
passDStpF
,
passDStrtF
>
;
Data
,
passDVF
,
PUSHMI_TEMPLATE
(
class
Data
,
class
DDF
)
on_error_fn
<
DEFN
...
>
,
(
requires
PUSHMI_EXP
(
defer
::
True
<>
PUSHMI_AND
defer
::
Receiver
<
Data
>
PUSHMI_AND
defer
::
Invocable
<
DDF
&
,
Data
&>
))
passDDF
,
flow_single
(
Data
d
,
DDF
)
->
passDStpF
,
flow_single
<
Data
,
passDVF
,
passDEF
,
DDF
,
passDStpF
,
passDStrtF
>
;
passDStrtF
>
;
PUSHMI_TEMPLATE
(
class
Data
,
class
DVF
,
class
DEF
)
PUSHMI_TEMPLATE
(
class
Data
,
class
DVF
,
class
DEF
)
(
requires
Receiver
<
Data
>
&&
!
detail
::
is_v
<
DVF
,
on_error_fn
>
&&
(
requires
PUSHMI_EXP
(
defer
::
Receiver
<
Data
>
PUSHMI_BROKEN_SUBSUMPTION
(
PUSHMI_AND
not
defer
::
Invocable
<
DEF
&
,
Data
&>
)))
!
detail
::
is_v
<
DVF
,
on_done_fn
>
&&
!
detail
::
is_v
<
DEF
,
on_done_fn
>
)
flow_single
(
Data
d
,
DVF
vf
,
DEF
ef
)
->
flow_single
(
Data
d
,
DVF
vf
,
DEF
ef
)
flow_single
<
Data
,
DVF
,
DEF
,
passDDF
,
passDStpF
,
passDStrtF
>
;
->
flow_single
<
Data
,
DVF
,
DEF
,
passDDF
,
passDStpF
,
passDStrtF
>
;
PUSHMI_TEMPLATE
(
class
Data
,
class
...
DEFN
,
class
DDF
)
(
requires
Receiver
<
Data
>
)
flow_single
(
Data
d
,
on_error_fn
<
DEFN
...
>
,
on_done_fn
<
DDF
>
)
->
flow_single
<
Data
,
passDVF
,
on_error_fn
<
DEFN
...
>
,
on_done_fn
<
DDF
>
,
passDStpF
,
passDStrtF
>
;
PUSHMI_TEMPLATE
(
class
Data
,
class
DDF
)
PUSHMI_TEMPLATE
(
class
Data
,
class
D
EF
,
class
D
DF
)
(
requires
Receiver
<
Data
>
)
(
requires
PUSHMI_EXP
(
defer
::
Receiver
<
Data
>
PUSHMI_AND
defer
::
Invocable
<
DDF
&
,
Data
&>
)
)
flow_single
(
Data
d
,
on_done_fn
<
DDF
>
)
flow_single
(
Data
d
,
DEF
,
DDF
)
->
->
flow_single
<
Data
,
passDVF
,
passDEF
,
on_done_fn
<
DDF
>
,
passDStpF
,
passDStrtF
>
;
flow_single
<
Data
,
passDVF
,
DEF
,
DDF
,
passDStpF
,
passDStrtF
>
;
PUSHMI_TEMPLATE
(
class
Data
,
class
DVF
,
class
DEF
,
class
DDF
)
PUSHMI_TEMPLATE
(
class
Data
,
class
DVF
,
class
DEF
,
class
DDF
)
(
requires
Receiver
<
Data
>
&&
Invocable
<
DDF
&
,
Data
&>
)
(
requires
PUSHMI_EXP
(
defer
::
Receiver
<
Data
>
PUSHMI_AND
defer
::
Invocable
<
DDF
&
,
Data
&>
)
)
flow_single
(
Data
d
,
DVF
vf
,
DEF
ef
,
DDF
df
)
flow_single
(
Data
d
,
DVF
vf
,
DEF
ef
,
DDF
df
)
->
->
flow_single
<
Data
,
DVF
,
DEF
,
DDF
,
passDStpF
,
passDStrtF
>
;
flow_single
<
Data
,
DVF
,
DEF
,
DDF
,
passDStpF
,
passDStrtF
>
;
PUSHMI_TEMPLATE
(
class
Data
,
class
DVF
,
class
DEF
,
class
DDF
,
class
DStpF
)
PUSHMI_TEMPLATE
(
class
Data
,
class
DVF
,
class
DEF
,
class
DDF
,
class
DStpF
)
(
requires
Receiver
<
Data
>
&&
Invocable
<
DDF
&
,
Data
&>
&&
Invocable
<
DStpF
&
,
Data
&>
)
(
requires
PUSHMI_EXP
(
defer
::
Receiver
<
Data
>
PUSHMI_AND
defer
::
Invocable
<
DDF
&
,
Data
&>
PUSHMI_AND
defer
::
Invocable
<
DStpF
&
,
Data
&>
))
flow_single
(
Data
d
,
DVF
vf
,
DEF
ef
,
DDF
df
,
DStpF
stpf
)
flow_single
(
Data
d
,
DVF
vf
,
DEF
ef
,
DDF
df
,
DStpF
stpf
)
->
->
flow_single
<
Data
,
DVF
,
DEF
,
DDF
,
DStpF
,
passDStrtF
>
;
flow_single
<
Data
,
DVF
,
DEF
,
DDF
,
DStpF
,
passDStrtF
>
;
PUSHMI_TEMPLATE
(
PUSHMI_TEMPLATE
(
class
Data
,
class
DVF
,
class
DEF
,
class
DDF
,
class
DStpF
,
class
DStrtF
)
class
Data
,
(
requires
PUSHMI_EXP
(
defer
::
Receiver
<
Data
>
PUSHMI_AND
defer
::
Invocable
<
DDF
&
,
Data
&>
PUSHMI_AND
defer
::
Invocable
<
DStpF
&
,
Data
&>
))
class
DVF
,
flow_single
(
Data
d
,
DVF
vf
,
DEF
ef
,
DDF
df
,
DStpF
stpf
,
DStrtF
strtf
)
->
class
DEF
,
flow_single
<
Data
,
DVF
,
DEF
,
DDF
,
DStpF
,
DStrtF
>
;
class
DDF
,
class
DStpF
,
class
DStrtF
)
(
requires
Receiver
<
Data
>
&&
Invocable
<
DDF
&
,
Data
&>
&&
Invocable
<
DStpF
&
,
Data
&>
)
flow_single
(
Data
d
,
DVF
vf
,
DEF
ef
,
DDF
df
,
DStpF
stpf
,
DStrtF
strtf
)
->
flow_single
<
Data
,
DVF
,
DEF
,
DDF
,
DStpF
,
DStrtF
>
;
#endif
#endif
template
<
class
V
,
class
PE
=
std
::
exception_ptr
,
class
E
=
PE
>
template
<
class
V
,
class
PE
=
std
::
exception_ptr
,
class
E
=
PE
>
...
...
Write
Preview
Markdown
is supported
0%
Try again
or
attach a new file
Attach a file
Cancel
You are about to add
0
people
to the discussion. Proceed with caution.
Finish editing this message first!
Cancel
Please
register
or
sign in
to comment