use new XT implementations (GoFunc, FCode, Data)

forge/builtins/builtins.go

@@ -22,7 +22,7 @@ func Get(f FE) *builtins {
 func setup(f FE) *builtins {
 	voc := f.Voc()
 	r := func(name string, fct forge.Callable) XT {
-		return forge.Register(voc, name, fct)
+		return forge.Register(voc, forge.GoFunc(name, fct))
 	}
 	return &builtins{
 		Add:  r("+", func(f FE, _ XT) { f.Push(f.Pop().(int) + f.Pop().(int)) }),

forge/forge.go

@@ -83,37 +83,57 @@ func (it *gofunc) Data() fptr {
 	return nil
 }
 
-// xitem: executable item with all parts
+// fcode: with forge code
 
-type xitem struct {
+type fcode struct {
+	name
+	code fptr
+}
+
+func FCode(n string, c fptr) XT {
+	return &fcode{name(n), c}
+}
+
+func (it *fcode) Fct() Callable {
+	return doDef
+}
+
+func (it *fcode) Code() fptr {
+	return it.code
+}
+
+func (it *fcode) Data() fptr {
+	return nil
+}
+
+// data: data provider, with optional forge code
+
+type data struct {
 	name
-	fct  Callable
-	body fptr
 	code fptr
 	data fptr
 }
 
-func (it *xitem) Fct() Callable {
+func Data(n string, d, c fptr) XT {
-	return it.fct
+	return &data{name(n), c, d}
 }
 
-func (it *xitem) Code() fptr {
+func (it *data) Fct() Callable {
-	//return it.code
+	return doData
-	return it.body
 }
 
-func (it *xitem) Data() fptr {
+func (it *data) Code() fptr {
-	//return it.data
+	return it.code
-	return it.body
 }
 
-func Register(voc *fvoc, n string, fct Callable) *xitem {
+func (it *data) Data() fptr {
-	it := xitem{
+	return it.data
-		name: name(n),
+}
-		fct:  fct,
+
-	}
+// func Register(voc *fvoc, n string, fct Callable) *xitem {
-	voc.Register(n, &it)
+func Register(voc *fvoc, it XT) XT {
-	return &it
+	voc.Register(it.Name(), it)
+	return it
 }
 
 // forgeEnv methods
@@ -139,16 +159,13 @@ func (f *forgeEnv) Exec(items ...fitem) {
 }
 
 func (f *forgeEnv) Def(name string, items ...fitem) XT {
-	xt := Register(f.voc, name, doDef)
+	code := f.Code(items...)
-	xt.body = newPtr(f.Code(items...)).Next()
+	return Register(f.voc, FCode(name, code))
-	return xt
 }
 
 func (f *forgeEnv) Const(name string, value fitem) XT {
-	xt := Register(f.voc, name, doData)
+	data := newScalar().Append(value)
-	xt.body = newScalar()
+	return Register(f.voc, Data(name, data, nil))
-	xt.body.Append(value)
-	return xt
 }
 
 func (f *forgeEnv) Literal() {
@@ -174,7 +191,7 @@ func (f *forgeEnv) Peek(d int) fitem {
 // basic functions for executable items
 
 func doDef(f *forgeEnv, xt XT) {
-	f.Call(xt.Code().Value().(fptr))
+	f.Call(xt.Code().(fptr))
 }
 
 func doData(f *forgeEnv, xt XT) {