@ironm00n/pyret-lang 0.0.1 → 0.0.3

package/tests/pyret/tests/test-well-formed.arr

@@ -1,491 +0,0 @@
-import file("../../../src/arr/compiler/compile-structs.arr") as CS
-import render-error-display as RED
-import file("../test-compile-helper.arr") as C
-
-run-str = C.run-str
-compile-error = C.compile-error
-output = C.output
-
-sc = lam(test-str): string-contains(_, test-str) end
-
-fun c(str) block:
-  errs = C.get-compile-errs(str)
-  when is-empty(errs):
-    print-error("Expected at least one error for running \n\n " + str + "\n\n" + " but got none ")
-  end
-  errs.first
-end
-fun cwfs(str):
-  err = c(str)
-  RED.display-to-string(err.render-reason(), torepr, empty)
-end
-  
-fun cok(str):
-  C.get-compile-errs(str)
-end
-
-check "mixed ops":
-  run-str("true and false or true") is%(output) compile-error(CS.is-mixed-binops)
-  run-str("1 + 2 - 3") is%(output) compile-error(CS.is-mixed-binops)
-  run-str("1 + 2 + 3 * 4") is%(output) compile-error(CS.is-mixed-binops)
-  run-str("1 / 2 + 3 * 4 - 5") is%(output) compile-error(CS.is-mixed-binops)
-end
-
-check "nullary methods":
-  run-str("method(): nothing end") is%(output) compile-error(CS.is-no-arguments)
-  run-str("{method foo(): nothing end}") is%(output) compile-error(CS.is-no-arguments)
-end
-
-check "multiple statements on a line":
-  msg =  "on the same line"
-  run-str("(5) (-2)") is%(output) compile-error(CS.is-same-line)
-  run-str("'ab''de'") is%(output) compile-error(CS.is-same-line)
-  run-str("a\"abc\"") is%(output) compile-error(CS.is-same-line)
-  run-str("a=3b=4") is%(output) compile-error(CS.is-same-line)
-  run-str("fun f(x) block: f x end") is%(output) compile-error(CS.is-same-line)
-  run-str("fun f(x) block: f (x) end") is%(output) compile-error(CS.is-same-line)
-  cok("fun f(x) block: num-sqr(f)\n (x) end\n10") is empty
-  cok("fun f(x) block:\n  num-sqr(f)\n  # a comment\n  (x)\nend\n10") is empty
-end
-
-check "pointless underscores":
-  run-str("var _ = 5") is%(output) compile-error(CS.is-pointless-var)
-  run-str("shadow _ = 5") is%(output) compile-error(CS.is-pointless-shadow)
-  run-str("rec _ = 5") is%(output) compile-error(CS.is-pointless-rec)
-end
-
-check "bad-checks":
-  run-str("5 is 5") is%(output) compile-error(CS.is-unwelcome-test)
-  run-str("5 is-not 5") is%(output) compile-error(CS.is-unwelcome-test)
-  run-str("5 is== 5") is%(output) compile-error(CS.is-unwelcome-test)
-  run-str("5 is=~ 5") is%(output) compile-error(CS.is-unwelcome-test)
-  run-str("5 is<=> 5") is%(output) compile-error(CS.is-unwelcome-test)
-  run-str("5 satisfies 5") is%(output) compile-error(CS.is-unwelcome-test)
-  run-str("5 violates 5") is%(output) compile-error(CS.is-unwelcome-test)
-  run-str("5 raises 5") is%(output) compile-error(CS.is-unwelcome-test)
-  run-str("5 does-not-raise") is%(output) compile-error(CS.is-unwelcome-test)
-  run-str("5 raises-other-than 5") is%(output) compile-error(CS.is-unwelcome-test)
-  run-str("5 raises-satisfies 5") is%(output) compile-error(CS.is-unwelcome-test)
-  run-str("5 raises-violates 5") is%(output) compile-error(CS.is-unwelcome-test)
-  run-str("lam(): 5 is 5 end") is%(output) compile-error(CS.is-unwelcome-test)
-  run-str("lam(): 5 is-not 5 end") is%(output) compile-error(CS.is-unwelcome-test)
-  run-str("lam(): 5 is== 5 end") is%(output) compile-error(CS.is-unwelcome-test)
-  run-str("lam(): 5 is=~ 5 end") is%(output) compile-error(CS.is-unwelcome-test)
-  run-str("lam(): 5 is<=> 5 end") is%(output) compile-error(CS.is-unwelcome-test)
-  run-str("lam(): 5 satisfies 5 end") is%(output) compile-error(CS.is-unwelcome-test)
-  run-str("lam(): 5 violates 5 end") is%(output) compile-error(CS.is-unwelcome-test)
-  run-str("lam(): 5 raises 5 end") is%(output) compile-error(CS.is-unwelcome-test)
-  run-str("lam(): 5 does-not-raise end") is%(output) compile-error(CS.is-unwelcome-test)
-  run-str("lam(): 5 raises-other-than 5 end") is%(output) compile-error(CS.is-unwelcome-test)
-  run-str("lam(): 5 raises-satisfies 5 end") is%(output) compile-error(CS.is-unwelcome-test)
-  run-str("lam(): 5 raises-violates 5 end") is%(output) compile-error(CS.is-unwelcome-test)
-  run-str("check: 5 satisfies%(5) 5 end") is%(output) compile-error(CS.is-unwelcome-test-refinement)
-  run-str("check: 5 violates%(5) 5 end") is%(output) compile-error(CS.is-unwelcome-test-refinement)
-  run-str("check: 5 is==%(5) 5 end") is%(output) compile-error(CS.is-unwelcome-test-refinement)
-  run-str("check: 5 is=~%(5) 5 end") is%(output) compile-error(CS.is-unwelcome-test-refinement)
-  run-str("check: 5 is<=>%(5) 5 end") is%(output) compile-error(CS.is-unwelcome-test-refinement)
-  run-str("check: 5 raises%(5) 5 end") is%(output) compile-error(CS.is-unwelcome-test-refinement)
-  run-str("check: 5 raises-satisfies%(5) 5 end") is%(output) compile-error(CS.is-unwelcome-test-refinement)
-  run-str("check: 5 raises-violates%(5) 5 end") is%(output) compile-error(CS.is-unwelcome-test-refinement)
-end
-
-check "bad objects":
-  run-str("{__proto__: 42}") is%(output) compile-error(CS.is-reserved-name)
-end
-
-check "bad constructors":
-  run-str("data Foo: return end") is%(output) compile-error(CS.is-reserved-name)
-  run-str("data Foo: return(x) end") is%(output) compile-error(CS.is-reserved-name)
-  run-str("cases(Foo) 5: | return => 3 end") is%(output) compile-error(CS.is-reserved-name)
-  run-str("cases(Foo) 5: | return(x) => 3 end") is%(output) compile-error(CS.is-reserved-name)
-end
-
-check "malformed blocks":
-  c("fun foo():\n" + 
-       " x = 10\n" + 
-       "end\n" + 
-       "10")
-    satisfies CS.is-block-ending
-
-  c("fun foo():\n" + 
-       " var x = 10\n" + 
-       "end\n" + 
-       "10")
-    satisfies CS.is-block-ending
-
-  c("fun foo():\n" + 
-       " fun f(): nothing end\n" + 
-       "end\n" + 
-       "10")
-    satisfies CS.is-block-ending
-
-  c("fun foo():\n" +
-       " 123\n" +
-       " a :: Number\n" +
-       "end\n" +
-       "10")
-    satisfies CS.is-block-needed
-
-  c("for map(): end") satisfies CS.is-wf-empty-block
-
-  run-str("lam(): x = 5 end") is%(output) compile-error(CS.is-block-ending)
-  run-str("lam(): var x = 5 end") is%(output) compile-error(CS.is-block-ending)
-  run-str("lam(): fun f(): nothing end end") is%(output) compile-error(CS.is-block-ending)
-  run-str("lam(): x = 5\n fun f(): nothing end end") is%(output) compile-error(CS.is-block-ending)
-  run-str("lam(): var x = 5\n y = 4\n fun f(): nothing end end") is%(output) compile-error(CS.is-block-ending)
-
-  run-str(
-    "x = 1\n" +
-    "fun f():\n" +
-    "  [list: 1]\n" +
-    "  spy: x end\n" +
-    "end") is%(output) compile-error(CS.is-block-ending)
-
-  run-str(
-    "x = 1\n" +
-    "fun f() block:\n" +
-    "  [list: 1]\n" +
-    "  spy: x end\n" +
-    "end") is%(output) compile-error(CS.is-block-ending)
-
-  run-str(
-    "x = 1\n" +
-    "fun f() block:\n" +
-    "  spy: x end\n" +
-    "  [list: 1]\n" +
-    "end") is%(output) C.success
-
-  c("lam():\n" + 
-       "  data D:\n" + 
-       "    | var1()\n" + 
-       "  end\n" + 
-       "  42\n" +
-       "end")
-    satisfies CS.is-block-needed
-  c("lam():\n" + 
-       "  y = 10\n" + 
-       "  x = 5\n" + 
-       "  fun f(): nothing end\n" + 
-       "  data D:\n" + 
-       "    | var1()\n" + 
-       "  end\n" + 
-       "  42\n" +
-       "end")
-    satisfies CS.is-block-needed
-  c("block:\n" + 
-       "  x = 5\n" + 
-       "  y = 10\n" + 
-       "end")
-    satisfies CS.is-block-ending
-
-  c("if x < y:\n" + 
-       "  print('x less than y')\n" + 
-       "end")
-    satisfies CS.is-single-branch-if
-
-  run-str("lam(): true where: 5 end") is%(output) compile-error(CS.is-unwelcome-where)
-  run-str("method(self): nothing where: 5 end") is%(output) compile-error(CS.is-unwelcome-where)
-  run-str("{method m(self): nothing where: 5 end}") is%(output) compile-error(CS.is-unwelcome-where)
-end
-
-check "table row sizes, non-top-level":
-  run-str("f(table: a, b row: end)") is%(output) compile-error(CS.is-table-empty-row)
-  run-str("f(table: a, b row: 1 end)") is%(output) compile-error(CS.is-table-row-wrong-size)
-  run-str("f(table: row: end)") is%(output) compile-error(CS.is-table-empty-header)
-end
-
-check "table loading checks":
-  c("load-table: h1 end") satisfies CS.is-load-table-no-body
-  c("load-table: source: src end") satisfies CS.is-table-empty-header
-  c("load-table: h1 "
-      + "sanitize h1 using s1 "
-      + "end") satisfies CS.is-load-table-bad-number-srcs
-  c("load-table: h1 "
-      + "source: src1 "
-      + "sanitize h1 using s1 "
-      + "source: src2 "
-      + "end") satisfies CS.is-load-table-bad-number-srcs
-  c("load-table: h1, h2 "
-      + "source: src1 "
-      + "sanitize h1 using s1 "
-      + "sanitize h2 using s2 "
-      + "sanitize h1 using s1 "
-      + "end") satisfies CS.is-load-table-duplicate-sanitizer
-  c("load-table: h1 "
-      + "source: src1 "
-      + "sanitize h1 using s1 "
-      + "sanitize h2 using s2 "
-      + "end") satisfies CS.is-table-sanitizer-bad-column
-end
-
-check "table headers":
-  run-str("table: a, b, a row: 1, 2, 3 end") is%(output) compile-error(CS.is-table-duplicate-column-name)
-  run-str("load-table: a, b, a source: src end") is%(output) compile-error(CS.is-table-duplicate-column-name)
-  run-str("load-table: timestamp, name, class source: src end") is%(output) compile-error(CS.is-reserved-name)
-end
-
-check "tuple bindings":
-  cwfs("data D: d({x;y}) end") satisfies sc("Tuple binding not allowed")
-  cwfs("let var {x;y} = 10: x end") satisfies sc("Variable bindings must be names")
-  cwfs("var {x;y} = 10") satisfies sc("Variable bindings must be names")
-  cwfs("rec {x;y} = 10") satisfies sc("Recursive bindings must be names")
-  cwfs("letrec {x;y} = 10: x end") satisfies sc("Recursive bindings must be names")
-
-  # Now nested in other scopes, since toplevel bindings are special
-  cwfs("lam(): var {x;y} = 10\nx end") satisfies sc("Variable bindings must be names")
-  cwfs("lam(): rec {x;y} = 10\nx end") satisfies sc("Recursive bindings must be names")
-end
-
-check "reactors":
-  cwfs("reactor: todraw: 67 end") satisfies sc("must have a field named `init`")
-  cwfs("reactor: init: 5, todraw: 67 end") satisfies sc("but found one named `todraw`")
-  cwfs("reactor: method f(self): 5 end end") satisfies sc("cannot contain method fields")
-  cwfs("reactor: init: 5, init: 10 end") satisfies sc("Duplicate")
-end
-
-check "malformed reactors":
-  c("reactor:\n" +
-    "  init: nothing,\n" +
-    "  on-tick: lam(_):\n" +
-    "      1 > true * 2\n" +
-    "      1 + _\n" +
-    "    end,\n" +
-    "end") satisfies CS.is-block-needed
-  c("reactor:\n" +
-    "  init: nothing,\n" +
-    "  on-tick: lam(_):\n" +
-    "      1 > true * 2\n" +
-    "    end,\n" +
-    "end") satisfies CS.is-mixed-binops
-end  
-
-check "empty data definitions":
-  cok("data NoVariants: end") is empty
-  cok("data NoVariants:\nend") is empty
-end
-
-check "duplicated names in data defintiions":
-  run-str("data Foo: is-Foo end") is%(output) compile-error(CS.is-duplicate-is-data)
-  run-str("data Foo: Foo end") is%(output) compile-error(CS.is-data-variant-duplicate-name)
-  run-str("data is-Foo3: Foo3 | baz end") is%(output) compile-error(CS.is-duplicate-is-data-variant)
-  run-str("data Foo: bar | is-bar end") is%(output) compile-error(CS.is-duplicate-is-variant)
-  run-str("data Foo: is-bar | bar end") is%(output) compile-error(CS.is-duplicate-is-variant)
-  run-str("data Foo: bar | bar end") is%(output) compile-error(CS.is-duplicate-variant)
-end
-
-check "duplicated names in record type":
-  run-str("type foo = {x :: Number, x :: Number}") is%(output) compile-error(CS.is-duplicate-field)
-  run-str("type foo = {y :: Number, y :: Boolean}") is%(output) compile-error(CS.is-duplicate-field)
-  run-str("type foo = {x :: Number, y :: Number, x :: Number}") is%(output) compile-error(CS.is-duplicate-field)
-  run-str("type foo = {x :: Number, y :: Number, x :: Boolean}") is%(output) compile-error(CS.is-duplicate-field)
-  run-str("type foo = {x :: Number, y :: Number, y :: Boolean}") is%(output) compile-error(CS.is-duplicate-field)
-  run-str("type foo = {bar :: Number, bar :: Boolean, bar :: List}") is%(output) compile-error(CS.is-duplicate-field)
-end
-
-check "underscores":
-  run-str("cases(List) _: | empty => 5 end") is%(output) compile-error(CS.is-underscore-as-expr)
-  run-str("cases(List) _: | empty => 5 | else => 6 end") is%(output) compile-error(CS.is-underscore-as-expr)
-  run-str("cases(List) empty: | empty => _ end") is%(output) compile-error(CS.is-underscore-as-expr)
-  run-str("cases(List) empty: | _ => 5 end") is%(output) compile-error(CS.is-underscore-as-pattern)
-  run-str("block:\n _ \n 5 \n end") is%(output) compile-error(CS.is-wf-err)
-  run-str("{ method foo(self): _ end }") is%(output) compile-error(CS.is-underscore-as-expr)
-  run-str("{ fieldname: _ }") is%(output) compile-error(CS.is-underscore-as-expr)
-  run-str("method(self): _ end") is%(output) compile-error(CS.is-underscore-as-expr)
-  run-str("lam(self): _ end") is%(output) compile-error(CS.is-underscore-as-expr)
-  run-str("fun foo(self): _ end") is%(output) compile-error(CS.is-underscore-as-expr)
-  run-str("provide _ end") is%(output) compile-error(CS.is-non-object-provide)
-
-  run-str("table: _, a row: 1, 2 end") is%(output) compile-error(CS.is-underscore-as)
-
-  run-str("{a: 1}.{_: 2}") is%(output) compile-error(CS.is-underscore-as)
-  run-str("{a: 1}._") is%(output) compile-error(CS.is-underscore-as)
-end
-
-check "standalone expressions":
-  cok("1 + 2\n1 + 5") is empty
-  cok("x = 5\n1 == 1\nx") is empty
-  cok("x = 10\nx + 1\nx") is empty
-  cok("x = 5\ny = 12\nx\ny") is empty
-
-  run-str("block: 1 + 2\n1 + 3 end") is%(output) compile-error(CS.is-wf-err)
-  run-str("block: x\ny end") is%(output) compile-error(CS.is-wf-err)
-  run-str("block: x = 10\nx\nx + 1 end") is%(output) compile-error(CS.is-wf-err)
-end
-
-check "empty if blocks":
-  run-str("if true: else if false: 4 end") is%(output) compile-error(CS.is-wf-empty-block)
-  run-str("if true: 4 else if false: end") is%(output) compile-error(CS.is-wf-empty-block)
-  run-str("if true: end") is%(output) compile-error(CS.is-single-branch-if)
-end
-
-
-#|
-      it("should notice empty blocks", function(done) {
-        P.checkCompileError("lam(): end", function(e) {
-          expect(e.length).toEqual(1);
-          return true;
-        });
-        P.checkCompileError("for each(elt from [list: ]): end", function(e) {
-          expect(e.length).toEqual(1);
-          return true;
-        });
-        P.checkCompileError("letrec x = 10: end", function(e) {
-          expect(e.length).toEqual(1);
-          return true;
-        });
-        P.checkCompileError("let x = 10: end", function(e) {
-          expect(e.length).toEqual(1);
-          return true;
-        });
-        P.checkCompileError("when true: end", function(e) {
-          expect(e.length).toEqual(1);
-          return true;
-        });
-        P.wait(done);
-      });
-      it("malformed cases", function(done) {
-        P.checkCompileErrorMsg("cases(List) [list: ]:\n" +
-                               "  | empty => 1\n" +
-                               "  | empty => 2\n" +
-                               "end",
-                               "Duplicate case for empty");
-
-        P.checkCompileErrorMsg("cases(List) [list: ]:\n" +
-                               "  | empty => 1\n" +
-                               "  | link(f, r) => 2\n" +
-                               "  | empty => 2\n" +
-                               "end",
-                               "Duplicate case for empty");
-
-        P.checkCompileErrorMsg("cases(List) [list: ]:\n" +
-                               "  | empty => 1\n" +
-                               "  | empty => 2\n" +
-                               "  | else => 3\n" +
-                               "end",
-                               "Duplicate case for empty");
-
-        P.checkCompileErrorMsg("cases(List) [list: ]:\n" +
-                               "  | link(f, r) => 2\n" +
-                               "  | bogus => 'bogus'\n" +
-                               "  | bogus2 => 'bogus'\n" +
-                               "  | empty => 1\n" +
-                               "  | bogus3 => 'bogus'\n" +
-                               "  | empty => 2\n" +
-                               "  | else => 3\n" +
-                               "end",
-                               "Duplicate case for empty");
-
-        P.checkCompileErrorMsg("cases(List) [list: ]:\n" +
-                               "  | empty => 2\n" +
-                               "  | bogus => 'bogus'\n" +
-                               "  | bogus2 => 'bogus'\n" +
-                               "  | link(f, r) => 1\n" +
-                               "  | bogus3 => 'bogus'\n" +
-                               "  | link(_, _) => 2\n" +
-                               "end",
-                               "Duplicate case for link");
-
-
-        P.wait(done);
-      });
-      it("reserved words", function(done) {
-        var reservedNames = [
-          "function",
-          "break",
-          "return",
-          "do",
-          "yield",
-          "throw",
-          "continue",
-          "while",
-          "class",
-          "interface",
-          "generator",
-          "alias",
-          "extends",
-          "implements",
-          "module",
-          "package",
-          "namespace",
-          "use",
-          "public",
-          "private",
-          "protected",
-          "static",
-          "const",
-          "enum",
-          "super",
-          "export",
-          "new",
-          "try",
-          "finally",
-          "debug",
-          "spy",
-          "switch",
-          "this",
-          "match",
-          "case",
-          "with"
-        ];
-        for(var i = 0; i < reservedNames.length; i++) {
-          var err = "disallows the use of `" + reservedNames[i] + "` as an identifier";
-          P.checkCompileErrorMsg(reservedNames[i], err);
-          P.checkCompileErrorMsg(reservedNames[i] + " = 5", err);
-          P.checkCompileErrorMsg("fun f(" + reservedNames[i] + "): 5 end", err);
-          P.checkCompileErrorMsg("fun " + reservedNames[i] + "(): 5 end", err);
-          if (reservedNames[i] !== "type") {
-            P.checkCompileErrorMsg("{ " + reservedNames[i] + " : 42 }", err);
-            P.checkCompileErrorMsg("{ " + reservedNames[i] + "(self): 42 end }", err);
-          }
-        }
-
-        P.wait(done);
-      });
-      it("fraction literals", function(done) {
-        var err = "fraction literal with zero denominator"
-        P.checkCompileErrorMsg("1/0", err);
-        P.checkCompileErrorMsg("100/0", err);
-        P.checkCompileErrorMsg("0/0", err);
-        P.checkCompileErrorMsg("0/00000", err);
-        P.wait(done);
-      });
-      xit("special imports", function(done) {
-        var err = "Unsupported import type";
-        P.checkCompileErrorMsg("import mydrive('foo') as D", err);
-        P.checkNoCompileError("import my-gdrive('foo') as F");
-        P.checkCompileErrorMsg("import my-gdrive('a', 'b') as D", "one argument");
-        P.checkCompileErrorMsg("import shared-gdrive('a') as D", "two arguments");
-        P.wait(done);
-      });
-      it("examples restriction", function(done) {
-        P.checkCompileErrorMsg("examples: f() end", "must contain only test");
-        P.wait(done);
-      });
-      it("underscores", function(done) {
-        P.checkCompileErrorMsg("cases(List) _: | empty => 5 end") satisfies CS.as-underscore
-        P.checkCompileErrorMsg("cases(List) _: | empty => 5 | else => 6 end") satisfies CS.as-underscore
-        P.checkCompileErrorMsg("cases(List) empty: | empty => _ end", "The underscore");
-        P.checkCompileErrorMsg("cases(List) empty: | _ => 5 end", "Found a cases branch using _");
-        P.checkCompileErrorMsg("block:\n _ \n 5 \n end", "The underscore");
-        P.checkCompileErrorMsg("{ foo(self): _ end }", "The underscore");
-        P.checkCompileErrorMsg("{ fieldname: _ }", "The underscore");
-        P.checkCompileErrorMsg("method(self): _ end", "The underscore");
-        P.checkCompileErrorMsg("lam(self): _ end", "The underscore");
-        P.checkCompileErrorMsg("fun foo(self): _ end", "The underscore");
-        P.checkCompileErrorMsg("check: _ end", "The underscore");
-        P.checkCompileErrorMsg("provide _ end", "The underscore");
-        P.checkCompileErrorMsg("x = {1; 2; 3}\n x.{-1}", "Index too small");
-        P.wait(done);
-      });
-        it("tuples", function(done) {
-        P.checkCompileErrorMsg("x = {1; 2; 3}\n x.{-1}", "Index too small");
-        P.wait(done);
-      });
-    });
-  }
-  return { performTest: performTest };
-});
-
-
-
-|#

package/tests/pyret/tests/test-within.arr

@@ -1,183 +0,0 @@
-check "num-within-abs":
-   1  is%(num-within-abs(0.1))       1
-   1  is%(num-within-abs(0.1))      ~1
-  ~3  is%(num-within-abs(0.1))      ~3
-  ~2  is-not%(num-within-abs(0.1))  ~3
-  ~2  is%(num-within-abs(1.1))      ~3
-  ~2  is%(num-within-abs(1))        ~3
-  ~2  is%(num-within-abs(~1))       ~3
-  ~2  is-not%(num-within-abs(~0.9)) ~3
-   2  is%(num-within-abs(1))        ~3
-   2  is%(num-within-abs(1.1))      ~3
-   2  is-not%(num-within-abs(0.9))  ~3
-   5  is%(num-within-abs(4))         3
-
-   num-within-abs(-0.1)(1, 1.05) raises "negative tolerance"
-end
-
-check "within":
-   1  is%(within-abs(0.1))       1
-   1  is%(within-abs(0.1))      ~1
-  ~3  is%(within-abs(0.1))      ~3
-  ~2  is-not%(within-abs(0.1))  ~3
-  ~2  is%(within-abs(1.1))      ~3
-  ~2  is%(within-abs(1))        ~3
-  ~2  is%(within-abs(~1))       ~3
-  ~2  is-not%(within-abs(~0.9)) ~3
-   2  is%(within-abs(1))        ~3
-   2  is%(within-abs(1.1))      ~3
-   2  is-not%(within-abs(0.9))  ~3
-   5  is%(within-abs(4))         3
-
-   within-abs(-0.1)(1, 1.05) raises "negative tolerance"
-
-   l1 = [list: 1]
-   l2 = [list: 1.2]
-   l1 is%(within-abs(0.5))  l2
-   l1 is-not%(within-abs(0.1)) l2
-   l1 is%(within(~0.5))  l2
-   l1 is-not%(within-abs(~0.1)) l2
-
-   l3 = [list: ~1]
-   l4 = [list: 1.2]
-   l3 is%(within-abs(0.5))  l4
-   l3 is-not%(within-abs(0.1)) l4
-   l3 is%(within-abs(~0.5))  l4
-   l3 is-not%(within-abs(~0.1)) l4
-
-   l5 = [list: 1]
-   l6 = [list: ~1.2]
-   l5 is%(within-abs(0.5))  l6
-   l5 is-not%(within-abs(0.1)) l6
-   l5 is%(within-abs(~0.5))  l6
-   l5 is-not%(within-abs(~0.1)) l6
-
-   l7 = [list: 1]
-   l8 = [list: ~1.2]
-   l7 is%(within-abs(0.5))  l8
-   l7 is-not%(within-abs(0.1)) l8
-   l7 is%(within-abs(~0.5))  l8
-   l7 is-not%(within-abs(~0.1)) l8
-end
-
-check "within-rel":
-   1  is%(within-rel(0.1))       1
-   1  is%(within-rel(0.1))      ~1
-  ~3  is%(within-rel(0.1))      ~3
-  ~2  is-not%(within-rel(0.1))  ~3
-  ~2  is%(within-rel(0.4))      ~3
-  ~20  is-not%(within-rel(~0.3))   ~30
-   2  is-not%(within-rel(0.1))    ~3
-   #5  is%(within-rel(0.5))         3
-   5  is-not%(within-rel(0.5))         3
-   3  is%(within-rel(0.5))       5
-
-   within-rel(-0.1)(1, 1.05) raises "tolerance"
-   # rel tols > 1 are now acceptable
-   #within-rel(1.1)(~2, ~3)   raises "relative tolerance"
-   #within-rel(4)(5, 3)       raises "relative tolerance"
-   within-rel(1.1)(~2, ~3)   is true
-   within-rel(4)(5, 3)       is true
-
-   l1 = [list: 1]
-   l2 = [list: 1.2]
-   l1 is%(within-rel(0.5))  l2
-   l1 is-not%(within-rel(0.1)) l2
-   l1 is%(within-rel(~0.5))  l2
-   l1 is-not%(within-rel(~0.1)) l2
-
-   l3 = [list: ~1]
-   l4 = [list: 1.2]
-   l3 is%(within-rel(0.5))  l4
-   l3 is-not%(within-rel(0.1)) l4
-   l3 is%(within-rel(~0.5))  l4
-   l3 is-not%(within-rel(~0.1)) l4
-
-   l5 = [list: 1]
-   l6 = [list: ~1.2]
-   l5 is%(within-rel(0.5))  l6
-   l5 is-not%(within-rel(0.1)) l6
-   l5 is%(within-rel(~0.5))  l6
-   l5 is-not%(within-rel(~0.1)) l6
-
-   l7 = [list: 1]
-   l8 = [list: ~1.2]
-   l7 is%(within-rel(0.5))  l8
-   l7 is-not%(within-rel(0.1)) l8
-   l7 is%(within-rel(~0.5))  l8
-   l7 is-not%(within-rel(~0.1)) l8
-end
-
-data Box:
-  | box(ref v)
-end
-
-check "within-abs-now":
-  b1 = box(5)
-  b2 = box(5)
-  l1 = [list: 2, b1]
-  l2 = [list: 2.1, b2]
-
-  2 is%(within-abs(0.3)) 2.1
-  l1 is%(within-abs-now(0.3)) l2
-  l1 is%(within-rel-now(0.5)) l2
-  l1 is-not%(within-abs(0.3)) l2
-  l1 is-not%(within-rel(0.5)) l2
-
-  b1!{v: 10}
-
-  l1 is-not%(within-abs-now(0.3)) l2
-  l1 is-not%(within-rel-now(0.5)) l2
-end
-
-check "num-within-rel":
-  100000 is%(num-within-rel(0.1)) 95000
-  100000 is-not%(num-within-rel(0.1)) 85000
-  -100000 is%(num-within-rel(0.1)) -95000
-  -100000 is-not%(num-within-rel(0.1)) -85000
-  usr-num-within-rel = lam(rel-tol):
-                     lam(a, b):
-                       abs-tol = num-abs(((a + b) / 2) * rel-tol)
-                       (num-within-abs(abs-tol))(a, b)
-                     end
-                    end
-  -100000 is%(num-within-rel(0.1)) -95000
-  -100000 is-not%(num-within-rel(0.1)) -85000
-  100000 is%(usr-num-within-rel(0.1)) 95000
-  100000 is-not%(usr-num-within-rel(0.1)) 85000
-  -100000 is%(usr-num-within-rel(0.1)) -95000
-  -100000 is-not%(usr-num-within-rel(0.1)) -85000
-end
-
-check "comparing very small roughnums":
-  within-abs(~5e-324)(~12e-324, ~5e-324) raises "too small"
-  within-abs(~5e-324)(~12e-300, ~5e-324) is false
-  within-abs(~5e-312)(~12e-300, ~5e-324) is false
-  within-abs(5e-324)(12e-324, 5e-324) is false
-  within-abs(~10e-324)(~30e-324, ~10e-324) is false
-  within-abs(~1e-322)(~2.5e-322, ~1e-322) is false
-  within-abs(~1e-300)(~2.5e-300, ~1e-300) is false
-  within-abs(~1e-10)(~2.5e-10, ~1e-10) is false
-end
-
-check "rational with huge num and den":
-  within-abs(0.1)(0, 1623661768784682555628130151803732303823731397584604134434712085109537989167054680295758318409915953030552964736059575595461966294775666179502061096203869360118880960667793751146401768244701375970246097720878895899268070204857508281530675977229160007910464168127741485245775743781785616662411713763689231281064379513523432502547356005487844663970152189160201765407027985353074208688533763274501604996414630630394190081448539115299233288126813967753879087576171919/755514561303212495820119886905991823211308425045882281922060624339278043382100575558499380814515152419865252136969066086837161325241011943120713668028741350351111648910894342499713054600527610841990182908340717629849286713218055161453042659353860567734406665523150739074507776863711937202614139387402967614602827448114338965584371047818122254165209560756327433738273322173223495584757894740144146963057126420855755764727296465065007588010409322127232154083518081) is false
-end
-
-check "all within variants are defined":
-  num-within does-not-raise
-  num-within-rel does-not-raise
-  num-within-abs does-not-raise
-  within-now does-not-raise
-  within-rel does-not-raise
-  within-rel-now does-not-raise
-  within-abs does-not-raise
-  within-abs-now does-not-raise
-  within does-not-raise
-  within-now3 does-not-raise
-  within-rel3 does-not-raise
-  within-rel-now3 does-not-raise
-  within-abs3 does-not-raise
-  within-abs-now3 does-not-raise
-  within3 does-not-raise
-end

package/tests/pyret/tests/use/test-essentials.arr

@@ -1,6 +0,0 @@
-use context essentials2020
-
-check:
-  map satisfies is-function
-  to-repr satisfies is-function
-end

package/tests/pyret/tests/use/test-simple-use.arr

@@ -1,6 +0,0 @@
-use context global
-include lists
-
-check:
-  is-function(map) is true
-end