fix: Addressed few failing test cases and code optimizations

Author: Yagth

utilities/general-helpers.metta

@@ -711,6 +711,7 @@
 ;; Converts a tuple of pairs into ordered multimap
 ;; Ex: ((k1 v1) (k2 v2)) -> (cons (k1 v1) (cons (k2 v2) ()))
 ;; (: expToMMap (-> Expression (MultiMap ($k $v)) (-> $k $k Bool) (MultiMap ($k $v))))
+;; TODO: Change this to simpler function
 (= (expToMMap () $map $compFunc) ())
 (= (expToMMap $tuple $map $compFunc)
 (let*
@@ -953,9 +954,6 @@
 (= (coll.append NilOMS $el) (eval (OMS.insert $el NilOMS)))
 (= (coll.append (ConsOMS $x $xs) $el) (eval (OMS.insert $el (ConsOMS $x $xs))))
 
-;; Ordered Set insertion should stay explicit through `OS.insert` because raw cons-lists
-;; are also used for normal lists and pair-backed containers after the cons migration.
-
 ;; Deme — append ScoredInstance to its InstanceSet
 (= (coll.append (mkDeme $rep (mkSInstSet $list) $demeId) $el)
    (mkDeme $rep (mkSInstSet (coll.append $list $el)) $demeId))

utilities/list-methods.metta

@@ -28,7 +28,7 @@
 (= (List.sum $xs) (List.foldr + 0 $xs))
 
 ; (: List.append (-> $a (List $a) (List $a)))
-(= (List.append $val ()) (cons-atom $val ()))
+(= (List.append $val ()) ($val))
 (= (List.append $val (cons $head $tail))
    (cons-atom $head (List.append $val $tail)))
 
@@ -40,15 +40,15 @@
        (index-atom $xs $idx)))
 
 ; (: List.insert (-> $a (List $a) (List $a)))
-(= (List.insert $x ()) (cons-atom $x ()))
+(= (List.insert $x ()) ($x))
 (= (List.insert $x (cons $head $tail))
    (if (< $x $head)
-       (cons-atom $x (cons-atom $head $tail))
-       (cons-atom $head (List.insert $x $tail))))
+       (cons $x (cons $head $tail))
+       (cons $head (List.insert $x $tail))))
 
 ;; Sort a list in ascending order by default.
 (= (List.sort ()) ())
-(= (List.sort $xs) (List.sort $xs <))
+(= (List.sort (cons $x $xs)) (List.sort (cons $x $xs) <))
 (= (List.sort $xs $op)
    (selectionSort $xs (size-atom $xs) $op))
 
@@ -64,7 +64,7 @@
    (let $new-head ($f $head $arg)
      (if (== $new-head ())
          (List.mapOverArg $f $tail $arg)
-         (cons-atom $new-head (List.mapOverArg $f $tail $arg)))))
+         (cons $new-head (List.mapOverArg $f $tail $arg)))))
 
 ; (: List.filter (-> (-> $a Bool) (List $a) (List $a)))
 (= (List.filter $p $xs) (filter-atom $xs $p))
@@ -86,20 +86,25 @@
 (= (List.max $xs) (List.max >= $xs))
 
 ; (: List.contains (-> $a (List $a) Bool))
-(= (List.contains $a ()) False)
-(= (List.contains $a (cons $head $tail))
-   (if (== $a $head) True (List.contains $a $tail)))
+(= (List.contains $a $list) (is-member $a $list))
 
 ; (: List.replaceAt (-> (List $a) Number $a (List $a)))
 (= (List.replaceAt () $n $elem) ())
 (= (List.replaceAt (cons $head $tail) $n $elem)
    (if (== $n 0)
-       (cons-atom $elem $tail)
-       (cons-atom $head (List.replaceAt $tail (- $n 1) $elem))))
+       (cons $elem $tail)
+       (cons $head (List.replaceAt $tail (- $n 1) $elem))))
 
 ; (: List.prepend (-> $a (List $a) (List $a)))
-(= (List.prepend $a $list) (cons-atom $a $list))
-
+(= (List.prepend $a $list) (cons $a $list))
+
+;; Find an element in a list
+;; Params: 
+;;  $list: The list to search
+;;  $target: The element to find
+;; Returns: 
+;;  The index of the first found element or
+;;  -1 If the element can't be found
 ; (: List.index (-> (List $a) $a Number))
 (= (List.index () $target) -1)
 (= (List.index (cons $x $xs) $target)
@@ -116,6 +121,7 @@
 (= (List.tail ()) ())
 (= (List.tail (cons $x $xs)) $xs)
 
+;; INFO: The previous overloaded version doesn't work here after changing to expression.
 ; (: List.sub (-> (List Number) (List Number) (List Number)))
 (= (List.sub $xs $ys)
    (if (== $xs ())
@@ -138,22 +144,23 @@
 (= (List.zip () (cons $y $ys)) ())
 (= (List.zip (cons $x $xs) ()) ())
 (= (List.zip (cons $x $xs) (cons $y $ys))
-   (cons-atom ($x $y) (List.zip $xs $ys)))
+   (cons ($x $y) (List.zip $xs $ys)))
 
 ; (: List.zipWith (-> (-> $a $b $c) (List $a) (List $b) (List $c)))
 (= (List.zipWith $f () ()) ())
 (= (List.zipWith $f () (cons $y $ys)) ())
 (= (List.zipWith $f (cons $x $xs) ()) ())
 (= (List.zipWith $f (cons $x $xs) (cons $y $ys))
-   (cons-atom ($f $x $y) (List.zipWith $f $xs $ys)))
+   (cons ($f $x $y) (List.zipWith $f $xs $ys)))
 
 ; (: List.drop (-> Number (List $a) (List $a)))
 (= (List.drop $n ()) ())
 (= (List.drop $n (cons $x $xs))
    (if (== $n 0)
-       (cons-atom $x $xs)
+       (cons $x $xs)
        (List.drop (- $n 1) $xs)))
 
+;; INFO: Behavior has changed from previous List.flatten. Investigation needed if causes an error.
 ; (: List.flatten (-> (List (List $a)) (List $a)))
 (= (List.flatten ()) ())
 (= (List.flatten (cons $x $xs))
@@ -165,7 +172,7 @@
 (= (List.repeat $n $a)
    (if (== $n 0)
        ()
-       (cons-atom $a (List.repeat (- $n 1) $a))))
+       (cons $a (List.repeat (- $n 1) $a))))
 
 ; (: List.concat (-> (List $a) (List $a) (List $a)))
 (= (List.concat $list1 $list2) (append $list1 $list2))
@@ -174,19 +181,19 @@
 (= (List.removeAtIdx () $idx) ())
 (= (List.removeAtIdx (cons $head $tail) $idx)
    (if (< $idx 0)
-       (cons-atom $head $tail)
+       (cons $head $tail)
        (if (== $idx 0)
            $tail
-           (cons-atom $head (List.removeAtIdx $tail (- $idx 1))))))
+           (cons $head (List.removeAtIdx $tail (- $idx 1))))))
 
 ; (: List.isMember (-> $a (List $a) Bool))
 (= (List.isMember $elem $list) (List.contains $elem $list))
 
 ; (: List.partialSort (-> (-> $a $a Bool) (List $a) Number (List $a) (List $a)))
 (= (List.partialSort $comparator () $n $acc) $acc)
-(= (List.partialSort $comparator $xs $n $acc)
-   (let* (($max (List.max $comparator $xs))
-          ($unsortedList (List.delete $max $xs))
+(= (List.partialSort $comparator (cons $x $xs) $n $acc)
+   (let* (($max (List.max $comparator (cons $x $xs)))
+          ($unsortedList (List.delete $max (cons $x $xs)))
           ($sortedList (List.append $max $acc)))
      (if (<= (- $n 1) 0)
          (List.appendList $unsortedList $sortedList)
@@ -203,7 +210,7 @@
 (= (List.delete $a (cons $x $xs))
    (if (== $x $a)
        $xs
-       (cons-atom $x (List.delete $a $xs))))
+       (cons $x (List.delete $a $xs))))
 
 ; (: List.takeN (-> Number (List $a) (List $a)))
 (= (List.takeN $n ()) ())
@@ -222,7 +229,7 @@
 ; (: List.generate (-> Number Number (List Number)))
 (= (List.generate $length $element)
    (if (> $length 0)
-       (cons-atom $element (List.generate (- $length 1) $element))
+       (cons $element (List.generate (- $length 1) $element))
        ()))
 
 ;; Remove an element from a list by index.
@@ -231,7 +238,7 @@
    (if (== $i 0)
        $xs
        (chain (List.pop (- $i 1) $xs) $res
-         (if-error $res (cons-atom $x ()) (cons-atom $x $res)))))
+         (if-error $res (cons $x ()) (cons $x $res)))))
 
 (= (List.splitAt $i $xs)
    ((List.takeN $i $xs) (List.drop $i $xs)))

utilities/map.metta

@@ -2,25 +2,25 @@
 (: Map (-> ($k $v) Type))
 
 ;; An insertion function that also allows map to act as a counter
-(= (Map.insertCounter $key ()) (cons-atom ($key 1) ()))
+(= (Map.insertCounter $key ()) (cons ($key 1) ()))
 (= (Map.insertCounter $key (cons ($curKey $curVal) $tail))
     (if (== $key $curKey)
-        (cons-atom ($curKey (+ $curVal 1)) $tail)
+        (cons ($curKey (+ $curVal 1)) $tail)
         (if (< $key $curKey)
-            (cons-atom ($key 1) (cons-atom ($curKey $curVal) $tail))
-            (cons-atom ($curKey $curVal) (Map.insertCounter $key $tail)))))
+            (cons ($key 1) (cons ($curKey $curVal) $tail))
+            (cons ($curKey $curVal) (Map.insertCounter $key $tail)))))
 
 ;; insert an element to a Map using custom comparison functions (equality + less-than)
-(= (Map.insert ($key $value) () $fEq $fLt) (cons-atom ($key $value) ()))
+(= (Map.insert ($key $value) () $fEq $fLt) (cons ($key $value) ()))
 (= (Map.insert ($key $value) (cons ($curKey $curVal) $tail) $fEq $fLt)
     (if ($fEq $key $curKey)
-        (cons-atom ($key $value) $tail)
+        (cons ($key $value) $tail)
         (if ($fLt $key $curKey)
-            (cons-atom ($key $value) (cons-atom ($curKey $curVal) $tail))
-            (cons-atom ($curKey $curVal) (Map.insert ($key $value) $tail $fEq $fLt)))))
+            (cons ($key $value) (cons ($curKey $curVal) $tail))
+            (cons ($curKey $curVal) (Map.insert ($key $value) $tail $fEq $fLt)))))
 
 ;; insert an element to a Map
-(= (Map.insert ($key $value) ()) (cons-atom ($key $value) ()))
+(= (Map.insert ($key $value) ()) (cons ($key $value) ()))
 (= (Map.insert ($key $value) (cons ($curKey $curVal) $tail))
     (if (== $key $curKey)
         (cons-atom ($key $value) $tail)
@@ -35,8 +35,8 @@
 
 ;; Get a pair from a Map using index
 (= (Map.getByIdx () $i) (Error () "Index out of bounds"))
-(= (Map.getByIdx $map $i)
-   (List.getByIdx $map $i))
+(= (Map.getByIdx (cons $x $xs) $i)
+   (List.getByIdx (cons $x $xs) $i))
 
 ;; Check if a key is in the Map
 (= (Map.contains $key ()) False)
@@ -54,7 +54,7 @@
     (if (== $key $curKey)
         $tail
         (chain (Map.remove $key $tail) $res
-          (if-error $res $res (cons-atom ($curKey $curVal) $res)))))
+          (if-error $res $res (cons ($curKey $curVal) $res)))))
 
 ;; Get all the values from the map
 (= (Map.values $map)

utilities/ordered-multimap.metta

@@ -2,18 +2,18 @@
 (: MultiMap (-> ($k $v) Type))
 
 ;; insert an element to the Ordered multimap using custom function
-(= (MultiMap.insert ($key $value) () $fn) (cons-atom ($key $value) ()))
+(= (MultiMap.insert ($key $value) () $fn) (cons ($key $value) ()))
 (= (MultiMap.insert ($key $value) (cons ($curKey $curVal) $tail) $fn)
    (if ($fn $key $curKey)
-       (cons-atom ($key $value) (cons-atom ($curKey $curVal) $tail))
-       (cons-atom ($curKey $curVal) (MultiMap.insert ($key $value) $tail $fn))))
+       (cons ($key $value) (cons ($curKey $curVal) $tail))
+       (cons ($curKey $curVal) (MultiMap.insert ($key $value) $tail $fn))))
 
 ;; default insert function using <=
 (= (MultiMap.insert $newValue $mMap) (MultiMap.insert $newValue $mMap <=))
 
 ;; Get the key value pair given an index.
 (= (MultiMap.getByIdx $idx ()) (Error () (Can't find $idx)))
-(= (MultiMap.getByIdx $idx $mmap) (List.getByIdx $mmap $idx))
+(= (MultiMap.getByIdx $idx (cons $x $xs)) (List.getByIdx (cons $x $xs) $idx))
 
 ;; Get the first found value with the given key from the Ordered multimap using key
 (= (MultiMap.findOne $key ()) (Error $key "not found"))
@@ -24,7 +24,7 @@
 (= (MultiMap.findAll $key ()) ())
 (= (MultiMap.findAll $key (cons ($curKey $curVal) $tail))
     (if (== $key $curKey)
-        (cons-atom $curVal (MultiMap.findAll $key $tail))
+        (cons $curVal (MultiMap.findAll $key $tail))
         (MultiMap.findAll $key $tail)))
 
 ;; Check if a key is in the Ordered multimap
@@ -43,14 +43,14 @@
     (if (== $key $curKey)
         $tail
         (chain (MultiMap.removeOne $key $tail) $res
-          (if-error $res $res (cons-atom ($curKey $curVal) $res)))))
+          (if-error $res $res (cons ($curKey $curVal) $res)))))
 
 ;; Remove all key-value pairs with a given key from the Ordered multimap
 (= (MultiMap.removeAll $key ()) ())
 (= (MultiMap.removeAll $key (cons ($curKey $curVal) $tail))
     (if (== $key $curKey)
         (MultiMap.removeAll $key $tail)
-        (cons-atom ($curKey $curVal) (MultiMap.removeAll $key $tail))))
+        (cons ($curKey $curVal) (MultiMap.removeAll $key $tail))))
 
 ;; Get all the values from the multimap
 (= (MultiMap.values $mmap)

utilities/ordered-set.metta

@@ -2,18 +2,19 @@
 (: OS (-> $a Type))
 
 ;; Insert an element into an ordered set using comparator returning G/E/L.
-(= (OS.insert $comparator $x ()) (cons-atom $x ()))
+;; TODO: comparison operators used in the original MOSES implementation works by finding the difference between the scores and 
+;;      two exemplars are deemed equal if this difference value is within a certain range which is a samll number
+(= (OS.insert $comparator $x ()) ($x))
 (= (OS.insert $comparator $new (cons $x $xs))
     (case ($comparator $new $x)
-      ((G (cons-atom $new (cons-atom $x $xs)))
-       (E (cons-atom $x $xs))
-       (L (cons-atom $x (OS.insert $comparator $new $xs))))))
+      ((G (cons $new (cons $x $xs)))
+       (E (cons $x $xs))
+       (L (cons $x (OS.insert $comparator $new $xs))))))
 
 ;; Length of an OS
 (= (OS.length $os) (size-atom $os))
 
 ;; OS.getByIdx -- get by index
-(= (OS.getByIdx $idx ()) (Error $idx "empty set/index out of range"))
 (= (OS.getByIdx $idx $os)
    (if (or (< $idx 0) (>= $idx (size-atom $os)))
        (Error 0 "empty set/index out of range")
@@ -24,7 +25,7 @@
 (= (OS.takeN $n (cons $x $xs))
     (if (<= $n 0)
         ()
-        (cons-atom $x (OS.takeN (- $n 1) $xs))))
+        (cons $x (OS.takeN (- $n 1) $xs))))
 
 ;; OS.contains -- check if an ordered list contains a particular element
 (= (OS.contains $os $el) (is-member $el $os))
@@ -37,17 +38,18 @@
         (chain (OS.removeByIdx $xs (- $index 1)) $res
           (if (== $res ())
               ($x)
-              (if-error $res $res (cons-atom $x $res))))))
+              (if-error $res $res (cons $x $res))))))
 
 ;; Check if an Exemplar is a member of an ordered set
 (= (OS.isMember $exemplar $os) (OS.contains $os $exemplar))
 
 ;; Retrieves the first N elements from an ordered set.
 (= (OS.getTopN $n ()) (Error () "empty ordered set/ fewer items than required"))
-(= (OS.getTopN $n $os)
-   (if (> $n (size-atom $os))
-       (Error () "empty ordered set/ fewer items than required")
-       (OS.takeN $n $os)))
+(= (OS.getTopN $n (cons $x $xs))
+   (if (== $n 1)
+       (cons $x ())
+       (chain (OS.getTopN (- $n 1) $xs) $res
+          (if-error $res $res (cons $x $res)))))
 
 ;; Comparator helpers
 (= (genericCompare $atom1 $atom2)
@@ -94,12 +96,8 @@
          (OS.difference $tail $set2 $newResult))))
 
 ;; Convert OrderedSet to Expression
-(= (osToExpression $os $acc) (append $os $acc))
+;; (= (osToExpression $os $acc) (append $os $acc))
+(= (osToExpression $os $acc) $os)
 
 ;; Convert Expression to OrderedSet
-(= (expressionToOS $expr $currentOS)
-    (if (== $expr ())
-        $currentOS
-        (let ($head $tail) (decons-atom $expr)
-             (chain (OS.insert genericCompare $head $currentOS) $newOS
-                 (expressionToOS $tail $newOS)))))
+(= (expressionToOS $expr $currentOS) $expr)

utilities/tests/general-helper-functions-test.metta

@@ -532,32 +532,6 @@
 !(println! ("testing coll.getByIdx"))
 !(assertEqual (coll.getByIdx (cons 10 (cons 20 (cons 30 ()))) 1) 20)
 
-;; --------------------------------
-;; Map — keys/values/items/find/getByKey/length/contains
-;; --------------------------------
-!(println! ("testing  coll.length"))
-; Raw cons-backed Map semantics are ambiguous after the container constructor migration.
-; They are covered by utilities/tests/map-test.metta.
-
-;; --------------------------------
-;; MultiMap — findOne/findAll/length/contains
-;; --------------------------------
-!(println! ("testing coll.length"))
-; Raw cons-backed MultiMap semantics are ambiguous after the container constructor migration.
-; They are covered by utilities/tests/ordered-multimap-test.metta.
-
-;; ;; --------------------------------
-;; ;; OrderedSet — contains/getByIdx/removeByIdx/takeN
-;; ;; --------------------------------
-!(println! ("testing coll.length "))
-; Raw cons-backed OrderedSet semantics are ambiguous after the container constructor migration.
-; They are covered by utilities/tests/ordered-set-test.metta.
-
-;; ;; --------------------------------
-;; OrderedMultiset — length/append/contains/getByIdx/remove
-;; --------------------------------
-
-; Covered by utilities/tests/ordered-multiset-test.metta
 
 ;; Cscore comparisons via apply (inline mkCscore)
 !(println! ("apply >"))