CoreLib

Witnesses that F is a bifunctor (covariant in both variables).

Contravariant functor from category -⚬ to the category => of Scala functions. It takes a morphism A -⚬ B internal to the DSL and maps it to a morphism F[B] => F[A] in the meta language (Scala), i.e. external to the DSL.

Witnesses that F is a contravariant endofunctor on the category -⚬.

Evidence that A flowing in one direction is equivalent to to B flowing in the opposite direction. It must hold that

       ┏━━━━━┓                         ┏━━━━━┓
       ┞─┐ r ┃                         ┃  l  ┞─┐
       ╎A│ I ┃                         ┃  I  ╎B│
       ┟─┘ n ┃                         ┃  n  ┟─┘
 ┏━━━━━┫   v ┃     ┏━━━━━━━━━┓         ┃  v  ┣━━━━━┓     ┏━━━━━━━━━┓
 ┃  l  ┞─┐ e ┃     ┞─┐       ┞─┐       ┃  e  ┞─┐ r ┃     ┞─┐       ┞─┐
 ┃  I  ╎B│ r ┃  =  ╎A│ id[A] ╎A│       ┃  r  ╎A│ I ┃  =  ╎B│ id[B] ╎B│
 ┃  n  ┟─┘ t ┃     ┟─┘       ┟─┘       ┃  t  ┟─┘ n ┃     ┟─┘       ┟─┘
 ┃  v  ┣━━━━━┛     ┗━━━━━━━━━┛         ┗━━━━━┫   v ┃     ┗━━━━━━━━━┛
 ┃  e  ┞─┐                                   ┞─┐ e ┃
 ┃  r  ╎A│                                   ╎B│ r ┃
 ┃  t  ┟─┘                                   ┟─┘ t ┃
 ┗━━━━━┛                                     ┗━━━━━┛

Evidence that if A is dual to B, then F[A] is dual to G[B].

Functor from category -⚬ to the category => of Scala functions. It takes a morphism A -⚬ B internal to the DSL and maps it to a morphism F[A] => F[B] in the meta language (Scala), i.e. external to the DSL.

Focused on B in F[B], where B is in a covariant position.

Focused on B in the output F[B] of linear function A -⚬ F[B], where B is in a contravariant position.

Witnesses that F is a covariant endofunctor on the category -⚬.

A Comonoid whose counit can be chained before a signal flowing in the '''N'''egative direction (Need), effectively taking on the responsibility to await completion of some computation.

The dual of PMonoid.

A weaker version of Monoid whose unit creates a liability - a signal traveling in the '''N'''egative direction (Need) that eventually needs to be awaited.

Its dual is PComonoid.

A weaker version of Comonoid whose counit cannot discard the input completely, but can reduce it to a signal traveling in the '''P'''ositive direction (Done) that eventually needs to be awaited.

The dual of NMonoid.

A Monoid whose unit can be chained after a signal flowing in the '''P'''ositive direction (Done), effectively taking on the responsibility to wait for completion of some computation.

Its dual is NComonoid.

A type alias expressing the ''intent'' that A is delayed (in some sense) until a signal (Need) is received. Equivalent to Done =⚬ A, but the formulation as Need |*| A does not rely on the more powerful concept of ''function types'' (internal hom objects), i.e. does not require ClosedDSL.

An endless source of elements, where the consumer decides whether to pull one more element or close. Dual to LList, in which the producer decides how many elements will be produced.

Non-empty list, i.e. a list with at least one element.

Zero or more instances of A. The exact multiplicity is determined by the producer.

Similar to LList, but unlike LList, the producer of Multiple is not required to unveil the elements sequentially. There are many different representations (in fact an infinite number) of the same sequence of elements of type A as Multiple[A], while there is only one representation of that sequence as LList[A].

Unlimited supply of As. The consumer chooses how many As to consume.

Λ is the uppercase Greek letter lambda.

Λ is the uppercase Greek letter lambda.

Chooses the left alternative A of the choice A |&| B, but only after the Need signal from the first out-port arrives. Until then, the producer of A |&| B will see it as undecided. This is different from chooseL[A, B] > awaitNegFst[A], in which the producer of A |&| B knows immediately that the left side is chosen.

Analogous to awaitChooseL, but chooses the right side.

Injects A from the the second in-port to the left side of the |+| in the out-port, but only after the Done signal from the first in-port arrives. That means that the consumer of A |+| B will see it as undecided until the Done signal arrives. This is different from awaitPosFst[A] > injectL[A, B], in which the consumer of A |+| B knows immediately that it is the left case.

This is a convenience method on top of injectLWhenDone that which absorbs the Done signal using the given Junction.Positive.

Analogous to joinInjectL, but injects to the right.

Analogous to awaitChooseL, but awaits a positive (i.e. Done) signal.

Analogous to awaitChooseR, but awaits a positive (i.e. Done) signal.

If F[A] is dual to G[B] for all dual pairs A, B, then Rec[F] is dual to Rec[G].

From the choice ''available'' on the right (C |&| D), choose the one corresponding to the choice ''made'' on the left (A |+| B): if on the left there is A, choose C, if on the left thre is B, choose D.

From the choice ''available'' on the left (A |&| B), choose the one corresponding to the choice ''made'' on the right (C |+| D): if on the right there is C, choose A, if on the right there is D, choose B.

Notifies when the choice (|&|) is made and if it is left, the left side notifies using the given function.

Notifies when the choice (|&|) is made and if it is left, the left side notifies.

Notifies when the choice (|&|) is made and if it is right, the right side notifies using the given function.

Notifies when the choice (|&|) is made and if it is right, the right side notifies.

Notifies when the choice (|&|) is made and the chosen side notifies using the respective given function.

Notifies when the choice (|&|) is made and the chosen side notifies.

Notifies when the |+| is decided and if it is left, the left side notifies using the given function.

Notifies when the |+| is decided and if it is left, the left side notifies.

Notifies when the |+| is decided and if it is right, the right side notifies using the given function.

Notifies when the |+| is decided and if it is right, the right side notifies.

Notifies when the |+| is decided and the present side notifies using the respective given function.

Notifies when the |+| is decided and the present side notifies.

Present a non-empty list of resources A as an unlimited supply of "borrowed" resources A ⊗ Ā, where Ā is the dual of A. A borrowed resource A ⊗ Ā must be "returned" by "annihilating" A and its dual Ā, namely via an inversion on the right A ⊗ Ā -⚬ One. A returned resource will become available for further use when it signals readiness using the Signaling.Positive instance.

When all accesses to the pooled resources (obtained via the Unlimited[A |*| Ā] in the first out-port) are closed, the resources are returned in the second out-port.

Races the two Done signals and

• produces left if the first signal wins, in which case it returns the second signal that still has to be awaited;
• produces right if the second signal wins, in which case it returns the first signal that still has to be awaited. It is biased to the left: if both signals have arrived by the time of inquiry, returns left.

Creates a pair of mutually recursive functions.

Races two Need signals, i.e. signals traveling in the negative direction (i.e. opposite the -⚬ arrow). Based on which Need signal from the out-port wins the race, selects one of the two Need signals from the in-port:

• If the first signal from the out-port wins the race, selects the left signal from the in-port and pipes to it the remaining (i.e. the right) signal from the out-port.
• If the second signal from the out-port wins the race, selects the right signal from the in-port and pipes to it the reamining (i.e. the left) signal from the out-port. It is biased to the left: if both signals from the out-port have arrived by the time of inquiry, selects the left signal from the in-port.

Alias for sequence_PP.

Present a choice between two pairs ((A |*| B) |&| (C |*| D)) as a choice (B |&| D) between the second parts of the respective pairs and on the side provide the other part of the chosen input pair, i.e. either A or C (A |+| C).

Present a choice between two pairs ((A |*| B) |&| (C |*| D)) as a choice (A |&| C) between the first parts of the respective pairs and on the side provide the other part of the chosen input pair, i.e. either B or D (B |+| D).