af

package
Version: v0.0.0-...-ed4a9a5 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Nov 18, 2021 License: MIT Imports: 20 Imported by: 1

Documentation

Overview

Package af contains a set of adapative functions.

Example (Coalesce) 
package main

import (
	"fmt"

	"github.com/spatialcurrent/go-adaptive-functions/pkg/af"
)

func main() {
	out, err := af.Coalesce.ValidateRun(nil, "", "foo")
	if err != nil {
		panic(err)
	}
	fmt.Printf("%#v\n", out)
}

Output:

"foo"
Example (Concat1) 
package main

import (
	"fmt"

	"github.com/spatialcurrent/go-adaptive-functions/pkg/af"
)

func main() {
	out, err := af.Concat.ValidateRun("foo", "bar")
	if err != nil {
		panic(err)
	}
	fmt.Printf("%#v\n", out)
}

Output:

"foobar"
Example (Concat2) 
package main

import (
	"fmt"

	"github.com/spatialcurrent/go-adaptive-functions/pkg/af"
)

func main() {
	out, err := af.Concat.ValidateRun("1", "2", 3)
	if err != nil {
		panic(err)
	}
	fmt.Printf("%#v\n", out)
}

Output:

"123"
Example (Concat3) 
package main

import (
	"fmt"

	"github.com/spatialcurrent/go-adaptive-functions/pkg/af"
)

func main() {
	in := []interface{}{
		[]interface{}{
			"a",
			"b",
			"c",
			[]interface{}{
				"d",
				"e",
				"f",
			},
			[]interface{}{
				"g",
				"h",
				"i",
			},
			"j",
			"k",
		},
		"l",
		"m",
		"n",
	}
	out, err := af.Concat.ValidateRun(in)
	if err != nil {
		panic(err)
	}
	fmt.Printf("%#v\n", out)
}

Output:

"abcdefghijklmn"
Example (Flat) 
package main

import (
	"fmt"

	"github.com/spatialcurrent/go-adaptive-functions/pkg/af"
)

func main() {
	in := []interface{}{
		[]interface{}{"a", "b"},
		[]interface{}{"c", "d"},
		[]interface{}{"e", "f"},
	}
	out, err := af.Flat.ValidateRun(in)
	if err != nil {
		panic(err)
	}
	fmt.Printf("%#v\n", out)
}

Output:

[]interface {}{"a", "b", "c", "d", "e", "f"}
Example (IInMap)

This examples shows the use of the iin function to test if a key exists in a map. 

package main

import (
	"fmt"

	"github.com/spatialcurrent/go-adaptive-functions/pkg/af"
)

func main() {
	out, err := af.IIn.ValidateRun("A", map[string]interface{}{"a": "x", "b": "y"})
	if err != nil {
		panic(err)
	}
	fmt.Printf("%#v\n", out)
}

Output:

true
Example (IInSlice)

This examples shows the use of the in function to test if an element is in a slice. 

package main

import (
	"fmt"

	"github.com/spatialcurrent/go-adaptive-functions/pkg/af"
)

func main() {
	out, err := af.IIn.ValidateRun("A", []string{"a", "b", "c"})
	if err != nil {
		panic(err)
	}
	fmt.Printf("%#v\n", out)
}

Output:

true
Example (InIPRange)

This examples shows the use of the in function checking if an IP address is in an IP range. 

package main

import (
	"fmt"
	"net"

	"github.com/spatialcurrent/go-adaptive-functions/pkg/af"
)

func main() {
	addr := net.ParseIP("192.0.2.100")
	n := net.IPNet{IP: net.ParseIP("192.0.2.0"), Mask: net.CIDRMask(24, 32)}
	out, err := af.In.ValidateRun(addr, n)
	if err != nil {
		panic(err)
	}
	fmt.Printf("%#v\n", out)
}

Output:

true
Example (InMap)

This examples shows the use of the in function to test if a key exists in a map. 

package main

import (
	"fmt"

	"github.com/spatialcurrent/go-adaptive-functions/pkg/af"
)

func main() {
	out, err := af.In.ValidateRun("a", map[string]interface{}{"a": "x", "b": "y"})
	if err != nil {
		panic(err)
	}
	fmt.Printf("%#v\n", out)
}

Output:

true
Example (InSlice)

This examples shows the use of the in function to test if an element is in a slice. 

package main

import (
	"fmt"

	"github.com/spatialcurrent/go-adaptive-functions/pkg/af"
)

func main() {
	out, err := af.In.ValidateRun("a", []string{"a", "b", "c"})
	if err != nil {
		panic(err)
	}
	fmt.Printf("%#v\n", out)
}

Output:

true
Example (Join)

This examples shows the use of the join function. 

package main

import (
	"fmt"

	"github.com/spatialcurrent/go-adaptive-functions/pkg/af"
)

func main() {
	out, err := af.Join.ValidateRun([]interface{}{"a", "b", "c"}, ",")
	if err != nil {
		panic(err)
	}
	fmt.Printf("%#v\n", out)
}

Output:

"a,b,c"
Example (Limit)

This examples shows the use of the limit function to limit the number of elements in a slice. 

package main

import (
	"fmt"

	"github.com/spatialcurrent/go-adaptive-functions/pkg/af"
)

func main() {
	out, err := af.Limit.ValidateRun([]string{"a", "b", "c"}, 2)
	if err != nil {
		panic(err)
	}
	fmt.Printf("%#v\n", out)
}

Output:

[]string{"a", "b"}
Example (Max) 
package main

import (
	"fmt"

	"github.com/spatialcurrent/go-adaptive-functions/pkg/af"
)

func main() {
	out, err := af.Max.ValidateRun(1, 2, 4)
	if err != nil {
		panic(err)
	}
	fmt.Println(out)
}

Output:

4
Example (Min) 
package main

import (
	"fmt"

	"github.com/spatialcurrent/go-adaptive-functions/pkg/af"
)

func main() {
	out, err := af.Min.ValidateRun(1, 2, 4)
	if err != nil {
		panic(err)
	}
	fmt.Println(out)
}

Output:

1
Example (Repeat) 
package main

import (
	"fmt"

	"github.com/spatialcurrent/go-adaptive-functions/pkg/af"
)

func main() {
	out, err := af.Repeat.ValidateRun("ciao", 2)
	if err != nil {
		panic(err)
	}
	fmt.Println(out)
}

Output:

ciaociao
Example (Sort) 
package main

import (
	"fmt"

	"github.com/spatialcurrent/go-adaptive-functions/pkg/af"
)

func main() {
	out, err := af.Sort.ValidateRun([]string{"foo", "bar"})
	if err != nil {
		panic(err)
	}
	fmt.Println(out)
}

Output:

[bar foo]
Example (Split) 
package main

import (
	"fmt"

	"github.com/spatialcurrent/go-adaptive-functions/pkg/af"
)

func main() {
	in := "foo,bar"
	out, err := af.Split.ValidateRun(in, ",")
	if err != nil {
		panic(err)
	}
	fmt.Printf("%#v\n", out)
}

Output:

[]string{"foo", "bar"}
Example (Sum) 
package main

import (
	"fmt"

	"github.com/spatialcurrent/go-adaptive-functions/pkg/af"
)

func main() {
	out, err := af.Sum.ValidateRun(1, 2, 4)
	if err != nil {
		panic(err)
	}
	fmt.Println(out)
}

Output:

7
Example (ToKeys) 
package main

import (
	"fmt"

	"github.com/spatialcurrent/go-adaptive-functions/pkg/af"
)

func main() {
	out, err := af.ToKeys.ValidateRun(map[string]interface{}{"a": "x"})
	if err != nil {
		panic(err)
	}
	fmt.Printf("%#v\n", out)
}

Output:

[]string{"a"}
Example (ToLower) 
package main

import (
	"fmt"

	"github.com/spatialcurrent/go-adaptive-functions/pkg/af"
)

func main() {
	out, err := af.ToLower.ValidateRun("Hello World")
	if err != nil {
		panic(err)
	}
	fmt.Println(out)
}

Output:

hello world
Example (ToTitle) 
package main

import (
	"fmt"

	"github.com/spatialcurrent/go-adaptive-functions/pkg/af"
)

func main() {
	out, err := af.ToTitle.ValidateRun("hello world")
	if err != nil {
		panic(err)
	}
	fmt.Println(out)
}

Output:

Hello World
Example (ToUpper) 
package main

import (
	"fmt"

	"github.com/spatialcurrent/go-adaptive-functions/pkg/af"
)

func main() {
	out, err := af.ToUpper.ValidateRun("Hello World")
	if err != nil {
		panic(err)
	}
	fmt.Println(out)
}

Output:

HELLO WORLD
Example (ToValues) 
package main

import (
	"fmt"

	"github.com/spatialcurrent/go-adaptive-functions/pkg/af"
)

func main() {
	out, err := af.ToValues.ValidateRun(map[string]string{"a": "x"})
	if err != nil {
		panic(err)
	}
	fmt.Printf("%#v\n", out)
}

Output:

[]string{"x"}

Index

Examples

Constants

This section is empty.

Variables

View Source 
var Add = Function{
	Name:    "Add",
	Aliases: []string{"add"},
	Definitions: []Definition{
		Definition{Inputs: []interface{}{reflect.Int, reflect.Int}, Output: reflect.Int},
		Definition{Inputs: []interface{}{reflect.Int, reflect.Int64}, Output: reflect.Int},
		Definition{Inputs: []interface{}{reflect.Int, reflect.Float64}, Output: reflect.Float64},
		Definition{Inputs: []interface{}{reflect.Int64, reflect.Int}, Output: reflect.Int},
		Definition{Inputs: []interface{}{reflect.Int64, reflect.Int64}, Output: reflect.Int},
		Definition{Inputs: []interface{}{reflect.Int64, reflect.Float64}, Output: reflect.Float64},
		Definition{Inputs: []interface{}{reflect.Float64, reflect.Int}, Output: reflect.Int},
		Definition{Inputs: []interface{}{reflect.Float64, reflect.Int64}, Output: reflect.Int},
		Definition{Inputs: []interface{}{reflect.Float64, reflect.Float64}, Output: reflect.Float64},
		Definition{Inputs: []interface{}{reflect.String, reflect.String}, Output: reflect.String},
		Definition{Inputs: []interface{}{reflect.Int, reflect.String}, Output: reflect.String},
		Definition{Inputs: []interface{}{reflect.Int32, reflect.String}, Output: reflect.String},
		Definition{Inputs: []interface{}{reflect.Int64, reflect.String}, Output: reflect.String},
		Definition{Inputs: []interface{}{reflect.Float64, reflect.String}, Output: reflect.String},
		Definition{Inputs: []interface{}{reflect.String, reflect.Int}, Output: reflect.String},
		Definition{Inputs: []interface{}{reflect.String, reflect.Int32}, Output: reflect.String},
		Definition{Inputs: []interface{}{reflect.String, reflect.Int64}, Output: reflect.String},
		Definition{Inputs: []interface{}{reflect.String, reflect.Float64}, Output: reflect.String},
		Definition{Inputs: []interface{}{reflect.Slice, reflect.Array}, Output: reflect.Slice},
		Definition{Inputs: []interface{}{reflect.Slice, reflect.Slice}, Output: reflect.Slice},
		Definition{Inputs: []interface{}{reflect.Array, reflect.Array}, Output: reflect.Slice},
		Definition{Inputs: []interface{}{reflect.Array, reflect.Slice}, Output: reflect.Slice},
		Definition{Inputs: []interface{}{reflect.Map, reflect.Map}, Output: reflect.Map},
	},
	Function: add,
}
View Source 
var Base = Function{
	Name:    "Base",
	Aliases: []string{"base"},
	Definitions: []Definition{
		Definition{Inputs: []interface{}{stringType}, Output: stringType},
	},
	Function: func(args ...interface{}) (interface{}, error) {
		if str, ok := args[0].(string); ok {
			return path.Base(str), nil
		}
		return nil, &ErrInvalidArguments{Function: "Base", Arguments: args}
	},
}
View Source 
var Bottom = Function{
	Name:    "Bottom",
	Aliases: []string{"bottom"},
	Definitions: []Definition{
		Definition{Inputs: []interface{}{stringIntMapType, intType}, Output: stringSliceType},
		Definition{Inputs: []interface{}{stringIntMapType, intType, intType}, Output: stringSliceType},
	},
	Function: bottom,
}
View Source 
var BoundingBox = Function{
	Name:    "BoundingBox",
	Aliases: []string{"boundingBox", "bbox"},
	Definitions: []Definition{
		Definition{Inputs: []interface{}{reflect.Array}, Output: float64ArrayType},
		Definition{Inputs: []interface{}{reflect.Slice}, Output: float64ArrayType},
	},
	Function: boundingBox,
}
View Source 
var Clean = Function{
	Name:    "Clean",
	Aliases: []string{"clean"},
	Definitions: []Definition{
		Definition{Inputs: []interface{}{stringType}, Output: stringType},
	},
	Function: func(args ...interface{}) (interface{}, error) {
		if str, ok := args[0].(string); ok {
			return filepath.Clean(str), nil
		}
		return nil, &ErrInvalidArguments{Function: "Clean", Arguments: args}
	},
}
View Source 
var Coalesce = Function{
	Name:        "Coalesce",
	Aliases:     []string{"coalesce"},
	Definitions: []Definition{},
	Function:    coalesce,
}
View Source 
var Concat = Function{
	Name:    "Concat",
	Aliases: []string{"concat"},
	Definitions: []Definition{
		Definition{Inputs: nil, Output: reflect.String},
	},
	Function: func(args ...interface{}) (interface{}, error) {
		return stringify.Concat(args, stringify.NewDefaultStringer())
	},
}
View Source 
var Divide = Function{
	Name:        "Divide",
	Aliases:     []string{"divide"},
	Definitions: []Definition{},
	Function: func(args ...interface{}) (interface{}, error) {
		if len(args) != 2 {
			return nil, &ErrInvalidArguments{Function: "Divide", Arguments: args}
		}
		return math.Divide(args[0], args[1])
	},
}
View Source 
var Empty = Function{
	Name:    "Empty",
	Aliases: []string{"empty"},
	Definitions: []Definition{
		Definition{Inputs: []interface{}{byteSliceType}, Output: reflect.Bool},
		Definition{Inputs: []interface{}{uint8SliceType}, Output: reflect.Bool},
		Definition{Inputs: []interface{}{intSliceType}, Output: reflect.Bool},
		Definition{Inputs: []interface{}{int64ArrayType}, Output: reflect.Bool},
		Definition{Inputs: []interface{}{float64ArrayType}, Output: reflect.Bool},
		Definition{Inputs: []interface{}{stringSliceType}, Output: reflect.Bool},
		Definition{Inputs: []interface{}{stringIntMapSliceType}, Output: reflect.Bool},
		Definition{Inputs: []interface{}{interfaceArrayType}, Output: reflect.Bool},
		Definition{Inputs: []interface{}{reflect.String}, Output: reflect.Bool},
		Definition{Inputs: []interface{}{reflect.Map}, Output: reflect.Bool},
	},
	Function: empty,
}
View Source 
var First = Function{
	Name:    "First",
	Aliases: []string{"first"},
	Definitions: []Definition{
		Definition{Inputs: []interface{}{byteSliceType}, Output: reflect.Uint8},
		Definition{Inputs: []interface{}{uint8SliceType}, Output: reflect.Uint8},
		Definition{Inputs: []interface{}{intSliceType}, Output: reflect.Int},
		Definition{Inputs: []interface{}{int64ArrayType}, Output: reflect.Int64},
		Definition{Inputs: []interface{}{float64ArrayType}, Output: reflect.Float64},
		Definition{Inputs: []interface{}{stringSliceType}, Output: reflect.String},
		Definition{Inputs: []interface{}{stringIntMapSliceType}, Output: stringIntMapType},
		Definition{Inputs: []interface{}{interfaceArrayType}, Output: nil},
		Definition{Inputs: []interface{}{reflect.String}, Output: reflect.Uint8},
		Definition{Inputs: []interface{}{reflect.Map}, Output: nil},
	},
	Function: first,
}
View Source 
var Flat = Function{
	Name:        "Flat",
	Aliases:     []string{"flat", "flatten"},
	Definitions: []Definition{},
	Function: func(args ...interface{}) (interface{}, error) {
		return flat.Flat(args), nil
	},
}

Flat is a function that flattens an array of arrays.

View Source 
var Fold = Function{
	Name:    "Fold",
	Aliases: []string{"fold"},
	Definitions: []Definition{
		Definition{Inputs: []interface{}{reflect.String}, Output: reflect.String},
	},
	Function: fold,
}
View Source 
var Format = Function{
	Name:    "Format",
	Aliases: []string{"fmt", "format"},
	Definitions: []Definition{
		Definition{Inputs: []interface{}{timeType, reflect.String}, Output: reflect.String},
		Definition{Inputs: nil, Output: reflect.String},
	},
	Function: format,
}
View Source 
var Functions = []Function{
	Add,
	Base,
	Bottom,
	BoundingBox,
	Clean,
	Coalesce,
	Concat,
	Divide,
	Empty,
	First,
	Flat,
	Fold,
	Format,
	Length,
	ILike,
	In,
	IIn,
	Intersects,
	Join,
	JSON,
	Last,
	Like,
	Limit,
	Lookup,
	Make,
	Max,
	Mean,
	Min,
	Multiply,
	Now,
	Prefix,
	Pow,
	Repeat,
	Replace,
	Second,
	Slice,
	Split,
	Sort,
	Stringify,
	Subtract,
	Suffix,
	Sum,
	TileX,
	TileY,
	ToBigEndian,
	ToBytes,
	ToInt,
	ToInt8,
	ToInt16,
	ToInt32,
	ToInt64,
	ToIntSlice,
	ToFloat32,
	ToFloat64,
	ToFloat64Slice,
	ToItems,
	ToKeys,
	ToLittleEndian,
	ToLower,
	ToSet,
	ToString,
	ToStringSet,
	ToTitle,
	ToTime,
	Top,
	ToUpper,
	ToValues,
	Trim,
	Within,
	Words,
}

Functions is an array of all the adapative functions defined in this package.

View Source 
var IIn = Function{
	Name:    "IIn",
	Aliases: []string{"iin"},
	Definitions: []Definition{
		Definition{Inputs: []interface{}{reflect.String, reflect.String}, Output: reflect.Bool},
		Definition{Inputs: []interface{}{reflect.String, reflect.Array}, Output: reflect.Bool},
		Definition{Inputs: []interface{}{reflect.String, reflect.Slice}, Output: reflect.Bool},
		Definition{Inputs: []interface{}{reflect.String, reflect.Map}, Output: reflect.Bool},
		Definition{Inputs: []interface{}{reflect.String, reflect.Struct}, Output: reflect.Bool},
		Definition{Inputs: []interface{}{stringSliceType, stringSliceType}, Output: reflect.Bool},
	},
	Function: iin,
}
View Source 
var ILike = Function{
	Name:    "ILike",
	Aliases: []string{"ilike"},
	Definitions: []Definition{
		Definition{Inputs: []interface{}{reflect.String, reflect.String}, Output: reflect.Bool},
	},
	Function: ilike,
}
View Source 
var In = Function{
	Name:    "In",
	Aliases: []string{"in"},
	Definitions: []Definition{
		Definition{Inputs: []interface{}{ipType, ipNetType}, Output: reflect.Bool},
		Definition{Inputs: []interface{}{ipType, ipNetPtrType}, Output: reflect.Bool},
		Definition{Inputs: []interface{}{reflect.String, reflect.String}, Output: reflect.Bool},
		Definition{Inputs: []interface{}{intSliceType, intSliceType}, Output: reflect.Bool},
		Definition{Inputs: []interface{}{stringSliceType, stringSliceType}, Output: reflect.Bool},
		Definition{Inputs: []interface{}{byteSliceType, byteSliceType}, Output: reflect.Bool},
		Definition{Inputs: []interface{}{reflect.String, reflect.Array}, Output: reflect.Bool},
		Definition{Inputs: []interface{}{reflect.String, reflect.Slice}, Output: reflect.Bool},
		Definition{Inputs: []interface{}{reflect.String, reflect.Map}, Output: reflect.Bool},
		Definition{Inputs: []interface{}{reflect.String, reflect.Struct}, Output: reflect.Bool},
	},
	Function: in,
}
View Source 
var Intersects = Function{
	Name:    "intersects",
	Aliases: []string{"intersects"},
	Definitions: []Definition{
		Definition{Inputs: []interface{}{reflect.Map, reflect.Map}, Output: boolType},
		Definition{Inputs: []interface{}{float64ArrayType, float64ArrayType}, Output: boolType},
	},
	Function: intersects,
}
View Source 
var JSON = Function{
	Name:    "json",
	Aliases: []string{"json"},
	Definitions: []Definition{
		Definition{Inputs: []interface{}{nil}, Output: reflect.String},
	},
	Function: func(args ...interface{}) (interface{}, error) {
		if len(args) != 1 {
			return nil, &ErrInvalidArguments{Function: "Json", Arguments: args}
		}
		out, err := json.Marshal(args[0])
		if err != nil {
			return err, errors.Wrap(err, "error marshaling to json")
		}
		return out, nil
	},
}
View Source 
var Join = Function{
	Name:    "Join",
	Aliases: []string{"join"},
	Definitions: []Definition{
		Definition{Inputs: []interface{}{uint82DSliceType, uint8Type}, Output: reflect.String},
		Definition{Inputs: []interface{}{uint82DSliceType, uint8SliceType}, Output: reflect.String},
		Definition{Inputs: []interface{}{reflect.Array, reflect.String}, Output: reflect.String},
		Definition{Inputs: []interface{}{reflect.Slice, reflect.String}, Output: reflect.String},
		Definition{Inputs: []interface{}{reflect.String, reflect.String}, Output: reflect.String},
		Definition{Inputs: []interface{}{stringSetType, reflect.String}, Output: reflect.String},
	},
	Function: join,
}
View Source 
var Last = Function{
	Name:    "Last",
	Aliases: []string{"last"},
	Definitions: []Definition{
		Definition{Inputs: []interface{}{byteSliceType}, Output: reflect.Uint8},
		Definition{Inputs: []interface{}{uint8SliceType}, Output: reflect.Uint8},
		Definition{Inputs: []interface{}{intSliceType}, Output: reflect.Int},
		Definition{Inputs: []interface{}{int64ArrayType}, Output: reflect.Int64},
		Definition{Inputs: []interface{}{float64ArrayType}, Output: reflect.Float64},
		Definition{Inputs: []interface{}{stringSliceType}, Output: reflect.String},
		Definition{Inputs: []interface{}{stringIntMapSliceType}, Output: stringIntMapType},
		Definition{Inputs: []interface{}{interfaceArrayType}, Output: nil},
		Definition{Inputs: []interface{}{reflect.String}, Output: reflect.Uint8},
	},
	Function: last,
}
View Source 
var Length = Function{
	Name:    "Length",
	Aliases: []string{"len", "length"},
	Definitions: []Definition{
		Definition{
			Inputs: []interface{}{reflect.Array},
			Output: reflect.Int,
		},
		Definition{
			Inputs: []interface{}{reflect.Slice},
			Output: reflect.Int,
		},
		Definition{
			Inputs: []interface{}{reflect.Map},
			Output: reflect.Int,
		},
		Definition{
			Inputs: []interface{}{reflect.String},
			Output: reflect.Int,
		},
	},
	Function: length,
}
View Source 
var Like = Function{
	Name:    "Like",
	Aliases: []string{"like"},
	Definitions: []Definition{
		Definition{Inputs: []interface{}{reflect.String, reflect.String}, Output: reflect.Bool},
	},
	Function: like,
}
View Source 
var Limit = Function{
	Name:    "Limit",
	Aliases: []string{"limit"},
	Definitions: []Definition{
		Definition{
			Inputs: []interface{}{reflect.Array, reflect.Int},
			Output: reflect.Slice,
		},
		Definition{
			Inputs: []interface{}{reflect.Slice, reflect.Int},
			Output: reflect.Slice,
		},
	},
	Function: limit,
}
View Source 
var Lookup = Function{
	Name:    "Lookup",
	Aliases: []string{"lookup"},
	Definitions: []Definition{
		Definition{Inputs: []interface{}{reflect.Array, nil}, Output: nil},
		Definition{Inputs: []interface{}{reflect.Array, nil, nil}, Output: nil},
		Definition{Inputs: []interface{}{reflect.Slice, nil}, Output: nil},
		Definition{Inputs: []interface{}{reflect.Slice, nil, nil}, Output: nil},
		Definition{Inputs: []interface{}{reflect.Map, nil}, Output: nil},
		Definition{Inputs: []interface{}{reflect.Map, nil, nil}, Output: nil},
	},
	Function: lookup,
}
View Source 
var Make = Function{
	Name:    "Make",
	Aliases: []string{"make"},
	Definitions: []Definition{

		Definition{Inputs: []interface{}{reflect.String}, Output: nil},

		Definition{Inputs: []interface{}{reflect.String, reflect.String}, Output: nil},

		Definition{Inputs: []interface{}{reflect.String, reflect.String, reflect.Int}, Output: nil},

		Definition{Inputs: []interface{}{reflect.String, reflect.String, reflect.Int, reflect.Int}, Output: nil},

		Definition{Inputs: []interface{}{reflect.String, reflect.String, reflect.String}, Output: nil},

		Definition{Inputs: []interface{}{reflect.String, reflect.String, reflect.String, reflect.Int}, Output: nil},
	},
	Function: makeObject,
}
View Source 
var Max = Function{
	Name:        "Max",
	Aliases:     []string{"max"},
	Definitions: []Definition{},
	Function: func(args ...interface{}) (interface{}, error) {
		return math.Max(flat.Flat(args))
	},
}
View Source 
var Mean = Function{
	Name:        "Mean",
	Aliases:     []string{"mean"},
	Definitions: []Definition{},
	Function: func(args ...interface{}) (interface{}, error) {
		return math.Mean(flat.Flat(args))
	},
}
View Source 
var Min = Function{
	Name:        "Min",
	Aliases:     []string{"min"},
	Definitions: []Definition{},
	Function: func(args ...interface{}) (interface{}, error) {
		return math.Min(flat.Flat(args))
	},
}
View Source 
var Multiply = Function{
	Name:        "Multiply",
	Aliases:     []string{"multiply", "mul"},
	Definitions: []Definition{},
	Function: func(args ...interface{}) (interface{}, error) {
		return math.Product(flat.Flat(args))
	},
}
View Source 
var Now = Function{
	Name:    "Now",
	Aliases: []string{"now"},
	Definitions: []Definition{
		Definition{Inputs: make([]interface{}, 0), Output: timeType},
	},
	Function: func(args ...interface{}) (interface{}, error) {
		if len(args) != 0 {
			return nil, &ErrInvalidArguments{Function: "Now", Arguments: args}
		}
		return time.Now(), nil
	},
}
View Source 
var Pow = Function{
	Name:        "Pow",
	Aliases:     []string{"pow"},
	Definitions: []Definition{},
	Function: func(args ...interface{}) (interface{}, error) {
		if len(args) != 2 {
			return nil, &ErrInvalidArguments{Function: "Pow", Arguments: args}
		}
		return math.Pow(args[0], args[1])
	},
}
View Source 
var Prefix = Function{
	Name:    "Prefix",
	Aliases: []string{"prefix"},
	Definitions: []Definition{
		Definition{Inputs: []interface{}{reflect.String, reflect.String}, Output: reflect.Bool},
		Definition{Inputs: []interface{}{reflect.Array, reflect.Array}, Output: reflect.Bool},
		Definition{Inputs: []interface{}{reflect.Array, reflect.Slice}, Output: reflect.Bool},
		Definition{Inputs: []interface{}{reflect.Slice, reflect.Array}, Output: reflect.Bool},
		Definition{Inputs: []interface{}{reflect.Slice, reflect.Slice}, Output: reflect.Bool},
	},
	Function: prefix,
}
View Source 
var Repeat = Function{
	Name:    "Repeat",
	Aliases: []string{"repeat"},
	Definitions: []Definition{
		Definition{Inputs: []interface{}{reflect.Array, reflect.Int}, Output: reflect.Array},
		Definition{Inputs: []interface{}{reflect.Slice, reflect.Int}, Output: reflect.Slice},
		Definition{Inputs: []interface{}{reflect.String, reflect.Int}, Output: reflect.String},
		Definition{Inputs: []interface{}{reflect.Uint8, reflect.Int}, Output: reflect.Slice},
	},
	Function: repeat,
}
View Source 
var Replace = Function{
	Name:    "Replace",
	Aliases: []string{"replace"},
	Definitions: []Definition{
		Definition{Inputs: []interface{}{reflect.String, reflect.String, reflect.String}, Output: reflect.String},
		Definition{Inputs: []interface{}{reflect.String, reflect.String, reflect.String, reflect.Int}, Output: reflect.String},
		Definition{Inputs: []interface{}{uint8SliceType, uint8Type, uint8Type}, Output: uint8SliceType},
		Definition{Inputs: []interface{}{uint8SliceType, uint8SliceType, uint8SliceType}, Output: uint8SliceType},
		Definition{Inputs: []interface{}{uint8SliceType, uint8SliceType, uint8SliceType, reflect.Int}, Output: uint8SliceType},
	},
	Function: replace,
}
View Source 
var Second = Function{
	Name:    "Second",
	Aliases: []string{"second"},
	Definitions: []Definition{
		Definition{Inputs: []interface{}{byteSliceType}, Output: reflect.Uint8},
		Definition{Inputs: []interface{}{uint8SliceType}, Output: reflect.Uint8},
		Definition{Inputs: []interface{}{intSliceType}, Output: reflect.Int},
		Definition{Inputs: []interface{}{int64ArrayType}, Output: reflect.Int64},
		Definition{Inputs: []interface{}{float64ArrayType}, Output: reflect.Float64},
		Definition{Inputs: []interface{}{stringSliceType}, Output: reflect.String},
		Definition{Inputs: []interface{}{stringIntMapSliceType}, Output: stringIntMapType},
		Definition{Inputs: []interface{}{interfaceArrayType}, Output: nil},
		Definition{Inputs: []interface{}{reflect.String}, Output: reflect.Uint8},
	},
	Function: second,
}
View Source 
var Slice = Function{
	Name:    "Slice",
	Aliases: []string{"slice"},
	Definitions: []Definition{
		Definition{Inputs: []interface{}{reflect.Array, intType}, Output: reflect.Slice},
		Definition{Inputs: []interface{}{reflect.Array, intType, intType}, Output: reflect.Slice},
		Definition{Inputs: []interface{}{reflect.Slice, intType}, Output: reflect.Slice},
		Definition{Inputs: []interface{}{reflect.Slice, intType, intType}, Output: reflect.Slice},
		Definition{Inputs: []interface{}{reflect.String, intType}, Output: reflect.String},
		Definition{Inputs: []interface{}{reflect.String, intType, intType}, Output: reflect.String},
	},
	Function: func(args ...interface{}) (interface{}, error) {
		if len(args) == 2 {
			if start, ok := args[1].(int); ok {
				v := reflect.ValueOf(args[0])
				switch v.Type().Kind() {
				case reflect.Array, reflect.Slice, reflect.String:
					return v.Slice(start, v.Len()).Interface(), nil
				}
			}
		} else if len(args) == 3 {
			if start, ok := args[1].(int); ok {
				if end, ok := args[2].(int); ok {
					v := reflect.ValueOf(args[0])
					switch v.Type().Kind() {
					case reflect.Array, reflect.Slice, reflect.String:
						return v.Slice(start, end).Interface(), nil
					}
				}
			}
		}
		return nil, &ErrInvalidArguments{Function: "Slice", Arguments: args}
	},
}
View Source 
var Sort = Function{
	Name:    "Sort",
	Aliases: []string{"sort"},
	Definitions: []Definition{
		Definition{Inputs: []interface{}{stringSliceType}, Output: stringSliceType},
		Definition{Inputs: []interface{}{intSliceType}, Output: intSliceType},
		Definition{Inputs: []interface{}{stringSliceType, boolType}, Output: stringSliceType},
		Definition{Inputs: []interface{}{intSliceType, boolType}, Output: intSliceType},
	},
	Function: sortArray,
}
View Source 
var Split = Function{
	Name:    "Split",
	Aliases: []string{"split"},
	Definitions: []Definition{
		Definition{Inputs: []interface{}{stringType, stringType}, Output: reflect.Slice},
		Definition{Inputs: []interface{}{stringType, stringType, intType}, Output: reflect.Slice},
	},
	Function: func(args ...interface{}) (interface{}, error) {
		if str, ok := args[0].(string); ok {
			if delim, ok := args[1].(string); ok {
				if len(args) == 2 {
					return strings.Split(str, delim), nil
				} else if len(args) == 3 {
					if n, ok := args[2].(int); ok {
						return strings.SplitN(str, delim, n), nil
					}
				}
			}
		}
		return nil, &ErrInvalidArguments{Function: "Split", Arguments: args}
	},
}
View Source 
var Stringify = Function{
	Name:    "Stringify",
	Aliases: []string{"stringify"},
	Definitions: []Definition{
		Definition{Inputs: []interface{}{nil}, Output: nil},
	},
	Function: func(args ...interface{}) (interface{}, error) {
		if len(args) != 1 {
			return nil, &ErrInvalidArguments{Function: "Stringify", Arguments: args}
		}
		return stringify.StringifyMapKeys(args[0], stringify.NewDefaultStringer())
	},
}
View Source 
var Subtract = Function{
	Name:    "Subtract",
	Aliases: []string{"subtract", "sub"},
	Definitions: []Definition{
		Definition{Inputs: []interface{}{reflect.Int, reflect.Int}, Output: reflect.Int},
		Definition{Inputs: []interface{}{reflect.Int, reflect.Int32}, Output: reflect.Int},
		Definition{Inputs: []interface{}{reflect.Int, reflect.Int64}, Output: reflect.Int64},
		Definition{Inputs: []interface{}{reflect.Int, reflect.Float64}, Output: reflect.Float64},
		Definition{Inputs: []interface{}{reflect.Int64, reflect.Int}, Output: reflect.Int},
		Definition{Inputs: []interface{}{reflect.Int64, reflect.Int64}, Output: reflect.Int},
		Definition{Inputs: []interface{}{reflect.Int64, reflect.Float64}, Output: reflect.Float64},
		Definition{Inputs: []interface{}{reflect.Float64, reflect.Int}, Output: reflect.Int},
		Definition{Inputs: []interface{}{reflect.Float64, reflect.Int64}, Output: reflect.Int},
		Definition{Inputs: []interface{}{reflect.Float64, reflect.Float64}, Output: reflect.Float64},
		Definition{Inputs: []interface{}{reflect.Map, reflect.Map}, Output: reflect.Map},
	},
	Function: subtract,
}
View Source 
var Suffix = Function{
	Name:    "Suffix",
	Aliases: []string{"suffix"},
	Definitions: []Definition{
		Definition{Inputs: []interface{}{reflect.String, reflect.String}, Output: reflect.Bool},
		Definition{Inputs: []interface{}{reflect.Array, reflect.Array}, Output: reflect.Bool},
		Definition{Inputs: []interface{}{reflect.Array, reflect.Slice}, Output: reflect.Bool},
		Definition{Inputs: []interface{}{reflect.Slice, reflect.Array}, Output: reflect.Bool},
		Definition{Inputs: []interface{}{reflect.Slice, reflect.Slice}, Output: reflect.Bool},
	},
	Function: suffix,
}
View Source 
var Sum = Function{
	Name:        "Sum",
	Aliases:     []string{"sum"},
	Definitions: []Definition{},
	Function: func(args ...interface{}) (interface{}, error) {
		return math.Sum(flat.Flat(args))
	},
}
View Source 
var TileX = Function{
	Name:    "TileX",
	Aliases: []string{"tileX"},
	Definitions: []Definition{
		Definition{Inputs: []interface{}{float64Type, intType}, Output: intType},
		Definition{Inputs: []interface{}{intType, intType}, Output: intType},
	},
	Function: tileX,
}
View Source 
var TileY = Function{
	Name:    "TileY",
	Aliases: []string{"tileY"},
	Definitions: []Definition{
		Definition{Inputs: []interface{}{float64Type, intType}, Output: intType},
		Definition{Inputs: []interface{}{intType, intType}, Output: intType},
	},
	Function: tileY,
}
View Source 
var ToBigEndian = Function{
	Name:    "ToBigEndian",
	Aliases: []string{"big"},
	Definitions: []Definition{
		Definition{Inputs: []interface{}{intType}, Output: byteSliceType},
		Definition{Inputs: []interface{}{int8Type}, Output: byteSliceType},
		Definition{Inputs: []interface{}{int16Type}, Output: byteSliceType},
		Definition{Inputs: []interface{}{int32Type}, Output: byteSliceType},
		Definition{Inputs: []interface{}{int64Type}, Output: byteSliceType},
	},
	Function: toBigEndian,
}
View Source 
var ToBytes = Function{
	Name:    "ToBytes",
	Aliases: []string{"bytes"},
	Definitions: []Definition{
		Definition{Inputs: []interface{}{byteType}, Output: byteSliceType},
		Definition{Inputs: []interface{}{byteSliceType}, Output: byteSliceType},
		Definition{Inputs: []interface{}{stringType}, Output: byteSliceType},
	},
	Function: toBytes,
}
View Source 
var ToFloat32 = Function{
	Name:    "ToFloat32",
	Aliases: []string{"float32"},
	Definitions: []Definition{
		Definition{Inputs: []interface{}{intType}, Output: float32Type},
		Definition{Inputs: []interface{}{int8Type}, Output: float32Type},
		Definition{Inputs: []interface{}{int16Type}, Output: float32Type},
		Definition{Inputs: []interface{}{int32Type}, Output: float32Type},
		Definition{Inputs: []interface{}{int64Type}, Output: float32Type},
		Definition{Inputs: []interface{}{float32Type}, Output: float32Type},
		Definition{Inputs: []interface{}{float64Type}, Output: float32Type},
		Definition{Inputs: []interface{}{reflect.String}, Output: float32Type},
	},
	Function: toFloat32,
}
View Source 
var ToFloat64 = Function{
	Name:    "ToFloat64",
	Aliases: []string{"float64"},
	Definitions: []Definition{
		Definition{Inputs: []interface{}{intType}, Output: float64Type},
		Definition{Inputs: []interface{}{int8Type}, Output: float64Type},
		Definition{Inputs: []interface{}{int16Type}, Output: float64Type},
		Definition{Inputs: []interface{}{int32Type}, Output: float64Type},
		Definition{Inputs: []interface{}{int64Type}, Output: float64Type},
		Definition{Inputs: []interface{}{float64Type}, Output: float64Type},
		Definition{Inputs: []interface{}{reflect.String}, Output: float64Type},
	},
	Function: toFloat64,
}
View Source 
var ToFloat64Slice = Function{
	Name:    "Float64Slice",
	Aliases: []string{"float64Array", "float64Slice"},
	Definitions: []Definition{
		Definition{Inputs: []interface{}{reflect.Array}, Output: float64ArrayType},
		Definition{Inputs: []interface{}{reflect.Slice}, Output: float64ArrayType},
	},
	Function: float64Slice,
}
View Source 
var ToInt = Function{
	Name:    "ToInt",
	Aliases: []string{"int"},
	Definitions: []Definition{
		Definition{Inputs: []interface{}{intType}, Output: intType},
		Definition{Inputs: []interface{}{int8Type}, Output: intType},
		Definition{Inputs: []interface{}{int16Type}, Output: intType},
		Definition{Inputs: []interface{}{int32Type}, Output: intType},
		Definition{Inputs: []interface{}{int64Type}, Output: intType},
		Definition{Inputs: []interface{}{float32Type}, Output: intType},
		Definition{Inputs: []interface{}{float64Type}, Output: intType},
		Definition{Inputs: []interface{}{reflect.String}, Output: intType},
	},
	Function: toInt,
}
View Source 
var ToInt16 = Function{
	Name:    "ToInt16",
	Aliases: []string{"int16"},
	Definitions: []Definition{
		Definition{Inputs: []interface{}{intType}, Output: int16Type},
		Definition{Inputs: []interface{}{int8Type}, Output: int16Type},
		Definition{Inputs: []interface{}{int16Type}, Output: int16Type},
		Definition{Inputs: []interface{}{int32Type}, Output: int16Type},
		Definition{Inputs: []interface{}{int64Type}, Output: int16Type},
		Definition{Inputs: []interface{}{reflect.String}, Output: int16Type},
	},
	Function: toInt16,
}
View Source 
var ToInt32 = Function{
	Name:    "ToInt32",
	Aliases: []string{"int32"},
	Definitions: []Definition{
		Definition{Inputs: []interface{}{intType}, Output: int32Type},
		Definition{Inputs: []interface{}{int8Type}, Output: int32Type},
		Definition{Inputs: []interface{}{int16Type}, Output: int32Type},
		Definition{Inputs: []interface{}{int32Type}, Output: int32Type},
		Definition{Inputs: []interface{}{int64Type}, Output: int32Type},
		Definition{Inputs: []interface{}{float32Type}, Output: int32Type},
		Definition{Inputs: []interface{}{float64Type}, Output: int32Type},
		Definition{Inputs: []interface{}{reflect.String}, Output: int32Type},
	},
	Function: toInt32,
}
View Source 
var ToInt64 = Function{
	Name:    "ToInt64",
	Aliases: []string{"int64"},
	Definitions: []Definition{
		Definition{Inputs: []interface{}{intType}, Output: int64Type},
		Definition{Inputs: []interface{}{int8Type}, Output: int64Type},
		Definition{Inputs: []interface{}{int16Type}, Output: int64Type},
		Definition{Inputs: []interface{}{int32Type}, Output: int64Type},
		Definition{Inputs: []interface{}{int64Type}, Output: int64Type},
		Definition{Inputs: []interface{}{float32Type}, Output: int64Type},
		Definition{Inputs: []interface{}{float64Type}, Output: int64Type},
		Definition{Inputs: []interface{}{reflect.String}, Output: int64Type},
	},
	Function: toInt64,
}
View Source 
var ToInt8 = Function{
	Name:    "ToInt8",
	Aliases: []string{"int8"},
	Definitions: []Definition{
		Definition{Inputs: []interface{}{intType}, Output: int8Type},
		Definition{Inputs: []interface{}{int8Type}, Output: int8Type},
		Definition{Inputs: []interface{}{int16Type}, Output: int8Type},
		Definition{Inputs: []interface{}{int32Type}, Output: int8Type},
		Definition{Inputs: []interface{}{int64Type}, Output: int8Type},
		Definition{Inputs: []interface{}{reflect.String}, Output: int8Type},
	},
	Function: toInt8,
}
View Source 
var ToIntSlice = Function{
	Name:    "IntSlice",
	Aliases: []string{"intArray", "intSlice"},
	Definitions: []Definition{
		Definition{Inputs: []interface{}{reflect.Array}, Output: intSliceType},
		Definition{Inputs: []interface{}{reflect.Slice}, Output: intSliceType},
	},
	Function: intArray,
}
View Source 
var ToItems = Function{
	Name:    "ToItems",
	Aliases: []string{"items"},
	Definitions: []Definition{
		Definition{Inputs: []interface{}{reflect.Map}, Output: reflect.Slice},
	},
	Function: toItems,
}
View Source 
var ToKeys = Function{
	Name:    "ToKeys",
	Aliases: []string{"keys"},
	Definitions: []Definition{
		Definition{Inputs: []interface{}{reflect.Map}, Output: reflect.Slice},
	},
	Function: toKeys,
}
View Source 
var ToLittleEndian = Function{
	Name:    "ToLittleEndian",
	Aliases: []string{"little"},
	Definitions: []Definition{
		Definition{Inputs: []interface{}{intType}, Output: byteSliceType},
		Definition{Inputs: []interface{}{int8Type}, Output: byteSliceType},
		Definition{Inputs: []interface{}{int16Type}, Output: byteSliceType},
		Definition{Inputs: []interface{}{int32Type}, Output: byteSliceType},
		Definition{Inputs: []interface{}{int64Type}, Output: byteSliceType},
	},
	Function: toLittleEndian,
}
View Source 
var ToLower = Function{
	Name:    "ToLower",
	Aliases: []string{"lower"},
	Definitions: []Definition{
		Definition{Inputs: []interface{}{stringType}, Output: stringType},
		Definition{Inputs: []interface{}{byteSliceType}, Output: byteSliceType},
	},
	Function: toLower,
}
View Source 
var ToSet = Function{
	Name:    "ToSet",
	Aliases: []string{"set"},
	Definitions: []Definition{
		Definition{Inputs: []interface{}{reflect.Array}, Output: reflect.Map},
		Definition{Inputs: []interface{}{reflect.Slice}, Output: reflect.Map},
		Definition{Inputs: []interface{}{reflect.Map}, Output: reflect.Map},
	},
	Function: toSet,
}
View Source 
var ToString = Function{
	Name:    "ToString",
	Aliases: []string{"string", "str"},
	Definitions: []Definition{
		Definition{Inputs: []interface{}{nil}, Output: stringType},
	},
	Function: toString,
}
View Source 
var ToStringSet = Function{
	Name:    "ToStringSet",
	Aliases: []string{"stringSet"},
	Definitions: []Definition{
		Definition{Inputs: []interface{}{reflect.Array}, Output: stringSetType},
		Definition{Inputs: []interface{}{reflect.Slice}, Output: stringSetType},
		Definition{Inputs: []interface{}{reflect.Map}, Output: stringSetType},
	},
	Function: stringSet,
}
View Source 
var ToStringSlice = Function{
	Name:    "StringSlice",
	Aliases: []string{"stringArray", "stringSlice"},
	Definitions: []Definition{
		Definition{Inputs: []interface{}{reflect.Array}, Output: stringSliceType},
		Definition{Inputs: []interface{}{reflect.Slice}, Output: stringSliceType},
		Definition{Inputs: []interface{}{reflect.String}, Output: stringSliceType},
	},
	Function: stringSlice,
}
View Source 
var ToTime = Function{
	Name:    "ToTime",
	Aliases: []string{"time"},
	Definitions: []Definition{
		Definition{Inputs: []interface{}{stringType}, Output: timeType},
		Definition{Inputs: []interface{}{timeType}, Output: timeType},
	},
	Function: toTime,
}
View Source 
var ToTitle = Function{
	Name:    "ToTitle",
	Aliases: []string{"title"},
	Definitions: []Definition{
		Definition{Inputs: []interface{}{stringType}, Output: stringType},
		Definition{Inputs: []interface{}{byteSliceType}, Output: byteSliceType},
	},
	Function: toTitle,
}
View Source 
var ToUpper = Function{
	Name:    "ToUpper",
	Aliases: []string{"upper"},
	Definitions: []Definition{
		Definition{Inputs: []interface{}{stringType}, Output: stringType},
		Definition{Inputs: []interface{}{byteSliceType}, Output: byteSliceType},
	},
	Function: toUpper,
}
View Source 
var ToValues = Function{
	Name:    "ToValues",
	Aliases: []string{"values"},
	Definitions: []Definition{
		Definition{Inputs: []interface{}{reflect.Map}, Output: interfaceArrayType},
	},
	Function: toValues,
}
View Source 
var Top = Function{
	Name:    "Top",
	Aliases: []string{"top"},
	Definitions: []Definition{
		Definition{Inputs: []interface{}{stringIntMapType, intType}, Output: stringSliceType},
		Definition{Inputs: []interface{}{stringIntMapType, intType, intType}, Output: stringSliceType},
	},
	Function: top,
}
View Source 
var Trim = Function{
	Name:    "Trim",
	Aliases: []string{"trim"},
	Definitions: []Definition{
		Definition{Inputs: []interface{}{reflect.String}, Output: reflect.String},
		Definition{Inputs: []interface{}{stringSliceType}, Output: reflect.String},
		Definition{Inputs: []interface{}{interfaceArrayType}, Output: reflect.String},
	},
	Function: trim,
}
View Source 
var Within = Function{
	Name:    "Within",
	Aliases: []string{"within"},
	Definitions: []Definition{
		Definition{Inputs: []interface{}{float64ArrayType, float64ArrayType}, Output: reflect.Bool},
		Definition{Inputs: []interface{}{intSliceType, intSliceType}, Output: reflect.Bool},
	},
	Function: func(args ...interface{}) (interface{}, error) {
		if coordinate, ok := args[0].([]float64); ok {
			if extent, ok := args[1].([]float64); ok {
				dims := len(coordinate)
				if dims*2 == len(extent) {
					for i, x := range coordinate {
						if x < extent[i] || x > extent[i+dims] {
							return false, nil
						}
					}
					return true, nil
				}
			}
		} else if coordinate, ok := args[0].([]int); ok {
			if extent, ok := args[1].([]int); ok {
				dims := len(coordinate)
				if dims*2 == len(extent) {
					for i, x := range coordinate {
						if x < extent[i] || x > extent[i+dims] {
							return false, nil
						}
					}
					return true, nil
				}
			}
		}
		return nil, &ErrInvalidArguments{Function: "Within", Arguments: args}
	},
}
View Source 
var Words = Function{
	Name:    "Words",
	Aliases: []string{"words"},
	Definitions: []Definition{
		Definition{Inputs: []interface{}{uint8SliceType}, Output: reflect.Slice},
		Definition{Inputs: []interface{}{stringType}, Output: reflect.Slice},
	},
	Function: func(args ...interface{}) (interface{}, error) {
		if len(args) == 1 {
			switch in := args[0].(type) {
			case string:
				scanner := bufio.NewScanner(strings.NewReader(in))
				scanner.Split(bufio.ScanWords)
				words := make([]string, 0)
				for scanner.Scan() {
					words = append(words, scanner.Text())
				}
				if err := scanner.Err(); err != nil {
					return words, err
				}
				return words, nil
			case []byte:
				scanner := bufio.NewScanner(bytes.NewReader(in))
				scanner.Split(bufio.ScanWords)
				words := make([]string, 0)
				for scanner.Scan() {
					words = append(words, scanner.Text())
				}
				if err := scanner.Err(); err != nil {
					return words, err
				}
				return words, nil
			}
		}
		return nil, &ErrInvalidArguments{Function: "Words", Arguments: args}
	},
}

Functions

This section is empty.

Types

type Definition 

type Definition struct {
	Inputs []interface{} // an array of types or kinds
	Output interface{}   // the type or kind returned by the defined function
}

Definition is a struct containing a function definition

func (Definition) IsValid 

func (d Definition) IsValid(args ...interface{}) bool

IsValid returns true if the args match the kinds or types or the definition.

type ErrInvalidArguments 

type ErrInvalidArguments struct {
	Function  string        // the name of the Function
	Arguments []interface{} // the arguments for the function
}

ErrInvalidArguments is an error returned when a function is called with invalid arguments.

func (ErrInvalidArguments) Error 

func (e ErrInvalidArguments) Error() string

Error returns the error as a string.

type ErrInvalidCapacity 

type ErrInvalidCapacity struct {
	Value  int
	Length int
}

ErrInvalidCapacity is an error returned when the capacity for a slice is too low since it must always be greater than or equal to the length.

func (ErrInvalidCapacity) Error 

func (e ErrInvalidCapacity) Error() string

Error returns the error as a string.

type ErrOutOfRange 

type ErrOutOfRange struct {
	Index int
	Max   int
}

ErrOutOfRange is an error returned when an array or slice index is out of range.

func (ErrOutOfRange) Error 

func (e ErrOutOfRange) Error() string

Error returns the error as a string.

type ErrOverflow 

type ErrOverflow struct {
	Original interface{}  // the original value
	Target   reflect.Type // the target type
}

ErrOverflow is an error returned a number can't be converted to a lower bitsize.

func (ErrOverflow) Error 

func (e ErrOverflow) Error() string

Error returns the error as a string.

type Function 

type Function struct {
	Name        string                                         // the name of the function
	Description string                                         // a description of the function
	Aliases     []string                                       // aliases for the function used when providing a public API
	Definitions []Definition                                   // the definitions of the function
	Function    func(args ...interface{}) (interface{}, error) // the underlying function to execute
}

Function is a struct used for giving an underlying function a name and definitions.

func (Function) IsValid 

func (f Function) IsValid(args ...interface{}) bool

IsValid returns true if the arguments match a definition of the function.

func (Function) Map 

func (f Function) Map() map[string]interface{}

Map returns a map of metadata about the function.

func (Function) MustRun 

func (f Function) MustRun(args ...interface{}) interface{}

MustRun executes the function with the provided arguments and returns the result. If there is any error, then panics.

func (Function) Run 

func (f Function) Run(args ...interface{}) (interface{}, error)

Run executes the function with the provided arguments and returns the result, and error if any. It accepts variadic input.

func (Function) Validate 

func (f Function) Validate(args ...interface{}) error

Validate returns a ErrInvalidArguments error if the arguments do not match a definition of the function.

func (Function) ValidateRun 

func (f Function) ValidateRun(args ...interface{}) (interface{}, error)

ValidateRun validates the function arguments and then runs the function if valid. It accepts variadic input.

type TestCase 

type TestCase struct {
	Inputs   []interface{} // the inputs to the function
	Function Function      // the function to evaluate
	Output   interface{}   // the result of the evaluation
}

TestCase is a struct containing the variables for a unit test of function evaluation

func NewTestCase 

func NewTestCase(inputs []interface{}, function Function, output interface{}) TestCase

NewTestCase returns a new TestCase

Source Files

View all

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.