feat: add primitive compare

pkg/primitive/binary.go

@@ -57,6 +57,32 @@ func (o Binary) Equal(v Object) bool {
 	}
 }
 
+func (o Binary) Compare(v Object) int {
+	if r, ok := v.(Binary); !ok {
+		if o.Kind() > v.Kind() {
+			return 1
+		} else {
+			return -1
+		}
+	} else {
+		for i := 0; i < o.Len(); i++ {
+			if r.Len() == i {
+				return 1
+			}
+
+			v1 := o.Get(i)
+			v2 := r.Get(i)
+
+			if v1 > v2 {
+				return 1
+			} else if v1 < v2 {
+				return -1
+			}
+		}
+		return 0
+	}
+}
+
 func (o Binary) Hash() uint32 {
 	h := fnv.New32()
 	h.Write([]byte{byte(KindBinary), 0})

pkg/primitive/binary_test.go

@@ -22,13 +22,19 @@ func TestBinary_Get(t *testing.T) {
 
 func TestBinary_Equal(t *testing.T) {
 	v1 := NewBinary([]byte{0})
-	v2 := NewBinary([]byte{0})
-	v3 := NewBinary([]byte{1})
+	v2 := NewBinary([]byte{1})
 
-	assert.True(t, v1.Equal(v2))
-	assert.True(t, v2.Equal(v1))
-	assert.False(t, v1.Equal(v3))
-	assert.False(t, v2.Equal(v3))
+	assert.True(t, v1.Equal(v1))
+	assert.False(t, v1.Equal(v2))
+}
+
+func TestBinary_Compare(t *testing.T) {
+	v1 := NewBinary([]byte{0})
+	v2 := NewBinary([]byte{1})
+
+	assert.Equal(t, 0, v1.Compare(v1))
+	assert.Equal(t, -1, v1.Compare(v2))
+	assert.Equal(t, 1, v2.Compare(v1))
 }
 
 func TestBinary_Hash(t *testing.T) {

pkg/primitive/bool.go

@@ -42,6 +42,22 @@ func (o Bool) Equal(v Object) bool {
 	}
 }
 
+func (o Bool) Compare(v Object) int {
+	if r, ok := v.(Bool); !ok {
+		if o.Kind() > v.Kind() {
+			return 1
+		} else {
+			return -1
+		}
+	} else if o == r {
+		return 0
+	} else if o == TRUE {
+		return 1
+	} else {
+		return -1
+	}
+}
+
 func (o Bool) Hash() uint32 {
 	var v byte
 	if o {

pkg/primitive/bool_test.go

@@ -13,6 +13,13 @@ func TestNewBool(t *testing.T) {
 	assert.Equal(t, true, v.Interface())
 }
 
+func TestBool_Compare(t *testing.T) {
+	assert.Equal(t, 0, TRUE.Compare(TRUE))
+	assert.Equal(t, 0, FALSE.Compare(FALSE))
+	assert.Equal(t, 1, TRUE.Compare(FALSE))
+	assert.Equal(t, -1, FALSE.Compare(TRUE))
+}
+
 func TestBool_Equal(t *testing.T) {
 	assert.True(t, TRUE.Equal(TRUE))
 	assert.True(t, FALSE.Equal(FALSE))

pkg/primitive/compare.go

@@ -0,0 +1,20 @@
+package primitive
+
+type (
+	ordered interface {
+		~int | ~int8 | ~int16 | ~int32 | ~int64 | ~uint | ~uint8 | ~uint16 | ~uint32 | ~uint64 | ~uintptr | ~float32 | ~float64 | ~string
+	}
+)
+
+func compare[T ordered](x, y T) int {
+	if x == y {
+		return 0
+	}
+	if x > y {
+		return 1
+	}
+	if x < y {
+		return -1
+	}
+	return 0
+}

pkg/primitive/float.go

@@ -52,6 +52,22 @@ func (o Float32) Equal(v Object) bool {
 	}
 }
 
+func (o Float32) Compare(v Object) int {
+	if r, ok := v.(Float); !ok {
+		if r, ok := v.(Integer); ok {
+			return compare[float64](o.Float(), float64(r.Int()))
+		} else if r, ok := v.(Uinteger); ok {
+			return compare[float64](o.Float(), float64(r.Uint()))
+		} else if o.Kind() > v.Kind() {
+			return 1
+		} else {
+			return -1
+		}
+	} else {
+		return compare[float64](o.Float(), r.Float())
+	}
+}
+
 func (o Float32) Hash() uint32 {
 	var buf [4]byte
 	binary.BigEndian.PutUint32(buf[:], math.Float32bits(float32(o)))
@@ -95,6 +111,22 @@ func (o Float64) Equal(v Object) bool {
 	}
 }
 
+func (o Float64) Compare(v Object) int {
+	if r, ok := v.(Float); !ok {
+		if r, ok := v.(Integer); ok {
+			return compare[float64](o.Float(), float64(r.Int()))
+		} else if r, ok := v.(Uinteger); ok {
+			return compare[float64](o.Float(), float64(r.Uint()))
+		} else if o.Kind() > v.Kind() {
+			return 1
+		} else {
+			return -1
+		}
+	} else {
+		return compare[float64](o.Float(), r.Float())
+	}
+}
+
 func (o Float64) Hash() uint32 {
 	var buf [8]byte
 	binary.BigEndian.PutUint64(buf[:], math.Float64bits(float64(o)))

pkg/primitive/float_test.go

@@ -25,7 +25,7 @@ func TestFloat_Equal(t *testing.T) {
 	t.Run("32", func(t *testing.T) {
 		assert.True(t, NewFloat32(0).Equal(NewFloat32(0)))
 		assert.True(t, NewFloat32(0).Equal(NewFloat64(0)))
-		assert.False(t, NewFloat32(0).Equal(NewFloat32(1)))
+		assert.False(t, NewFloat32(1).Equal(NewFloat32(0)))
 	})
 
 	t.Run("64", func(t *testing.T) {
@@ -35,6 +35,22 @@ func TestFloat_Equal(t *testing.T) {
 	})
 }
 
+func TestFloat_Compare(t *testing.T) {
+	t.Run("32", func(t *testing.T) {
+		assert.Equal(t, 0, NewFloat32(0).Compare(NewFloat32(0)))
+		assert.Equal(t, 0, NewFloat32(0).Compare(NewFloat64(0)))
+		assert.Equal(t, 1, NewFloat32(1).Compare(NewFloat32(0)))
+		assert.Equal(t, -1, NewFloat32(0).Compare(NewFloat32(1)))
+	})
+
+	t.Run("64", func(t *testing.T) {
+		assert.Equal(t, 0, NewFloat64(0).Compare(NewFloat64(0)))
+		assert.Equal(t, 0, NewFloat64(0).Compare(NewFloat32(0)))
+		assert.Equal(t, 1, NewFloat64(1).Compare(NewFloat64(0)))
+		assert.Equal(t, -1, NewFloat64(0).Compare(NewFloat64(1)))
+	})
+}
+
 func TestFloat_Hash(t *testing.T) {
 	t.Run("32", func(t *testing.T) {
 		assert.NotEqual(t, NewFloat32(0).Hash(), NewFloat32(1).Hash())

pkg/primitive/int.go

@@ -60,6 +60,22 @@ func (o Int) Equal(v Object) bool {
 	}
 }
 
+func (o Int) Compare(v Object) int {
+	if r, ok := v.(Integer); !ok {
+		if r, ok := v.(Uinteger); ok {
+			return compare[int64](o.Int(), int64(r.Uint()))
+		} else if r, ok := v.(Float); ok {
+			return compare[float64](float64(o.Int()), r.Float())
+		} else if o.Kind() > v.Kind() {
+			return 1
+		} else {
+			return -1
+		}
+	} else {
+		return compare[int64](o.Int(), r.Int())
+	}
+}
+
 func (o Int) Hash() uint32 {
 	buf := *(*[unsafe.Sizeof(o)]byte)(unsafe.Pointer(&o))
 
@@ -102,6 +118,22 @@ func (o Int8) Equal(v Object) bool {
 	}
 }
 
+func (o Int8) Compare(v Object) int {
+	if r, ok := v.(Integer); !ok {
+		if r, ok := v.(Uinteger); ok {
+			return compare[int64](o.Int(), int64(r.Uint()))
+		} else if r, ok := v.(Float); ok {
+			return compare[float64](float64(o.Int()), r.Float())
+		} else if o.Kind() > v.Kind() {
+			return 1
+		} else {
+			return -1
+		}
+	} else {
+		return compare[int64](o.Int(), r.Int())
+	}
+}
+
 func (o Int8) Hash() uint32 {
 	buf := *(*[unsafe.Sizeof(o)]byte)(unsafe.Pointer(&o))
 
@@ -144,6 +176,22 @@ func (o Int16) Equal(v Object) bool {
 	}
 }
 
+func (o Int16) Compare(v Object) int {
+	if r, ok := v.(Integer); !ok {
+		if r, ok := v.(Uinteger); ok {
+			return compare[int64](o.Int(), int64(r.Uint()))
+		} else if r, ok := v.(Float); ok {
+			return compare[float64](float64(o.Int()), r.Float())
+		} else if o.Kind() > v.Kind() {
+			return 1
+		} else {
+			return -1
+		}
+	} else {
+		return compare[int64](o.Int(), r.Int())
+	}
+}
+
 func (o Int16) Hash() uint32 {
 	buf := *(*[unsafe.Sizeof(o)]byte)(unsafe.Pointer(&o))
 
@@ -186,6 +234,22 @@ func (o Int32) Equal(v Object) bool {
 	}
 }
 
+func (o Int32) Compare(v Object) int {
+	if r, ok := v.(Integer); !ok {
+		if r, ok := v.(Uinteger); ok {
+			return compare[int64](o.Int(), int64(r.Uint()))
+		} else if r, ok := v.(Float); ok {
+			return compare[float64](float64(o.Int()), r.Float())
+		} else if o.Kind() > v.Kind() {
+			return 1
+		} else {
+			return -1
+		}
+	} else {
+		return compare[int64](o.Int(), r.Int())
+	}
+}
+
 func (o Int32) Hash() uint32 {
 	buf := *(*[unsafe.Sizeof(o)]byte)(unsafe.Pointer(&o))
 
@@ -228,6 +292,22 @@ func (o Int64) Equal(v Object) bool {
 	}
 }
 
+func (o Int64) Compare(v Object) int {
+	if r, ok := v.(Integer); !ok {
+		if r, ok := v.(Uinteger); ok {
+			return compare[int64](o.Int(), int64(r.Uint()))
+		} else if r, ok := v.(Float); ok {
+			return compare[float64](float64(o.Int()), r.Float())
+		} else if o.Kind() > v.Kind() {
+			return 1
+		} else {
+			return -1
+		}
+	} else {
+		return compare[int64](o.Int(), r.Int())
+	}
+}
+
 func (o Int64) Hash() uint32 {
 	buf := *(*[unsafe.Sizeof(o)]byte)(unsafe.Pointer(&o))
 

pkg/primitive/int_test.go

@@ -67,6 +67,39 @@ func TestInt_Equal(t *testing.T) {
 	})
 }
 
+func TestInt_Compare(t *testing.T) {
+	t.Run("", func(t *testing.T) {
+		assert.Equal(t, 0, NewInt(0).Compare(NewInt(0)))
+		assert.Equal(t, 1, NewInt(1).Compare(NewInt(0)))
+		assert.Equal(t, -1, NewInt(0).Compare(NewInt(1)))
+		assert.Equal(t, 0, NewInt(0).Compare(NewFloat32(0)))
+	})
+	t.Run("8", func(t *testing.T) {
+		assert.Equal(t, 0, NewInt8(0).Compare(NewInt(0)))
+		assert.Equal(t, 1, NewInt8(1).Compare(NewInt(0)))
+		assert.Equal(t, -1, NewInt8(0).Compare(NewInt(1)))
+		assert.Equal(t, 0, NewInt8(0).Compare(NewFloat32(0)))
+	})
+	t.Run("16", func(t *testing.T) {
+		assert.Equal(t, 0, NewInt16(0).Compare(NewInt(0)))
+		assert.Equal(t, 1, NewInt16(1).Compare(NewInt(0)))
+		assert.Equal(t, -1, NewInt16(0).Compare(NewInt(1)))
+		assert.Equal(t, 0, NewInt16(0).Compare(NewFloat32(0)))
+	})
+	t.Run("32", func(t *testing.T) {
+		assert.Equal(t, 0, NewInt32(0).Compare(NewInt(0)))
+		assert.Equal(t, 1, NewInt32(1).Compare(NewInt(0)))
+		assert.Equal(t, -1, NewInt32(0).Compare(NewInt(1)))
+		assert.Equal(t, 0, NewInt32(0).Compare(NewFloat32(0)))
+	})
+	t.Run("64", func(t *testing.T) {
+		assert.Equal(t, 0, NewInt64(0).Compare(NewInt(0)))
+		assert.Equal(t, 1, NewInt64(1).Compare(NewInt(0)))
+		assert.Equal(t, -1, NewInt64(0).Compare(NewInt(1)))
+		assert.Equal(t, 0, NewInt64(0).Compare(NewFloat32(0)))
+	})
+}
+
 func TestInt_Hash(t *testing.T) {
 	t.Run("", func(t *testing.T) {
 		assert.NotEqual(t, NewInt(0).Hash(), NewInt(1).Hash())

pkg/primitive/map.go

@@ -139,6 +139,44 @@ func (o *Map) Equal(v Object) bool {
 	}
 }
 
+func (o *Map) Compare(v Object) int {
+	if r, ok := v.(*Map); !ok {
+		if o.Kind() > v.Kind() {
+			return 1
+		} else {
+			return -1
+		}
+	} else {
+		keys1 := o.Keys()
+		keys2 := r.Keys()
+
+		for i, k1 := range keys1 {
+			if len(keys2) == i {
+				return 1
+			}
+
+			k2 := keys2[i]
+			if diff := Compare(k1, k2); diff != 0 {
+				return diff
+			}
+
+			v1, ok1 := o.Get(k1)
+			v2, ok2 := o.Get(k2)
+			if diff := Compare(NewBool(ok1), NewBool(ok2)); diff != 0 {
+				return diff
+			}
+			if diff := Compare(v1, v2); diff != 0 {
+				return diff
+			}
+		}
+
+		if len(keys2) > len(keys1) {
+			return -1
+		}
+		return 0
+	}
+}
+
 func (o *Map) Hash() uint32 {
 	h := fnv.New32()
 	h.Write([]byte{byte(KindMap), 0})