move Assert and check to the stdlib

Move the Assert and check function from the local test library to the
stdlib, under the name of `std.test.Assert` and `std.test.assert_all`.

Co-authored-by: Yann Hamdaoui <yann.hamdaoui@gmail.com>

HACKING.md

@@ -147,14 +147,13 @@ directory. All `.ncl` files in this directory are automatically converted into
 Rust integration tests, which run the file and assert that no errors were
 raised during evaluation.
 
-Each of these `.ncl` files is structured as an array of `Bool` expressions, which
-is ultimately passed to a `check` function defined in
-`core/tests/integration/pass/lib/assert.ncl`.
-This function applies an `Assert` contract to each value in the array, which
-checks that the value it is applied to evaluates to `true`. The benefit of using
-a contract for this is that if a test fails we can simply run the file directly
-using Nickel, which gives better error messages than the ones we get by default
-from `cargo test`.
+Each of these `.ncl` files is structured as an array of `Bool` expressions,
+which is ultimately passed to `std.contract.check` function defined in the
+standard library. This function applies an `Assert` (`std.test.Assert`)
+contract to each value in the array, which checks that the value it is applied
+to evaluates to `true`. The benefit of using a contract for this is that if a
+test fails we can simply run the file directly using Nickel, which gives better
+error messages than the ones we get by default from `cargo test`.
 
 Tests which are expected to fail may be written in Rust in `core/tests/integration`.
 However, simple failure test cases can make use of the test annotation support

core/stdlib/std.ncl

@@ -792,6 +792,28 @@
   },
 
   contract = {
+    Assert
+      | doc m%"
+        A contract that checks if its argument is the boolean true.
+
+        We could get by just using arrays of boolean tests and `std.array.all`.
+
+        However, this contract provides fine-grained error reporting,
+        pinpointoing the exact expression that failed in an array of tests, as
+        opposed to the pure boolean solution.
+
+        # Examples
+
+        ```nickel
+        1 == 2 | std.test.Assert
+         => error: contract broken by a value
+
+        1 == 1 | std.test.Assert
+         => true
+        ```
+        "%
+      = fun l x => if x then true else %blame% l,
+
     Equal
       | doc m%"
         `Equal` is a contract enforcing equality to a given constant.
@@ -3064,6 +3086,44 @@
       = fun s => %enum_from_str% s,
   },
 
+  test = {
+    Assert
+      | doc m%"
+        A contract that checks if its argument is the boolean true.
+
+        # Examples
+
+        ```nickel
+        1 == 2 | std.test.Assert
+         => error: contract broken by a value
+
+        1 == 1 | std.test.Assert
+         => true
+        ```
+        "%
+      = fun l x => if x then true else %blame% l,
+
+    # We statically type `assert_all` because (x | Assert) is not of type bool.
+    # We could use additional contracts to make it work but it's not worth the
+    # hassle, given the size of the function.
+    assert_all
+      | doc m%"
+        Asserts that all the elements of an array are equal to true. Applies the
+        `std.test.Assert` contract on each element of the given array.
+
+        Evalutes to `true` if all the elements of the array are equal to true,
+        or fails with a contract error otherwise.
+
+        # Example
+
+        ```nickel
+        [ (1 == 2), (1 == 1), (1 == 3) ] |> std.test.assert_all
+         => error: contract broken by a value
+        ```
+        "%
+      = std.array.fold_left (fun acc test => (test | Assert) && acc) true,
+  },
+
   is_number
     : Dyn -> Bool
     | doc m%"

core/tests/integration/inputs/adts/enum_primops.ncl

@@ -1,5 +1,5 @@
 # test.type = 'pass'
-let {check, ..} = import "../lib/assert.ncl" in
+
 
 [
   %enum_unwrap_variant% ('Left (1+1)) == 2,
@@ -8,4 +8,4 @@ let {check, ..} = import "../lib/assert.ncl" in
   %enum_get_tag% 'Right == 'Right,
   %enum_get_tag% ('Right "stuff") == 'Right,
 ]
-|> check
+|> std.test.assert_all

core/tests/integration/inputs/contracts/contracts.ncl

@@ -1,5 +1,5 @@
 # test.type = 'pass'
-let {check, Assert, ..} = import "../lib/assert.ncl" in
+let Assert = std.test.Assert in
 
 [
   let AlwaysTrue = fun l t =>
@@ -179,4 +179,4 @@ let {check, Assert, ..} = import "../lib/assert.ncl" in
   in
   tag == 'some_tag,
 ]
-|> check
+|> std.test.assert_all

core/tests/integration/inputs/contracts/let_order.ncl

@@ -1,5 +1,5 @@
 # test.type = 'pass'
-let { check, Assert, .. } = import "../lib/assert.ncl" in
+
 let ConstantTrue = fun _label value => std.seq value true in
 [
   let foo | ConstantTrue | Bool = "not a bool" in
@@ -12,4 +12,4 @@ let ConstantTrue = fun _label value => std.seq value true in
       = "still not a bool"
   }.foo
 ]
-|> check
+|> std.test.assert_all

core/tests/integration/inputs/contracts/types_dont_propagate.ncl

@@ -1,5 +1,5 @@
 # test.type = 'pass'
-let {check, ..} = import "../lib/assert.ncl" in
+
 
 [
   # check that a record type literal is indeed converted to the corresponding
@@ -21,4 +21,4 @@ let {check, ..} = import "../lib/assert.ncl" in
   & {foo | force = false, bar | force = true})
   == {foo = false, bar = true},
 ]
-|> check
+|> std.test.assert_all

core/tests/integration/inputs/core/arrays.ncl

@@ -1,5 +1,5 @@
 # test.type = 'pass'
-let {check, ..} = import "../lib/assert.ncl" in
+
 
 [
   # accesses
@@ -49,4 +49,4 @@ let {check, ..} = import "../lib/assert.ncl" in
 
   std.array.map_with_index (+) [1, 2, 3] == [1, 3, 5],
 ]
-|> check
+|> std.test.assert_all

core/tests/integration/inputs/core/basics.ncl

@@ -1,5 +1,5 @@
 # test.type = 'pass'
-let {check, ..} = import "../lib/assert.ncl" in
+
 
 [
   # basic arithmetic
@@ -35,4 +35,4 @@ let {check, ..} = import "../lib/assert.ncl" in
   # This test checks that the terms of a match are closured
   let x = 3 in ((3 + 2) |> match { 'foo => 1, _ => x}) == 3,
 ]
-|> check
+|> std.test.assert_all

core/tests/integration/inputs/core/builtins.ncl

@@ -1,5 +1,5 @@
 # test.type = 'pass'
-let {check, ..} = import "../lib/assert.ncl" in
+
 
 [
   # is_record
@@ -28,4 +28,4 @@ let {check, ..} = import "../lib/assert.ncl" in
    |> std.deserialize 'Json
    == [3,4],
 ]
-|> check
+|> std.test.assert_all

core/tests/integration/inputs/core/curried_dot.ncl

@@ -1,5 +1,5 @@
 # test.type = 'pass'
-let {check, ..} = import "../lib/assert.ncl" in
+
 
 let record = {foo = 1, bar = { baz = 2 }} in
 let field = "bar" in
@@ -9,4 +9,4 @@ let part = "ba" in
   (.) record field == { baz = 2 },
   let res = (.) record field == {baz = 2} in res,
   (.) record "%{part}r" == { baz = 2 },
-] |> check
+] |> std.test.assert_all

core/tests/integration/inputs/core/eq.ncl

@@ -1,5 +1,5 @@
 # test.type = 'pass'
-let {check, ..} = import "../lib/assert.ncl" in
+
 
 [
   # basic
@@ -84,4 +84,4 @@ let {check, ..} = import "../lib/assert.ncl" in
   'Left 2 != 'Right 2,
   'Up [1,2,3] == 'Up [0+1,1+1,2+1],
 ]
-|> check
+|> std.test.assert_all

core/tests/integration/inputs/core/fibo.ncl

@@ -1,5 +1,5 @@
 # test.type = 'pass'
-let {Assert, ..} = import "../lib/assert.ncl" in
+let Assert = std.test.Assert in
 
 let Y | ((Number -> Number) -> Number -> Number) -> Number -> Number = fun f => (fun x => f (x x)) (fun x => f (x x)) in
 let dec : Number -> Number = fun x => x + (-1) in

core/tests/integration/inputs/core/functions.ncl

@@ -1,5 +1,5 @@
 # test.type = 'pass'
-let {check, ..} = import "../lib/assert.ncl" in
+
 
 [
   (fun x => x) 3 == 3,
@@ -16,4 +16,4 @@ let {check, ..} = import "../lib/assert.ncl" in
     g true
     == 4,
 ]
-|> check
+|> std.test.assert_all

core/tests/integration/inputs/core/import.ncl

@@ -1,3 +1,3 @@
 # test.type = 'pass'
-let { Assert, .. } = import "../lib/assert.ncl" in
+let Assert = std.test.Assert in
 ((import "../lib/imported.ncl") 3 == 3 | Assert)

core/tests/integration/inputs/core/numbers.ncl

@@ -1,10 +1,10 @@
 # test.type = 'pass'
-let {check, ..} = import "../lib/assert.ncl" in
+
 
 [
   5 + 5 == 10,
   5 * 5 == 25,
   1e6 == 1000000,
   1e+3 / 2e-3 == 0.5e6,
 ]
-|> check
+|> std.test.assert_all

core/tests/integration/inputs/core/records.ncl

@@ -1,5 +1,5 @@
 # test.type = 'pass'
-let { check, .. } = import "../lib/assert.ncl" in
+
 
 [
   # accesses
@@ -171,4 +171,4 @@ let { check, .. } = import "../lib/assert.ncl" in
     && r.force == "no"
   )
 ]
-|> check
+|> std.test.assert_all

core/tests/integration/inputs/core/recursive_let.ncl

@@ -1,8 +1,8 @@
 # test.type = 'pass'
-let {check, ..} = import "../lib/assert.ncl" in
+
 
 [
   let rec f = fun n => if n == 0 then n else f (n - 1) in f 10 == 0,
   let rec fib = fun n => if n == 0 || n == 1 then 1 else fib (n - 1) + fib (n - 2) in fib 5 == 8,
 ]
-|> check
+|> std.test.assert_all

core/tests/integration/inputs/imports/yaml_import.ncl

@@ -1,6 +1,6 @@
 # test.type = 'pass'
 
-let {check, ..} = import "../lib/assert.ncl" in
+
 [
   (import "imported/empty.yaml") == null,
 
@@ -9,4 +9,4 @@ let {check, ..} = import "../lib/assert.ncl" in
     { type = "event", id = 2 }
   ],
 ]
-|> check
+|> std.test.assert_all

core/tests/integration/inputs/merging/adts.ncl

@@ -1,5 +1,5 @@
 # test.type = 'pass'
-let { check, .. } = import "../lib/assert.ncl" in
+
 
 [
   'Foo true & 'Foo true == 'Foo true,
@@ -13,4 +13,4 @@ let { check, .. } = import "../lib/assert.ncl" in
   & { two.b = 1, one = 'Qux {c = 0} }
   == { one = 'Qux { a = 1, b = 1, c = 0 }, two = { a = 1, b = 1 } },
 ]
-|> check
+|> std.test.assert_all

core/tests/integration/inputs/merging/array-merge.ncl

@@ -1,5 +1,5 @@
 # test.type = 'pass'
-let {check, ..} = import "../lib/assert.ncl" in
+
 
 [
   # array pointwise merging
@@ -25,4 +25,4 @@ let {check, ..} = import "../lib/assert.ncl" in
   & ([0 + 0, 1 + 0, 2 + 0] | Array AddOne)
   == [1, 2, 3],
 ]
-|> check
+|> std.test.assert_all

core/tests/integration/inputs/merging/lazy-propagation.ncl

@@ -1,5 +1,5 @@
 # test.type = 'pass'
-let {check, Assert, ..} = import "../lib/assert.ncl" in
+
 
 # tests related to RFC005. Check in particular that the motivating examples of
 # RFC005 are indeed fixed by lazy propagation.
@@ -44,4 +44,4 @@ let {check, Assert, ..} = import "../lib/assert.ncl" in
   & {bar = "bar"})
   == {foo = 5, bar = "bar"},
 ]
-|> check
+|> std.test.assert_all

core/tests/integration/inputs/merging/metavalues.ncl

@@ -1,5 +1,5 @@
 # test.type = 'pass'
-let {check, Assert, ..} = import "../lib/assert.ncl" in
+let Assert = std.test.Assert in
 
 [
   {val | default | Number = 10}.val == 10,
@@ -132,4 +132,4 @@ let {check, Assert, ..} = import "../lib/assert.ncl" in
     (%fields% value == ["foo", "opt"] | Assert)
   ),
 ]
-|> check
+|> std.test.assert_all

core/tests/integration/inputs/merging/multiple_overrides.ncl

@@ -1,5 +1,5 @@
 # test.type = 'pass'
-let {check, ..} = import "../lib/assert.ncl" in
+
 
 [
   # regression test for issue #908 (https://github.com/tweag/nickel/issues/908)
@@ -121,6 +121,6 @@ let {check, ..} = import "../lib/assert.ncl" in
       fst_data = "override",
       snd_data = "override",
     }
-  ] |> check,
+  ] |> std.test.assert_all,
 ]
-|> check
+|> std.test.assert_all