tur/gen
generator helpers and macros for consuming and composing generators.
Auto-loaded alongside stdlib/macros.tur.
Since: Phase GF2
gen-some?
(gen-some? [p :ptr<void>] :bool)
test whether a gen-next result contains a value.
| p | void* pointer returned by gen-next |
true if p is non-NULL (a value was yielded), false if the generator was exhausted and gen-next returned NULL.
(let [v (gen-next g)] (when (gen-some? v) (println (gen-unwrap v))))
Since: GF2
gen-unwrap
(gen-unwrap [p :ptr<void>] :int)
extract the yielded value from a gen-next pointer.
The compiler treats gen-unwrap as a core form: the result is typed at the generator's element type -- the T of its (Generator T) (a yielded 7.25 reads back as a float, a cstr as a cstr, a struct as that struct) -- when the argument is a (gen-next g) or a binding that holds one. This definition is the reader's documented shape and the interpreter's native fallback; only an opaque pointer of unknown provenance reads the slot as an int.
| p | a non-NULL void* pointer returned by gen-next |
The value that was yielded, at the generator's element type.
(gen-unwrap (gen-next g)) ; => the yielded value
Since: GF2
gen-none
(gen-none :ptr<void>)
return a null generator result representing no value.
NULL as :ptr<void>; test with gen-some? to distinguish from a real value.
(gen-none) ; => NULL
Since: GF2
gen-arr-new
(gen-arr-new :int)
allocate an empty int64 array (the seq-collect result).
Opaque pointer to an empty array (len=0).
(let [a (gen-arr-new)] ...)
Since: GF2
gen-arr-push!
(gen-arr-push! [a val] :nil)
append val to the end of a gen-arr array.
| a | array pointer returned by gen-arr-new | |
| val | int64_t value to append |
(gen-arr-push! my-arr 42)
Since: GF2
gen-arr-len
(gen-arr-len [a] :int)
return the number of elements in a gen-arr array.
| a | array pointer returned by gen-arr-new |
Number of collected elements.
(gen-arr-len my-arr) ; => 3
Since: GF2
gen-arr-get
(gen-arr-get [a i] :int)
return the element at index i in a gen-arr array.
| a | array pointer returned by gen-arr-new | |
| i | zero-based index |
The int64_t value stored at position i.
(gen-arr-get my-arr 0) ; => first element
Since: GF2
gen-collect
(gen-collect [g])
materialise all yielded values into a vector.
| g | a generator expression |
A (Vec T) holding every value g yields, in order, typed at the generator's element type T (int, float, cstr, a struct, ...). Iterate with vec-len and vec-get.
(let [arr (gen-collect (gen [] (yield 1.5) (yield 2.5)))] (println (vec-get arr 1))) ; => 2.5
Since: GF2
gen-for-each
(gen-for-each [f g])
call f with every value yielded by a generator.
| f | a one-argument callable applied to each yielded value | |
| g | a generator expression |
(gen-for-each println my-gen)
Since: GF2
gen-nth
(gen-nth [n g])
return the nth (0-indexed) yielded value, or gen-none.
| n | zero-based index | |
| g | a generator expression |
The raw void* pointer from gen-next at position n, or gen-none (NULL) if the generator has fewer than n+1 values. Test with gen-some? and extract with gen-unwrap.
(let [v (gen-nth 2 my-gen)] (when (gen-some? v) (println (gen-unwrap v))))
Since: GF2
yield*
(yield* [inner])
re-yield every value from an inner generator.
| inner | a generator expression whose values are to be forwarded |
(gen [] (yield* inner-gen) (yield 99))
Since: GF2