tur/arrow
arrow combinators over the (->) function arrow, in two surfaces.
Since: Phase CA0
arr
(arr [^fat f])
lift a function to an arrow (identity for function arrows).
| f | the function to lift |
The function itself.
(arr (fn [x] (+ x 1))) ; => identity for functions
>>>
(>>> [A B C])
compose two function arrows sequentially (register-class-correct).
| f | first arrow (A -> B) | |
| g | second arrow (B -> C) |
A ptr<void> closure (A -> C) that applies f then g.
((>>> (fn [x : float] : float (+ x 1.0))
(fn [x : float] : float (* x 2.0))) 3.0) ; => 8.0
Since: Phase CA1
arrow-first
(arrow-first [^fat f])
apply a function to the first component of a Tuple2.
| f | function to apply |
A function on Tuple2 that applies f to the first field.
((arrow-first (fn [x] (+ x 1))) <heap Tuple2 (5, 10)>) ; => Tuple2(6, 10)
arrow-second
(arrow-second [^fat f])
apply a function to the second component of a Tuple2.
| f | function to apply |
A function on Tuple2 that applies f to the second field.
((arrow-second (fn [x] (+ x 1))) <heap Tuple2 (5, 10)>) ; => Tuple2(5, 11)
par-comp
(par-comp [a b c d ^fat f ^fat g])
parallel composition of two functions on Tuple2 types.
| f | function a -> b | |
| g | function c -> d |
A function on Tuple2 a c -> Tuple2 b d: (par-comp f g)(tuple2 x y) = tuple2(f x, g y).
((par-comp inc double) (tuple2 1 2)) ; => Tuple2(2, 4)
arrow-split
(arrow-split [a b c ^fat f ^fat g])
duplicate input and apply two functions, returning a Tuple2.
| f | function a -> b | |
| g | function a -> c |
A function a -> Tuple2 b c: (arrow-split f g)(x) = tuple2(f x, g x).
((arrow-split inc double) 3) ; => Tuple2(4, 6)
arrow-const
(arrow-const [v])
arrow that ignores its input and always returns v.
| v | the constant value to return |
An arrow (any -> v).
((arrow-const 42) 999) ; => 42
Since: Phase B2
arrow-dup
(arrow-dup [x] :)
arrow that duplicates its input into a Tuple2.
| x | the value to duplicate |
A Tuple2 of x with itself: Tuple2(x, x).
(tuple2-1st (arrow-dup 7)) ; => 7
Since: Phase B2
Arrow[]
(definstance Arrow [])
the function arrow: arr is the identity (a plain function
ArrowChoice[]
(definstance ArrowChoice [])
map an arrow over one arm of an Either, passing the
ArrowLoop[f]
(definstance ArrowLoop [f])
non-recursive feedback: project the first output slot
ArrowApply[p]
(definstance ArrowApply [p])
the apply arrow: run the arrow in slot 0 on slot 1.
Category[]
(definstance Category [])
the function arrow: `ident` is the plain identity
Internal definitions
__arrow_pair_first-- inline-C: apply fv to e1 of a heap pair *p,__arrow_pair_second-- inline-C: apply fv to e2 of a heap pair *p,__arrow_pair_par-- inline-C: apply fv to e1 and gv to e2 of *p.__arrow_pair_split-- inline-C: produce a heap pair from (fv x, gv x).__arrow_pair_dup-- inline-C: produce a heap pair with both fields = x.__ac_pair_first-- inline-C: apply fv to slot 0 of a heap pair, copy slot 1.__ac_pair_second-- inline-C: copy slot 0 of a heap pair, apply fv to slot 1.__ac_loop_step-- inline-C: non-recursive ArrowLoop step. Build the input__ac_app-- inline-C: ArrowApply for (->). The input pair carries an arrow