tur/core
Seq
(defstruct Seq [mk :int])
a lazy sequence backed by a generator-producing thunk.
seq-new
(seq-new [mk :int] :int)
allocate a heap Seq wrapping a fat closure mk.
| mk | a fat closure (int64_t) that produces a fresh generator when called |
int64_t pointer to the heap-allocated Seq value.
(seq-new (fn [] (gen [] (yield 1))))
Since: LZ0
seq-iter
(seq-iter [s :int] :ptr<void>)
invoke the Seq factory to obtain a fresh generator.
| s | int64_t pointer to a Seq (returned by seq-new) |
void* pointer to a fresh generator for s.
(let [g (seq-iter my-seq)] ...)
Since: LZ0
seq-gen-done
(seq-gen-done [g :ptr<void>] :bool)
test whether a void* generator has been exhausted.
| g | void* generator pointer returned by seq-iter |
true if the generator's __state == -1 (done), false otherwise.
(seq-gen-done g) ; => false while values remain
Since: LZ0
seq-gen-next
(seq-gen-next [g :ptr<void>] :ptr<void>)
advance a void* generator and return the next yield pointer.
| g | void* generator pointer returned by seq-iter |
void* pointer to the yielded int64_t value, or NULL if the generator is now exhausted. Test with seq-val-some? before calling seq-val-unwrap.
(let [v (seq-gen-next g)]
(when (seq-val-some? v) (println (seq-val-unwrap v))))
Since: LZ0
seq-val-some?
(seq-val-some? [v :ptr<void>] :bool)
test whether a yield pointer is non-NULL.
| v | void* returned by seq-gen-next |
true if v is non-NULL (a value was yielded).
(seq-val-some? (seq-gen-next g)) ; => true while values remain
Since: LZ0
seq-val-unwrap
(seq-val-unwrap [v :ptr<void>] :int)
extract the int64_t value from a yield pointer.
| v | a non-NULL void* returned by seq-gen-next |
The int64_t value that was yielded.
(seq-val-unwrap v) ; => yielded integer
Since: LZ0
seq-of
(seq-of [v :int] :int)
construct a single-element Seq.
| v | the single value to yield |
A Seq that yields v exactly once.
(let [s (seq-of 42)] ...) ; yields 42 then done
Since: LZ0
empty-seq
(empty-seq :int)
construct a Seq that yields no values.
A Seq that is immediately exhausted.
(let [s (empty-seq)] (seq-gen-done (seq-iter s))) ; => true
Since: LZ0
seq-vec-len
(seq-vec-len [v :int] :int)
return the length of a vec without #{Unsafe}.
seq-vec-get
(seq-vec-get [v :int i :int] :int)
seq-list-nil?
(seq-list-nil? [lst :int] :bool)
test whether a list is empty (NULL).
seq-list-head
(seq-list-head [lst :int] :int)
seq-list-tail
(seq-list-tail [lst :int] :int)
seq-from-vec
(seq-from-vec [v :int] :int)
construct a Seq that yields all elements of a vec.
| v | int64_t pointer to a vec (from vec-new / vec-push!) |
A Seq that yields each element of v in order.
(let [v (vec-new)]
(vec-push! v 10)
(vec-push! v 20)
(let [s (seq-from-vec v)] ...))
Since: LZ0
seq-from-list
(seq-from-list [l :int] :int)
construct a Seq that yields all elements of a linked list.
| l | int64_t head pointer to a singly-linked list (Cons cells) |
A Seq that yields each element from head to tail.
(let [lst (cons 1 (cons 2 (nil-value)))]
(let [s (seq-from-list lst)] ...))
Since: LZ0
seq-for-each
(seq-for-each [f s])
call f with every value yielded by a Seq.
| f | a one-argument callable applied to each yielded value | |
| s | a Seq expression |
(seq-for-each println my-seq)
Since: LZ0
seq-collect
(seq-collect [s])
materialise all values of a Seq into a gen-arr array.
| s | a Seq expression |
A gen-arr (from gen-arr-new) containing all int64_t values. Iterate with gen-arr-len and gen-arr-get.
(let [arr (seq-collect my-seq)]
(println (gen-arr-len arr)))
Since: LZ0