type renamings: as private as possible

forge/builtins/builtins.go

@@ -2,11 +2,11 @@ package builtins
 
 import "git.sr.ht/~cco/go-scopes/forge"
 
-type FE = *forge.ForgeEnv
-type XT = *forge.Item
+type FE = forge.FE
+type XT = forge.XT
 
 type builtins struct {
-	Add, Lit forge.XT
+	Add, Lit XT
 }
 
 func Setup(f FE) *builtins {

forge/forge.go

@@ -10,49 +10,51 @@ import (
 	"git.sr.ht/~cco/go-scopes/common/voc"
 )
 
-type DataItem interface{}
+type fitem interface{}
 
-type Ptr = ptr.Ptr[DataItem]
-type Stack = stack.Stack[DataItem]
-type Voc = voc.Vocabulary[XT]
+type fptr = ptr.Ptr[fitem]
+type fstack = stack.Stack[fitem]
+type fvoc = voc.Vocabulary[XT]
 
-type Callable func(*ForgeEnv, XT)
+type Callable func(*forgeEnv, XT)
 
-type Item struct {
+type xitem struct {
 	name      string
 	immediate bool
 	fct       Callable
-	body      Ptr
+	body      fptr
 }
 
-type XT = *Item
+type XT = *xitem
 
-type ForgeEnv struct {
-	ds, rs     Stack
-	cp, ip, dp Ptr
-	voc        *Voc
+type forgeEnv struct {
+	ds, rs     fstack
+	cp, ip, dp fptr
+	voc        *fvoc
 	latestXT   XT
 	cstate     bool
 	output     io.Writer
 }
 
-func NewVoc(parent *Voc) *Voc {
+type FE = *forgeEnv
+
+func NewVoc(parent *fvoc) *fvoc {
 	return voc.NewVoc[XT](parent)
 }
 
-func NewFE() *ForgeEnv {
+func NewFE() *forgeEnv {
 	return newFE(NewVoc(nil))
 }
 
-func (f *ForgeEnv) ChildFE() *ForgeEnv {
+func (f *forgeEnv) ChildFE() *forgeEnv {
 	return newFE(NewVoc(f.voc))
 }
 
-func newFE(voc *Voc) *ForgeEnv {
-	return &ForgeEnv{
-		ds:     stack.NewStack[DataItem](),
-		rs:     stack.NewStack[DataItem](),
-		ip:     ptr.NewSlice[DataItem](),
+func newFE(voc *fvoc) *forgeEnv {
+	return &forgeEnv{
+		ds:     stack.NewStack[fitem](),
+		rs:     stack.NewStack[fitem](),
+		ip:     ptr.NewSlice[fitem](),
 		voc:    voc,
 		output: os.Stdout,
 	}
@@ -60,8 +62,8 @@ func newFE(voc *Voc) *ForgeEnv {
 
 // basic functions and methods
 
-func Register(voc *Voc, name string, fct Callable) *Item {
-	it := Item{
+func Register(voc *fvoc, name string, fct Callable) *xitem {
+	it := xitem{
 		name: name,
 		fct:  fct,
 	}
@@ -69,58 +71,47 @@ func Register(voc *Voc, name string, fct Callable) *Item {
 	return &it
 }
 
-func (it *Item) IsImmediate() bool {
+func (it *xitem) IsImmediate() bool {
 	return it.immediate
 }
 
-func (it *Item) Immediate() {
+func (it *xitem) Immediate() {
 	it.immediate = true
 }
 
-func (it *Item) Body() Ptr {
+func (it *xitem) Body() fptr {
 	if it.body == nil {
-		it.body = ptr.NewSlice[DataItem]()
+		it.body = ptr.NewSlice[fitem]()
 	}
 	return it.body
 }
 
-func (it *Item) Name() string {
+func (it *xitem) Name() string {
 	return it.name
 }
 
 // ForgeEnv methods
 
-func (f *ForgeEnv) Voc() *Voc {
+func (f *forgeEnv) Voc() *fvoc {
 	return f.voc
 }
 
-func (f *ForgeEnv) IP() Ptr {
+func (f *forgeEnv) IP() fptr {
 	return f.ip
 }
 
-func (f *ForgeEnv) Exec(items ...DataItem) {
-	f.ip = ptr.NewSlice[DataItem](items...)
+func (f *forgeEnv) Exec(items ...fitem) {
+	f.ip = ptr.NewSlice[fitem](items...)
 	for f.ip.Next() != nil {
 		it := f.ip.Value().(XT)
 		it.fct(f, it)
 	}
 }
 
-func (f *ForgeEnv) Push(it DataItem) {
+func (f *forgeEnv) Push(it fitem) {
 	f.ds.Push(it)
 }
 
-func (f *ForgeEnv) Pop() DataItem {
+func (f *forgeEnv) Pop() fitem {
 	return f.ds.Pop()
 }
-
-// dummy stuff for testing
-
-var builtins = struct{ add, sub XT }{}
-
-var work = struct{ square XT }{}
-
-func init() {
-	builtins.add = &Item{}
-	builtins.sub = &Item{}
-}