Introduce DeepRefl which checks for cycles, only fully implemented fo…

…r O, uses unexposed V.Contains

src/block.go

@@ -19,6 +19,10 @@ func (b B) Refl() string {
 	return "[ " + str + " ]"
 }
 
+func (b B) DeepRefl(list V) (V, string) {
+	return list, b.Refl()
+}
+
 func (b B) PP() string {
 	str := b.Disassemble().Refl()
 	str = str[1:(len(str) - 1)]

src/item_interfaces.go

@@ -2,11 +2,13 @@ package main
 
 type datatypes interface {
 	Refl() string
+	DeepRefl(V) (V, string)
 	Value() interface{}
 }
 
 type sequence interface {
 	Refl() string
+	DeepRefl(V) (V, string)
 	Value() interface{}
 	Cat(sequence) sequence
 	App(datatypes) sequence
@@ -25,6 +27,7 @@ type byter interface {
 
 type stackable interface {
 	Refl() string
+	DeepRefl(V) (V, string)
 	Value() interface{}
 	Push(datatypes)
 	Pop() datatypes

src/meta.go

@@ -35,6 +35,10 @@ func (m *Meta) Refl() string {
 	return str + ">"
 }
 
+func (m *Meta) DeepRefl(list V) (V, string) {
+	return list, m.Refl()
+}
+
 // for stack interface compatibility
 // will panic if you try to push anything other than a stack
 func (m *Meta) Push(i datatypes) {

src/number.go

@@ -15,6 +15,10 @@ func (n N) Refl() string {
 	return fmt.Sprint(n)
 }
 
+func (n N) DeepRefl(list V) (V, string) {
+	return list, n.Refl()
+}
+
 func (n N) Value() interface{} {
 	return int64(n)
 }

src/object.go

@@ -1,5 +1,10 @@
 package main
 
+import (
+	"fmt"
+	"reflect"
+)
+
 type Object struct {
 	Slots  map[W]datatypes
 	Parent *Object
@@ -64,15 +69,74 @@ func (o *Object) DeleGet(meta *Meta, w W) bool {
 }
 
 func (o Object) Refl() string {
+	str := ""
+
+	list := V{}
+	_, s := o.DeepRefl(list)
+	str += s
+
+	return str + ""
+}
+
+func (o Object) ShallowRefl() string {
 	str := "\033[32mO{ "
 
 	for k, v := range o.Slots {
-		str += k.Refl() + ":" + v.Refl() + " "
+		str += k.Refl() + ":" 
+
+		switch t := v.(type) {
+		case *Object:
+			str += v.(*Object).SimpleRefl()
+		case N, C, T, B, OP:
+			str += v.Refl()
+		default:
+			str += "..."
+			str += fmt.Sprint(reflect.TypeOf(t))
+			str += "..."
+		}
+
+		str += " "
 	}
 
 	return str + "}\033[0m"
 }
 
+func (o Object) DeepRefl(list V) (V, string) {
+	str := "\033[32mO{ "
+
+	for k, v := range o.Slots {
+		str += k.Refl() + ":" 
+
+		switch t := v.(type) {
+		case N, C, T, B, OP:
+			str += v.Refl()
+		default:
+			if list.Contains(v).Kind == "true" {
+				str += "..."
+				str += fmt.Sprint(reflect.TypeOf(t))
+				str += "..."
+			} else {
+				list = list.App(v).(V)
+				l, s := v.DeepRefl(list)
+				list = l
+				str += s
+			}
+		}
+
+		str += " \033[32m"
+	}
+
+	return list, str + "}\033[0m"
+}
+
+func (o Object) SimpleRefl() string {
+	str := "O#"
+
+	str = str + fmt.Sprint(len(o.Slots))
+
+	return str + ""
+}
+
 func (o Object) Value() interface{} {
 	return o.Slots
 }

src/octet.go

@@ -14,6 +14,10 @@ func (c C) Refl() string {
 	return fmt.Sprintf("0x%0.2X", c)
 }
 
+func (c C) DeepRefl(list V) (V, string) {
+	return list, c.Refl()
+}
+
 func (c C) Value() interface{} {
 	return byte(c)
 }

src/opword.go

@@ -10,6 +10,10 @@ func (op OP) Refl() string {
 	return "`" + op.Print()
 }
 
+func (op OP) DeepRefl(list V) (V, string) {
+	return list, op.Refl()
+}
+
 func (op OP) Value() interface{} {
 	return uint8(op)
 }

src/queue.go

@@ -70,3 +70,7 @@ PrintLoop:
 
 	return str + " |"
 }
+
+func (q Queue) DeepRefl(list V) (V, string) {
+	return list, q.Refl()
+}

src/rune.go

@@ -17,6 +17,10 @@ func (r R) Refl() string {
 	return "\\u" + hex.EncodeToString(buf)
 }
 
+func (r R) DeepRefl(list V) (V, string) {
+	return list, r.Refl()
+}
+
 func (r R) Value() interface{} {
 	return rune(r)
 }

src/stack.go

@@ -66,6 +66,10 @@ func (s *Stack) Refl() string {
 	return str + ">"
 }
 
+func (s *Stack) DeepRefl(list V) (V, string) {
+	return list, s.Refl()
+}
+
 func (s *Stack) ReflHeader() string {
 	str := ""
 

src/tag.go

@@ -24,6 +24,10 @@ func (t Tag) Refl() string {
 	return t.Kind + "#" + t.Label
 }
 
+func (t Tag) DeepRefl(list V) (V, string) {
+	return list, t.Refl()
+}
+
 func (t Tag) Value() interface{} {
 	return t.Kind
 }

src/text.go

@@ -16,6 +16,10 @@ func (t T) Refl() string {
 	return "'" + string(t) + "'"
 }
 
+func (t T) DeepRefl(list V) (V, string) {
+	return list, t.Refl()
+}
+
 func (t T) Value() interface{} {
 	return string(t)
 }

src/vector.go

@@ -1,5 +1,9 @@
 package main
 
+import (
+	"reflect"
+)
+
 type V []datatypes
 
 func (v V) Refl() string {
@@ -13,6 +17,10 @@ func (v V) Refl() string {
 	return str + ")"
 }
 
+func (v V) DeepRefl(list V) (V, string) {
+	return list, v.Refl()
+}
+
 func (v V) Value() interface{} {
 	return []datatypes(v)
 }
@@ -36,6 +44,15 @@ func (v V) Rmo(n N) sequence {
 	return v
 }
 
+func (v V) Contains(d datatypes) *Tag {
+	for _, i := range v {
+		if reflect.DeepEqual(i, d) {
+			return NewTrue("contains")
+		}
+	}
+	return NewNil("contains")
+}
+
 func (v V) Len() N {
 	return N(len(v))
 }

src/word.go

@@ -14,6 +14,10 @@ func (w W) Refl() string {
 	return "~" + w.Print()
 }
 
+func (w W) DeepRefl(list V) (V, string) {
+	return list, w.Refl()
+}
+
 func (w W) Value() interface{} {
 	return uint64(w)
 }