Documentation

Overview

Package slicefunc provides types and code to call user-defined functions with Bigslice.

Index

• type Func
  • func Of(fn interface{}) (Func, bool)
  • func (f Func) Call(ctx context.Context, args []reflect.Value) []reflect.Value
  • func (f Func) IsNil() bool

Constants

This section is empty.

Variables

This section is empty.

Functions

This section is empty.

Types

type Func

type Func struct {
	// In and Out represent the slicetype of the function's input and output,
	// respectively.
	In, Out slicetype.Type
	// IsVariadic is whether the function's final parameter is variadic. If it
	// is, In.Out(In.NumOut()-1) returns the parameter's implicit actual slice
	// type. For example, if this represents func(x int, y ...string):
	//
	//  fn.In.NumOut() == 2
	//  fn.In.Out(0) is the reflect.Type for "int"
	//  fn.In.Out(1) is the reflect.Type for "[]string"
	//  fn.IsVariadic == true
	IsVariadic bool

	// contains filtered or unexported fields

}

Func represents a user-defined function within Bigslice. Currently it's a simple shim that's used to determine whether a context should be supplied to the callee.

TODO(marius): Evolve this abstraction over time to avoid the use of reflection. For example, we can generate (via a template) code for invocations on common types. Having this abstraction in place makes this possible to do without changing any of the callers.

TODO(marius): Another possibility is to exploit the fact that we have already typechecked the data pipeline within Bigslice, and thus can avoid the per-call typechecking overhead that is incurred by reflection. For example, we could allow Funcs to mint a new re-usable call frame that we can write values directly into. This might get us most of the former but with more generality and arguably less complexity. We could even pre-generate call frames for each row in a frame, since that is re-used also.

TODO(marius): consider using this package to allow user-defined funcs to return an error in the last argument.

var Nil Func

Nil is a nil Func.

func Of

func Of(fn interface{}) (Func, bool)

Of creates a Func from the provided function, along with a bool indicating whether fn is a valid function. If it is not, the returned Func is invalid.

func (Func) Call

func (f Func) Call(ctx context.Context, args []reflect.Value) []reflect.Value

Call invokes the function with the provided arguments, and returns the reflected return values.

TODO(marius): using reflect.Value here is not ideal for performance, but there may be more holistic approaches (see above) since we're (almost) always invoking functions from frames.

func (Func) IsNil

func (f Func) IsNil() bool

IsNil returns whether the Func f is nil.