aboutsummaryrefslogtreecommitdiff
path: root/stdlib/test
diff options
context:
space:
mode:
Diffstat (limited to 'stdlib/test')
-rw-r--r--stdlib/test/test/lux/data/coll/array.lux80
1 files changed, 40 insertions, 40 deletions
diff --git a/stdlib/test/test/lux/data/coll/array.lux b/stdlib/test/test/lux/data/coll/array.lux
index 81f8144d2..d5fde5a64 100644
--- a/stdlib/test/test/lux/data/coll/array.lux
+++ b/stdlib/test/test/lux/data/coll/array.lux
@@ -3,7 +3,7 @@
(lux (control [monad #+ do Monad]
pipe)
[io]
- (data (coll ["&" array]
+ (data (coll ["@" array]
[list])
[number]
[maybe])
@@ -18,72 +18,72 @@
(context: "Arrays and their copies"
[size bounded-size
original (R;array size R;nat)
- #let [clone (&;clone original)
- copy (: (&;Array Nat)
- (&;new size))
- manual-copy (: (&;Array Nat)
- (&;new size))]]
+ #let [clone (@;clone original)
+ copy (: (Array Nat)
+ (@;new size))
+ manual-copy (: (Array Nat)
+ (@;new size))]]
($_ seq
(test "Size function must correctly return size of array."
- (n.= size (&;size original)))
+ (n.= size (@;size original)))
(test "Cloning an array should yield and identical array, but not the same one."
- (and (:: (&;Eq<Array> number;Eq<Nat>) = original clone)
+ (and (:: (@;Eq<Array> number;Eq<Nat>) = original clone)
(not (is original clone))))
(test "Full-range manual copies should give the same result as cloning."
- (exec (&;copy size +0 original +0 copy)
- (and (:: (&;Eq<Array> number;Eq<Nat>) = original copy)
+ (exec (@;copy size +0 original +0 copy)
+ (and (:: (@;Eq<Array> number;Eq<Nat>) = original copy)
(not (is original copy)))))
(test "Array folding should go over all values."
- (exec (:: &;Fold<Array> fold
+ (exec (:: @;Fold<Array> fold
(function [x idx]
- (exec (&;put idx x manual-copy)
+ (exec (@;write idx x manual-copy)
(n.inc idx)))
+0
original)
- (:: (&;Eq<Array> number;Eq<Nat>) = original manual-copy)))
+ (:: (@;Eq<Array> number;Eq<Nat>) = original manual-copy)))
(test "Transformations between (full) arrays and lists shouldn't cause lose or change any values."
(|> original
- &;to-list &;from-list
- (:: (&;Eq<Array> number;Eq<Nat>) = original)))
+ @;to-list @;from-list
+ (:: (@;Eq<Array> number;Eq<Nat>) = original)))
))
(context: "Array mutation"
[size bounded-size
idx (:: @ map (n.% size) R;nat)
array (|> (R;array size R;nat)
- (R;filter (|>. &;to-list (list;any? n.odd?))))
- #let [value (maybe;assume (&;get idx array))]]
+ (R;filter (|>. @;to-list (list;any? n.odd?))))
+ #let [value (maybe;assume (@;read idx array))]]
($_ seq
(test "Shouldn't be able to find a value in an unoccupied cell."
- (case (&;get idx (&;remove idx array))
+ (case (@;read idx (@;delete idx array))
(#;Some _) false
#;None true))
(test "You should be able to access values put into the array."
- (case (&;get idx (&;put idx value array))
+ (case (@;read idx (@;write idx value array))
(#;Some value') (n.= value' value)
#;None false))
(test "All cells should be occupied on a full array."
- (and (n.= size (&;occupied array))
- (n.= +0 (&;vacant array))))
+ (and (n.= size (@;occupied array))
+ (n.= +0 (@;vacant array))))
(test "Filtering mutates the array to remove invalid values."
- (exec (&;filter n.even? array)
- (and (n.< size (&;occupied array))
- (n.> +0 (&;vacant array))
- (n.= size (n.+ (&;occupied array)
- (&;vacant array))))))
+ (exec (@;filter n.even? array)
+ (and (n.< size (@;occupied array))
+ (n.> +0 (@;vacant array))
+ (n.= size (n.+ (@;occupied array)
+ (@;vacant array))))))
))
(context: "Finding values."
[size bounded-size
array (|> (R;array size R;nat)
- (R;filter (|>. &;to-list (list;any? n.even?))))]
+ (R;filter (|>. @;to-list (list;any? n.even?))))]
($_ seq
(test "Can find values inside arrays."
- (|> (&;find n.even? array)
+ (|> (@;find n.even? array)
(case> (#;Some _) true
#;None false)))
(test "Can find values inside arrays (with access to indices)."
- (|> (&;find+ (function [idx n]
+ (|> (@;find+ (function [idx n]
(and (n.even? n)
(n.< size idx)))
array)
@@ -93,8 +93,8 @@
(context: "Functor"
[size bounded-size
array (R;array size R;nat)]
- (let [(^open) &;Functor<Array>
- (^open) (&;Eq<Array> number;Eq<Nat>)]
+ (let [(^open) @;Functor<Array>
+ (^open) (@;Eq<Array> number;Eq<Nat>)]
($_ seq
(test "Functor shouldn't alter original array."
(let [copy (map id array)]
@@ -111,20 +111,20 @@
sizeR bounded-size
left (R;array sizeL R;nat)
right (R;array sizeR R;nat)
- #let [(^open) &;Monoid<Array>
- (^open) (&;Eq<Array> number;Eq<Nat>)
+ #let [(^open) @;Monoid<Array>
+ (^open) (@;Eq<Array> number;Eq<Nat>)
fusion (compose left right)]]
($_ seq
(test "Appending two arrays should produce a new one twice as large."
- (n.= (n.+ sizeL sizeR) (&;size fusion)))
+ (n.= (n.+ sizeL sizeR) (@;size fusion)))
(test "First elements of fused array should equal the first array."
- (|> (: (&;Array Nat)
- (&;new sizeL))
- (&;copy sizeL +0 fusion +0)
+ (|> (: (Array Nat)
+ (@;new sizeL))
+ (@;copy sizeL +0 fusion +0)
(= left)))
(test "Last elements of fused array should equal the second array."
- (|> (: (&;Array Nat)
- (&;new sizeR))
- (&;copy sizeR sizeL fusion +0)
+ (|> (: (Array Nat)
+ (@;new sizeR))
+ (@;copy sizeR sizeL fusion +0)
(= right)))
))