From 4f4656b278c6f9dfbdd15d5d9bc86d63c5b44333 Mon Sep 17 00:00:00 2001 From: Eduardo Julian Date: Wed, 15 Sep 2021 20:22:07 -0400 Subject: "Sequence" => "Stream" --- .../source/documentation/lux/data/collection.lux | 4 +- .../documentation/lux/data/collection/sequence.lux | 77 ------------ .../documentation/lux/data/collection/stream.lux | 76 +++++++++++ .../library/lux/data/collection/sequence.lux | 140 --------------------- .../source/library/lux/data/collection/stream.lux | 140 +++++++++++++++++++++ stdlib/source/library/lux/documentation.lux | 14 +-- stdlib/source/test/lux/abstract/comonad/cofree.lux | 24 ++-- stdlib/source/test/lux/data/collection.lux | 4 +- .../source/test/lux/data/collection/sequence.lux | 123 ------------------ stdlib/source/test/lux/data/collection/stream.lux | 123 ++++++++++++++++++ 10 files changed, 362 insertions(+), 363 deletions(-) delete mode 100644 stdlib/source/documentation/lux/data/collection/sequence.lux create mode 100644 stdlib/source/documentation/lux/data/collection/stream.lux delete mode 100644 stdlib/source/library/lux/data/collection/sequence.lux create mode 100644 stdlib/source/library/lux/data/collection/stream.lux delete mode 100644 stdlib/source/test/lux/data/collection/sequence.lux create mode 100644 stdlib/source/test/lux/data/collection/stream.lux (limited to 'stdlib') diff --git a/stdlib/source/documentation/lux/data/collection.lux b/stdlib/source/documentation/lux/data/collection.lux index 7d4e0a6bc..9fae3d77f 100644 --- a/stdlib/source/documentation/lux/data/collection.lux +++ b/stdlib/source/documentation/lux/data/collection.lux @@ -14,7 +14,7 @@ ["[1][0]" list] ["[1][0]" queue] ["[1][0]" row] - ["[1][0]" sequence] + ["[1][0]" stream] ["[1][0]" stack] ["[1][0]" set] ["[1][0]" tree]]) @@ -28,7 +28,7 @@ /list.documentation /queue.documentation /row.documentation - /sequence.documentation + /stream.documentation /stack.documentation /set.documentation /tree.documentation diff --git a/stdlib/source/documentation/lux/data/collection/sequence.lux b/stdlib/source/documentation/lux/data/collection/sequence.lux deleted file mode 100644 index 1bbf4db94..000000000 --- a/stdlib/source/documentation/lux/data/collection/sequence.lux +++ /dev/null @@ -1,77 +0,0 @@ -(.module: - [library - [lux {"-" list} - ["$" documentation {"+" documentation:}] - [control - ["<>" parser - ["<[0]>" code]]] - [data - ["[0]" text {"+" \n} - ["%" format {"+" format}]]] - [macro - [syntax {"+" syntax:}] - ["[0]" code] - ["[0]" template]]]] - [\\library - ["[0]" /]]) - -(documentation: (/.Sequence it) - "An infinite sequence of values.") - -(documentation: /.iterations - "A stateful way of infinitely calculating the values of a sequence." - [(iterations step init)]) - -(documentation: /.repeated - "Repeat a value forever." - [(repeated x)]) - -(documentation: /.cycle - (format "Go over the elements of a list forever." - \n "The list should not be empty.") - [(cycle [start next])]) - -(documentation: /.item - "" - [(item idx sequence)]) - -(documentation: /.only - "A new sequence only with items that satisfy the predicate." - [(only predicate sequence)]) - -(documentation: /.partition - (format "Split a sequence in two based on a predicate." - \n "The left side contains all entries for which the predicate is #1." - \n "The right side contains all entries for which the predicate is #0.") - [(partition left? xs)]) - -(documentation: /.^sequence& - (format "Allows destructuring of sequences in pattern-matching expressions." - \n "Caveat emptor: Only use it for destructuring, and not for testing values within the sequences.") - [(let [(^sequence& x y z _tail) (some_sequence_func +1 +2 +3)] - (func x y z))]) - -(.def: .public documentation - (.List $.Module) - ($.module /._ - "" - [..Sequence - ..iterations - ..repeated - ..cycle - ..item - - ..only - ..partition - ..^sequence& - ($.default /.head) - ($.default /.tail) - ($.default /.functor) - ($.default /.comonad) - ($.default /.while) - ($.default /.until) - ($.default /.first) - ($.default /.after) - ($.default /.split_when) - ($.default /.split_at)] - [])) diff --git a/stdlib/source/documentation/lux/data/collection/stream.lux b/stdlib/source/documentation/lux/data/collection/stream.lux new file mode 100644 index 000000000..9486be114 --- /dev/null +++ b/stdlib/source/documentation/lux/data/collection/stream.lux @@ -0,0 +1,76 @@ +(.module: + [library + [lux {"-" list} + ["$" documentation {"+" documentation:}] + [control + ["<>" parser + ["<[0]>" code]]] + [data + ["[0]" text {"+" \n} + ["%" format {"+" format}]]] + [macro + [syntax {"+" syntax:}] + ["[0]" code] + ["[0]" template]]]] + [\\library + ["[0]" /]]) + +(documentation: (/.Stream it) + "An infinite sequence of values.") + +(documentation: /.iterations + "A stateful way of infinitely calculating the values of a stream." + [(iterations step init)]) + +(documentation: /.repeated + "Repeat a value forever." + [(repeated x)]) + +(documentation: /.cycle + "Go over the elements of a list forever." + [(cycle [start next])]) + +(documentation: /.item + "" + [(item idx stream)]) + +(documentation: /.only + "A new stream only with items that satisfy the predicate." + [(only predicate stream)]) + +(documentation: /.partition + (format "Split a stream in two based on a predicate." + \n "The left side contains all entries for which the predicate is #1." + \n "The right side contains all entries for which the predicate is #0.") + [(partition left? xs)]) + +(documentation: /.^stream& + (format "Allows destructuring of streams in pattern-matching expressions." + \n "Caveat emptor: Only use it for destructuring, and not for testing values within the streams.") + [(let [(^stream& x y z _tail) (some_stream_func +1 +2 +3)] + (func x y z))]) + +(.def: .public documentation + (.List $.Module) + ($.module /._ + "" + [..Stream + ..iterations + ..repeated + ..cycle + ..item + + ..only + ..partition + ..^stream& + ($.default /.head) + ($.default /.tail) + ($.default /.functor) + ($.default /.comonad) + ($.default /.while) + ($.default /.until) + ($.default /.first) + ($.default /.after) + ($.default /.split_when) + ($.default /.split_at)] + [])) diff --git a/stdlib/source/library/lux/data/collection/sequence.lux b/stdlib/source/library/lux/data/collection/sequence.lux deleted file mode 100644 index fcfe2d0ed..000000000 --- a/stdlib/source/library/lux/data/collection/sequence.lux +++ /dev/null @@ -1,140 +0,0 @@ -(.module: - [library - [lux "*" - [abstract - [functor {"+" Functor}] - [comonad {"+" CoMonad}]] - [control - ["//" continuation {"+" Cont}] - ["<>" parser - ["<[0]>" code {"+" Parser}]]] - [macro {"+" with_symbols} - [syntax {"+" syntax:}] - ["[0]" code]] - [data - ["[0]" bit] - [collection - ["[0]" list ("[1]#[0]" monad)]]] - [math - [number - ["n" nat]]]]]) - -(type: .public (Sequence a) - (Cont [a (Sequence a)])) - -(def: .public (iterations step init) - (All (_ a b) - (-> (-> a [a b]) a (Sequence b))) - (let [[next x] (step init)] - (//.pending [x (iterations step next)]))) - -(def: .public (repeated x) - (All (_ a) - (-> a (Sequence a))) - (//.pending [x (repeated x)])) - -(def: .public (cycle [start next]) - (All (_ a) - (-> [a (List a)] (Sequence a))) - (loop [head start - tail next] - (//.pending [head (case tail - {.#End} - (again start next) - - {.#Item head' tail'} - (again head' tail'))]))) - -(template [ ] - [(def: .public ( sequence) - (All (_ a) (-> (Sequence a) )) - (let [[head tail] (//.result sequence)] - ))] - - [head a] - [tail (Sequence a)] - ) - -(def: .public (item idx sequence) - (All (_ a) (-> Nat (Sequence a) a)) - (let [[head tail] (//.result sequence)] - (case idx - 0 head - _ (item (-- idx) tail)))) - -(template [ ] - [(def: .public ( pred xs) - (All (_ a) - (-> (Sequence a) (List a))) - (let [[x xs'] (//.result xs)] - (if ( ) - (list& x ( xs')) - (list)))) - - (def: .public ( pred xs) - (All (_ a) - (-> (Sequence a) (Sequence a))) - (let [[x xs'] (//.result xs)] - (if ( ) - ( xs') - xs)))] - - [while until (-> a Bit) (pred x) pred |>] - [first after Nat (n.= 0 pred) (-- pred) not] - ) - -(template [ ] - [(def: .public ( pred xs) - (All (_ a) - (-> (Sequence a) [(List a) (Sequence a)])) - (let [[x xs'] (//.result xs)] - (if - [(list) xs] - (let [[tail next] ( xs')] - [{.#Item [x tail]} next]))))] - - [split_when (-> a Bit) (pred x) pred] - [split_at Nat (n.= 0 pred) (-- pred)] - ) - -(def: .public (only predicate sequence) - (All (_ a) (-> (-> a Bit) (Sequence a) (Sequence a))) - (let [[head tail] (//.result sequence)] - (if (predicate head) - (//.pending [head (only predicate tail)]) - (only predicate tail)))) - -(def: .public (partition left? xs) - (All (_ a) (-> (-> a Bit) (Sequence a) [(Sequence a) (Sequence a)])) - [(..only left? xs) - (..only (bit.complement left?) xs)]) - -(implementation: .public functor - (Functor Sequence) - - (def: (each f fa) - (let [[head tail] (//.result fa)] - (//.pending [(f head) (each f tail)])))) - -(implementation: .public comonad - (CoMonad Sequence) - - (def: &functor ..functor) - - (def: out head) - - (def: (disjoint wa) - (let [[head tail] (//.result wa)] - (//.pending [wa (disjoint tail)])))) - -(syntax: .public (^sequence& [patterns (.form (<>.many .any)) - body .any - branches (<>.some .any)]) - (with_symbols [g!sequence] - (let [body+ (` (let [(~+ (|> patterns - (list#each (function (_ pattern) - (list (` [(~ pattern) (~ g!sequence)]) - (` ((~! //.result) (~ g!sequence)))))) - list#conjoint))] - (~ body)))] - (in (list& g!sequence body+ branches))))) diff --git a/stdlib/source/library/lux/data/collection/stream.lux b/stdlib/source/library/lux/data/collection/stream.lux new file mode 100644 index 000000000..f09423882 --- /dev/null +++ b/stdlib/source/library/lux/data/collection/stream.lux @@ -0,0 +1,140 @@ +(.module: + [library + [lux "*" + [abstract + [functor {"+" Functor}] + [comonad {"+" CoMonad}]] + [control + ["//" continuation {"+" Cont}] + ["<>" parser + ["<[0]>" code {"+" Parser}]]] + [macro {"+" with_symbols} + [syntax {"+" syntax:}] + ["[0]" code]] + [data + ["[0]" bit] + [collection + ["[0]" list ("[1]#[0]" monad)]]] + [math + [number + ["n" nat]]]]]) + +(type: .public (Stream a) + (Cont [a (Stream a)])) + +(def: .public (iterations step init) + (All (_ a b) + (-> (-> a [a b]) a (Stream b))) + (let [[next x] (step init)] + (//.pending [x (iterations step next)]))) + +(def: .public (repeated x) + (All (_ a) + (-> a (Stream a))) + (//.pending [x (repeated x)])) + +(def: .public (cycle [start next]) + (All (_ a) + (-> [a (List a)] (Stream a))) + (loop [head start + tail next] + (//.pending [head (case tail + {.#End} + (again start next) + + {.#Item head' tail'} + (again head' tail'))]))) + +(template [ ] + [(def: .public ( stream) + (All (_ a) (-> (Stream a) )) + (let [[head tail] (//.result stream)] + ))] + + [head a] + [tail (Stream a)] + ) + +(def: .public (item idx stream) + (All (_ a) (-> Nat (Stream a) a)) + (let [[head tail] (//.result stream)] + (case idx + 0 head + _ (item (-- idx) tail)))) + +(template [ ] + [(def: .public ( pred xs) + (All (_ a) + (-> (Stream a) (List a))) + (let [[x xs'] (//.result xs)] + (if ( ) + (list& x ( xs')) + (list)))) + + (def: .public ( pred xs) + (All (_ a) + (-> (Stream a) (Stream a))) + (let [[x xs'] (//.result xs)] + (if ( ) + ( xs') + xs)))] + + [while until (-> a Bit) (pred x) pred |>] + [first after Nat (n.= 0 pred) (-- pred) not] + ) + +(template [ ] + [(def: .public ( pred xs) + (All (_ a) + (-> (Stream a) [(List a) (Stream a)])) + (let [[x xs'] (//.result xs)] + (if + [(list) xs] + (let [[tail next] ( xs')] + [{.#Item [x tail]} next]))))] + + [split_when (-> a Bit) (pred x) pred] + [split_at Nat (n.= 0 pred) (-- pred)] + ) + +(def: .public (only predicate stream) + (All (_ a) (-> (-> a Bit) (Stream a) (Stream a))) + (let [[head tail] (//.result stream)] + (if (predicate head) + (//.pending [head (only predicate tail)]) + (only predicate tail)))) + +(def: .public (partition left? xs) + (All (_ a) (-> (-> a Bit) (Stream a) [(Stream a) (Stream a)])) + [(..only left? xs) + (..only (bit.complement left?) xs)]) + +(implementation: .public functor + (Functor Stream) + + (def: (each f fa) + (let [[head tail] (//.result fa)] + (//.pending [(f head) (each f tail)])))) + +(implementation: .public comonad + (CoMonad Stream) + + (def: &functor ..functor) + + (def: out head) + + (def: (disjoint wa) + (let [[head tail] (//.result wa)] + (//.pending [wa (disjoint tail)])))) + +(syntax: .public (^stream& [patterns (.form (<>.many .any)) + body .any + branches (<>.some .any)]) + (with_symbols [g!stream] + (let [body+ (` (let [(~+ (|> patterns + (list#each (function (_ pattern) + (list (` [(~ pattern) (~ g!stream)]) + (` ((~! //.result) (~ g!stream)))))) + list#conjoint))] + (~ body)))] + (in (list& g!stream body+ branches))))) diff --git a/stdlib/source/library/lux/documentation.lux b/stdlib/source/library/lux/documentation.lux index 5bd6f7f30..ec99259f9 100644 --- a/stdlib/source/library/lux/documentation.lux +++ b/stdlib/source/library/lux/documentation.lux @@ -18,7 +18,7 @@ [collection ["[0]" list ("[1]#[0]" monad mix monoid)] ["[0]" set {"+" Set}] - ["[0]" sequence {"+" Sequence}]] + ["[0]" stream {"+" Stream}]] [format ["md" markdown {"+" Markdown Block}]]] ["[0]" macro @@ -165,9 +165,9 @@ ) (def: type_variable_names - (Sequence Text) - (sequence.iterations (product.forked ++ parameter_type_name) - 0)) + (Stream Text) + (stream.iterations (product.forked ++ parameter_type_name) + 0)) (template [ ] [(def: ( id) @@ -193,9 +193,9 @@ _ (let [parameter_id (n.- (list.size type_function_arguments) parameter_id)] (|> type_variable_names - (sequence.only (function (_ var_name) - (not (list.member? text.equivalence type_function_arguments var_name)))) - (sequence.item parameter_id))))) + (stream.only (function (_ var_name) + (not (list.member? text.equivalence type_function_arguments var_name)))) + (stream.item parameter_id))))) type_function_name)) (def: (level_parameters offset level) diff --git a/stdlib/source/test/lux/abstract/comonad/cofree.lux b/stdlib/source/test/lux/abstract/comonad/cofree.lux index dca4680de..285628356 100644 --- a/stdlib/source/test/lux/abstract/comonad/cofree.lux +++ b/stdlib/source/test/lux/abstract/comonad/cofree.lux @@ -13,29 +13,29 @@ [data [collection ["[0]" list] - ["[0]" sequence {"+" Sequence} ("[1]#[0]" comonad)]]] + ["[0]" stream {"+" Stream} ("[1]#[0]" comonad)]]] [math ["[0]" random]]]] [\\library ["[0]" /]]) (def: (injection value) - (Injection (/.CoFree Sequence)) - [value (sequence#each injection (sequence.repeated value))]) + (Injection (/.CoFree Stream)) + [value (stream#each injection (stream.repeated value))]) (def: (interpret [head tail]) - (All (_ a) (-> (/.CoFree Sequence a) (Sequence a))) + (All (_ a) (-> (/.CoFree Stream a) (Stream a))) (|> tail - (sequence#each (# (/.comonad sequence.functor) out)) + (stream#each (# (/.comonad stream.functor) out)) [head] //.pending)) (def: comparison - (Comparison (/.CoFree Sequence)) + (Comparison (/.CoFree Stream)) (function (_ == left right) (# (list.equivalence ==) = - (sequence.first 100 (..interpret left)) - (sequence.first 100 (..interpret right))))) + (stream.first 100 (..interpret left)) + (stream.first 100 (..interpret right))))) (def: .public test Test @@ -43,9 +43,9 @@ (_.for [/.CoFree]) ($_ _.and (_.for [/.functor] - ($functor.spec ..injection ..comparison (: (Functor (/.CoFree Sequence)) - (/.functor sequence.functor)))) + ($functor.spec ..injection ..comparison (: (Functor (/.CoFree Stream)) + (/.functor stream.functor)))) (_.for [/.comonad] - ($comonad.spec ..injection ..comparison (: (CoMonad (/.CoFree Sequence)) - (/.comonad sequence.functor)))) + ($comonad.spec ..injection ..comparison (: (CoMonad (/.CoFree Stream)) + (/.comonad stream.functor)))) ))) diff --git a/stdlib/source/test/lux/data/collection.lux b/stdlib/source/test/lux/data/collection.lux index 4d7de7ed5..e4caad8c8 100644 --- a/stdlib/source/test/lux/data/collection.lux +++ b/stdlib/source/test/lux/data/collection.lux @@ -7,7 +7,7 @@ ["[1][0]" bits] ["[1][0]" list] ["[1][0]" row] - ["[1][0]" sequence] + ["[1][0]" stream] ["[1][0]" stack] ["[1][0]" dictionary ["[1]/[0]" ordered] @@ -59,7 +59,7 @@ /bits.test /list.test /row.test - /sequence.test + /stream.test /stack.test ..dictionary ..queue diff --git a/stdlib/source/test/lux/data/collection/sequence.lux b/stdlib/source/test/lux/data/collection/sequence.lux deleted file mode 100644 index 22dc1b37e..000000000 --- a/stdlib/source/test/lux/data/collection/sequence.lux +++ /dev/null @@ -1,123 +0,0 @@ -(.module: - [library - [lux "*" - ["_" test {"+" Test}] - [abstract - [monad {"+" do}] - [equivalence {"+" Equivalence}] - ["[0]" enum] - [\\specification - ["$[0]" functor] - ["$[0]" comonad]]] - [data - ["[0]" text - ["%" format {"+" format}]] - [collection - ["[0]" list ("[1]#[0]" functor)]]] - [math - ["[0]" random] - [number - ["n" nat]]]]] - [\\library - ["[0]" /]]) - -(implementation: (equivalence super) - (All (_ a) (-> (Equivalence a) (Equivalence (/.Sequence a)))) - - (def: (= reference subject) - (# (list.equivalence super) = - (/.first 100 reference) - (/.first 100 subject)))) - -(def: (iterations step) - (All (_ a) - (-> (-> a a) - (-> a (/.Sequence a)))) - (/.iterations - (function (_ state) - (let [state' (step state)] - [state' state])))) - -(def: .public test - Test - (<| (_.covering /._) - (_.for [/.Sequence]) - (let [(^open "list#[0]") (list.equivalence n.equivalence)]) - (do [! random.monad] - [repeated random.nat - index (# ! each (n.% 100) random.nat) - size (# ! each (|>> (n.% 10) ++) random.nat) - offset (# ! each (n.% 100) random.nat) - cycle_start random.nat - cycle_next (random.list size random.nat)] - ($_ _.and - (_.for [/.functor] - ($functor.spec /.repeated ..equivalence /.functor)) - (_.for [/.comonad] - ($comonad.spec /.repeated ..equivalence /.comonad)) - - (_.cover [/.item] - (n.= (n.+ offset index) - (/.item index (..iterations ++ offset)))) - (_.cover [/.repeated] - (n.= repeated - (/.item index (/.repeated repeated)))) - (_.cover [/.first] - (list#= (enum.range n.enum offset (-- (n.+ size offset))) - (/.first size (..iterations ++ offset)))) - (_.cover [/.after] - (list#= (enum.range n.enum offset (-- (n.+ size offset))) - (/.first size (/.after offset (..iterations ++ 0))))) - (_.cover [/.split_at] - (let [[drops takes] (/.split_at size (..iterations ++ 0))] - (and (list#= (enum.range n.enum 0 (-- size)) - drops) - (list#= (enum.range n.enum size (-- (n.* 2 size))) - (/.first size takes))))) - (_.cover [/.while] - (list#= (enum.range n.enum 0 (-- size)) - (/.while (n.< size) (..iterations ++ 0)))) - (_.cover [/.until] - (list#= (enum.range n.enum offset (-- (n.+ size offset))) - (/.while (n.< (n.+ size offset)) - (/.until (n.< offset) (..iterations ++ 0))))) - (_.cover [/.split_when] - (let [[drops takes] (/.split_when (n.= size) (..iterations ++ 0))] - (and (list#= (enum.range n.enum 0 (-- size)) - drops) - (list#= (enum.range n.enum size (-- (n.* 2 size))) - (/.while (n.< (n.* 2 size)) takes))))) - (_.cover [/.head] - (n.= offset - (/.head (..iterations ++ offset)))) - (_.cover [/.tail] - (list#= (enum.range n.enum (++ offset) (n.+ size offset)) - (/.first size (/.tail (..iterations ++ offset))))) - (_.cover [/.only] - (list#= (list#each (n.* 2) (enum.range n.enum 0 (-- size))) - (/.first size (/.only n.even? (..iterations ++ 0))))) - (_.cover [/.partition] - (let [[evens odds] (/.partition n.even? (..iterations ++ 0))] - (and (n.= (n.* 2 offset) - (/.item offset evens)) - (n.= (++ (n.* 2 offset)) - (/.item offset odds))))) - (_.cover [/.iterations] - (let [(^open "/#[0]") /.functor - (^open "list#[0]") (list.equivalence text.equivalence)] - (list#= (/.first size - (/#each %.nat (..iterations ++ offset))) - (/.first size - (/.iterations (function (_ n) [(++ n) (%.nat n)]) - offset))))) - (_.cover [/.cycle] - (let [cycle (list& cycle_start cycle_next)] - (list#= (list.together (list.repeated size cycle)) - (/.first (n.* size (list.size cycle)) - (/.cycle [cycle_start cycle_next]))))) - (_.cover [/.^sequence&] - (let [(/.^sequence& first second third next) (..iterations ++ offset)] - (and (n.= offset first) - (n.= (n.+ 1 offset) second) - (n.= (n.+ 2 offset) third)))) - )))) diff --git a/stdlib/source/test/lux/data/collection/stream.lux b/stdlib/source/test/lux/data/collection/stream.lux new file mode 100644 index 000000000..bd73a3204 --- /dev/null +++ b/stdlib/source/test/lux/data/collection/stream.lux @@ -0,0 +1,123 @@ +(.module: + [library + [lux "*" + ["_" test {"+" Test}] + [abstract + [monad {"+" do}] + [equivalence {"+" Equivalence}] + ["[0]" enum] + [\\specification + ["$[0]" functor] + ["$[0]" comonad]]] + [data + ["[0]" text + ["%" format {"+" format}]] + [collection + ["[0]" list ("[1]#[0]" functor)]]] + [math + ["[0]" random] + [number + ["n" nat]]]]] + [\\library + ["[0]" /]]) + +(implementation: (equivalence super) + (All (_ a) (-> (Equivalence a) (Equivalence (/.Stream a)))) + + (def: (= reference subject) + (# (list.equivalence super) = + (/.first 100 reference) + (/.first 100 subject)))) + +(def: (iterations step) + (All (_ a) + (-> (-> a a) + (-> a (/.Stream a)))) + (/.iterations + (function (_ state) + (let [state' (step state)] + [state' state])))) + +(def: .public test + Test + (<| (_.covering /._) + (_.for [/.Stream]) + (let [(^open "list#[0]") (list.equivalence n.equivalence)]) + (do [! random.monad] + [repeated random.nat + index (# ! each (n.% 100) random.nat) + size (# ! each (|>> (n.% 10) ++) random.nat) + offset (# ! each (n.% 100) random.nat) + cycle_start random.nat + cycle_next (random.list size random.nat)] + ($_ _.and + (_.for [/.functor] + ($functor.spec /.repeated ..equivalence /.functor)) + (_.for [/.comonad] + ($comonad.spec /.repeated ..equivalence /.comonad)) + + (_.cover [/.item] + (n.= (n.+ offset index) + (/.item index (..iterations ++ offset)))) + (_.cover [/.repeated] + (n.= repeated + (/.item index (/.repeated repeated)))) + (_.cover [/.first] + (list#= (enum.range n.enum offset (-- (n.+ size offset))) + (/.first size (..iterations ++ offset)))) + (_.cover [/.after] + (list#= (enum.range n.enum offset (-- (n.+ size offset))) + (/.first size (/.after offset (..iterations ++ 0))))) + (_.cover [/.split_at] + (let [[drops takes] (/.split_at size (..iterations ++ 0))] + (and (list#= (enum.range n.enum 0 (-- size)) + drops) + (list#= (enum.range n.enum size (-- (n.* 2 size))) + (/.first size takes))))) + (_.cover [/.while] + (list#= (enum.range n.enum 0 (-- size)) + (/.while (n.< size) (..iterations ++ 0)))) + (_.cover [/.until] + (list#= (enum.range n.enum offset (-- (n.+ size offset))) + (/.while (n.< (n.+ size offset)) + (/.until (n.< offset) (..iterations ++ 0))))) + (_.cover [/.split_when] + (let [[drops takes] (/.split_when (n.= size) (..iterations ++ 0))] + (and (list#= (enum.range n.enum 0 (-- size)) + drops) + (list#= (enum.range n.enum size (-- (n.* 2 size))) + (/.while (n.< (n.* 2 size)) takes))))) + (_.cover [/.head] + (n.= offset + (/.head (..iterations ++ offset)))) + (_.cover [/.tail] + (list#= (enum.range n.enum (++ offset) (n.+ size offset)) + (/.first size (/.tail (..iterations ++ offset))))) + (_.cover [/.only] + (list#= (list#each (n.* 2) (enum.range n.enum 0 (-- size))) + (/.first size (/.only n.even? (..iterations ++ 0))))) + (_.cover [/.partition] + (let [[evens odds] (/.partition n.even? (..iterations ++ 0))] + (and (n.= (n.* 2 offset) + (/.item offset evens)) + (n.= (++ (n.* 2 offset)) + (/.item offset odds))))) + (_.cover [/.iterations] + (let [(^open "/#[0]") /.functor + (^open "list#[0]") (list.equivalence text.equivalence)] + (list#= (/.first size + (/#each %.nat (..iterations ++ offset))) + (/.first size + (/.iterations (function (_ n) [(++ n) (%.nat n)]) + offset))))) + (_.cover [/.cycle] + (let [cycle (list& cycle_start cycle_next)] + (list#= (list.together (list.repeated size cycle)) + (/.first (n.* size (list.size cycle)) + (/.cycle [cycle_start cycle_next]))))) + (_.cover [/.^stream&] + (let [(/.^stream& first second third next) (..iterations ++ offset)] + (and (n.= offset first) + (n.= (n.+ 1 offset) second) + (n.= (n.+ 2 offset) third)))) + )))) -- cgit v1.2.3