diff options
Diffstat (limited to '')
| -rw-r--r-- | stdlib/source/lux/data/coll/row.lux (renamed from stdlib/source/lux/data/coll/sequence.lux) | 75 |
1 files changed, 37 insertions, 38 deletions
diff --git a/stdlib/source/lux/data/coll/sequence.lux b/stdlib/source/lux/data/coll/row.lux index 4e6226dcd..0b258a2ec 100644 --- a/stdlib/source/lux/data/coll/sequence.lux +++ b/stdlib/source/lux/data/coll/row.lux @@ -169,7 +169,7 @@ #.Nil)))) ## [Types] -(type: #export (Sequence a) +(type: #export (Row a) {#level Level #size Nat #root (Hierarchy a) @@ -177,18 +177,18 @@ ## [Exports] (def: #export empty - Sequence + Row {#level (level-up root-level) #size +0 #root (array.new full-node-size) #tail (array.new +0)}) -(def: #export (size sequence) - (All [a] (-> (Sequence a) Nat)) - (get@ #size sequence)) +(def: #export (size row) + (All [a] (-> (Row a) Nat)) + (get@ #size row)) (def: #export (add val vec) - (All [a] (-> a (Sequence a) (Sequence a))) + (All [a] (-> a (Row a) (Row a))) ## Check if there is room in the tail. (let [vec-size (get@ #size vec)] (if (|> vec-size (n/- (tail-off vec-size)) (n/< full-node-size)) @@ -214,14 +214,14 @@ ## Otherwise, just push the current tail onto the root. (|> vec (update@ #root (push-tail vec-size (get@ #level vec) (get@ #tail vec))))) - ## Finally, update the size of the Sequence and grow a new + ## Finally, update the size of the row and grow a new ## tail with the new element as it's sole member. (update@ #size inc) (set@ #tail (new-tail val))) ))) (def: (base-for idx vec) - (All [a] (-> Index (Sequence a) (Maybe (Base a)))) + (All [a] (-> Index (Row a) (Maybe (Base a)))) (let [vec-size (get@ #size vec)] (if (and (n/>= +0 idx) (n/< vec-size idx)) @@ -241,17 +241,17 @@ #.None _ - (error! "Incorrect sequence structure.")))) + (error! "Incorrect row structure.")))) #.None))) (def: #export (nth idx vec) - (All [a] (-> Nat (Sequence a) (Maybe a))) + (All [a] (-> Nat (Row a) (Maybe a))) (do maybe.Monad<Maybe> [base (base-for idx vec)] (array.read (branch-idx idx) base))) (def: #export (put idx val vec) - (All [a] (-> Nat a (Sequence a) (Sequence a))) + (All [a] (-> Nat a (Row a) (Row a))) (let [vec-size (get@ #size vec)] (if (and (n/>= +0 idx) (n/< vec-size idx)) @@ -267,7 +267,7 @@ vec))) (def: #export (update idx f vec) - (All [a] (-> Nat (-> a a) (Sequence a) (Sequence a))) + (All [a] (-> Nat (-> a a) (Row a) (Row a))) (case (nth idx vec) (#.Some val) (put idx (f val) vec) @@ -276,7 +276,7 @@ vec)) (def: #export (pop vec) - (All [a] (-> (Sequence a) (Sequence a))) + (All [a] (-> (Row a) (Row a))) (case (get@ #size vec) +0 empty @@ -318,28 +318,28 @@ )) (def: #export (to-list vec) - (All [a] (-> (Sequence a) (List a))) + (All [a] (-> (Row a) (List a))) (list/compose (to-list' (#Hierarchy (get@ #root vec))) (to-list' (#Base (get@ #tail vec))))) (def: #export (from-list list) - (All [a] (-> (List a) (Sequence a))) + (All [a] (-> (List a) (Row a))) (list/fold add empty list)) (def: #export (member? a/Eq vec val) - (All [a] (-> (Eq a) (Sequence a) a Bool)) + (All [a] (-> (Eq a) (Row a) a Bool)) (list.member? a/Eq (to-list vec) val)) (def: #export empty? - (All [a] (-> (Sequence a) Bool)) + (All [a] (-> (Row a) Bool)) (|>> (get@ #size) (n/= +0))) ## [Syntax] -(syntax: #export (sequence {elems (p.some s.any)}) - {#.doc (doc "Sequence literals." - (sequence 10 20 30 40))} +(syntax: #export (row {elems (p.some s.any)}) + {#.doc (doc "Row literals." + (row 10 20 30 40))} (wrap (list (` (from-list (list (~+ elems))))))) ## [Structures] @@ -355,7 +355,7 @@ _ false))) -(struct: #export (Eq<Sequence> Eq<a>) (All [a] (-> (Eq a) (Eq (Sequence a)))) +(struct: #export (Eq<Row> Eq<a>) (All [a] (-> (Eq a) (Eq (Row a)))) (def: (= v1 v2) (and (n/= (get@ #size v1) (get@ #size v2)) (let [(^open "Node/") (Eq<Node> Eq<a>)] @@ -376,7 +376,7 @@ hierarchy)) )) -(struct: #export _ (Fold Sequence) +(struct: #export _ (Fold Row) (def: (fold f init xs) (let [(^open) Fold<Node>] (fold f @@ -386,8 +386,7 @@ (#Base (get@ #tail xs)))) )) -(struct: #export Monoid<Sequence> (All [a] - (Monoid (Sequence a))) +(struct: #export Monoid<Row> (All [a] (Monoid (Row a))) (def: identity empty) (def: (compose xs ys) (list/fold add xs (to-list ys)))) @@ -402,7 +401,7 @@ (#Hierarchy (array/map (map f) hierarchy))) )) -(struct: #export _ (Functor Sequence) +(struct: #export _ (Functor Row) (def: (map f xs) {#level (get@ #level xs) #size (get@ #size xs) @@ -410,29 +409,29 @@ #tail (|> xs (get@ #tail) (array/map f)) })) -(struct: #export _ (Apply Sequence) - (def: functor Functor<Sequence>) +(struct: #export _ (Apply Row) + (def: functor Functor<Row>) (def: (apply ff fa) - (let [(^open) Functor<Sequence> - (^open) Fold<Sequence> - (^open) Monoid<Sequence> + (let [(^open) Functor<Row> + (^open) Fold<Row> + (^open) Monoid<Row> results (map (function (_ f) (map f fa)) ff)] (fold compose identity results)))) -(struct: #export _ (Monad Sequence) - (def: functor Functor<Sequence>) +(struct: #export _ (Monad Row) + (def: functor Functor<Row>) - (def: wrap (|>> sequence)) + (def: wrap (|>> row)) (def: join - (let [(^open) Fold<Sequence> - (^open) Monoid<Sequence>] + (let [(^open) Fold<Row> + (^open) Monoid<Row>] (fold (function (_ post pre) (compose pre post)) identity)))) (def: #export (reverse xs) - (All [a] (-> (Sequence a) (Sequence a))) - (let [(^open) Fold<Sequence> - (^open) Monoid<Sequence>] + (All [a] (-> (Row a) (Row a))) + (let [(^open) Fold<Row> + (^open) Monoid<Row>] (fold add identity xs))) |