Remove "assert" library

The runtime spends a lot of time during the assertion.

The internal "assert" library impacts perfomance.

Version is inlined into bytecode.

Author: regeda

README.md

@@ -170,5 +170,5 @@ equals("foo,bar,baz", join(",", ["foo", "bar", "baz"]))
 ```
 cpu: Intel(R) Core(TM) i5-8259U CPU @ 2.30GHz
 BenchmarkExec
-BenchmarkExec-8          1318488               887.4 ns/op             0 B/op          0 allocs/op
+BenchmarkExec-8          1432002               833.2 ns/op             0 B/op          0 allocs/op
 ```

assert/assert.go

@@ -33,7 +33,7 @@ union Op {
   OpRet
 }
 
-table Version {
+struct Version {
   minor:ubyte;
   major:ubyte;
 }

bytecode/Program.go

@@ -30,15 +30,12 @@ func (c *Compiler) reset() {
 }
 
 func (c *Compiler) writeVersion(major, minor byte) flatbuffers.UOffsetT {
-	bytecode.VersionStart(c.b)
-	bytecode.VersionAddMajor(c.b, major)
-	bytecode.VersionAddMinor(c.b, minor)
-	return bytecode.VersionEnd(c.b)
+	return bytecode.CreateVersion(c.b, minor, major)
 }
 
-func (c *Compiler) writeProgram(version, frames flatbuffers.UOffsetT) flatbuffers.UOffsetT {
+func (c *Compiler) writeProgram(frames flatbuffers.UOffsetT) flatbuffers.UOffsetT {
 	bytecode.ProgramStart(c.b)
-	bytecode.ProgramAddVer(c.b, version)
+	bytecode.ProgramAddVer(c.b, c.writeVersion(MajorVersion, MinorVersion))
 	bytecode.ProgramAddFrames(c.b, frames)
 	return bytecode.ProgramEnd(c.b)
 }
@@ -151,7 +148,6 @@ func (c *Compiler) Compile(node *ast.Node) []byte {
 	c.reset()
 
 	c.b.Finish(c.writeProgram(
-		c.writeVersion(MajorVersion, MinorVersion),
 		c.writeFrames(node),
 	))
 

bytecode/Version.go

@@ -1,7 +1,6 @@
 package delegate
 
 import (
-	"github.com/regeda/expr/assert"
 	"github.com/regeda/expr/memory"
 )
 
@@ -14,12 +13,3 @@ type DelegatorFunc func(*memory.Memory, []memory.Addr) (memory.Addr, error)
 func (f DelegatorFunc) Delegate(mem *memory.Memory, argv []memory.Addr) (memory.Addr, error) {
 	return f(mem, argv)
 }
-
-func (f DelegatorFunc) Assert(a assert.Asserter) DelegatorFunc {
-	return func(mem *memory.Memory, argv []memory.Addr) (memory.Addr, error) {
-		if err := a.Assert(argv); err != nil {
-			return memory.Nil, err
-		}
-		return f(mem, argv)
-	}
-}

bytecode/proto.fbs

@@ -1,64 +1,26 @@
 package stdlib
 
 import (
-	"github.com/regeda/expr/assert"
+	"errors"
+
 	"github.com/regeda/expr/delegate"
 	"github.com/regeda/expr/memory"
 )
 
 var Compare = delegate.Module{
-	"equals": delegate.DelegatorFunc(equals).
-		Assert(assert.Every(
-			assert.Len(2),
-			assert.Any(
-				assert.TypeInt64,
-				assert.TypeBytes,
-				assert.Every(
-					assert.TypeVector,
-					assert.VectorAt(0, assert.Any(
-						assert.TypeInt64,
-						assert.TypeBytes,
-					)),
-					assert.VectorAt(1, assert.Any(
-						assert.TypeInt64,
-						assert.TypeBytes,
-					)),
-				),
-			),
-		)),
-	"contains": delegate.DelegatorFunc(contains).
-		Assert(assert.Every(
-			assert.Len(2),
-			assert.TypeAt(0, memory.TypeVector),
-			assert.Any(
-				assert.Every(
-					assert.VectorAt(0, assert.TypeInt64),
-					assert.TypeAt(1, memory.TypeInt64),
-				),
-				assert.Every(
-					assert.VectorAt(0, assert.TypeBytes),
-					assert.TypeAt(1, memory.TypeBytes),
-				),
-			),
-		)),
-	"intersects": delegate.DelegatorFunc(intersects).
-		Assert(assert.Every(
-			assert.Len(2),
-			assert.TypeVector,
-			assert.Any(
-				assert.Every(
-					assert.VectorAt(0, assert.Type(memory.TypeInt64)),
-					assert.VectorAt(1, assert.Type(memory.TypeInt64)),
-				),
-				assert.Every(
-					assert.VectorAt(0, assert.Type(memory.TypeBytes)),
-					assert.VectorAt(1, assert.Type(memory.TypeBytes)),
-				),
-			),
-		)),
+	"equals":     delegate.DelegatorFunc(equals),
+	"contains":   delegate.DelegatorFunc(contains),
+	"intersects": delegate.DelegatorFunc(intersects),
 }
 
+var (
+	errEqualsExpectedTwoArgs = errors.New("equals: expected 2 args")
+)
+
 func equals(mem *memory.Memory, argv []memory.Addr) (memory.Addr, error) {
+	if len(argv) != 2 {
+		return memory.Nil, errEqualsExpectedTwoArgs
+	}
 	if !argv[0].EqualType(argv[1]) {
 		return memory.False, nil
 	}
@@ -79,7 +41,22 @@ func equals(mem *memory.Memory, argv []memory.Addr) (memory.Addr, error) {
 	return memory.False, nil
 }
 
+var (
+	errContainsExpectedTwoArgs   = errors.New("contains: expected 2 args")
+	errContainsExpectedArrayAt0  = errors.New("contains: expected array at 0")
+	errContainsExpectedScalarAt1 = errors.New("contains: expected scalar at 1")
+)
+
 func contains(mem *memory.Memory, argv []memory.Addr) (memory.Addr, error) {
+	if len(argv) != 2 {
+		return memory.Nil, errContainsExpectedTwoArgs
+	}
+	if !argv[0].TypeOf(memory.TypeVector) {
+		return memory.Nil, errContainsExpectedArrayAt0
+	}
+	if argv[1].TypeOf(memory.TypeVector) {
+		return memory.Nil, errContainsExpectedScalarAt1
+	}
 	for _, p := range argv[0].Vector() {
 		if p.EqualBytes(argv[1]) {
 			return memory.True, nil
@@ -88,7 +65,18 @@ func contains(mem *memory.Memory, argv []memory.Addr) (memory.Addr, error) {
 	return memory.False, nil
 }
 
+var (
+	errIntersectsExpectedTwoArgs = errors.New("intersects: expected 2 args")
+	errIntersectsExpectedArrays  = errors.New("intersects: expected arrays")
+)
+
 func intersects(mem *memory.Memory, argv []memory.Addr) (memory.Addr, error) {
+	if len(argv) != 2 {
+		return memory.Nil, errIntersectsExpectedTwoArgs
+	}
+	if !argv[0].EqualType(argv[1]) || !argv[0].TypeOf(memory.TypeVector) {
+		return memory.Nil, errIntersectsExpectedArrays
+	}
 	for _, a := range argv[0].Vector() {
 		for _, b := range argv[1].Vector() {
 			if a.EqualBytes(b) {