diff --git a/unison-src/transcripts-using-base/base.u b/unison-src/transcripts-using-base/base.u index 9c7bc9113..c39a37667 100644 --- a/unison-src/transcripts-using-base/base.u +++ b/unison-src/transcripts-using-base/base.u @@ -353,8 +353,10 @@ saveTestCase name f i = dir = "unison-src/transcripts-using-base/serialized-cases/" sfile = dir ++ name ++ ".ser" ofile = dir ++ name ++ ".out" + hfile = dir ++ name ++ ".hash" output = f i saveSelfContained (f, i) sfile writeFile ofile (toUtf8 output) + writeFile hfile (crypto.hash Sha3_512 (f, i)) diff --git a/unison-src/transcripts-using-base/random-deserial.md b/unison-src/transcripts-using-base/random-deserial.md new file mode 100644 index 000000000..3fe3f1c0a --- /dev/null +++ b/unison-src/transcripts-using-base/random-deserial.md @@ -0,0 +1,55 @@ +```ucm:hide +.> builtins.mergeio +``` + +```unison +directory = "unison-src/transcripts-using-base/serialized-cases/" + +availableCases : '{IO,Exception} [Text] +availableCases _ = + l = filter (contains ".ser") (directoryContents directory) + map (t -> Text.take (drop (Text.size t) 4) t) l + +gen : Nat -> Nat -> (Nat, Nat) +gen seed k = + c = 1442695040888963407 + a = 6364136223846793005 + (mod seed k, a * seed + c) + +shuffle : Nat -> [a] -> [a] +shuffle = + pick acc seed = cases + l | lteq (List.size l) 1 -> acc ++ l + | otherwise -> match gen seed (Nat.drop (size l) 1) with + (k, seed) -> match (take k l, drop k l) with + (pre, x +: post) -> pick (acc :+ x) seed (pre ++ post) + + pick [] + +runTestCase : Text ->{Exception,IO} Test.Result +runTestCase name = + sfile = directory ++ name ++ ".ser" + ofile = directory ++ name ++ ".out" + hfile = directory ++ name ++ ".hash" + + p@(f, i) = loadSelfContained sfile + o = fromUtf8 (readFile ofile) + h = readFile hfile + + if f i == o + then if crypto.hash Sha3_512 p == h + then Ok name + else Fail (name ++ " hash mismatch") + else Fail (name ++ " output mismatch") + +serialTests : '{IO,Exception} [Test.Result] +serialTests = do + l = !availableCases + cs = shuffle (toRepresentation !systemTimeMicroseconds) l + List.map runTestCase cs +``` + +```ucm +.> add +.> io.test serialTests +``` diff --git a/unison-src/transcripts-using-base/random-deserial.output.md b/unison-src/transcripts-using-base/random-deserial.output.md new file mode 100644 index 000000000..6ebde7767 --- /dev/null +++ b/unison-src/transcripts-using-base/random-deserial.output.md @@ -0,0 +1,86 @@ +```unison +directory = "unison-src/transcripts-using-base/serialized-cases/" + +availableCases : '{IO,Exception} [Text] +availableCases _ = + l = filter (contains ".ser") (directoryContents directory) + map (t -> Text.take (drop (Text.size t) 4) t) l + +gen : Nat -> Nat -> (Nat, Nat) +gen seed k = + c = 1442695040888963407 + a = 6364136223846793005 + (mod seed k, a * seed + c) + +shuffle : Nat -> [a] -> [a] +shuffle = + pick acc seed = cases + l | lteq (List.size l) 1 -> acc ++ l + | otherwise -> match gen seed (Nat.drop (size l) 1) with + (k, seed) -> match (take k l, drop k l) with + (pre, x +: post) -> pick (acc :+ x) seed (pre ++ post) + + pick [] + +runTestCase : Text ->{Exception,IO} Test.Result +runTestCase name = + sfile = directory ++ name ++ ".ser" + ofile = directory ++ name ++ ".out" + hfile = directory ++ name ++ ".hash" + + p@(f, i) = loadSelfContained sfile + o = fromUtf8 (readFile ofile) + h = readFile hfile + + if f i == o + then if crypto.hash Sha3_512 p == h + then Ok name + else Fail (name ++ " hash mismatch") + else Fail (name ++ " output mismatch") + +serialTests : '{IO,Exception} [Test.Result] +serialTests = do + l = !availableCases + cs = shuffle (toRepresentation !systemTimeMicroseconds) l + List.map runTestCase cs +``` + +```ucm + + I found and typechecked these definitions in scratch.u. If you + do an `add` or `update`, here's how your codebase would + change: + + ⍟ These new definitions are ok to `add`: + + availableCases : '{IO, Exception} [Text] + directory : Text + gen : Nat -> Nat -> (Nat, Nat) + runTestCase : Text ->{IO, Exception} Result + serialTests : '{IO, Exception} [Result] + shuffle : Nat -> [a] -> [a] + +``` +```ucm +.> add + + ⍟ I've added these definitions: + + availableCases : '{IO, Exception} [Text] + directory : Text + gen : Nat -> Nat -> (Nat, Nat) + runTestCase : Text ->{IO, Exception} Result + serialTests : '{IO, Exception} [Result] + shuffle : Nat -> [a] -> [a] + +.> io.test serialTests + + New test results: + + ◉ serialTests case-00 + + ✅ 1 test(s) passing + + Tip: Use view serialTests to view the source of a test. + +``` diff --git a/unison-src/transcripts-using-base/serial-test-00.md b/unison-src/transcripts-using-base/serial-test-00.md new file mode 100644 index 000000000..63eb7726e --- /dev/null +++ b/unison-src/transcripts-using-base/serial-test-00.md @@ -0,0 +1,77 @@ +```ucm:hide +.> builtins.mergeio +``` + +```unison +structural type Tree a = Leaf | Node (Tree a) a (Tree a) + +foldMap : r -> (r -> r -> r) -> (a -> r) -> Tree a -> r +foldMap z m f = + walk = cases + Leaf -> z + Node l x r -> m (walk l) (m (f x) (walk r)) + + walk + +tree0 : Tree Nat +tree0 = + (Node + (Node Leaf 2 Leaf) + 1 + (Node Leaf 3 (Node Leaf 4 Leaf))) + +tree1 : Tree Nat +tree1 = + Node + tree0 + 0 + (Node + (Node + (Node Leaf 7 Leaf) + 6 + (Node + Leaf + 8 + (Node Leaf 9 Leaf))) + 5 + Leaf) + +tree2 : Tree Nat +tree2 = Node tree0 10 tree1 + +tree3 : Tree Text +tree3 = + Node + (Node Leaf "hello" Leaf) + " " + (Node (Node Leaf "good" Leaf) + "bye" + Leaf) + +evaluate + : (Tree Nat ->{} Nat) + -> (Tree Text ->{} Text) + -> (Tree Nat, Tree Nat, Tree Nat, Tree Text) + -> Text +evaluate f g = cases + (w, x, y, z) -> + ow = f w + ox = f x + oy = f y + oz = g z + "(" ++ toText ow ++ ", " ++ toText ox ++ ", " ++ toText oy ++ ", " ++ oz ++ ")" + +mkTestCase : '{IO,Exception} () +mkTestCase = do + balancedSum = foldMap 0 (Nat.+) (x -> x) + catenate = foldMap "" (Text.++) (x -> x) + f = evaluate balancedSum catenate + tup = (tree0, tree1, tree2, tree3) + + saveTestCase "case-00" f tup +``` + +```ucm +.> add +.> run mkTestCase +``` diff --git a/unison-src/transcripts-using-base/serial-test-00.output.md b/unison-src/transcripts-using-base/serial-test-00.output.md new file mode 100644 index 000000000..6b704bc5d --- /dev/null +++ b/unison-src/transcripts-using-base/serial-test-00.output.md @@ -0,0 +1,122 @@ +```unison +structural type Tree a = Leaf | Node (Tree a) a (Tree a) + +foldMap : r -> (r -> r -> r) -> (a -> r) -> Tree a -> r +foldMap z m f = + walk = cases + Leaf -> z + Node l x r -> m (walk l) (m (f x) (walk r)) + + walk + +tree0 : Tree Nat +tree0 = + (Node + (Node Leaf 2 Leaf) + 1 + (Node Leaf 3 (Node Leaf 4 Leaf))) + +tree1 : Tree Nat +tree1 = + Node + tree0 + 0 + (Node + (Node + (Node Leaf 7 Leaf) + 6 + (Node + Leaf + 8 + (Node Leaf 9 Leaf))) + 5 + Leaf) + +tree2 : Tree Nat +tree2 = Node tree0 10 tree1 + +tree3 : Tree Text +tree3 = + Node + (Node Leaf "hello" Leaf) + " " + (Node (Node Leaf "good" Leaf) + "bye" + Leaf) + +evaluate + : (Tree Nat ->{} Nat) + -> (Tree Text ->{} Text) + -> (Tree Nat, Tree Nat, Tree Nat, Tree Text) + -> Text +evaluate f g = cases + (w, x, y, z) -> + ow = f w + ox = f x + oy = f y + oz = g z + "(" ++ toText ow ++ ", " ++ toText ox ++ ", " ++ toText oy ++ ", " ++ oz ++ ")" + +mkTestCase : '{IO,Exception} () +mkTestCase = do + balancedSum = foldMap 0 (Nat.+) (x -> x) + catenate = foldMap "" (Text.++) (x -> x) + f = evaluate balancedSum catenate + tup = (tree0, tree1, tree2, tree3) + + saveTestCase "case-00" f tup +``` + +```ucm + + I found and typechecked these definitions in scratch.u. If you + do an `add` or `update`, here's how your codebase would + change: + + ⍟ These new definitions are ok to `add`: + + structural type Tree a + evaluate : (Tree Nat -> Nat) + -> (Tree Text -> Text) + -> (Tree Nat, Tree Nat, Tree Nat, Tree Text) + -> Text + foldMap : ∀ a r g2 g1 g. + r + -> (r ->{g2} r ->{g1} r) + -> (a ->{g} r) + -> Tree a + ->{g2, g1, g} r + mkTestCase : '{IO, Exception} () + tree0 : Tree Nat + tree1 : Tree Nat + tree2 : Tree Nat + tree3 : Tree Text + +``` +```ucm +.> add + + ⍟ I've added these definitions: + + structural type Tree a + evaluate : (Tree Nat -> Nat) + -> (Tree Text -> Text) + -> (Tree Nat, Tree Nat, Tree Nat, Tree Text) + -> Text + foldMap : ∀ a r g2 g1 g. + r + -> (r ->{g2} r ->{g1} r) + -> (a ->{g} r) + -> Tree a + ->{g2, g1, g} r + mkTestCase : '{IO, Exception} () + tree0 : Tree Nat + tree1 : Tree Nat + tree2 : Tree Nat + tree3 : Tree Text + +.> run mkTestCase + + () + +``` diff --git a/unison-src/transcripts-using-base/serialized-cases/case-00.hash b/unison-src/transcripts-using-base/serialized-cases/case-00.hash new file mode 100644 index 000000000..bf527ac97 --- /dev/null +++ b/unison-src/transcripts-using-base/serialized-cases/case-00.hash @@ -0,0 +1 @@ +rA;U+vLԫQGh;Z54m =Z;:3v6w{=R \ No newline at end of file diff --git a/unison-src/transcripts-using-base/serialized-cases/case-00.out b/unison-src/transcripts-using-base/serialized-cases/case-00.out new file mode 100644 index 000000000..248fffd4a --- /dev/null +++ b/unison-src/transcripts-using-base/serialized-cases/case-00.out @@ -0,0 +1 @@ +(10, 45, 65, hello goodbye) \ No newline at end of file diff --git a/unison-src/transcripts-using-base/serialized-cases/case-00.ser b/unison-src/transcripts-using-base/serialized-cases/case-00.ser new file mode 100644 index 000000000..f5dc3df20 --- /dev/null +++ b/unison-src/transcripts-using-base/serialized-cases/case-00.ser @@ -0,0 +1 @@ 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== \ No newline at end of file