diff --git a/example/list.sw b/example/list.sw index eb49f8521..8f5619611 100644 --- a/example/list.sw +++ b/example/list.sw @@ -1,3 +1,4 @@ + /*******************************************************************/ /* LIST ENCODING IN INT */ /* */ @@ -8,37 +9,39 @@ /* */ /* For examples of usage see the unit tests in testLIST function. */ /* */ -/*******************************************************************/ +/* NOTE THAT THIS IS NOT EFFICIENT OR ERGONIMIC!!! YOU SHOULD USE: */ +tydef NormalListType a = rec l. Unit + (a * l) end + +/* */ +/* This code was written before swarm had 'format' or 'rec', but */ +/* it still serves as an example of pure swarm code with tests. */ +/*******************************************************************/ +// // Definitions: // - MAIN: nil (Haskell []), cons (Haskell (:)), head, tail // - BONUS: headTail, index, for, for_each, for_each_i // - ARITH: len, mod, shiftL, shiftR, shiftLH, shiftRH // - HELPERS: consP, getLenPart, setLenPart, to1numA, getLenA // - TESTS: assert, testLIST, testLIST_BIG, testLIST_ALL - +// /*******************************************************************/ /* TYPE */ /*******************************************************************/ - // Type of list of ints - the inner ints can themselves be lists, // so *any* type can be encoded inside. // // It is the callers responsibility to make sure a program using this // "type" is type safe. Notably 2 == [0] != [] == 0 but [] !! x == 0. -// -// TODO: once #153 is resolved, add types to definitions -// -// type ListI = Int +tydef ListI = Int end + /*******************************************************************/ /* LAYOUT */ /*******************************************************************/ - // The length of a number is kept in the header and split into 7bit // chunks each prefixed by 1bit that marks if the byte is last in // the header (0=YES). - /* EXAMPLE - [short_x,long_y] - concretly e.g. [42, 2^(2^7)] 0 < len short_x < 2^7 @@ -50,265 +53,254 @@ vvvvvvvvvvvv vvvvvvvvvvvvvvvvvvvvvvvvv vvv ^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ head tail */ - /*******************************************************************/ /* ARITH PRIMITIVES */ /*******************************************************************/ - // bitlength of a number (shifting by one) -def naive_len : Int -> Int = \i. - if (i == 0) {0} {1 + naive_len (i/2)} +def naive_len: Int -> Int -> Int + = \acc. \i. + if (i == 0) {acc} {naive_len (1 + acc) (i / 2)} end + // modulus function (%) -def mod : Int -> Int -> Int = \i.\m. - i - m * (i / m) -end +def mod: Int -> Int -> Int = \i. \m. i - m * (i / m) end + // f X Y = Y * 2^(-X) -def shiftL : Int -> Int -> Int = \s.\i. - i / 2^s -end +def shiftL: Int -> Int -> Int = \s. \i. i / 2 ^ s end + // f X Y = Y * 2^(X) -def shiftR : Int -> Int -> Int = \s.\i. - i * 2^s -end +def shiftR: Int -> Int -> Int = \s. \i. i * 2 ^ s end + // shift by (8bit) bytes -def shiftLH : Int -> Int -> Int = \s. shiftL (s*8) end -def shiftRH : Int -> Int -> Int = \s. shiftR (s*8) end +def shiftLH: Int -> Int -> Int = \s. shiftL (s * 8) end + +def shiftRH: Int -> Int -> Int = \s. shiftR (s * 8) end + -// bitlength of a number (shifting by 64) -def len : Int -> Int = \i. - let next = i / 2^64 in - if (next == 0) {naive_len i} {64 + len next} +// bitlength of a number using an accumulator (shifting by 64) +def len_accum: Int -> Int -> Int + = \acc. \i. + let next = i / 2 ^ 64 in + if (next == 0) {naive_len acc i} {len_accum (acc + 64) next} end + +// bitlength of a number (uses an accumulator and shifts by 64 bits) +def len: Int -> Int = len_accum 0 end + + /*******************************************************************/ /* helper functions */ /*******************************************************************/ +def getLenPart: Int -> Int = \i. mod (i / 2) (2 ^ 7) end + +def setLenPart: Int -> Int = \i. 2 * mod i (2 ^ 7) end -def getLenPart : Int -> Int = \i. mod (i/2) (2^7) end -def setLenPart : Int -> Int = \i. 2 * (mod i (2^7)) end // Split length into 7-bit parts and prefix all but last with 1 -def to1numA : Int -> Int * Int = \i. +def to1numA: Int -> (Int * Int) + = \i. let nextPart = shiftL 7 i in - if (nextPart == 0) - { ((2 * i), 1) } /* last part */ - { let p = to1numA nextPart in - ( 1 /* header isEnd bit */ + setLenPart i + shiftRH 1 (fst p) - , 1 + snd p - ) - } + if (nextPart == 0) { + + // last part + (2 * i, 1) + } { + let p = to1numA nextPart in + (1 /* header isEnd bit */ + setLenPart i + shiftRH 1 (fst p), 1 + snd p) + } end + // Get bitlength of the first number in the list // and also the list starting at the number itself -// -// getLenA : ListI -> Int * Int -def getLenA = \xs. +def getLenA: ListI -> (Int * Int) + = \xs. let isEnd = 0 == mod xs 2 in let l = getLenPart xs in let nextPart = shiftLH 1 xs in - if isEnd - { (l, nextPart) } - { let p = getLenA nextPart in - (l + shiftR 7 (fst p), snd p) - } + if isEnd {(l, nextPart)} { + let p = getLenA nextPart in (l + shiftR 7 (fst p), snd p) + } end + /*******************************************************************/ /* LIST FUNCTIONS */ /*******************************************************************/ - -// headTail : ListI -> {Int} * {ListI} -def headTail = \xs. +def headTail: ListI -> (Int * ListI) + = \xs. let sign = mod xs 2 in let ns = xs / 2 in let p = getLenA ns in - ( { let x = mod (snd p) $ 2 ^ fst p in - if (sign == 0) {x} {-x} - } - , { shiftL (fst p) (snd p) } - ) + ( let x = mod (snd p) $ 2 ^ fst p in if (sign == 0) {x} {-x} + , shiftL (fst p) (snd p) ) end -// head : ListI -> Int -def head : Int -> Int = \xs. - force $ fst $ headTail xs +def head: ListI -> Int + = \xs. + let sign = mod xs 2 in + let ns = xs / 2 in + let p = getLenA ns in + let x = mod (snd p) $ 2 ^ fst p in if (sign == 0) {x} {-x} end -// tail : ListI -> ListI -def tail = \xs. - force $ snd $ headTail xs +def tail: ListI -> ListI + = \xs. + let sign = mod xs 2 in + let ns = xs / 2 in let p = getLenA ns in shiftL (fst p) (snd p) end -// nil : ListI -def nil = 0 end +def nil: ListI = 0 end + // Add non-negative number to beginning of list (cons adds the sign) -// consP : nat -> ListI -> Int -def consP = \x.\xs. - if (x == 0) - { 2 /* header says one bit length */ + shiftR (8+1) xs} - { let l = len x in - let pl = to1numA l in - (fst pl + shiftRH (snd pl) (x + shiftR l xs)) - } +def consP: Int -> ListI -> Int + = \x. \xs. + if (x == 0) {2 /* header says one bit length */ + shiftR (8 + 1) xs} { + let l = len x in + let pl = to1numA l in fst pl + shiftRH (snd pl) (x + shiftR l xs) + } end + // Add integer to the beginning of the list -// consP : Int -> ListI -> ListI -def cons = \x.\xs. - if (x >= 0) - { 2 * consP x xs } - { 1 + 2 * consP (-x) xs } +def cons: Int -> ListI -> ListI + = \x. \xs. + if (x >= 0) {2 * consP x xs} {1 + 2 * consP (-x) xs} end /*******************************************************************/ /* MORE LIST FUNCTIONS */ /*******************************************************************/ - -// index : Int -> ListI -> Int -def index = \i.\xs. - if (i <= 0) - {head xs} - {index (i-1) (tail xs)} +def index: Int -> ListI -> Int + = \i. \xs. + if (i <= 0) {head xs} {index (i - 1) (tail xs)} end -def for : Int -> Int -> (Int -> Cmd a) -> Cmd Unit = \s.\e.\act. - if (s == e) {} - {act s; for (s+1) e act} +def for: ∀ a. Int -> Int -> (Int -> Cmd a) -> Cmd Unit + = \s. \e. \act. + if (s == e) {} {act s; for (s + 1) e act} end -// for_each_i : Int -> ListI Int -> (Int * Int -> Cmd a) -> Cmd Unit -def for_each_i = \i.\xs.\act. - if (xs == nil) {} - { let ht = headTail xs - in act i (force $ fst ht); for_each_i (i+1) (force $ snd ht) act +def for_each_i: Int -> ListI -> (Int -> Int -> Cmd Unit) -> Cmd Unit + = \i. \xs. \act. + if (xs == nil) {} { + let ht = headTail xs in act i (fst ht); for_each_i (i + 1) (snd ht) act } end -// for_each : ListI Int -> (Int -> Cmd a) -> Cmd Unit -def for_each = \xs.\act. +def for_each: ListI -> (Int -> Cmd Unit) -> Cmd Unit + = \xs. \act. for_each_i 0 xs (\i. act) end + /*******************************************************************/ /* UNIT TESTS */ /*******************************************************************/ +def assert = \b. \m. if b {} {log "FAIL:"; fail m} end -// TODO: show values when #248 is implemented -def assert = \b.\m. - if b {} {log "FAIL:"; fail m} +def assert_eq + = \exp. \act. \m. + if (exp == act) {} { + log ("FAIL: expected " ++ format exp ++ " actual " ++ format act); + fail m + } end def testLIST = log "STARTING TESTS OF LIST:"; - log "check [0]"; let l0 = cons 0 nil in - assert (l0 == 4) "[0] ~ 4"; - assert (head l0 == 0) "head [0] == 0"; - assert (tail l0 == nil) "tail [0] == []"; - + assert_eq l0 4 "[0] ~ 4"; + assert_eq (head l0) 0 "head [0] == 0"; + assert_eq (tail l0) nil "tail [0] == []"; log "check [1]"; let l1 = cons 1 nil in - assert (l1 == 516) "[1] ~ 516"; - assert (head l1 == 1) "head [1] == 1"; - assert (tail l1 == nil) "tail [1] == []"; - + assert_eq l1 516 "[1] ~ 516"; + assert_eq (head l1) 1 "head [1] == 1"; + assert_eq (tail l1) nil "tail [1] == []"; log "check [-1]"; let ln1 = cons (-1) nil in - assert (ln1 == 517) "[-1] ~ 517"; - assert (head ln1 == -1) "head [-1] == -1"; - assert (tail ln1 == nil) "tail [-1] == []"; - + assert_eq ln1 517 "[-1] ~ 517"; + assert_eq (head ln1) (-1) "head [-1] == -1"; + assert_eq (tail ln1) nil "tail [-1] == []"; log "check [42]"; let l42 = cons 42 nil in - assert (l42 == 21528) "[42] ~ 21528"; - assert (head l42 == 42) "head [42] == 42"; - assert (tail l42 == nil) "tail [42] == []"; - + assert_eq l42 21528 "[42] ~ 21528"; + assert_eq (head l42) 42 "head [42] == 42"; + assert_eq (tail l42) nil "tail [42] == []"; log "check [499672]"; let l499672 = cons 499672 nil in - assert (l499672 == 255832140) "[499672] ~ 255832140"; - assert (head l499672 == 499672) "head [499672] == 499672"; - assert (tail l499672 == nil) "tail [499672] == []"; - + assert_eq l499672 255832140 "[499672] ~ 255832140"; + assert_eq (head l499672) 499672 "head [499672] == 499672"; + assert_eq (tail l499672) nil "tail [499672] == []"; log "check [1,0]"; let l1_0 = cons 1 l0 in - assert (l1_0 == 4612) "[1,0] ~ 4612"; - assert (head l1_0 == 1) "head [1,0] == 1"; - assert (tail l1_0 == l0) "tail [1,0] == [0]"; - + assert_eq l1_0 4612 "[1,0] ~ 4612"; + assert_eq (head l1_0) 1 "head [1,0] == 1"; + assert_eq (tail l1_0) l0 "tail [1,0] == [0]"; log "check [11,1,0]"; let l11_1_0 = cons 11 l1_0 in - assert (head l11_1_0 == 11) "head [11,1,0] == 11"; - assert (tail l11_1_0 == l1_0) "tail [11,1,0] == [1,0]"; - + assert_eq (head l11_1_0) 11 "head [11,1,0] == 11"; + assert_eq (tail l11_1_0) l1_0 "tail [11,1,0] == [1,0]"; log "check [0..9]"; - let l0__9 = cons 0 $ cons 1 $ cons 2 $ cons 3 $ cons 4 $ cons 5 $ cons 6 $ cons 7 $ cons 8 $ cons 9 nil in - assert (head l0__9 == 0) "head [0..9] == 0"; - - log "check indices"; - assert (index 0 l0__9 == 0) "[0..9] !! 0 == 0"; - assert (index 9 l0__9 == 9) "[0..9] !! 9 == 9"; - - // TODO: log the number of iteration once #248 is implemented - - log "check for"; - for 0 9 (\i. - assert (index i l0__9 == i) "[0..9] - every index I has value I" + let l0__9 = + cons 0 $ cons 1 $ cons 2 $ cons 3 $ cons 4 $ cons 5 $ cons 6 $ cons 7 $ cons 8 $ cons 9 nil in + assert_eq (head l0__9) 0 "head [0..9] == 0"; + log "- check indices"; + assert_eq (index 0 l0__9) 0 "[0..9] !! 0 == 0"; + assert_eq (index 9 l0__9) 9 "[0..9] !! 9 == 9"; + log "check for + index"; + for 0 9 ( + \i. log ("- at index " ++ format i); + assert_eq (index i l0__9) i "[0..9] - every index I has value I" ); - log "check for_each"; - for_each l0__9 (\x. - assert (x < 10) "[0..9] - every value X < 10" + for_each l0__9 ( + \x. log ("- at value " ++ format x); + assert (x < 10) "[0..9] - every value X < 10" ); - log "check for_each_i"; - for_each_i 0 l0__9 (\i.\x. - assert (i == x) "[0..9] - I == X for every value X at index I" + for_each_i 0 l0__9 ( + \i. \x. log ("- at index " ++ format i); + assert_eq i x "[0..9] - I == X for every value X at index I" ); - log "OK - ALL TEST PASSED\a" end + // This tests uses VERY LONG lists of size up to 2097332 bits. // TIP: increase the game speed (ticks/s) when you run this test. def testLIST_BIG = log "STARTING TESTS OF BIG LISTS:"; - log "check [2^(2^7)] aka [big]"; - let big = 2^2^7 in - assert (len big == 129) "len (2^2^7) == 2^7+1"; - assert (to1numA 129 == (515,2)) "to1numA: 129 == 1000_0001 --> 515 == [0000 001 0] [0000 001 1]"; - assert (getLenA 515 == (129,nil)) "getLenA: 515 --> 129"; + let big = 2 ^ 2 ^ 7 in + assert_eq (len big) 129 "len (2^2^7) == 2^7+1"; + assert_eq (to1numA 129) ( 515 + , 2 ) "to1numA: 129 == 1000_0001 --> 515 == [0000 001 0] [0000 001 1]"; + assert_eq (getLenA 515) (129, nil) "getLenA: 515 --> 129"; let ibig = 2 * (shiftR 16 big + 515) in let lbig = cons big nil in - assert (lbig == ibig) "[big] ~ 2 * ((big * 2^(2*8)) + 515)"; - assert (head lbig == big) "head [big] == big"; - assert (tail lbig == nil) "tail [big] == []"; - + assert_eq lbig ibig "[big] ~ 2 * ((big * 2^(2*8)) + 515)"; + assert_eq (head lbig) big "head [big] == big"; + assert_eq (tail lbig) nil "tail [big] == []"; log "check [2^(2^21)] aka [bigger]"; - let bigger = 2^(2^21) in + let bigger = 2 ^ 2 ^ 21 in let lbigger = cons bigger nil in - assert (head lbigger == bigger) "head [bigger] == bigger"; - assert (tail lbigger == nil) "tail [bigger] == []"; - + assert_eq (head lbigger) bigger "head [bigger] == bigger"; + assert_eq (tail lbigger) nil "tail [bigger] == []"; log "check [2^(2^21),2^(2^7)] aka [bigger,big]"; let lbiggest = cons bigger lbig in - assert (head lbiggest == bigger) "head [bigger,big] == bigger"; - assert (tail lbiggest == lbig) "tail [bigger,big] == [big]"; - - log "OK - ALL TEST PASSED"; + assert_eq (head lbiggest) bigger "head [bigger,big] == bigger"; + assert_eq (tail lbiggest) lbig "tail [bigger,big] == [big]"; + log "OK - ALL TEST PASSED" end -def testLIST_ALL = - testLIST; - testLIST_BIG; -end +def testLIST_ALL = testLIST; testLIST_BIG end \ No newline at end of file