go-pkg/expr
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Linked-list: added support for operators '<<' and '>>'. Also fixed list insertion: ['x'] >> [1,2] must return [1,2,['x'], not [1,2,'x']; use $([]) to flat a list

Browse Source
This commit is contained in:
Celestino Amoroso
2026-05-22 06:46:04 +02:00
parent ac5c97bfd3
commit 4b2b573420
4 changed files with 48 additions and 31 deletions
Download Patch File Download Diff File Expand all files Collapse all files
iter-factory.go
+9
View File
@@ -11,6 +11,15 @@ import (
"git.portale-stac.it/go-pkg/expr/scan"
)
func NewFormalIterator(value any) (it kern.Iterator) {
if value == nil {
it = NewArrayIterator([]any{})
} else {
it = NewArrayIterator([]any{value})
}
return
}
func NewIterator(ctx kern.ExprContext, value any, ops []*scan.Term) (it kern.Iterator, err error) {
if value == nil {
return NewArrayIterator([]any{}), nil
operator-insert.go
+18 -20
View File
@@ -31,13 +31,11 @@ func newAppendTerm(tk *scan.Token) (inst *scan.Term) {
}
}
func prependToList(ctx kern.ExprContext, opTerm *scan.Term, leftValue, rightValue any) (result any, err error) {
func prependToList(opTerm *scan.Term, leftValue, rightValue any) (result any, err error) {
if list, ok := rightValue.(*kern.ListType); ok {
var it kern.Iterator
if it, ok = leftValue.(kern.Iterator); !ok {
if it, err = NewIterator(ctx, leftValue, nil); err != nil {
return
}
it = NewFormalIterator(leftValue)
}
ls := kern.NewLinkedList()
@@ -54,12 +52,13 @@ func prependToList(ctx kern.ExprContext, opTerm *scan.Term, leftValue, rightValu
newList = append(newList, item)
}
result = &newList
} else if list, ok := rightValue.(*kern.LinkedList); ok {
var it kern.Iterator
if it, ok = leftValue.(kern.Iterator); !ok {
it = NewFormalIterator(leftValue)
}
// ***** EVENTUALMENTE ABILITARE LA MODIFICA DELLA VARIABILE
// ***** CON UN OPERATORE SPECIFICO
// if opTerm.Children[1].Symbol() == scan.SymVariable {
// ctx.UnsafeSetVar(opTerm.Children[1].Source(), result)
// }
result = list.SeqPushBack(it)
} else {
err = opTerm.ErrIncompatibleTypes(leftValue, rightValue)
}
@@ -73,17 +72,15 @@ func evalPrepend(ctx kern.ExprContext, opTerm *scan.Term) (v any, err error) {
return
}
v, err = prependToList(ctx, opTerm, leftValue, rightValue)
v, err = prependToList(opTerm, leftValue, rightValue)
return
}
func appendToList(ctx kern.ExprContext, opTerm *scan.Term, leftValue, rightValue any) (result any, err error) {
func appendToList(opTerm *scan.Term, leftValue, rightValue any) (result any, err error) {
if list, ok := leftValue.(*kern.ListType); ok {
var it kern.Iterator
if it, ok = rightValue.(kern.Iterator); !ok {
if it, err = NewIterator(ctx, rightValue, nil); err != nil {
return
}
it = NewFormalIterator(rightValue)
}
ls := kern.NewLinkedList()
@@ -100,12 +97,13 @@ func appendToList(ctx kern.ExprContext, opTerm *scan.Term, leftValue, rightValue
newList = append(newList, node.Data())
}
result = &newList
} else if list, ok := leftValue.(*kern.LinkedList); ok {
var it kern.Iterator
if it, ok = rightValue.(kern.Iterator); !ok {
it = NewFormalIterator(rightValue)
}
// ***** EVENTUALMENTE ABILITARE LA MODIFICA DELLA VARIABILE
// ***** CON UN OPERATORE SPECIFICO
// if opTerm.Children[0].Symbol() == scan.SymVariable {
// ctx.UnsafeSetVar(opTerm.Children[0].Source(), result)
// }
result = list.SeqPushBack(it)
} else {
err = opTerm.ErrIncompatibleTypes(leftValue, rightValue)
}
@@ -119,7 +117,7 @@ func evalAppend(ctx kern.ExprContext, opTerm *scan.Term) (v any, err error) {
return
}
v, err = appendToList(ctx, opTerm, leftValue, rightValue)
v, err = appendToList(opTerm, leftValue, rightValue)
return
}
operator-shift.go
+2 -2
View File
@@ -40,7 +40,7 @@ func evalRightShift(ctx kern.ExprContext, opTerm *scan.Term) (v any, err error)
}
if v, err = bitRightShift(opTerm, leftValue, rightValue); err != nil {
v, err = prependToList(ctx, opTerm, leftValue, rightValue)
v, err = prependToList(opTerm, leftValue, rightValue)
}
return
}
@@ -74,7 +74,7 @@ func evalLeftShift(ctx kern.ExprContext, opTerm *scan.Term) (v any, err error) {
}
if v, err = bitLeftShift(opTerm, leftValue, rightValue); err != nil {
v, err = appendToList(ctx, opTerm, leftValue, rightValue)
v, err = appendToList(opTerm, leftValue, rightValue)
}
return
}
t_operator_test.go
+19 -9
View File
@@ -53,15 +53,25 @@ func TestOperatorInsert(t *testing.T) {
section := "Operator-Insert"
inputs := []inputType{
/* 1 */ {`["a", "b"] << nil`, kern.NewListA("a", "b"), nil},
/* 2 */ {`["a", "b"] << []`, kern.NewListA("a", "b"), nil},
/* 3 */ {`["a", "b"] << 3`, kern.NewListA("a", "b", int64(3)), nil},
/* 4 */ {`3 << ["a", "b"]`, nil, `[1:5] left operand '3' [integer] and right operand '["a", "b"]' [list] are not compatible with operator "<<"`},
/* 5 */ {`nil >> ["a", "b"]`, kern.NewListA("a", "b"), nil},
/* 6 */ {`[] >> ["a", "b"]`, kern.NewListA("a", "b"), nil},
/* 7 */ {`["a", "b"] << $([1,2,3])`, kern.NewListA("a", "b", int64(1), int64(2), int64(3)), nil},
/* 8 */ {`L=["a", "b"]; L << $([1,2,3])`, kern.NewListA("a", "b", int64(1), int64(2), int64(3)), nil},
/* 9 */ {`L=["a", "b"]; L << $([1,2,3]); L`, kern.NewListA("a", "b"), nil},
/* 10 */ {`L << $([1,2,3])`, nil, `undefined variable or function "L"`},
/* 2 */ {`["a", "b"] << []`, kern.NewListA("a", "b", kern.NewListA()), nil},
/* 3 */ {`["a", "b"] << $([])`, kern.NewListA("a", "b"), nil},
/* 4 */ {`["a", "b"] << 3`, kern.NewListA("a", "b", int64(3)), nil},
/* 5 */ {`3 << ["a", "b"]`, nil, `[1:5] left operand '3' [integer] and right operand '["a", "b"]' [list] are not compatible with operator "<<"`},
/* 6 */ {`nil >> ["a", "b"]`, kern.NewListA("a", "b"), nil},
/* 7 */ {`[] >> ["a", "b"]`, kern.NewListA(kern.NewListA(), "a", "b"), nil},
/* 8 */ {`$([]) >> ["a", "b"]`, kern.NewListA("a", "b"), nil},
/* 9 */ {`["a", "b"] << $([1,2,3])`, kern.NewListA("a", "b", int64(1), int64(2), int64(3)), nil},
/* 10 */ {`L=["a", "b"]; L << $([1,2,3])`, kern.NewListA("a", "b", int64(1), int64(2), int64(3)), nil},
/* 11 */ {`L=["a", "b"]; L << $([1,2,3]); L`, kern.NewListA("a", "b"), nil},
/* 12 */ {`L << $([1,2,3])`, nil, `undefined variable or function "L"`},
/* 13 */ {`[<>] << 1`, kern.NewLinkedListA(1), nil},
/* 14 */ {`[<>] << [1,2]`, kern.NewLinkedListA(kern.NewListA(int64(1), int64(2))), nil},
/* 15 */ {`[<>] << [<1,2>]`, kern.NewLinkedListA(kern.NewLinkedListA(1, 2)), nil},
/* 16 */ {`1 >> [<>]`, kern.NewLinkedListA(1), nil},
/* 17 */ {`[1,2] >> [<>]`, kern.NewLinkedListA(kern.NewListA(int64(1), int64(2))), nil},
/* 18 */ {`[<1,2>] >> [<>]`, kern.NewLinkedListA(kern.NewLinkedListA(1, 2)), nil},
/* 19 */ {`$([1,2]) >> [<>]`, kern.NewLinkedListA(1, 2), nil},
/* 20 */ {`$([<1,2>]) >> [<>]`, kern.NewLinkedListA(1, 2), nil},
}
// runTestSuiteSpec(t, section, inputs, 9)