Add more assert function types

[ngeiswei]

Implement assert

We have assertEqual and so, but we don't have assert. It is a trivial addition, but my point is that it should probably be part of the stdlib.

To be clear what I mean

!(assert (or True False))

would output

[()]

While

!(assert (and True False))

would raise an error.

Implement assertContain

Another very convenient one would be assertContain (and maybe assertAlphaContain as well) which would check if the expected result is contained in a superposition of results.

For instance

(= (foo) 41)
(= (foo) 42)
(= (foo) 43)

;; Make sure that 42 is part of the solution set of foo
!(assertContain (foo) 42)

[ngeiswei]

This issue is different but related to #861 .

[vsbogd]

I did some experiments trying to understand is it possible to write asserts in pure MeTTa using hyperon-experimental. I tried to implement assertCallback which gets condition $cond and function $f parameters, evaluates $cond and if it is not True calls $f passing $cond and evaluated $cond as arguments.

I use the following example as a test:

(= (error') (Error (error) "This is a error"))
(= (error) (error'))
(= (true') True)
(= (true) (true'))
(= (false') False)
(= (false) (false'))

(: _assertAutoMessage (-> Atom Atom ErrorType))
(= (_assertAutoMessage $orig $eval)
  (let $msg (format-args "Expected to be True, but got: {}" ($eval)) (Error $orig $msg)))

(: assert (-> Atom (->)))
(= (assert $cond)
  (assertCallback $cond _assertAutoMessage))

!(assert (true)) ; should return ()
!(assert (false)) ; should return (Error (false) "Expected to be True, but got: False")
!(assert (error)) ; should return (Error (error) "Expected to be True, but got: (Error (error) \"This is a error\")")
!(assert (empty)) ; should return (Error (empty) "Expected to be True, but got: Empty")

The following implementation passes the test, nevertheless here are two problems.

(: assertCallback (-> Atom (-> Atom Atom ErrorType) (->)))
(= (assertCallback $cond $f)
 (switch (chain (collapse-bind (metta $cond %Undefined% &self)) $c (quote $c)) (
   ((quote ()) ($f $cond Empty))
   ((quote $r) (switch (chain (superpose-bind $r) $sr (quote $sr)) (
     ((quote True) ())
     ((quote $other) ($f $cond $other))
   )))
 )))

I need to use metta to run interpreter recursively but it requires passing space parameter. In the example above &self is passed and it is incorrect because &self token contains the space where assertCallback code is written. Thus this example works in a standalone file but assertCallback will not work if put its code into a standard library. It is a first problem.

We have (mod-space! top) which returns the top module space (i.e. root of the modules hierarchy). It may work instead of &self in a simple cases but generally it is more wider context than needed. Thus we need adding something to provide context atomspace to the metta or grounded operations. It can be an additional minimal MeTTa instruction (self-space) or default parameter of metta.

Second issue is related to the (Error ...) results processing. At the moment if some argument of the expression is evaluated to Error then outer expression is not evaluated and Error is returned instead. There is no way to intercept error similarly to catch in C++ or except in Python. In the code above I solved it using quote. It also requires _assertAutoMessage have the Atom as a type of the first parameter, i.e. we cannot use (-> $a $b $c) functions such as lambdas. This probably can be workarounded by allowing specify type of lambda function manually.

Another example of using the assertCallback function above which is implemented using lambda:

(: force-eval (-> %Undefined% %Undefined%))
(= (force-eval $x) $x)

(: \ (-> Variable Variable Atom (-> Atom $b $c)))
(= ((\ $arg1 $arg2 $body) $val1 $val2)
   (force-eval (sealed ($arg1 $arg2)
     (chain $val1 $arg1
       (chain $val2 $arg2
         $body )))))

(: assertMsg (-> Atom String (->)))
(= (assertMsg $cond $msg)
  (assertCallback $cond
    (\ $orig $eval (Error $orig $msg)) ))

!(assertMsg (true) "Expected to be True") ; returns ()
!(assertMsg (false) "Expected to be True") ; returns (Error (false) "Expected to be True")
!(assertMsg (error) "Expected to be True") ; returns (Error (error) "Expected to be True")
!(assertMsg (empty) "Expected to be True") ; returns (Error (empty) "Expected to be True")

[vsbogd]

In general I would like to introduce universal assert implementation:

(: assertGeneric (-> Atom (-> Atom Bool) (-> Atom Atom ErrorType) (->)))
(= (assertGeneric $data $cond $on-false)
 (switch (chain (collapse-bind (metta ($cond $data) %Undefined% &self)) $c (quote $c)) (
   ((quote ()) ($on-false $data Empty))
   ((quote $r) (switch (chain (superpose-bind $r) $sr (quote $sr)) (
     ((quote True) ())
     ((quote $other) ($on-false $data $other))
   )))
 )))

And implement all other asserts by calling it with appropriate $cond and $on-false values.

[vsbogd]

Last part implemented by #974