Modwords - fist support for modwords, change to setwords (#210)

* changing Rye shell to basic ansi colors, so it themable in terminals and works in emacs ansi-term

* added testing for failures in various do functions, ssh sever basics

* new funcs like nl and pink, ssh integration and example, errors tests starting

* ryel tools, embed_main flag, small fixes all around

* adding support for modwords and lmodwords , also partially opcpaths and pipecpaths

* improved modword with left options, added support for opcpath and pipecpath

env/env.go

@@ -243,8 +243,30 @@ func (e *RyeCtx) Get2(word int) (Object, bool, *RyeCtx) {
 }
 
 func (e *RyeCtx) Set(word int, val Object) Object {
-	e.state[word] = val
-	return val
+	if _, exists := e.state[word]; exists {
+		return NewError("Can't set already set word, try using modword")
+	} else {
+		e.state[word] = val
+		return val
+	}
+}
+
+func (e *RyeCtx) Unset(word int) Object {
+	if _, exists := e.state[word]; !exists {
+		return NewError("Can't unset non-existing word in this context")
+	} else {
+		delete(e.state, word)
+		return NewInteger(1)
+	}
+}
+
+func (e *RyeCtx) Mod(word int, val Object) Object {
+	if _, exists := e.state[word]; exists {
+		e.state[word] = val
+		return val
+	} else {
+		return NewError("Can't mod an unset word, try using setword")
+	}
 }
 
 type ProgramState struct {

env/idxs.go

@@ -48,6 +48,10 @@ var NativeTypes = [...]string{ // Todo change to BuiltinTypes
 	"SpreadsheetRowType",
 	"Decimal",
 	"Vector",
+	"OpCPath",
+	"PipeCPath",
+	"Modword",
+	"LModword",
 }
 
 func (e *Idxs) IndexWord(w string) int {

env/object.go

@@ -48,6 +48,10 @@ const (
 	SpreadsheetRowType Type = 33
 	DecimalType        Type = 34
 	VectorType         Type = 35
+	OpCPathType        Type = 36
+	PipeCPathType      Type = 37
+	ModwordType        Type = 38
+	LModwordType       Type = 39
 )
 
 // after adding new type here, also add string to idxs.go
@@ -601,6 +605,96 @@ func (i LSetword) Dump(e Idxs) string {
 	return ":" + e.GetWord(i.Index)
 }
 
+//
+// MODWORD
+//
+
+type Modword struct {
+	Index int
+}
+
+func NewModword(index int) *Modword {
+	nat := Modword{index}
+	return &nat
+}
+
+func (i Modword) Type() Type {
+	return ModwordType
+}
+
+func (i Modword) Inspect(e Idxs) string {
+	return "[Modword: " + e.GetWord(i.Index) + "]"
+}
+
+func (b Modword) Print(e Idxs) string {
+	return e.GetWord(b.Index) + ":"
+}
+
+func (i Modword) Trace(msg string) {
+	fmt.Print(msg + "(Modword): ")
+	fmt.Println(i.Index)
+}
+
+func (i Modword) GetKind() int {
+	return int(ModwordType)
+}
+
+func (i Modword) Equal(o Object) bool {
+	if i.Type() != o.Type() {
+		return false
+	}
+	return i.Index == o.(Modword).Index
+}
+
+func (i Modword) Dump(e Idxs) string {
+	return e.GetWord(i.Index) + ":"
+}
+
+//
+// LMODWORD
+//
+
+type LModword struct {
+	Index int
+}
+
+func NewLModword(index int) *LModword {
+	nat := LModword{index}
+	return &nat
+}
+
+func (i LModword) Type() Type {
+	return LModwordType
+}
+
+func (i LModword) Inspect(e Idxs) string {
+	return "[LModword: " + e.GetWord(i.Index) + "]"
+}
+
+func (b LModword) Print(e Idxs) string {
+	return ":" + e.GetWord(b.Index)
+}
+
+func (i LModword) Trace(msg string) {
+	fmt.Print(msg + "(lModword): ")
+	fmt.Println(i.Index)
+}
+
+func (i LModword) GetKind() int {
+	return int(LModwordType)
+}
+
+func (i LModword) Equal(o Object) bool {
+	if i.Type() != o.Type() {
+		return false
+	}
+	return i.Index == o.(LModword).Index
+}
+
+func (i LModword) Dump(e Idxs) string {
+	return ":" + e.GetWord(i.Index)
+}
+
 //
 // OPWORD
 //
@@ -1448,6 +1542,7 @@ func (i Argword) Dump(e Idxs) string {
 //
 
 type CPath struct {
+	Mode  int // 0 Cpath, 1 OpCpath , 2 PipeCPath
 	Cnt   int
 	Word1 Word
 	Word2 Word
@@ -1491,15 +1586,17 @@ func (i CPath) GetKind() int {
 	return int(CPathType)
 }
 
-func NewCPath2(w1 Word, w2 Word) *CPath {
+func NewCPath2(mode int, w1 Word, w2 Word) *CPath {
 	var cp CPath
+	cp.Mode = mode
 	cp.Cnt = 2
 	cp.Word1 = w1
 	cp.Word2 = w2
 	return &cp
 }
-func NewCPath3(w1 Word, w2 Word, w3 Word) *CPath {
+func NewCPath3(mode int, w1 Word, w2 Word, w3 Word) *CPath {
 	var cp CPath
+	cp.Mode = mode
 	cp.Cnt = 3
 	cp.Word1 = w1
 	cp.Word2 = w2

evaldo/builtins.go

@@ -722,6 +722,20 @@ var builtins = map[string]*env.Builtin{
 		},
 	},
 
+	"unset!": { // ***
+		Argsn: 1,
+		Doc:   "Unset a word in current context",
+		Pure:  false,
+		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
+			switch word := arg0.(type) {
+			case env.Word:
+				return ps.Ctx.Unset(word.Index)
+			default:
+				return MakeArgError(ps, 1, []env.Type{env.WordType}, "set")
+			}
+		},
+	},
+
 	"get_": { // *** find a name or decide on order of naming with generic words clashes with
 		Argsn: 1,
 		Doc:   "Returns value of the word in context",

evaldo/evaldo.go

@@ -251,6 +251,32 @@ func MaybeEvalOpwordOnRight(nextObj env.Object, ps *env.ProgramState, limited bo
 		ps.Ser.Next()
 		ps = EvalWord(ps, opword.ToWord(), ps.Res, false, opword.Force > 0)
 		return MaybeEvalOpwordOnRight(ps.Ser.Peek(), ps, limited)
+	case env.CPath:
+		if opword.Mode == 1 {
+			ps.Ser.Next()
+			ps = EvalWord(ps, opword, ps.Res, false, false) // WWWWWWWWWWWWWWWWWWWWWWWWWWWW error interface converions
+			// when calling cpath
+			return MaybeEvalOpwordOnRight(ps.Ser.Peek(), ps, limited)
+		} else if opword.Mode == 2 {
+			if limited {
+				return ps
+			}
+			ps.Ser.Next()
+			ps = EvalWord(ps, opword, ps.Res, false, false) // TODO .. check opword force
+			if ps.ReturnFlag {
+				return ps //... not sure if we need this
+			}
+			// checkFlagsBi()
+			/*if ps.FailureFlag { // uncommented 202008017
+				ps.FailureFlag = false
+				ps.ErrorFlag = true
+				ps.ReturnFlag = true
+				return ps
+			}*/
+			return MaybeEvalOpwordOnRight(ps.Ser.Peek(), ps, limited)
+		} else {
+			ps.SkipFlag = false
+		}
 	case env.Pipeword:
 		if limited {
 			return ps
@@ -274,7 +300,25 @@ func MaybeEvalOpwordOnRight(nextObj env.Object, ps *env.ProgramState, limited bo
 		}
 		//ProcOpword(nextObj, es)
 		idx := opword.Index
-		ps.Ctx.Set(idx, ps.Res)
+		ps.Res = ps.Ctx.Set(idx, ps.Res)
+		if ps.Res.Type() == env.ErrorType {
+			ps.ErrorFlag = true
+			return ps
+		}
+		ps.Ser.Next()
+		ps.SkipFlag = false
+		return MaybeEvalOpwordOnRight(ps.Ser.Peek(), ps, limited)
+	case env.LModword:
+		if limited {
+			return ps
+		}
+		//ProcOpword(nextObj, es)
+		idx := opword.Index
+		ps.Res = ps.Ctx.Mod(idx, ps.Res)
+		if ps.Res.Type() == env.ErrorType {
+			ps.ErrorFlag = true
+			return ps
+		}
 		ps.Ser.Next()
 		ps.SkipFlag = false
 		return MaybeEvalOpwordOnRight(ps.Ser.Peek(), ps, limited)
@@ -329,6 +373,8 @@ func EvalExpressionConcrete(ps *env.ProgramState) *env.ProgramState {
 			return EvalGenword(ps, object.(env.Genword), nil, false)
 		case env.SetwordType:
 			return EvalSetword(ps, object.(env.Setword))
+		case env.ModwordType:
+			return EvalModword(ps, object.(env.Modword))
 		case env.GetwordType:
 			return EvalGetword(ps, object.(env.Getword), nil, false)
 		case env.CommaType:
@@ -360,7 +406,6 @@ func findWordValue(ps *env.ProgramState, word1 env.Object) (bool, env.Object, *e
 	case env.Opword:
 		object, found := ps.Ctx.Get(word.Index)
 		return found, object, nil
-
 	case env.CPath:
 		currCtx := ps.Ctx
 		i := 1
@@ -421,8 +466,9 @@ func EvalWord(ps *env.ProgramState, word env.Object, leftVal env.Object, toLeft
 			}
 		}
 		// fmt.Println(kind)
-		if leftVal != nil && ps.Ctx.Kind.Index != -1 { // don't use generic words if context kind is -1 --- TODO temporary solution to isolates, think about it more
-			object, found = ps.Gen.Get(kind, word.(env.Word).Index)
+		rword, ok := word.(env.Word)
+		if ok && leftVal != nil && ps.Ctx.Kind.Index != -1 { // don't use generic words if context kind is -1 --- TODO temporary solution to isolates, think about it more
+			object, found = ps.Gen.Get(kind, rword.Index)
 		}
 	}
 	if found {
@@ -495,7 +541,22 @@ func EvalSetword(ps *env.ProgramState, word env.Setword) *env.ProgramState {
 	// es1 := EvalExpression(es)
 	ps1, _ := EvalExpressionInj(ps, nil, false)
 	idx := word.Index
-	ps1.Ctx.Set(idx, ps1.Res)
+	ps1.Res = ps1.Ctx.Set(idx, ps1.Res)
+	if ps1.Res.Type() == env.ErrorType {
+		ps1.ErrorFlag = true
+	}
+	return ps1
+}
+
+// evaluates expression to the right and sets the result of it to a word in current context
+func EvalModword(ps *env.ProgramState, word env.Modword) *env.ProgramState {
+	// es1 := EvalExpression(es)
+	ps1, _ := EvalExpressionInj(ps, nil, false)
+	idx := word.Index
+	ps1.Res = ps1.Ctx.Mod(idx, ps1.Res)
+	if ps1.Res.Type() == env.ErrorType {
+		ps1.ErrorFlag = true
+	}
 	return ps1
 }