Go tooling and documentation

fern/README.md

@@ -0,0 +1,39 @@
+```
+docker run -it -w /app -v ./fern:/app golang:1.20.4 bash
+```
+
+render text
+then scroll overflow
+
+
+Add before as a function in all blocks
+
+let foo = a b ->
+delete all of a label leaves red mark
+
+delete arg
+
+let foo = _ y -> {
+    let fdd = 2
+    let y = 11
+}
+
+" -> string
+p -> perform
+handle -> handle
+{ -> record
+l -> let
+Enter Shift line above below
+[ -> list
+, -> list item
+m -> match {
+    Red missing
+
+}
+
+No special key for Tag yet
+letters for things means no typing for variables
+automatically assume typing for variables can have selection along bottom by number but then number cant strt aa number
+https://earthly.dev/blog/tui-app-with-go/
+
+delete on let removes line highlight first

fern/cmd/main.go

@@ -0,0 +1,54 @@
+package main
+
+import (
+	"fmt"
+	"os"
+	"path/filepath"
+
+	"github.com/gdamore/tcell/v2"
+	"github.com/midas-framework/project_wisdom/fern"
+)
+
+func main() {
+	tcell.SetEncodingFallback(tcell.EncodingFallbackASCII)
+	screen, err := tcell.NewScreen()
+	if err != nil {
+		fmt.Fprintf(os.Stderr, "%v\n", err)
+		os.Exit(1)
+	}
+	if err = screen.Init(); err != nil {
+		fmt.Fprintf(os.Stderr, "%v\n", err)
+		os.Exit(1)
+	}
+
+	dir, err := os.Getwd()
+	if err != nil {
+		fmt.Fprintf(os.Stderr, "%v\n", err)
+		os.Exit(1)
+	}
+	path := filepath.Join(dir, "saved.json")
+	// path := filepath.Join(dir, "../eyg/saved/saved.json")
+	store := &fileStore{path}
+
+	// fern.New(screen, store)
+	err = fern.Run(screen, store)
+	screen.Fini()
+	if err != nil {
+		fmt.Fprintf(os.Stderr, "%v\n", err)
+		os.Exit(1)
+	}
+}
+
+type fileStore struct {
+	path string
+}
+
+var _ fern.Store = (*fileStore)(nil)
+
+func (store *fileStore) Load() ([]byte, error) {
+	return os.ReadFile(store.path)
+}
+
+func (store *fileStore) Save(data []byte) error {
+	return os.WriteFile(store.path, data, 0644)
+}

fern/coordinate.go

@@ -0,0 +1,8 @@
+package fern
+
+// public fields because .X & .Y are useful interfactes to a point
+// Technically Coordinate is 1D but we use singular here to save plural for lists
+type Coordinate struct {
+	X int
+	Y int
+}

fern/cursor.go

@@ -0,0 +1,62 @@
+package fern
+
+func zipper(source Node, path []int) (Node, func(Node) Node, error) {
+	tree := source
+	var bs []func(Node) Node
+	for _, p := range path {
+		t, b, err := tree.child(p)
+		tree = t
+		if err != nil {
+			return Var{}, nil, err
+		}
+		bs = append(bs, b)
+	}
+	return tree, func(n Node) Node {
+		for i := len(bs) - 1; i >= 0; i-- {
+			n = bs[i](n)
+		}
+		return n
+	}, nil
+}
+
+// (call, (call, cons, x), tail)
+// ((cons x) tail)
+// (reverse (uppercase "bob"))
+// ((map users) uppercase)
+
+// x -> pre on list
+// default is 5 -> [5] but also [1, 2] -> [1, [2]]
+// always add to list
+
+// making my own gc
+// fast list of parents possible
+// func z(source []string, remaining int) {
+// 	root := source[0]
+// }
+
+// func unwrap(source []string, at int) {
+// 	var parents = []string{}
+// 	parent = parents[at]
+// 	i := 0
+// 	new := []string{}
+// 	for i := 0; i < parent; i++ {
+// 		new = append(new, source[i])
+// 	}
+// 	for i := at; i < len(source); i++ {
+// 		new = append(new, source[i])
+// 	}
+// 	return new[12]
+// }
+
+// func callWith(source []string, at int) [2]int {
+// 	// can have arrays for performance
+// 	new := []string{}
+// 	for i := 0; i < at; i++ {
+// 		new = append(new, source[i])
+// 	}
+// 	new = append(new, "call", "vacant")
+// 	for i := at; i < len(source); i++ {
+// 		new = append(new, source[i])
+// 	}
+
+// }

fern/decode.go

@@ -0,0 +1,98 @@
+package fern
+
+import (
+	"encoding/json"
+	"fmt"
+)
+
+type encoded struct {
+	Key   string          `json:"0"`
+	Label string          `json:"l"`
+	Body  json.RawMessage `json:"b"`
+	Fn    json.RawMessage `json:"f"`
+	Arg   json.RawMessage `json:"a"`
+	// Let, Integer, String all have value
+	Value json.RawMessage `json:"v"`
+	Then  json.RawMessage `json:"t"`
+	Note  string          `json:"c"`
+}
+
+// recursive, is continuation for looping a good style in go or is it just a hammer
+func decode(data []byte) (Node, error) {
+	var e encoded
+	err := json.Unmarshal(data, &e)
+	if err != nil {
+		return nil, err
+	}
+	switch e.Key {
+	case "f":
+		body, err := decode(e.Body)
+		if err != nil {
+			return nil, err
+		}
+		return Fn{e.Label, body}, nil
+	case "a":
+		fn, err := decode(e.Fn)
+		if err != nil {
+			return nil, err
+		}
+		arg, err := decode(e.Arg)
+		if err != nil {
+			return nil, err
+		}
+		return Call{fn, arg}, nil
+	case "v":
+		return Var{e.Label}, nil
+	case "l":
+		value, err := decode(e.Value)
+		if err != nil {
+			return nil, err
+		}
+		then, err := decode(e.Then)
+		if err != nil {
+			return nil, err
+		}
+		return Let{e.Label, value, then}, nil
+	case "z":
+		return Vacant{e.Note}, nil
+	case "i":
+		var value int
+		err := json.Unmarshal(e.Value, &value)
+		if err != nil {
+			return nil, err
+		}
+		return Integer{value}, nil
+	case "s":
+		var value string
+		err := json.Unmarshal(e.Value, &value)
+		if err != nil {
+			return nil, err
+		}
+		return String{value}, nil
+	case "ta":
+		return Tail{}, nil
+	case "c":
+		return Cons{}, nil
+	case "u":
+		return Empty{}, nil
+	case "e":
+		return Extend{e.Label}, nil
+	case "g":
+		return Select{e.Label}, nil
+	case "o":
+		return Overwrite{e.Label}, nil
+	case "t":
+		return Tag{e.Label}, nil
+	case "m":
+		return Case{e.Label}, nil
+	case "n":
+		return NoCases{}, nil
+	case "p":
+		return Perform{e.Label}, nil
+	case "h":
+		return Handle{e.Label}, nil
+	case "b":
+		return Builtin{e.Label}, nil
+	}
+	return nil, fmt.Errorf("unknown node type %s", e.Key)
+}

fern/e2.go

@@ -0,0 +1,64 @@
+package fern
+
+// context i.e. context free grammer
+// situation, surroundings
+// location
+// site
+// position as in tail position
+
+// ident path mode all needed, (block list)(sugar) also
+// linear iteration a real pain for call
+
+// linear walk through level on a line depth = new line and reduce ident
+// pass in *path if there render return cursor
+// dont pass in cursor if we delete from offset position that indicates selecting the node move to selected and path
+// if we delete use path for new cursor
+// arrow keys or escape exit
+
+type situ struct {
+	indent int
+	nested bool
+	block  bool
+	path   []int
+}
+
+// state with count, output, and mapping to info
+// len(info = count)
+// separate focus from highlight
+// func (string_ String) render(situ situ, focus []int, output []rendered) ([]rendered, []string) {
+// 	// make a new pusher with offset counter inside
+// 	zero := 0
+// 	output = append(output, rendered{charachter: '"', offset: &zero})
+// 	// start := len(output)
+// 	// if targeted(focus) {
+// 	// }
+// 	for i, ch := range string_.value {
+// 		offset := i + 1
+// 		output = append(output, rendered{charachter: ch, offset: &offset})
+// 	}
+// 	output = append(output, rendered{charachter: '"'})
+// 	if !situ.nested {
+// 		output = append(output, rendered{charachter: '\n'})
+// 	}
+// 	// start := len(output)
+
+// 	return nil, nil
+// }
+
+// y = count newlines
+// x = count back to newline
+
+func inner(focus []int, child int) []int {
+	// catches focus nil I believe
+	if len(focus) == 0 || focus[0] != child {
+		return nil
+	}
+	return focus[1:]
+}
+
+func targeted(focus []int) bool {
+	if focus != nil || len(focus) == 0 {
+		return true
+	}
+	return false
+}