Merge pull request #10 from AdrickTench/master

ci.yml changes and some tests

.github/workflows/ci.yml

@@ -23,7 +23,7 @@ jobs:
   generate-reports:
     runs-on: ubuntu-latest
 
-    if: (github.repository == 'logicmoo/metta-testsuite')
+    if: (github.repository == 'logicmoo/metta-testsuite') || (github.event_name != 'schedule')
 
     env:
       JOB_TYPE: ${{ github.event_name == 'schedule' && 'nightly' || 'ci' }}

tests/baseline_compat/metta-morph_tests/test.sh

@@ -1,3 +1,2 @@
 echo "Testing:" $1
 sh run.sh $1 2> /dev/null | grep "!=" && echo "FAILED:" $1
-

tests/baseline_compat/metta_lang/Basic_evaluation___MeTTa_Language1.metta

@@ -1,4 +1,3 @@
-
 ; 20241014 r.v.v converted metta-lang.dev to metta 
 ;  !(assertEqualToResult ( )  (  )  ) 
 ; This line will be ignored.

tests/baseline_compat/metta_lang/Basic_evaluation___MeTTa_Language11.metta

@@ -1,4 +1,3 @@
-
 ; 20241014 r.v.v converted metta-lang.dev to metta 
 ;  !(assertEqualToResult ( )  (  )  ) 
 (= (brother Mike) Tom)

tests/baseline_compat/metta_lang/Basic_evaluation___MeTTa_Language4.metta

@@ -1,4 +1,3 @@
-
 ; 20241014 r.v.v converted metta-lang.dev to metta 
 ;  !(assertEqualToResult ( )  (  )  ) 
 

tests/baseline_compat/metta_lang/Concrete_types___MeTTa_Language5.metta

@@ -1,4 +1,3 @@
-
 ; 20241014 r.v.v converted metta-lang.dev to metta 
 ;  !(assertEqualToResult ( )  (  )  ) 
 ; This function accepts an atom of type A and returns an atom of type B

tests/baseline_compat/metta_lang/Console_output_and_debugging___MeTTa_Language10.metta

@@ -1,4 +1,3 @@
-
 ; 20241014 r.v.v converted metta-lang.dev to metta 
 
 (Parent Bob Ann)

tests/baseline_compat/metta_lang/Metatypes___MeTTa_Language7.metta

@@ -1,4 +1,3 @@
-
 ; 20241014 r.v.v converted metta-lang.dev to metta 
 ;  !(assertEqualToResult ( )  (  )  ) 
 

tests/baseline_compat/metta_lang/Recursive_and_parametric_types___MeTTa_Language5.metta

@@ -1,4 +1,3 @@
-
 ; 20241014 r.v.v converted metta-lang.dev to metta 
 ;  !(assertEqualToResult ( )  (  )  ) 
 

tests/baseline_compat/metta_lang/Working_with_spaces___MeTTa_Language1.metta

@@ -1,4 +1,3 @@
-
 ; 20241014 r.v.v converted metta-lang.dev to metta 
 ;  !(assertEqualToResult ( )  (  )  ) 
 ; aa 

tests/baseline_compat/metta_lang/Working_with_spaces___MeTTa_Language2.metta

@@ -1,4 +1,3 @@
-
 ; 20241014 r.v.v converted metta-lang.dev to metta 
 ;  !(assertEqualToResult ( )  (  )  ) 
 

tests/baseline_compat/metta_lang/Working_with_spaces___MeTTa_Language3.metta

@@ -1,4 +1,3 @@
-
 ; 20241014 r.v.v converted metta-lang.dev to metta 
 ;  !(assertEqualToResult ( )  (  )  ) 
 

tests/compiler_baseline/anti-regression/bc_comp.metta

@@ -0,0 +1,80 @@
+
+!(pp-about! get-metatype)
+(: is-variable (-> Atom Bool))
+(= (is-variable $x) (== (get-metatype $x) Variable))
+
+(: lazy-or (-> Bool Atom Bool))
+(= (lazy-or False $x) $x)
+(= (lazy-or True $x) True)
+
+(: is-expression (-> Atom Bool))
+(= (is-expression $x) (== (get-metatype $x) Expression))
+
+(: is-closed (-> Atom Bool))
+(= (is-closed $x) (if (is-variable $x)
+					  False
+					  (if (== () $x) True
+					  (if (is-expression $x)
+						  (and (let $head (car-atom $x) (is-closed $head))
+							   (let $tail (cdr-atom $x) (is-closed $tail)))
+						  True))))
+
+
+;; KB
+!(bind! &kb (new-space))
+
+!(add-atom &kb (: axiom (nums 2 3)))
+
+!(add-atom &kb (: rule1 
+                (-> (nums $x $y)
+                    (rule1output $x $y))))
+
+!(add-atom &kb 
+    (: rule 
+       (-> (rule1output $x $y)
+        (-> (⍃ $x $y)
+            (less $x $y)))))
+
+; !(add-atom &kb 
+;     (: rule 
+;         (-> (⍃ $x $y)
+;             (-> (rule1output $x $y)
+;                 (less $x $y)))))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; DTL Backward chaining Curried ;;
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+
+(: bc (-> $a hyperon::space::DynSpace Nat $a))
+;; Base case
+(= (bc (: $prf $ccln) $space $_1) 
+    (match $space (: $prf $ccln) (: $prf $ccln)))
+;; if conclusion equals (⍃ $X $Y), then return (: CPU (⍃ $X $Y)) 
+;; if $x and $Y are fully grounded and (< $X $Y)
+(= (bc (: CPU (⍃ $X $Y)) $space $_2) 
+	(if (and (and (is-closed $X) (is-closed $Y)) (< $X $Y))
+		(: CPU (⍃ $X $Y))
+		(empty)))
+
+;; Recursive step
+(= (bc (: ($prfabs $prfarg) $ccln) $space (S $k))
+   (let* (((: $prfabs (-> $prms $ccln)) 
+			          (bc (: $prfabs (-> $prms $ccln)) $space $k))
+          ((: $prfarg $prms) 
+			          (bc (: $prfarg $prms) $space $k)))
+
+     (: ($prfabs $prfarg) $ccln)))
+
+
+; Test
+!(bc (: CPU (⍃ 2 3)) &kb Z)
+!(bc (: CPU (⍃ 4 3)) &kb Z)
+
+; !(pragma! eval debug)
+
+;! ( rtrace! (bc (: $prf (less $x $y)) (S (S (S Z)))))
+
+!(bc (: $prf (less $x $y)) &kb (S (S (S Z))))
+
+

tests/compiler_baseline/anti-regression/bchain.metta

@@ -0,0 +1,79 @@
+!(pragma! compile False)
+
+(: is-variable (-> Atom Bool))
+(= (is-variable $x) (== (get-metatype $x) Variable))
+
+(: lazy-or (-> Bool Atom Bool))
+(= (lazy-or False $x) $x)
+(= (lazy-or True $x) True)
+
+(: is-expression (-> Atom Bool))
+(= (is-expression $x) (== (get-metatype $x) Expression))
+
+(: is-closed (-> Atom Bool))
+(= (is-closed $x) (if (is-variable $x)
+					  False
+					  (if (== () $x) True
+					  (if (is-expression $x)
+						  (and (let $head (car-atom $x) (is-closed $head))
+							   (let $tail (cdr-atom $x) (is-closed $tail)))
+						  True))))
+
+
+;; KB
+!(bind! &kb (new-space))
+
+!(add-atom &kb (: axiom (nums 2 3)))
+
+!(add-atom &kb (: rule1 
+                (-> (nums $x $y)
+                    (rule1output $x $y))))
+
+!(add-atom &kb 
+    (: rule 
+       (-> (rule1output $x $y)
+        (-> (⍃ $x $y)
+            (less $x $y)))))
+
+; !(add-atom &kb 
+;     (: rule 
+;         (-> (⍃ $x $y)
+;             (-> (rule1output $x $y)
+;                 (less $x $y)))))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; DTL Backward chaining Curried ;;
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+
+(: bc (-> $a Nat $a))
+;; Base case
+(= (bc (: $prf $ccln) $_1) (match &kb (: $prf $ccln) (: $prf $ccln)))
+;; if conclusion equals (⍃ $X $Y), then return (: CPU (⍃ $X $Y)) 
+;; if $x and $Y are fully grounded and (< $X $Y)
+(= (bc (: CPU (⍃ $X $Y)) $_2) 
+    (if (and (and (is-closed $X) (is-closed $Y)) (< $X $Y))
+        (: CPU (⍃ $X $Y))
+        (empty)))
+
+;; Recursive step
+(= (bc (: ($prfabs $prfarg) $ccln) (S $k))
+   (let* (((: $prfabs (-> $prms $ccln)) 
+			          (bc (: $prfabs (-> $prms $ccln)) $k))
+          ((: $prfarg $prms) 
+			          (bc (: $prfarg $prms) $k)))
+
+     (: ($prfabs $prfarg) $ccln)))
+
+
+; Test
+!(bc (: CPU (⍃ 2 3)) Z)
+!(bc (: CPU (⍃ 4 3)) Z)
+
+; !(pragma! eval debug)
+
+;! ( rtrace! (bc (: $prf (less $x $y)) (S (S (S Z)))))
+
+!(bc (: $prf (less $x $y)) (S (S (S Z))))
+
+

tests/compiler_baseline/anti-regression/bchain_comp.metta

@@ -0,0 +1,79 @@
+!(pragma! compile full)
+
+(: is-variable (-> Atom Bool))
+(= (is-variable $x) (== (get-metatype $x) Variable))
+
+(: lazy-or (-> Bool Atom Bool))
+(= (lazy-or False $x) $x)
+(= (lazy-or True $x) True)
+
+(: is-expression (-> Atom Bool))
+(= (is-expression $x) (== (get-metatype $x) Expression))
+
+(: is-closed (-> Atom Bool))
+(= (is-closed $x) (if (is-variable $x)
+					  False
+					  (if (== () $x) True
+					  (if (is-expression $x)
+						  (and (let $head (car-atom $x) (is-closed $head))
+							   (let $tail (cdr-atom $x) (is-closed $tail)))
+						  True))))
+
+
+;; KB
+!(bind! &kb (new-space))
+
+!(add-atom &kb (: axiom (nums 2 3)))
+
+!(add-atom &kb (: rule1 
+                (-> (nums $x $y)
+                    (rule1output $x $y))))
+
+!(add-atom &kb 
+    (: rule 
+       (-> (rule1output $x $y)
+        (-> (⍃ $x $y)
+            (less $x $y)))))
+
+; !(add-atom &kb 
+;     (: rule 
+;         (-> (⍃ $x $y)
+;             (-> (rule1output $x $y)
+;                 (less $x $y)))))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; DTL Backward chaining Curried ;;
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+
+(: bc (-> $a Nat $a))
+;; Base case
+(= (bc (: $prf $ccln) $_1) (match &kb (: $prf $ccln) (: $prf $ccln)))
+;; if conclusion equals (⍃ $X $Y), then return (: CPU (⍃ $X $Y)) 
+;; if $x and $Y are fully grounded and (< $X $Y)
+(= (bc (: CPU (⍃ $X $Y)) $_2) 
+    (if (and (and (is-closed $X) (is-closed $Y)) (< $X $Y))
+        (: CPU (⍃ $X $Y))
+        (empty)))
+
+;; Recursive step
+(= (bc (: ($prfabs $prfarg) $ccln) (S $k))
+   (let* (((: $prfabs (-> $prms $ccln)) 
+			          (bc (: $prfabs (-> $prms $ccln)) $k))
+          ((: $prfarg $prms) 
+			          (bc (: $prfarg $prms) $k)))
+
+     (: ($prfabs $prfarg) $ccln)))
+
+
+; Test
+!(bc (: CPU (⍃ 2 3)) Z)
+!(bc (: CPU (⍃ 4 3)) Z)
+
+; !(pragma! eval debug)
+
+;! ( rtrace! (bc (: $prf (less $x $y)) (S (S (S Z)))))
+
+!(bc (: $prf (less $x $y)) (S (S (S Z))))
+
+

tests/compiler_baseline/anti-regression/comma_is_not_special.metta

@@ -0,0 +1,13 @@
+
+
+
+;; the comma only works in match 
+
+(= (test-func2 $b)  (let $a (, hello $b) $a))
+
+!(assertEqualToResult 
+     (test-func2 world) 
+       ((, hello world)))
+
+
+