Add sort tests

Signed-off-by: James Hamlin <jfhamlin@gmail.com>

Author: jfhamlin

internal/persistent/vector/vector.go

@@ -46,10 +46,10 @@ type Vector interface {
 
 // Iterator is an iterator over vector elements. It can be used like this:
 //
-//     for it := v.Iterator(); it.HasElem(); it.Next() {
-//         elem := it.Elem()
-//         // do something with elem...
-//     }
+//	for it := v.Iterator(); it.HasElem(); it.Next() {
+//	    elem := it.Elem()
+//	    // do something with elem...
+//	}
 type Iterator interface {
 	// Elem returns the element at the current position.
 	Elem() interface{}

pkg/lang/slices.go

@@ -42,6 +42,17 @@ func ToSlice(x any) []any {
 		return res
 	}
 
+	// Handle Set - convert to array of values
+	if s, ok := x.(*Set); ok {
+		seq := s.Seq()
+		res := make([]any, 0, s.Count())
+		for seq != nil {
+			res = append(res, seq.First())
+			seq = seq.Next()
+		}
+		return res
+	}
+	
 	// Handle string - convert to character array
 	if s, ok := x.(string); ok {
 		runes := []rune(s) // Important: use runes for proper Unicode handling

pkg/lang/sort.go

@@ -10,7 +10,7 @@ import (
 // - Stable sort (equal elements maintain their relative order)
 // - In-place modification of the array
 // - Comparator returns -1 for less than, 0 for equal, 1 for greater than
-func SortSlice(slice []any, comp any) error {
+func SortSlice(slice []any, comp any) {
 	// comp is a Clojure function that acts as a comparator
 	compFn, ok := comp.(IFn)
 	if !ok {
@@ -22,19 +22,24 @@ func SortSlice(slice []any, comp any) error {
 		// Call the comparator function with the two elements
 		result := compFn.Invoke(slice[i], slice[j])
 
-		// Comparator returns:
+		// Handle both boolean and numeric comparators
+		// Boolean comparator: returns true if i < j
+		// Numeric comparator: returns negative if i < j
+		if boolResult, ok := result.(bool); ok {
+			return boolResult
+		}
+		
+		// Numeric comparator returns:
 		// -1 if first arg is less than second
 		//  0 if args are equal
 		//  1 if first arg is greater than second
 		// We return true for "less than" case
 		resultInt, ok := AsInt(result)
 		if !ok {
-			panic(NewIllegalArgumentError(fmt.Sprintf("Comparator must return a number, got %T", result)))
+			panic(NewIllegalArgumentError(fmt.Sprintf("Comparator must return a boolean or number, got %T", result)))
 		}
 		return resultInt < 0
 	})
-
-	return nil
 }
 
 // Compare implements Clojure's compare function.
@@ -87,8 +92,8 @@ func Compare(x, y any) int {
 	}
 
 	// Handle symbols
-	if xSym, xOk := x.(Symbol); xOk {
-		if ySym, yOk := y.(Symbol); yOk {
+	if xSym, xOk := x.(*Symbol); xOk {
+		if ySym, yOk := y.(*Symbol); yOk {
 			// Compare namespace first
 			nsComp := Compare(xSym.Namespace(), ySym.Namespace())
 			if nsComp != 0 {
@@ -99,6 +104,44 @@ func Compare(x, y any) int {
 		}
 	}
 
+	// Handle characters
+	if xChar, xOk := x.(Char); xOk {
+		if yChar, yOk := y.(Char); yOk {
+			if xChar < yChar {
+				return -1
+			} else if xChar > yChar {
+				return 1
+			}
+			return 0
+		}
+	}
+
+	// Handle vectors (including MapEntry which is a vector)
+	if xVec, xOk := x.(IPersistentVector); xOk {
+		if yVec, yOk := y.(IPersistentVector); yOk {
+			xCount := xVec.Count()
+			yCount := yVec.Count()
+			minCount := xCount
+			if yCount < minCount {
+				minCount = yCount
+			}
+			// Compare element by element
+			for i := 0; i < minCount; i++ {
+				cmp := Compare(xVec.Nth(i), yVec.Nth(i))
+				if cmp != 0 {
+					return cmp
+				}
+			}
+			// If all compared elements are equal, shorter vector is less
+			if xCount < yCount {
+				return -1
+			} else if xCount > yCount {
+				return 1
+			}
+			return 0
+		}
+	}
+
 	// If we can't compare, panic with an error
 	panic(NewIllegalArgumentError(fmt.Sprintf("Cannot compare %T with %T", x, y)))
 }

test/glojure/test_glojure/sort.glj

@@ -0,0 +1,201 @@
+;; Tests for sort function
+;; Ensures Glojure behavior matches Clojure
+
+(ns glojure.test-glojure.sort
+  (:require [glojure.test :refer :all]
+            [glojure.string :as s]))
+
+(deftest test-sort-basic
+  (testing "Basic sort functionality"
+    ;; Numbers
+    (is (= '(1 2 3 4 5) (sort [3 1 4 2 5])))
+    (is (= '(1 1 3 4 5) (sort [3 1 4 1 5]))) ; duplicates preserved
+    (is (= '(1.0 2.5 3 4.7) (sort [4.7 1.0 3 2.5]))) ; mixed numeric types
+
+    ;; Strings
+    (is (= '("apple" "banana" "cherry") (sort ["cherry" "apple" "banana"])))
+    (is (= '("" "a" "ab" "b") (sort ["b" "a" "" "ab"]))) ; empty string sorts first
+
+    ;; Keywords
+    (is (= '(:a :b :c) (sort [:c :a :b])))
+    (is (= '(:a/x :b/x :c/x) (sort [:c/x :a/x :b/x]))) ; namespaced keywords
+
+    ;; Symbols
+    (is (= '(a b c) (sort '[c a b])))
+    (is (= '(a/x b/x c/x) (sort '[c/x a/x b/x]))) ; namespaced symbols
+
+    ;; Empty collection
+    (is (= '() (sort [])))
+    (is (= '() (sort '())))
+    (is (= '() (sort nil))) ; nil returns empty seq
+
+    ;; Single element
+    (is (= '(42) (sort [42])))
+
+    ;; Already sorted
+    (is (= '(1 2 3) (sort [1 2 3])))
+
+    ;; Reverse sorted
+    (is (= '(1 2 3) (sort [3 2 1])))))
+
+(deftest test-sort-with-comparator
+  (testing "Sort with custom comparator"
+    ;; Reverse sort
+    (is (= '(5 4 3 2 1) (sort (fn [a b] (compare b a)) [3 1 4 5 2])))
+    (is (= '(5 4 3 2 1) (sort > [3 1 4 5 2]))) ; using > as comparator
+
+    ;; Case-insensitive string sort
+    (is (= '("apple" "Banana" "cherry")
+           (sort (fn [a b] (compare (s/lower-case a) (s/lower-case b)))
+                 ["cherry" "apple" "Banana"])))
+
+    ;; Sort by string length
+    (is (= '("a" "bb" "ccc" "dddd")
+           (sort (fn [a b] (compare (count a) (count b)))
+                 ["ccc" "a" "dddd" "bb"])))
+
+    ;; Sort maps by a specific key
+    (let [data [{:name "John" :age 30}
+                {:name "Jane" :age 25}
+                {:name "Bob" :age 35}]]
+      (is (= [{:name "Jane" :age 25}
+              {:name "John" :age 30}
+              {:name "Bob" :age 35}]
+             (sort (fn [a b] (compare (:age a) (:age b))) data))))))
+
+(deftest test-sort-nil-handling
+  (testing "Nil handling in sort"
+    ;; nil sorts before everything
+    (is (= '(nil 1 2 3) (sort [3 nil 1 2])))
+    (is (= '(nil nil 1 2) (sort [2 nil 1 nil])))
+    (is (= '(nil "a" "b") (sort ["b" nil "a"])))
+
+    ;; With custom comparator that handles nil
+    (is (= '(3 2 1 nil)
+           (sort (fn [a b]
+                   (cond
+                     (nil? a) 1  ; nil goes to end
+                     (nil? b) -1
+                     :else (compare b a)))
+                 [nil 1 2 3])))))
+
+(deftest test-sort-different-collection-types
+  (testing "Sort works on different collection types"
+    ;; Vector
+    (is (= '(1 2 3) (sort [3 1 2])))
+
+    ;; List
+    (is (= '(1 2 3) (sort '(3 1 2))))
+
+    ;; Set
+    (is (= '(1 2 3) (sort #{3 1 2})))
+
+    ;; Map entries (sorted as vectors)
+    (let [result (sort {:b 2 :a 1 :c 3})]
+      (is (= 3 (count result)))
+      (is (every? vector? result))
+      (is (= :a (first (first result)))))
+
+    ;; String (converts to character sequence)
+    (is (= '(\a \b \c \d) (sort "dcba")))
+
+    ;; Range
+    (is (= '(0 1 2 3 4) (sort (reverse (range 5)))))))
+
+(deftest test-sort-stability
+  (testing "Sort is stable"
+    ;; Create items that compare equal but are distinguishable
+    (let [items [{:id 1 :value 1}
+                 {:id 2 :value 2}
+                 {:id 3 :value 1}
+                 {:id 4 :value 2}
+                 {:id 5 :value 1}]
+          sorted (sort (fn [a b] (compare (:value a) (:value b))) items)]
+      ;; Items with same value should maintain relative order
+      (is (= [{:id 1 :value 1}
+              {:id 3 :value 1}
+              {:id 5 :value 1}
+              {:id 2 :value 2}
+              {:id 4 :value 2}]
+             sorted)))))
+
+(deftest test-sort-metadata-preservation
+  (testing "Sort preserves metadata"
+    (let [coll ^{:my-meta true} [3 1 2]
+          sorted (sort coll)]
+      (is (= '(1 2 3) sorted))
+      (is (= true (:my-meta (meta sorted)))))))
+
+(deftest test-sort-edge-cases
+  (testing "Sort edge cases"
+    ;; Large collection
+    (let [large (repeatedly 1000 #(rand-int 100))
+          sorted (sort large)]
+      (is (= 1000 (count sorted)))
+      (is (apply <= sorted))) ; verify it's actually sorted
+
+    ;; All equal elements
+    (is (= '(1 1 1 1) (sort [1 1 1 1])))
+
+    ;; Mixed positive/negative numbers
+    (is (= '(-3 -1 0 1 3) (sort [1 -1 3 0 -3])))))
+
+(deftest test-sort-error-cases
+  (testing "Sort error cases"
+    ;; Invalid comparator (not a function)
+    (is (thrown? go/any (sort "not-a-function" [1 2 3])))
+
+    ;; Comparator returns non-numeric
+    (is (thrown? go/any
+                 (sort (fn [a b] "not-a-number") [1 2 3])))
+
+    ;; Uncomparable types (this might throw or might have undefined behavior)
+    ;; Clojure's behavior here is to throw ClassCastException
+    (is (thrown? go/any
+                 (sort [1 "a" :b])))))
+
+(deftest test-compare-function
+  (testing "Compare function behavior"
+    ;; Numbers
+    (is (= -1 (compare 1 2)))
+    (is (= 0 (compare 2 2)))
+    (is (= 1 (compare 3 2)))
+    (is (= -1 (compare 1.5 2)))
+    (is (= 1 (compare 2.5 2)))
+
+    ;; Strings
+    (is (= -1 (compare "a" "b")))
+    (is (= 0 (compare "hello" "hello")))
+    (is (= 1 (compare "z" "a")))
+
+    ;; Keywords
+    (is (= -1 (compare :a :b)))
+    (is (= 0 (compare :x :x)))
+
+    ;; Symbols
+    (is (= -1 (compare 'a 'b)))
+    (is (= 0 (compare 'x 'x)))
+
+    ;; nil handling
+    (is (= -1 (compare nil 1)))
+    (is (= -1 (compare nil "a")))
+    (is (= -1 (compare nil :a)))
+    (is (= 0 (compare nil nil)))
+    (is (= 1 (compare 1 nil)))
+
+    ;; Different numeric types
+    (is (= 0 (compare 1 1.0)))
+    (is (= 0 (compare 1.0 1)))))
+
+(deftest test-sort-maps-behavior
+  (testing "Sorting maps produces map entries"
+    (let [m {:b 2 :a 1 :c 3}
+          sorted (sort m)]
+      ;; Each element should be a map entry (vector of [k v])
+      (is (every? vector? sorted))
+      (is (every? #(= 2 (count %)) sorted))
+      ;; Should be sorted by key
+      (is (= [[:a 1] [:b 2] [:c 3]] sorted)))))
+
+;; Run tests
+(run-tests)