auto: Add FromFunc and Support for Function Arguments (#139)

* auto: Rework rules for passing some values.

* auto: Add support for function arguments.

* auto: Add a test of `Func()` using a `stream.Stream`.

* wdte: Update some dependencies.

* auto: Export `fromFunc()` as `FromFunc()`.

Author: DeedleFake

auto/auto.go

@@ -14,13 +14,13 @@ var (
 	stringType = reflect.TypeOf(wdte.String(""))
 )
 
-func fromWDTE(w wdte.Func, expected reflect.Type) reflect.Value {
+func fromWDTE(frame wdte.Frame, w wdte.Func, expected reflect.Type) reflect.Value {
 	v := reflect.ValueOf(w)
+	if v.Type() == expected {
+		return v
+	}
 
 	switch expected.Kind() {
-	case reflect.Bool, reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64, reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr, reflect.Float32, reflect.Float64, reflect.Complex64, reflect.Complex128, reflect.String:
-		return v.Convert(expected)
-
 	case reflect.Array:
 		v := v.Convert(arrayType).Interface().(wdte.Array)
 		if len(v) != expected.Len() {
@@ -30,12 +30,12 @@ func fromWDTE(w wdte.Func, expected reflect.Type) reflect.Value {
 		t := reflect.ArrayOf(expected.Len(), expected.Elem())
 		r := reflect.New(t).Elem()
 		for i := 0; i < r.Len(); i++ {
-			r.Index(i).Set(fromWDTE(v[i], expected.Elem()))
+			r.Index(i).Set(fromWDTE(frame, v[i], expected.Elem()))
 		}
 		return r
 
 	case reflect.Func:
-		panic(errors.New("func arguments are not yet supported"))
+		return FromFunc(frame, w, expected)
 
 	case reflect.Map:
 		panic(errors.New("map arguments are not yet supported"))
@@ -46,18 +46,19 @@ func fromWDTE(w wdte.Func, expected reflect.Type) reflect.Value {
 		t := reflect.SliceOf(expected.Elem())
 		r := reflect.MakeSlice(t, 0, len(v))
 		for _, e := range v {
-			r = reflect.Append(r, fromWDTE(e, expected.Elem()))
+			r = reflect.Append(r, fromWDTE(frame, e, expected.Elem()))
 		}
 		return r
-
-	case reflect.Struct:
-		panic(errors.New("struct arguments are not yet supported"))
 	}
 
-	panic(fmt.Errorf("unsupported type: %v", expected))
+	return v.Convert(expected)
 }
 
 func toWDTE(v reflect.Value) wdte.Func {
+	if v, ok := v.Interface().(wdte.Func); ok {
+		return v
+	}
+
 	switch v.Kind() {
 	case reflect.Bool:
 		return wdte.Bool(v.Bool())

auto/func.go

@@ -15,25 +15,25 @@ import (
 // function.
 //
 // Note that currently this is limited to functions that have a single
-// return value, and not all types are supported. Currently supported
-// types are as follows:
+// return value.
+//
+// Unrecognized types are passed through with an attempted conversion,
+// allowing a function to, for example, take a stream.Stream as an
+// argument. Similarly, if an expected type of an argument is the
+// exact type of the value passed, the value is passed through
+// directly. If a return value's type implements wdte.Func, it is also
+// passed directly. Types with special handling are as follows:
 //
 // Arguments:
-// * Any number type, including uintptrs.
-// * Arrays and slices of supported types. Note that the passed WDTE
-//   array's length must match the expected length of the array in the
-//   Go function's arguments.
-// * Booleans.
-// * Strings.
+//    * Arrays and slices. Note that the passed WDTE array's length
+//      must match the expected length of the array in the Go
+//      function's arguments.
 //
 // Return types:
-// * Any number type, including uintptrs.
-// * Arrays and slices of supported types.
-// * Booleans.
-// * Strings.
-// * Pointers to supported types.
-// * Functions that are supported by this function. The functions will
-//   use a frame with the name "<auto>".
+//    * Arrays and slices.
+//    * Pointers.
+//    * Functions that are supported by this function. The functions
+//      will use a frame with the name "<auto>".
 func Func(name string, f interface{}) wdte.Func {
 	v := reflect.ValueOf(f)
 
@@ -57,7 +57,7 @@ func Func(name string, f interface{}) wdte.Func {
 
 		in := make([]reflect.Value, t.NumIn())
 		for i := range in {
-			in[i] = fromWDTE(args[i].Call(frame), t.In(i))
+			in[i] = fromWDTE(frame, args[i].Call(frame), t.In(i))
 		}
 
 		out := v.Call(in)
@@ -66,3 +66,33 @@ func Func(name string, f interface{}) wdte.Func {
 	})
 	return r
 }
+
+// FromFunc does the opposite of Func, returning a Go function with
+// the signature given by expected that, when called, calls w with
+// frame. Type conversions are handled the same as in Func, but in
+// reverse, such that the return type stipulations in Func apply to
+// the arguments to w, and vice versa for the return value of w. The
+// requested function type must return exactly zero or one values.
+func FromFunc(frame wdte.Frame, w wdte.Func, expected reflect.Type) reflect.Value {
+	if expected.Kind() != reflect.Func {
+		panic(errors.New("expected is not a function type"))
+	}
+	if expected.NumOut() > 1 {
+		panic(fmt.Errorf("invalid number of returns: %v", expected.NumOut()))
+	}
+
+	return reflect.MakeFunc(expected, func(args []reflect.Value) []reflect.Value {
+		wargs := make([]wdte.Func, 0, len(args))
+		for _, arg := range args {
+			wargs = append(wargs, toWDTE(arg))
+		}
+
+		fmt.Println(w)
+		r := w.Call(frame, wargs...)
+		if expected.NumOut() == 0 {
+			// TODO: Should zero return values be allowed?
+			return nil
+		}
+		return []reflect.Value{fromWDTE(frame, r, expected.Out(0))}
+	})
+}

auto/func_test.go

@@ -7,8 +7,17 @@ import (
 
 	"github.com/DeedleFake/wdte"
 	"github.com/DeedleFake/wdte/auto"
+	"github.com/DeedleFake/wdte/std/stream"
 )
 
+func testFunc(frame wdte.Frame, args ...wdte.Func) wdte.Func {
+	if len(args) == 0 {
+		return wdte.GoFunc(testFunc)
+	}
+
+	return args[0].(wdte.Number) + 1
+}
+
 func TestFunc(t *testing.T) {
 	tests := []struct {
 		name  string
@@ -49,15 +58,43 @@ func TestFunc(t *testing.T) {
 		},
 		{
 			name: "Func",
-			f: func(v int) func() int {
+			f: func(f func(v int) int) func() int {
+				var v int
 				return func() int {
-					v++
-					return v - 1
+					p := v
+					v = f(v)
+					return p
 				}
 			},
-			args:  []wdte.Func{wdte.Number(0)},
+			args:  []wdte.Func{wdte.GoFunc(testFunc)},
 			calls: []wdte.Func{wdte.Number(0), wdte.Number(1), wdte.Number(2)},
 		},
+		{
+			name: "Direct",
+			f: func(a wdte.Array) wdte.String {
+				return wdte.String(fmt.Sprint(a))
+			},
+			args: []wdte.Func{wdte.Array{wdte.String("a"), wdte.String("test")}},
+			ret:  wdte.String("[a; test]"),
+		},
+		{
+			name: "Bool",
+			f: func(v bool) bool {
+				return !v
+			},
+			args: []wdte.Func{wdte.Bool(false)},
+			ret:  wdte.Bool(true),
+		},
+		{
+			name: "Stream",
+			f: func(s stream.Stream) int {
+				s.Next(wdte.F())
+				v, _ := s.Next(wdte.F())
+				return int(v.(wdte.Number))
+			},
+			args: []wdte.Func{stream.Range(wdte.F(), wdte.Number(10))},
+			ret:  wdte.Number(1),
+		},
 	}
 
 	for _, test := range tests {

go.mod

@@ -2,6 +2,6 @@ module github.com/DeedleFake/wdte
 
 require (
 	github.com/peterh/liner v1.1.0
-	golang.org/x/crypto v0.0.0-20181025113841-85e1b3f9139a
-	golang.org/x/sys v0.0.0-20181025063200-d989b31c8746 // indirect
+	golang.org/x/crypto v0.0.0-20181025213731-e84da0312774
+	golang.org/x/sys v0.0.0-20181026144532-2772b66316d2 // indirect
 )

go.sum

@@ -2,7 +2,7 @@ github.com/mattn/go-runewidth v0.0.3 h1:a+kO+98RDGEfo6asOGMmpodZq4FNtnGP54yps8Bz
 github.com/mattn/go-runewidth v0.0.3/go.mod h1:LwmH8dsx7+W8Uxz3IHJYH5QSwggIsqBzpuz5H//U1FU=
 github.com/peterh/liner v1.1.0 h1:f+aAedNJA6uk7+6rXsYBnhdo4Xux7ESLe+kcuVUF5os=
 github.com/peterh/liner v1.1.0/go.mod h1:CRroGNssyjTd/qIG2FyxByd2S8JEAZXBl4qUrZf8GS0=
-golang.org/x/crypto v0.0.0-20181025113841-85e1b3f9139a h1:Pg1/+l4/QV6z7N506eGnLiJ/Rl4IJf1FwYQKvP51OjA=
-golang.org/x/crypto v0.0.0-20181025113841-85e1b3f9139a/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4=
-golang.org/x/sys v0.0.0-20181025063200-d989b31c8746 h1:zTiiIq2XH/ldZGPA59ILL7NbDlz/btn3iJvO7H57mY8=
-golang.org/x/sys v0.0.0-20181025063200-d989b31c8746/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
+golang.org/x/crypto v0.0.0-20181025213731-e84da0312774 h1:a4tQYYYuK9QdeO/+kEvNYyuR21S+7ve5EANok6hABhI=
+golang.org/x/crypto v0.0.0-20181025213731-e84da0312774/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4=
+golang.org/x/sys v0.0.0-20181026144532-2772b66316d2 h1:W7CqTdBJ1CmxLKe7LptKDnBYV6PHrVLiGnoyBjaG/JQ=
+golang.org/x/sys v0.0.0-20181026144532-2772b66316d2/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=