ginger/vm/function.go

package vm

import (
	"fmt"

	"code.betamike.com/mediocregopher/ginger/gg"
	"code.betamike.com/mediocregopher/ginger/graph"
)

// Function is an entity which accepts an argument Value and performs some
// internal processing on that argument to return a resultant Value.
type Function interface {
	Perform(Value) Value
}

// FunctionFunc is a function which implements the Function interface.
type FunctionFunc func(Value) Value

// Perform calls the underlying FunctionFunc directly.
func (f FunctionFunc) Perform(arg Value) Value {
	return f(arg)
}

// Identity returns an Function which always returns the given Value,
// regardless of the input argument.
//
// TODO this might not be the right name
func Identity(val Value) Function {
	return FunctionFunc(func(Value) Value {
		return val
	})
}

var (
	valNameIn     = Value{Value: gg.Name("in")}
	valNameOut    = Value{Value: gg.Name("out")}
	valNameIf     = Value{Value: gg.Name("if")}
	valNameRecur  = Value{Value: gg.Name("recur")}
	valNumberZero = Value{Value: gg.Number(0)}
)

// FunctionFromGraph wraps the given Graph such that it can be used as an
// Function. The given Scope determines what values outside of the Graph are
// available for use within the Function.
func FunctionFromGraph(g *gg.Graph, scope Scope) (Function, error) {

	// edgeFn is distinct from a generic Function in that the Value passed into
	// Perform will _always_ be the value of "in" for the overall Function.
	//
	// edgeFns will wrap each other, passing "in" downwards to the leaf edgeFns.
	type edgeFn Function

	var compileEdge func(*gg.OpenEdge) (edgeFn, error)

	// TODO memoize?
	valToEdgeFn := func(val Value) (edgeFn, error) {

		if val.Name == nil {
			return edgeFn(Identity(val)), nil
		}

		name := *val.Name

		if val.Equal(valNameIn) {
			return edgeFn(FunctionFunc(func(inArg Value) Value {
				return inArg
			})), nil
		}

		// TODO intercept if and recur?

		edgesIn := g.ValueIns(val.Value)

		if l := len(edgesIn); l == 0 {

			val, err := scope.Resolve(name)

			if err != nil {
				return nil, fmt.Errorf("resolving name %q from the outer scope: %w", name, err)
			}

			return edgeFn(Identity(val)), nil

		} else if l != 1 {
			return nil, fmt.Errorf("resolved name %q to %d input edges, rather than one", name, l)
		}

		edge := edgesIn[0]

		return compileEdge(edge)
	}

	// "out" resolves to more than a static value, treat the graph as a full
	// operation.

	// thisFn is used to support recur. It will get filled in with the Function
	// which is returned by this function, once that Function is created.
	thisFn := new(Function)

	compileEdge = func(edge *gg.OpenEdge) (edgeFn, error) {

		return graph.MapReduce[gg.OptionalValue, gg.Value, edgeFn](
			edge,
			func(ggVal gg.Value) (edgeFn, error) {
				return valToEdgeFn(Value{Value: ggVal})
			},
			func(ggEdgeVal gg.OptionalValue, inEdgeFns []edgeFn) (edgeFn, error) {

				if ggEdgeVal.Equal(valNameIf.Value) {

					if len(inEdgeFns) != 3 {
						return nil, fmt.Errorf("'if' requires a 3-tuple argument")
					}

					return edgeFn(FunctionFunc(func(inArg Value) Value {

						if pred := inEdgeFns[0].Perform(inArg); pred.Equal(valNumberZero) {
							return inEdgeFns[2].Perform(inArg)
						}

						return inEdgeFns[1].Perform(inArg)

					})), nil
				}

				// "if" statements (above) are the only case where we want the
				// input edges to remain separated, otherwise they should always
				// be combined into a single edge whose value is a tuple. Do
				// that here.

				inEdgeFn := inEdgeFns[0]

				if len(inEdgeFns) > 1 {
					inEdgeFn = edgeFn(FunctionFunc(func(inArg Value) Value {
						tupVals := make([]Value, len(inEdgeFns))

						for i := range inEdgeFns {
							tupVals[i] = inEdgeFns[i].Perform(inArg)
						}

						return Tuple(tupVals...)
					}))
				}

				var edgeVal Value
				if ggEdgeVal.Valid {
					edgeVal.Value = ggEdgeVal.Value
				}

				if edgeVal.IsZero() {
					return inEdgeFn, nil
				}

				if edgeVal.Equal(valNameRecur) {
					return edgeFn(FunctionFunc(func(inArg Value) Value {
						return (*thisFn).Perform(inEdgeFn.Perform(inArg))
					})), nil
				}

				if edgeVal.Graph != nil {

					opFromGraph, err := FunctionFromGraph(
						edgeVal.Graph,
						scope.NewScope(),
					)

					if err != nil {
						return nil, fmt.Errorf("compiling graph to operation: %w", err)
					}

					edgeVal = Value{Function: opFromGraph}
				}

				// The Function is known at compile-time, so we can wrap it
				// directly into an edgeVal using the existing inEdgeFn as the
				// input.
				if edgeVal.Function != nil {
					return edgeFn(FunctionFunc(func(inArg Value) Value {
						return edgeVal.Function.Perform(inEdgeFn.Perform(inArg))
					})), nil
				}

				// the edgeVal is not an Function at compile time, and so
				// it must become one at runtime. We must resolve edgeVal to an
				// edgeFn as well (edgeEdgeFn), and then at runtime that is
				// given the inArg and (hopefully) the resultant Function is
				// called.

				edgeEdgeFn, err := valToEdgeFn(edgeVal)

				if err != nil {
					return nil, err
				}

				return edgeFn(FunctionFunc(func(inArg Value) Value {

					runtimeEdgeVal := edgeEdgeFn.Perform(inArg)

					if runtimeEdgeVal.Graph != nil {

						runtimeFn, err := FunctionFromGraph(
							runtimeEdgeVal.Graph,
							scope.NewScope(),
						)

						if err != nil {
							panic(fmt.Sprintf("compiling graph to operation: %v", err))
						}

						runtimeEdgeVal = Value{Function: runtimeFn}
					}

					if runtimeEdgeVal.Function == nil {
						panic("edge value must be an operation")
					}

					return runtimeEdgeVal.Function.Perform(inEdgeFn.Perform(inArg))

				})), nil
			},
		)
	}

	graphFn, err := valToEdgeFn(valNameOut)

	if err != nil {
		return nil, err
	}

	*thisFn = Function(graphFn)

	return Function(graphFn), nil
}