добавил ревизированый механизм последовательностей внутрь пакета rules

rt2/rules/assign.go

@@ -163,11 +163,13 @@ func assignSeq(f frame.Frame) (seq frame.Sequence, ret frame.WAIT) {
 		}
 	case statement.NEW:
 		if a.Right() != nil {
-			seq, ret = expectExpr(f, a.Right(), func(f frame.Frame) (frame.Sequence, frame.WAIT) {
+			seq, ret = This(expectExpr(f, a.Right(), func(...IN) OUT {
 				fmt.Println(rt2.DataOf(f)[a.Right()])
-				return frame.End()
-			})
+				fmt.Println("NEW here")
+				return End()
+			}))
 		} else {
+			fmt.Println("NEW here")
 			return frame.End()
 		}
 	default:

rt2/rules/call.go

@@ -33,7 +33,7 @@ type Msg struct {
 
 func callHandler(f frame.Frame, obj object.Object, data interface{}) {
 	//n := rt2.Utils.NodeOf(f)
-	fmt.Println("call handler", obj)
+	//fmt.Println("call handler", obj)
 	if obj == nil {
 		return
 	}

rt2/rules/case.go

@@ -9,17 +9,17 @@ import (
 	"ypk/assert"
 )
 
-func caseSeq(f frame.Frame) (seq frame.Sequence, ret frame.WAIT) {
+func caseSeq(f frame.Frame) (frame.Sequence, frame.WAIT) {
 	n := rt2.NodeOf(f)
 	var e int
 
-	in := func(f frame.Frame) (seq frame.Sequence, ret frame.WAIT) {
+	in := func(in ...IN) (out OUT) {
 		cond := n.Right().(node.ElseNode)
 		if e < cond.Min() || e > cond.Max() { //case?
-			seq = frame.Tail(frame.STOP)
-			ret = frame.NOW
+			out.do = Tail(STOP)
+			out.next = NOW
 		} else {
-			for next := cond.Left(); next != nil && seq == nil; next = next.Link() {
+			for next := cond.Left(); next != nil && out.do == nil; next = next.Link() {
 				var ok bool
 				for _c := next.Left(); _c != nil && !ok; _c = _c.Right() {
 					c := _c.(node.ConstantNode)
@@ -34,30 +34,32 @@ func caseSeq(f frame.Frame) (seq frame.Sequence, ret frame.WAIT) {
 				//fmt.Println(ok)
 				if ok {
 					rt2.Push(rt2.New(next.Right()), f)
-					seq = frame.Tail(frame.STOP)
-					ret = frame.LATER
+					out.do = Tail(STOP)
+					out.next = LATER
 				}
 			}
-			if seq == nil && cond.Right() != nil {
+			if out.do == nil && cond.Right() != nil {
 				rt2.Push(rt2.New(cond.Right()), f)
-				seq = frame.Tail(frame.STOP)
-				ret = frame.LATER
+				out.do = Tail(STOP)
+				out.next = LATER
 			}
 		}
-		assert.For(seq != nil, 60)
-		return seq, ret
+		assert.For(out.do != nil, 60)
+		return out
 	}
 
-	return expectExpr(f, n.Left(), func(f frame.Frame) (frame.Sequence, frame.WAIT) {
+	return This(expectExpr(f, n.Left(), func(...IN) (out OUT) {
 		_x := rt2.DataOf(f)[n.Left()]
 		switch x := _x.(type) {
 		case nil:
 			panic("nil")
 		case int32:
 			e = int(x)
-			return in, frame.NOW
+			out.do = in
+			out.next = NOW
+			return out
 		default:
 			panic(fmt.Sprintln("unsupported case expr", reflect.TypeOf(_x)))
 		}
-	})
+	}))
 }

rt2/rules/expect.go

@@ -11,29 +11,29 @@ import (
 )
 
 //функция вернет в данные родительского фрейма вычисленное значение expr
-func expectExpr(parent frame.Frame, expr node.Node, next frame.Sequence) (frame.Sequence, frame.WAIT) {
+func expectExpr(parent frame.Frame, expr node.Node, next Do) OUT {
 	assert.For(expr != nil, 20)
 	sm := rt2.ScopeOf(parent)
 	switch e := expr.(type) {
 	case node.ConstantNode:
 		rt2.DataOf(parent)[expr] = e.Data()
-		return next, frame.NOW
+		return OUT{do: next, next: NOW}
 	case node.VariableNode, node.ParameterNode:
 		rt2.DataOf(parent)[expr] = sm.Select(scope.Designator(expr))
-		return next, frame.NOW
+		return OUT{do: next, next: NOW}
 	case node.OperationNode, node.CallNode:
 		rt2.Push(rt2.New(expr), parent)
-		wait := func(frame.Frame) (frame.Sequence, frame.WAIT) {
+		wait := func(...IN) OUT {
 			if rt2.DataOf(parent)[expr] == nil {
 				panic("no result")
 			}
-			return next, frame.NOW
+			return OUT{do: next, next: NOW}
 		}
-		return wait, frame.LATER
+		return OUT{do: wait, next: LATER}
 	case node.IndexNode:
 		id := scope.Designator(expr)
 		rt2.Push(rt2.New(expr), parent)
-		wait := func(frame.Frame) (frame.Sequence, frame.WAIT) {
+		wait := func(...IN) OUT {
 			if rt2.DataOf(parent)[expr] == nil {
 				panic("no result")
 			} else {
@@ -41,12 +41,12 @@ func expectExpr(parent frame.Frame, expr node.Node, next frame.Sequence) (frame.
 				*id.Index = int64(rt2.DataOf(parent)[expr].(int32))
 				rt2.DataOf(parent)[expr] = sm.Select(id)
 			}
-			return next, frame.NOW
+			return OUT{do: next, next: NOW}
 		}
-		return wait, frame.LATER
+		return OUT{do: wait, next: LATER}
 	case node.ProcedureNode:
 		rt2.DataOf(parent)[expr] = e.Object()
-		return next, frame.NOW
+		return OUT{do: next, next: NOW}
 	default:
 		panic(fmt.Sprintln("not an expression", reflect.TypeOf(expr)))
 	}

rt2/rules/op.go

@@ -406,7 +406,7 @@ func mopSeq(f frame.Frame) (seq frame.Sequence, ret frame.WAIT) {
 			panic("wrong left")
 		}
 	case operation.ABS, operation.ODD, operation.CAP, operation.BITS:
-		return expectExpr(f, n.Left(), op)
+		return This(expectExpr(f, n.Left(), Expose(op)))
 	default:
 		panic(fmt.Sprintln("no such operation", n.(node.MonadicNode).Operation()))
 	}

rt2/rules/range.go

@@ -21,10 +21,10 @@ func bit_range(_f interface{}, _t interface{}) interface{} {
 
 func rangeSeq(f frame.Frame) (frame.Sequence, frame.WAIT) {
 	n := rt2.NodeOf(f)
-	return expectExpr(f, n.Left(), func(f frame.Frame) (frame.Sequence, frame.WAIT) {
-		return expectExpr(f, n.Right(), func(f frame.Frame) (frame.Sequence, frame.WAIT) {
+	return This(expectExpr(f, n.Left(), func(...IN) OUT {
+		return expectExpr(f, n.Right(), func(...IN) OUT {
 			rt2.DataOf(f.Parent())[n] = bit_range(rt2.DataOf(f)[n.Left()], rt2.DataOf(f)[n.Right()])
-			return frame.End()
+			return End()
 		})
-	})
+	}))
 }

rt2/rules/seq.go

@@ -0,0 +1,80 @@
+package rules
+
+import (
+	"fw/rt2/frame"
+)
+
+type WAIT int
+
+const (
+	WRONG WAIT = iota
+	STOP
+	LATER
+	NOW
+)
+
+type Do func(...IN) OUT
+
+type IN struct {
+	frame frame.Frame
+}
+
+type OUT struct {
+	do   Do
+	next WAIT
+}
+
+func (n WAIT) wait() frame.WAIT {
+	switch n {
+	case WRONG:
+		return frame.WRONG
+	case STOP:
+		return frame.STOP
+	case LATER:
+		return frame.LATER
+	case NOW:
+		return frame.NOW
+	default:
+		panic(n)
+	}
+}
+
+func waiting(n frame.WAIT) WAIT {
+	switch n {
+	case frame.WRONG:
+		return WRONG
+	case frame.STOP:
+		return STOP
+	case frame.LATER:
+		return LATER
+	case frame.NOW:
+		return NOW
+	default:
+		panic(n)
+	}
+}
+
+func End() OUT {
+	return OUT{next: STOP}
+}
+
+func Tail(x WAIT) Do {
+	return func(...IN) OUT { return OUT{next: x} }
+}
+
+func This(o OUT) (frame.Sequence, frame.WAIT) {
+	return Propose(o.do), o.next.wait()
+}
+
+func Propose(a Do) frame.Sequence {
+	return func(fr frame.Frame) (frame.Sequence, frame.WAIT) {
+		return This(a(IN{frame: fr}))
+	}
+}
+
+func Expose(f frame.Sequence) Do {
+	return func(in ...IN) (out OUT) {
+		s, w := f(in[0].frame)
+		return OUT{do: Expose(s), next: waiting(w)}
+	}
+}

rt2/scope/std/scope.go

@@ -239,7 +239,7 @@ func (m *manager) Initialize(n node.Node, par scope.PARAM) (seq frame.Sequence,
 	assert.For(h.root == n, 21)
 	assert.For(!h.ready, 22)
 	val := par.Values
-	fmt.Println("initialize")
+	//fmt.Println("initialize")
 	f := par.Frame
 	end := func(frame.Frame) (seq frame.Sequence, ret frame.WAIT) {
 		h.ready = true
@@ -253,8 +253,8 @@ func (m *manager) Initialize(n node.Node, par scope.PARAM) (seq frame.Sequence,
 	ret = frame.NOW
 	for next := par.Objects; next != nil; next = next.Link() {
 		assert.For(val != nil, 40)
-		fmt.Println(reflect.TypeOf(next), next.Name(), ":", next.Type())
-		fmt.Println(reflect.TypeOf(val))
+		//fmt.Println(reflect.TypeOf(next), next.Name(), ":", next.Type())
+		//fmt.Println(reflect.TypeOf(val))
 		switch ov := val.(type) {
 		case node.ConstantNode:
 			switch next.(type) {