From 4f4656b278c6f9dfbdd15d5d9bc86d63c5b44333 Mon Sep 17 00:00:00 2001 From: Eduardo Julian Date: Wed, 15 Sep 2021 20:22:07 -0400 Subject: "Sequence" => "Stream" --- 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 +++++++++++++++++++++ 4 files changed, 137 insertions(+), 137 deletions(-) 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/source/test') 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