dict_test.go

@@ -27,7 +27,6 @@ func TestDictParser(t *testing.T) {
 		/*  4 */ {`{1:"one",2:"two",3:"three"}.2`, "three", nil},
 		/*  5 */ {`#{1:"one",2:"two",3:"three"}`, int64(3), nil},
 		/*  6 */ {`{1:"one"} + {2:"two"}`, map[any]any{1: "one", 2: "two"}, nil},
-		/*  7 */ {`2 in {1:"one", 2:"two"}`, true, nil},
 	}
 
 	succeeded := 0

list_test.go

@@ -40,7 +40,6 @@ func TestListParser(t *testing.T) {
 		/*  18 */ {`["a", "b", "c"]`, newListA("a", "b", "c"), nil},
 		/*  19 */ {`["a", "b", "c"]`, newList([]any{"a", "b", "c"}), nil},
 		/*  20 */ {`#["a", "b", "c"]`, int64(3), nil},
-		/*  21 */ {`"b" in ["a", "b", "c"]`, true, nil},
 
 		// /*  8 */ {`[int(x)|x=csv("test.csv",1,all(),1)]`, []any{int64(10), int64(40), int64(20)}, nil},
 		// /*  9 */ {`sum(@[int(x)|x=csv("test.csv",1,all(),1)])`, []any{int64(10), int64(40), int64(20)}, nil},
@@ -59,8 +58,8 @@ func TestListParser(t *testing.T) {
 		var gotErr error
 
 		ctx := NewSimpleFuncStore()
-		// ctx.SetVar("var1", int64(123))
+		ctx.SetVar("var1", int64(123))
-		// ctx.SetVar("var2", "abc")
+		ctx.SetVar("var2", "abc")
 		ImportMathFuncs(ctx)
 		parser := NewParser(ctx)
 

operand-list.go

@@ -6,7 +6,6 @@ package expr
 
 import (
 	"fmt"
-	"reflect"
 	"strings"
 )
 
@@ -62,16 +61,6 @@ func newList(listAny []any) (list *ListType) {
 	return
 }
 
-func (list *ListType) indexDeepCmp(target any) (index int) {
-	index = -1
-	for i, item := range *list {
-		if reflect.DeepEqual(item, target) {
-			index = i
-			break
-		}
-	}
-	return
-}
 
 // -------- list term
 func newListTermA(args ...*term) *term {

operator-fraction.go

@@ -4,8 +4,6 @@
 // operand-fraction.go
 package expr
 
-//https://www.youmath.it/lezioni/algebra-elementare/lezioni-di-algebra-e-aritmetica-per-scuole-medie/553-dalle-frazioni-a-numeri-decimali.html
-
 import (
 	"errors"
 	"fmt"

operator-in.go

@@ -1,46 +0,0 @@
-// Copyright (c) 2024 Celestino Amoroso (celestino.amoroso@gmail.com).
-// All rights reserved.
-
-// operator-in.go
-package expr
-
-//-------- in term
-
-func newInTerm(tk *Token) (inst *term) {
-	return &term{
-		tk:       *tk,
-		children: make([]*term, 0, 2),
-		position: posInfix,
-		priority: priRelational,
-		evalFunc: evalIn,
-	}
-}
-
-func hasKey(d map[any]any, target any) (ok bool) {
-	_, ok = d[target]
-	return
-}
-
-func evalIn(ctx ExprContext, self *term) (v any, err error) {
-	var leftValue, rightValue any
-
-	if leftValue, rightValue, err = self.evalInfix(ctx); err != nil {
-		return
-	}
-
-	if IsList(rightValue) {
-		list, _ := rightValue.(*ListType)
-		v = list.indexDeepCmp(leftValue) >= 0
-	} else if IsDict(rightValue) {
-		d, _ := rightValue.(map[any]any)
-		v = hasKey(d, leftValue)
-	} else {
-		err = self.errIncompatibleTypes(leftValue, rightValue)
-	}
-	return
-}
-
-// init
-func init() {
-	registerTermConstructor(SymKwIn, newInTerm)
-}

symbol.go

@@ -99,7 +99,6 @@ const (
 	SymKwBut
 	SymKwFunc
 	SymKwBuiltin
-	SymKwIn
 	SymKwInclude
 	SymKwNil
 )
@@ -113,7 +112,6 @@ func init() {
 		"BUILTIN": SymKwBuiltin,
 		"BUT":     SymKwBut,
 		"FUNC":    SymKwFunc,
-		"IN":      SymKwIn,
 		"INCLUDE": SymKwInclude,
 		"NOT":     SymKwNot,
 		"OR":      SymKwOr,

term_test.go

@@ -31,7 +31,6 @@ func TestGetRoom(t *testing.T) {
 		t.Errorf("err: got <%v>, want <nil>", gotErr)
 	}
 }
-
 func TestGetChildrenCount(t *testing.T) {
 	tk1 := NewValueToken(0, 0, SymInteger, "100", 100)
 

utils_test.go

@@ -1,139 +0,0 @@
-// Copyright (c) 2024 Celestino Amoroso (celestino.amoroso@gmail.com).
-// All rights reserved.
-
-// utils_test.go
-package expr
-
-import (
-	"errors"
-	"testing"
-)
-
-func TestIsString(t *testing.T) {
-	count := 0
-	succeeded := 0
-	failed := 0
-
-	count++
-	if !IsBool(true) {
-		t.Errorf("%d: IsBool(true) -> result = false, want true", count)
-		failed++
-	} else {
-		succeeded++
-	}
-
-	count++
-	if !IsString("abc") {
-		t.Errorf("%d: IsString(\"abc\") -> result = false, want true", count)
-		failed++
-	} else {
-		succeeded++
-	}
-
-	count++
-	if !IsInteger(int64(123)) {
-		t.Errorf("%d: IsInteger(123) -> result = false, want true", count)
-		failed++
-	} else {
-		succeeded++
-	}
-
-	count++
-	if !IsFloat(1.23) {
-		t.Errorf("%d: IsFloat(1.23) -> result = false, want true", count)
-		failed++
-	} else {
-		succeeded++
-	}
-
-	count++
-	if !IsFloat(numAsFloat(123)) {
-		t.Errorf("%d: IsFloat(numAsFloat(123)) -> result = false, want true", count)
-		failed++
-	} else {
-		succeeded++
-	}
-
-	count++
-	b, ok := toBool(true)
-	if !(ok && b) {
-		t.Errorf("%d: toBool(true) b=%v, ok=%v -> result = false, want true", count, b, ok)
-		failed++
-	} else {
-		succeeded++
-	}
-
-	count++
-	b, ok = toBool("abc")
-	if !(ok && b) {
-		t.Errorf("%d: toBool(\"abc\") b=%v, ok=%v -> result = false, want true", count, b, ok)
-		failed++
-	} else {
-		succeeded++
-	}
-
-	t.Logf("test count: %d, succeeded count: %d, failed count: %d", count, succeeded, failed)
-}
-
-func TestToIntOk(t *testing.T) {
-	source := int64(64)
-	wantValue := int(64)
-	wantErr := error(nil)
-
-	gotValue, gotErr := toInt(source, "test")
-
-	if gotErr != nil || gotValue != wantValue {
-		t.Errorf("toInt(%v, \"test\") gotValue=%v, gotErr=%v -> wantValue=%v, wantErr=%v",
-			source, gotValue, gotErr, wantValue, wantErr)
-	}
-}
-
-func TestToIntErr(t *testing.T) {
-	source := uint64(64)
-	wantValue := 0
-	wantErr := errors.New(`test expected integer, got uint64 (64)`)
-
-	gotValue, gotErr := toInt(source, "test")
-
-	if gotErr.Error() != wantErr.Error() || gotValue != wantValue {
-		t.Errorf("toInt(%v, \"test\") gotValue=%v, gotErr=%v -> wantValue=%v, wantErr=%v",
-			source, gotValue, gotErr, wantValue, wantErr)
-	}
-}
-
-func TestAnyInteger(t *testing.T) {
-	type inputType struct {
-		source    any
-		wantValue int64
-		wantOk    bool
-	}
-	section := "utils.anyInteger"
-
-	inputs := []inputType{
-		/*  1 */ {int8(-8), int64(-8), true},
-		/*  2 */ {int16(-16), int64(-16), true},
-		/*  3 */ {int32(-32), int64(-32), true},
-		/*  4 */ {int64(-64), int64(-64), true},
-		/*  5 */ {uint8(8), int64(8), true},
-		/*  6 */ {uint16(16), int64(16), true},
-		/*  7 */ {uint32(32), int64(32), true},
-		/*  8 */ {uint64(64), int64(64), true},
-		/*  9 */ {int(-1), int64(-1), true},
-		/* 10 */ {true, 0, false},
-	}
-
-	succeeded := 0
-	failed := 0
-
-	for i, input := range inputs {
-		gotValue, gotOk := anyInteger(input.source)
-		if gotOk != input.wantOk || gotValue != input.wantValue {
-			t.Errorf("%d: anyInteger(%v) -> gotOk = %t, wantOk = %t; gotValue = %v, wantValue = %v",
-				i+1, input.source, gotOk, input.wantOk, gotValue, input.wantValue)
-			failed++
-		} else {
-			succeeded++
-		}
-	}
-	t.Logf("%s -- test count: %d, succeeded: %d, failed: %d", section, len(inputs), succeeded, failed)
-}