dict: implemented length of dict

dict_test.go

@@ -23,22 +23,9 @@ func TestDictParser(t *testing.T) {
 	inputs := []inputType{
 		/*  1 */ {`{}`, map[any]any{}, nil},
 		/*  2 */ {`{123}`, nil, errors.New(`[1:6] expected ":", got "}"`)},
-		/*  3 */ {`{1:"one",2:"two",3:"three"}`, map[int64]any{int64(1):"one", int64(2):"two", int64(3):"three"}, nil},
+		/*  3 */ {`{1:"one",2:"two",3:"three"}`, map[int64]any{int64(1): "one", int64(2): "two", int64(3): "three"}, nil},
 		/*  4 */ {`{1:"one",2:"two",3:"three"}.2`, "three", nil},
-		// /*  3 */ {`[1,2,"hello"]`, []any{int64(1), int64(2), "hello"}, nil},
-		// /*  4 */ {`[1+2, not true, "hello"]`, []any{int64(3), false, "hello"}, nil},
-		// /*  5 */ {`[1,2]+[3]`, []any{int64(1), int64(2), int64(3)}, nil},
-		// /*  6 */ {`[1,4,3,2]-[3]`, []any{int64(1), int64(4), int64(2)}, nil},
-		// /*  7 */ {`add([1,4,3,2])`, int64(10), nil},
-		// /*  8 */ {`add([1,[2,2],3,2])`, int64(10), nil},
-		// /*  9 */ {`mul([1,4,3.0,2])`, float64(24.0), nil},
-		// /* 10 */ {`add([1,"hello"])`, nil, errors.New(`add(): param nr 2 (2 in 1) has wrong type string, number expected`)},
-		// /* 11 */ {`[a=1,b=2,c=3] but a+b+c`, int64(6), nil},
-		// /* 12 */ {`[1,2,3] << 2+2`, []any{int64(1), int64(2), int64(3), int64(4)}, nil},
-		// /* 13 */ {`2-1 >> [2,3]`, []any{int64(1), int64(2), int64(3)}, nil},
-		// /* 14 */ {`[1,2,3].1`, int64(2), nil},
-		// /* 15 */ {`ls=[1,2,3] but ls.1`, int64(2), nil},
-		// /* 16 */ {`ls=[1,2,3] but ls.(-1)`, int64(3), nil},
+		/*  5 */ {`#{1:"one",2:"two",3:"three"}`, int64(3), nil},
 	}
 
 	succeeded := 0

func-base.go

@@ -43,6 +43,11 @@ func isFractionFunc(ctx ExprContext, name string, args []any) (result any, err e
 	return
 }
 
+func isRationalFunc(ctx ExprContext, name string, args []any) (result any, err error) {
+	result = IsRational(args[0])
+	return
+}
+
 func isListFunc(ctx ExprContext, name string, args []any) (result any, err error) {
 	result = IsList(args[0])
 	return
@@ -53,7 +58,6 @@ func isDictionaryFunc(ctx ExprContext, name string, args []any) (result any, err
 	return
 }
 
-
 func intFunc(ctx ExprContext, name string, args []any) (result any, err error) {
 	if len(args) == 1 {
 		switch v := args[0].(type) {
@@ -93,6 +97,7 @@ func ImportBuiltinsFuncs(ctx ExprContext) {
 	ctx.RegisterFunc("isString", &simpleFunctor{f: isStringFunc}, 1, 1)
 	ctx.RegisterFunc("isFraction", &simpleFunctor{f: isFractionFunc}, 1, 1)
 	ctx.RegisterFunc("isFract", &simpleFunctor{f: isFractionFunc}, 1, 1)
+	ctx.RegisterFunc("isRational", &simpleFunctor{f: isRationalFunc}, 1, 1)
 	ctx.RegisterFunc("isList", &simpleFunctor{f: isListFunc}, 1, 1)
 	ctx.RegisterFunc("isDictionary", &simpleFunctor{f: isDictionaryFunc}, 1, 1)
 	ctx.RegisterFunc("isDict", &simpleFunctor{f: isDictionaryFunc}, 1, 1)

funcs_test.go

@@ -57,12 +57,14 @@ func TestFuncs(t *testing.T) {
 		/*  44 */ {`builtin "string"; splitStr("one-two-three", "-", )`, newListA("one", "two", "three"), nil},
 		/*  45 */ {`isInt(2+1)`, true, nil},
 		/*  46 */ {`isInt(3.1)`, false, nil},
-		/*  46 */ {`isFloat(3.1)`, true, nil},
-		/*  47 */ {`isString("3.1")`, true, nil},
-		/*  48 */ {`isString("3" + 1)`, true, nil},
-		/*  49 */ {`isList(["3",  1])`, true, nil},
-		/*  50 */ {`isDict({"a":"3",  "b":1})`, true, nil},
-		/*  51 */ {`isFract(3|1)`, true, nil},
+		/*  47 */ {`isFloat(3.1)`, true, nil},
+		/*  48 */ {`isString("3.1")`, true, nil},
+		/*  49 */ {`isString("3" + 1)`, true, nil},
+		/*  50 */ {`isList(["3",  1])`, true, nil},
+		/*  51 */ {`isDict({"a":"3",  "b":1})`, true, nil},
+		/*  52 */ {`isFract(1|3)`, true, nil},
+		/*  53 */ {`isFract(3|1)`, false, nil},
+		/*  54 */ {`isRational(3|1)`, true, nil},
 	}
 
 	t.Setenv("EXPR_PATH", ".")

list_test.go

@@ -39,6 +39,7 @@ func TestListParser(t *testing.T) {
 		/*  17 */ {`list=["one","two","three"]; list.10`, nil, errors.New(`[1:36] index 10 out of bounds`)},
 		/*  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},
 
 		// /*  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},

operator-length.go

@@ -24,11 +24,14 @@ func evalLength(ctx ExprContext, self *term) (v any, err error) {
 	}
 
 	if IsList(childValue) {
-		list, _ := childValue.([]any)
-		v = int64(len(list))
+		ls, _ := childValue.(*ListType)
+		v = int64(len(*ls))
 	} else if IsString(childValue) {
 		s, _ := childValue.(string)
 		v = int64(len(s))
+	} else if IsDict(childValue) {
+		m, _ := childValue.(map[any]any)
+		v = int64(len(m))
 	} else if it, ok := childValue.(Iterator); ok {
 		if extIt, ok := childValue.(ExtIterator); ok && extIt.HasOperation(countName) {
 			count, _ := extIt.CallOperation(countName, nil)

utils.go

@@ -44,6 +44,13 @@ func IsFract(v any) (ok bool) {
 	return ok
 }
 
+func IsRational(v any) (ok bool) {
+	if _, ok = v.(*fraction); !ok {
+		_, ok = v.(int64)
+	}
+	return ok
+}
+
 func IsNumber(v any) (ok bool) {
 	return IsFloat(v) || IsInteger(v)
 }