aboutsummaryrefslogtreecommitdiff
path: root/stdlib/source
diff options
context:
space:
mode:
Diffstat (limited to 'stdlib/source')
-rw-r--r--stdlib/source/lux/control/transform.lux133
1 files changed, 60 insertions, 73 deletions
diff --git a/stdlib/source/lux/control/transform.lux b/stdlib/source/lux/control/transform.lux
index 9c26d4df4..6376a9554 100644
--- a/stdlib/source/lux/control/transform.lux
+++ b/stdlib/source/lux/control/transform.lux
@@ -20,9 +20,8 @@
[cs (-> cv cs (Result cs))])
(type: #export (Step v s)
- (#Yield s v)
- (#Skip s)
- #Done)
+ (#Continue s (Maybe v))
+ #Stop)
(type: #export (Transform pv cv ts)
[ts (-> pv ts (Step cv ts))])
@@ -37,22 +36,19 @@
[[init|prev init|next]
(function [input [state|prev state|next]]
(case (step|prev input state|prev)
- (#Yield state|prev' temp)
+ (#Continue state|prev' (#.Some temp))
(case (step|next temp state|next)
- (#Yield state|next' output)
- (#Yield [state|prev' state|next'] output)
+ (#Continue state|next' ?output)
+ (#Continue [state|prev' state|next'] ?output)
- (#Skip state|next')
- (#Skip [state|prev' state|next'])
-
- #Done
- #Done)
+ #Stop
+ #Stop)
- (#Skip state|prev')
- (#Skip [state|prev' state|next])
+ (#Continue state|prev' #.None)
+ (#Continue [state|prev' state|next] #.None)
- #Done
- #Done))]))
+ #Stop
+ #Stop))]))
(def: #export (each left right)
(All [a l r ls rs]
@@ -64,19 +60,19 @@
(function [input [state|left state|right]]
(case [(step|left input state|left)
(step|right input state|right)]
- [(#Yield state|left' output|left)
- (#Yield state|right' output|right)]
- (#Yield [state|left' state|right']
- [output|left output|right])
+ [(#Continue state|left' (#.Some output|left))
+ (#Continue state|right' (#.Some output|right))]
+ (#Continue [state|left' state|right']
+ (#.Some [output|left output|right]))
- (^or [#Done _] [_ #Done])
- #Done
+ (^or [#Stop _] [_ #Stop])
+ #Stop
- [(#Skip state|left') _]
- (#Skip [state|left' state|right])
+ [(#Continue state|left' #.None) _]
+ (#Continue [state|left' state|right] #.None)
- [_ (#Skip state|right')]
- (#Skip [state|left state|right'])))]))
+ [_ (#Continue state|right' #.None)]
+ (#Continue [state|left state|right'] #.None)))]))
(def: #export (either left right)
(All [a b ls rs]
@@ -87,22 +83,22 @@
[[init|left init|right]
(function [input [state|left state|right]]
(case (step|left input state|left)
- (#Yield state|left' output)
- (#Yield [state|left' state|right] output)
+ (#Continue state|left' (#.Some output))
+ (#Continue [state|left' state|right] (#.Some output))
(^template [<case> <left-state> <done>]
<case>
(case (step|right input state|right)
- (#Yield state|right' output)
- (#Yield [<left-state> state|right'] output)
+ (#Continue state|right' (#.Some output))
+ (#Continue [<left-state> state|right'] (#.Some output))
- (#Skip state|right')
- (#Skip [<left-state> state|right'])
+ (#Continue state|right' #.None)
+ (#Continue [<left-state> state|right'] #.None)
- #Done
+ #Stop
<done>))
- ([(#Skip state|left') state|left' (#Skip [state|left' state|right])]
- [#Done state|left #Done])
+ ([(#Continue state|left' #.None) state|left' (#Continue [state|left' state|right] #.None)]
+ [#Stop state|left #Stop])
))]))
(def: #export (run transform producer consumer)
@@ -122,7 +118,7 @@
(let [output (case (produce state|producer)
(#.Some [production state|producer'])
(case (step production state|transform)
- (#Yield state|transform' temp)
+ (#Continue state|transform' (#.Some temp))
(case (consume temp state|consumer)
(#Partial state|consumer')
(recur state|transform' state|producer' state|consumer')
@@ -130,10 +126,10 @@
(#Total output)
output)
- (#Skip state|transform')
+ (#Continue state|transform' #.None)
(recur state|transform' state|producer' state|consumer)
- #Done
+ #Stop
state|consumer)
#.None
@@ -164,67 +160,57 @@
(All [a b] (-> (-> a b) (Transform a b Unit)))
[[]
(function [input state]
- (#Yield state (f input)))])
+ (#Continue state (#.Some (f input))))])
(def: #export (map-indexed f)
(All [a b] (-> (-> Nat a b) (Transform a b Nat)))
[+0
(function [input index]
- (#Yield (n/inc index) (f index input)))])
+ (#Continue (n/inc index) (#.Some (f index input))))])
(def: #export (filter pred)
(All [a] (-> (-> a Bool) (Transform a a Unit)))
[[]
(function [input state]
- (if (pred input)
- (#Yield state input)
- (#Skip state)))])
+ (#Continue state (if (pred input)
+ (#.Some input)
+ #.None)))])
(def: #export (keep f)
(All [a b] (-> (-> a (Maybe b)) (Transform a b Unit)))
[[]
(function [input state]
- (case (f input)
- (#.Some output)
- (#Yield state output)
-
- #.None
- (#Skip state)))])
+ (#Continue state (f input)))])
(def: #export (keep-indexed f)
(All [a b] (-> (-> Nat a (Maybe b)) (Transform a b Nat)))
[+0
(function [input index]
- (case (f index input)
- (#.Some output)
- (#Yield (n/inc index) output)
-
- #.None
- (#Skip (n/inc index))))])
+ (#Continue (n/inc index) (f index input)))])
(def: #export (take amount)
(All [a] (-> Nat (Transform a a Nat)))
[amount
(function [input remaining]
(if (n/= +0 remaining)
- #Done
- (#Yield (n/dec remaining) input)))])
+ #Stop
+ (#Continue (n/dec remaining) (#.Some input))))])
(def: #export (drop amount)
(All [a] (-> Nat (Transform a a Nat)))
[amount
(function [input remaining]
(if (n/= +0 remaining)
- (#Yield remaining input)
- (#Skip (n/dec remaining))))])
+ (#Continue remaining (#.Some input))
+ (#Continue (n/dec remaining) #.None)))])
(def: #export (take-while pred)
(All [a] (-> (-> a Bool) (Transform a a Unit)))
[[]
(function [input state]
(if (pred input)
- (#Yield state input)
- #Done))])
+ (#Continue state (#.Some input))
+ #Stop))])
(def: #export (drop-while pred)
(All [a] (-> (-> a Bool) (Transform a a Bool)))
@@ -232,8 +218,8 @@
(function [input dropping?]
(if (and dropping?
(pred input))
- (#Skip true)
- (#Yield false input)))])
+ (#Continue true #.None)
+ (#Continue false (#.Some input))))])
(def: #export (take-nth nth)
(All [a] (-> Nat (Transform a a Nat)))
@@ -241,8 +227,8 @@
(function [input seen]
(let [mod (n/% nth (n/inc seen))]
(if (n/= +0 mod)
- (#Yield mod input)
- (#Skip mod))))])
+ (#Continue mod (#.Some input))
+ (#Continue mod #.None))))])
(def: #export (drop-nth nth)
(All [a] (-> Nat (Transform a a Nat)))
@@ -250,16 +236,16 @@
(function [input seen]
(let [mod (n/% nth (n/inc seen))]
(if (n/= +0 mod)
- (#Skip mod)
- (#Yield mod input))))])
+ (#Continue mod #.None)
+ (#Continue mod (#.Some input)))))])
(def: #export (distinct Hash<a>)
(All [a] (-> (Hash a) (Transform a a (Set a))))
[(set.new Hash<a>)
(function [input seen]
(if (set.member? seen input)
- (#Skip seen)
- (#Yield (set.add input seen) input)))])
+ (#Continue seen #.None)
+ (#Continue (set.add input seen) (#.Some input))))])
(def: #export (de-duplicate Eq<a>)
(All [a] (-> (Eq a) (Transform a a (Maybe a))))
@@ -267,10 +253,10 @@
(function [input last]
(case last
(^multi (#.Some last') (:: Eq<a> = last' input))
- (#Skip last)
+ (#Continue last #.None)
_
- (#Yield (#.Some input) input)))])
+ (#Continue (#.Some input) (#.Some input))))])
(def: #export (random probability prng)
(All [a] (-> Deg PRNG (Transform a a PRNG)))
@@ -278,8 +264,8 @@
(function [input prng]
(let [[prng' chance] (r.run prng r.deg)]
(if (d/< probability chance)
- (#Yield prng' input)
- (#Skip prng'))))])
+ (#Continue prng' (#.Some input))
+ (#Continue prng' #.None))))])
(def: #export (replace dict)
(All [a] (-> (Dict a a) (Transform a a Unit)))
@@ -288,4 +274,5 @@
(|> dict
(dict.get input)
(maybe.default input)
- (#Yield state)))])
+ #.Some
+ (#Continue state)))])