F
>
x
>
G
The execution of F
>
x
>
G
starts by executing F
. Whenever F
publishes a value, a new execution of G
begins in parallel with F
(and with any previous
executions of G
); in that execution of G
, variable x
is bound to the value
published by F
. Any value
published by any executions of G
is published by the whole expression, but the values published
by F
are not published by the whole expression; they are consumed by the variable binding.
F
>
P
>
G
The sequential combinator may be written as F
>
P
>
G
,
where P
is a pattern instead of
just a variable name. Any value published by F
is matched against the pattern P
.
If this match is successful, a new execution of G
begins, with all of the bindings
from the match. Otherwise, the published value is simply ignored, and no new execution
of G
is begun.
F
>>
G
This is equivalent to using a wildcard pattern: F
>_>
G
. Every publication
of F
will match the combinator pattern, causing an execution of G
for every individual
publication of F
. No bindings will be made in G
from these publications.

Combinator Precedence Level: sequential > parallel > pruning > otherwise [Full Table]
The type of F
>
P
>
G
is the type of G
in the context Γ_{F},
where Γ_{F} is the result of matching the pattern P
against the type of F
.
{ Publish 1 and 2 in parallel } (0  1) >n> n+1 { OUTPUT:PERMUTABLE 1 2 }
{ Filter out values of the form (_,false) } ( (4,true)  (5,false)  (6,true) ) >(x,true)> x { OUTPUT:PERMUTABLE 4 6 }
{ Print two strings to the console, but don't publish the return values of the calls. } Println("goodbye") >> Println("world") >> stop { OUTPUT: goodbye world }
Related Reference Topics
Related Tutorial Sections