native

pkg/deltanet/deltanet.go

···
 	NodeTypeEraser
 	NodeTypeReplicator
 	NodeTypeVar // Wire/Interface
+	NodeTypeData
+	NodeTypeNative
 )
 
 func (t NodeType) String() string {
···
 		return "Replicator"
 	case NodeTypeVar:
 		return "Var"
+	case NodeTypeData:
+		return "Data"
+	case NodeTypeNative:
+		return "Native"
 	default:
 		return "Unknown"
 	}
···
 	SetDead() bool
 	IsDead() bool
 	Revive()
+	// For Data nodes
+	GetValue() interface{}
+	// For Native nodes
+	GetName() string
 }
 
 // Port represents a connection point on a node.
···
 	dead  int32
 }
 
-func (n *BaseNode) Type() NodeType { return n.typ }
-func (n *BaseNode) ID() uint64     { return n.id }
-func (n *BaseNode) Ports() []*Port { return n.ports }
-func (n *BaseNode) Level() int     { return 0 }
-func (n *BaseNode) Deltas() []int  { return nil }
+func (n *BaseNode) Type() NodeType        { return n.typ }
+func (n *BaseNode) ID() uint64            { return n.id }
+func (n *BaseNode) Ports() []*Port        { return n.ports }
+func (n *BaseNode) Level() int            { return 0 }
+func (n *BaseNode) Deltas() []int         { return nil }
+func (n *BaseNode) GetValue() interface{} { return nil }
+func (n *BaseNode) GetName() string       { return "" }
 
 func (n *BaseNode) SetDead() bool {
 	return atomic.CompareAndSwapInt32(&n.dead, 0, 1)
···
 func (n *ReplicatorNode) Level() int    { return n.level }
 func (n *ReplicatorNode) Deltas() []int { return n.deltas }
 
+// DataNode holds opaque data values.
+type DataNode struct {
+	BaseNode
+	value interface{}
+}
+
+func (n *DataNode) GetValue() interface{} { return n.value }
+
+// NativeNode represents a registered native function.
+type NativeNode struct {
+	BaseNode
+	name string
+}
+
+func (n *NativeNode) GetName() string { return n.name }
+
+// NativeFunc is a pure function that takes data and returns data or error.
+type NativeFunc func(interface{}) (interface{}, error)
+
 // Network manages the graph of nodes and interactions.
 type Network struct {
 	nextID      uint64
···
 	nodes   map[uint64]Node
 	nodesMu sync.Mutex
 
+	// Native function registry
+	natives   map[string]NativeFunc
+	nativesMu sync.RWMutex
+
 	traceBuf []TraceEvent
 	traceCap uint64
 	traceIdx uint64
···
 		scheduler: NewScheduler(),
 		workers:   runtime.NumCPU(),
 		nodes:     make(map[uint64]Node),
+		natives:   make(map[string]NativeFunc),
 		phase:     1,
 	}
 	return n
···
 	return node
 }
 
+func (n *Network) NewData(value interface{}) Node {
+	id := n.nextNodeID()
+	node := &DataNode{
+		BaseNode: BaseNode{
+			id:    id,
+			typ:   NodeTypeData,
+			ports: make([]*Port, 1), // 0: Connection
+		},
+		value: value,
+	}
+	node.ports[0] = &Port{Node: node, Index: 0}
+	n.nodesMu.Lock()
+	if n.nodes == nil {
+		n.nodes = make(map[uint64]Node)
+	}
+	n.nodes[node.id] = node
+	n.nodesMu.Unlock()
+	return node
+}
+
+func (n *Network) NewNative(name string) Node {
+	id := n.nextNodeID()
+	node := &NativeNode{
+		BaseNode: BaseNode{
+			id:    id,
+			typ:   NodeTypeNative,
+			ports: make([]*Port, 1), // 0: Connection (for application)
+		},
+		name: name,
+	}
+	node.ports[0] = &Port{Node: node, Index: 0}
+	n.nodesMu.Lock()
+	if n.nodes == nil {
+		n.nodes = make(map[uint64]Node)
+	}
+	n.nodes[node.id] = node
+	n.nodesMu.Unlock()
+	return node
+}
+
+func (n *Network) RegisterNative(name string, fn NativeFunc) {
+	n.nativesMu.Lock()
+	defer n.nativesMu.Unlock()
+	n.natives[name] = fn
+}
+
+func (n *Network) GetNative(name string) (NativeFunc, bool) {
+	n.nativesMu.RLock()
+	defer n.nativesMu.RUnlock()
+	fn, ok := n.natives[name]
+	return fn, ok
+}
+
 // Canonicalize prunes all nodes not reachable from the given root (node, port).
 // For every unreachable node, all its connected wires are replaced by erasers.
 func (n *Network) Canonicalize(root Node, rootPort int) {
···
 				n.commuteFanReplicator(b, a, depth)
 			}
 		}
+	case (a.Type() == NodeTypeFan && b.Type() == NodeTypeNative) || (a.Type() == NodeTypeNative && b.Type() == NodeTypeFan):
+		// Fan-Native interaction: Application of native function
+		rule = RuleFanNative
+		if a.Type() == NodeTypeFan {
+			n.applyNative(a, b, depth)
+		} else {
+			n.applyNative(b, a, depth)
+		}
+	case (a.Type() == NodeTypeFan && b.Type() == NodeTypeData) || (a.Type() == NodeTypeData && b.Type() == NodeTypeFan):
+		// Fan-Data: should not happen in normal reduction (Data comes after Native)
+		// But if it does, treat Data as inert (like Var)
+		rule = RuleUnknown
+		fmt.Printf("Warning: Fan-Data interaction (Fan %d <-> Data %d)\n", a.ID(), b.ID())
+		a.Revive()
+		b.Revive()
 	default:
 		fmt.Printf("Unknown interaction: %v <-> %v\n", a.Type(), b.Type())
 	}
···
 
 func (n *Network) createReplicatorCopyWithLevel(original Node, newLevel int) Node {
 	return n.NewReplicator(newLevel, original.Deltas())
+}
+
+// applyNative executes a native function application: Fan-Native interaction
+// Fan represents application: Fan.0 = function, Fan.2 = argument, Fan.1 = result
+// Native is the function node
+func (n *Network) applyNative(fan, native Node, depth uint64) {
+	// Get the native function
+	nativeName := native.GetName()
+	fn, ok := n.GetNative(nativeName)
+	if !ok {
+		fmt.Printf("Error: Native function %q not registered\n", nativeName)
+		// Create error data node
+		errData := n.NewData(fmt.Errorf("native function %q not found", nativeName))
+		// Connect result to error
+		if fan.Ports()[1].Wire.Load() != nil {
+			n.splice(errData.Ports()[0], fan.Ports()[1])
+		}
+		n.removeNode(fan)
+		n.removeNode(native)
+		return
+	}
+
+	// Get the argument from Fan.2
+	argNode, _ := n.GetLink(fan, 2)
+
+	// Check if argument is Data
+	if argNode == nil {
+		fmt.Printf("Error: Native %q applied to nil argument\n", nativeName)
+		errData := n.NewData(fmt.Errorf("nil argument"))
+		if fan.Ports()[1].Wire.Load() != nil {
+			n.splice(errData.Ports()[0], fan.Ports()[1])
+		}
+		n.removeNode(fan)
+		n.removeNode(native)
+		return
+	}
+
+	if argNode.Type() == NodeTypeData {
+		// Execute native function with data
+		value := argNode.GetValue()
+		result, err := fn(value)
+
+		var resultNode Node
+		if err != nil {
+			// Return error as data
+			resultNode = n.NewData(err)
+		} else {
+			// Check if result is a function (for currying)
+			if resultFn, isFn := result.(func(interface{}) (interface{}, error)); isFn {
+				// Result is a partially applied function - create new Native node
+				// Register it with a unique name
+				partialName := fmt.Sprintf("%s$partial$%d", nativeName, n.nextNodeID())
+				n.RegisterNative(partialName, resultFn)
+				resultNode = n.NewNative(partialName)
+			} else {
+				// Result is data
+				resultNode = n.NewData(result)
+			}
+		}
+
+		// Connect result to Fan.1
+		if fan.Ports()[1].Wire.Load() != nil {
+			n.splice(resultNode.Ports()[0], fan.Ports()[1])
+		}
+
+		// Remove processed nodes
+		n.removeNode(fan)
+		n.removeNode(native)
+		n.removeNode(argNode)
+	} else {
+		// Argument is not Data yet - the argument needs to reduce first
+		// This shouldn't happen in normal execution since we reduce arguments before functions
+		// But if it does, we treat this as an error case
+		fmt.Printf("Warning: Native %q applied to non-Data argument (type %v)\n", nativeName, argNode.Type())
+
+		// For now, just leave the structure as-is
+		// The reduction will continue with other active wires
+		fan.Revive()
+		native.Revive()
+	}
 }
 
 func (n *Network) SetPhase(p int) {

pkg/deltanet/native_test.go

···
+package deltanet
+
+import (
+	"fmt"
+	"testing"
+)
+
+// TestStringConcat tests concatenating two strings using native functions
+func TestStringConcat(t *testing.T) {
+	net := NewNetwork()
+
+	// Register concat native function
+	net.RegisterNative("concat", func(a interface{}) (interface{}, error) {
+		// This returns a function that captures 'a' (first string)
+		s1, ok := a.(string)
+		if !ok {
+			return nil, fmt.Errorf("concat: first arg must be string, got %T", a)
+		}
+
+		// Return a native function that takes the second argument
+		return func(b interface{}) (interface{}, error) {
+			s2, ok := b.(string)
+			if !ok {
+				return nil, fmt.Errorf("concat: second arg must be string, got %T", b)
+			}
+			return s1 + s2, nil
+		}, nil
+	})
+
+	// Build net structure for: concat "hello" "world"
+	// This is: (concat "hello") "world"
+	// Structure: Fan(App) where:
+	//   Fan.0 -> connects to another Fan(App) for (concat "hello")
+	//   Fan.2 -> Data("world")
+	//   Fan.1 -> result
+
+	// Inner application: concat "hello"
+	innerFan := net.NewFan()
+	concatNode := net.NewNative("concat")
+	helloData := net.NewData("hello")
+
+	net.Link(innerFan, 0, concatNode, 0) // Function
+	net.Link(innerFan, 2, helloData, 0)  // Argument
+	// innerFan.1 is the result of (concat "hello")
+
+	// Outer application: (concat "hello") "world"
+	outerFan := net.NewFan()
+	worldData := net.NewData("world")
+
+	net.Link(outerFan, 0, innerFan, 1)  // Function (result of inner app)
+	net.Link(outerFan, 2, worldData, 0) // Argument
+	// outerFan.1 is the final result
+
+	// Connect result to output var
+	output := net.NewVar()
+	net.Link(outerFan, 1, output, 0)
+
+	// Reduce
+	net.ReduceAll()
+
+	// Check result
+	resultNode, resultPort := net.GetLink(output, 0)
+	if resultNode == nil {
+		t.Fatal("Result node is nil")
+	}
+	if resultNode.Type() != NodeTypeData {
+		t.Errorf("Expected result to be Data node, got %v", resultNode.Type())
+	}
+
+	result := resultNode.GetValue()
+	expected := "helloworld"
+	if result != expected {
+		t.Errorf("Expected %q, got %v", expected, result)
+	}
+
+	t.Logf("Result: %v (port %d)", result, resultPort)
+}
+
+// TestStringLength tests computing the length of a string
+func TestStringLength(t *testing.T) {
+	net := NewNetwork()
+
+	// Register length native function
+	net.RegisterNative("length", func(v interface{}) (interface{}, error) {
+		s, ok := v.(string)
+		if !ok {
+			return nil, fmt.Errorf("length: arg must be string, got %T", v)
+		}
+		return len(s), nil
+	})
+
+	// Build net structure for: length "hello"
+	// Structure: Fan(App) where:
+	//   Fan.0 -> Native("length")
+	//   Fan.2 -> Data("hello")
+	//   Fan.1 -> result
+
+	fan := net.NewFan()
+	lengthNode := net.NewNative("length")
+	helloData := net.NewData("hello")
+
+	net.Link(fan, 0, lengthNode, 0) // Function
+	net.Link(fan, 2, helloData, 0)  // Argument
+
+	// Connect result to output var
+	output := net.NewVar()
+	net.Link(fan, 1, output, 0)
+
+	// Reduce
+	net.ReduceAll()
+
+	// Check result
+	resultNode, resultPort := net.GetLink(output, 0)
+	if resultNode == nil {
+		t.Fatal("Result node is nil")
+	}
+	if resultNode.Type() != NodeTypeData {
+		t.Errorf("Expected result to be Data node, got %v", resultNode.Type())
+	}
+
+	result := resultNode.GetValue()
+	expected := 5
+	if result != expected {
+		t.Errorf("Expected %d, got %v", expected, result)
+	}
+
+	t.Logf("Result: %v (port %d)", result, resultPort)
+}
+
+// TestConcatLength tests composing concat and length
+// length (concat "hello" "world") should return 10
+func TestConcatLength(t *testing.T) {
+	net := NewNetwork()
+
+	// Register both natives
+	net.RegisterNative("concat", func(a interface{}) (interface{}, error) {
+		s1, ok := a.(string)
+		if !ok {
+			return nil, fmt.Errorf("concat: first arg must be string, got %T", a)
+		}
+		return func(b interface{}) (interface{}, error) {
+			s2, ok := b.(string)
+			if !ok {
+				return nil, fmt.Errorf("concat: second arg must be string, got %T", b)
+			}
+			return s1 + s2, nil
+		}, nil
+	})
+
+	net.RegisterNative("length", func(v interface{}) (interface{}, error) {
+		s, ok := v.(string)
+		if !ok {
+			return nil, fmt.Errorf("length: arg must be string, got %T", v)
+		}
+		return len(s), nil
+	})
+
+	// Build: length (concat "hello" "world")
+	// Structure:
+	// 1. Inner: concat "hello" -> partial
+	// 2. Middle: partial "world" -> "helloworld"
+	// 3. Outer: length "helloworld" -> 10
+
+	// Build concat application
+	concatInnerFan := net.NewFan()
+	concatNode := net.NewNative("concat")
+	helloData := net.NewData("hello")
+	net.Link(concatInnerFan, 0, concatNode, 0)
+	net.Link(concatInnerFan, 2, helloData, 0)
+
+	concatOuterFan := net.NewFan()
+	worldData := net.NewData("world")
+	net.Link(concatOuterFan, 0, concatInnerFan, 1)
+	net.Link(concatOuterFan, 2, worldData, 0)
+	// concatOuterFan.1 is "helloworld"
+
+	// Build length application
+	lengthFan := net.NewFan()
+	lengthNode := net.NewNative("length")
+	net.Link(lengthFan, 0, lengthNode, 0)
+	net.Link(lengthFan, 2, concatOuterFan, 1) // Apply to concat result
+
+	// Connect result
+	output := net.NewVar()
+	net.Link(lengthFan, 1, output, 0)
+
+	// Reduce
+	net.ReduceAll()
+
+	// Check result
+	resultNode, _ := net.GetLink(output, 0)
+	if resultNode == nil {
+		t.Fatal("Result node is nil")
+	}
+	if resultNode.Type() != NodeTypeData {
+		t.Errorf("Expected result to be Data node, got %v", resultNode.Type())
+	}
+
+	result := resultNode.GetValue()
+	expected := 10
+	if result != expected {
+		t.Errorf("Expected %d, got %v", expected, result)
+	}
+
+	t.Logf("length (concat \"hello\" \"world\") = %v", result)
+}

pkg/deltanet/trace.go

···
 	RuleRepDecay
 	RuleRepMerge
 	RuleAuxFanRep
+	RuleFanNative
 )
 
 type TraceEvent struct {