From 596f54f26256d389a380968bef0d6ba67b0e004f Mon Sep 17 00:00:00 2001 From: Ganesan Karuppasamy Date: Tue, 21 May 2024 14:40:48 +0530 Subject: [PATCH 001/113] Invoke the Deref function as needed for the function arguments. (#651) --- checker/checker.go | 2 +- compiler/compiler.go | 48 +++++++++++++++++++++++----- test/deref/deref_test.go | 67 ++++++++++++++++++++++++++++++++++++++++ 3 files changed, 109 insertions(+), 8 deletions(-) diff --git a/checker/checker.go b/checker/checker.go index a2c86c208..c71a98f07 100644 --- a/checker/checker.go +++ b/checker/checker.go @@ -1044,7 +1044,7 @@ func (v *checker) checkArguments( continue } - if !t.AssignableTo(in) && kind(t) != reflect.Interface { + if !(t.AssignableTo(in) || deref.Type(t).AssignableTo(in)) && kind(t) != reflect.Interface { return anyType, &file.Error{ Location: arg.Location(), Message: fmt.Sprintf("cannot use %v as argument (type %v) to call %v ", t, in, name), diff --git a/compiler/compiler.go b/compiler/compiler.go index 457088d3f..205d60234 100644 --- a/compiler/compiler.go +++ b/compiler/compiler.go @@ -592,8 +592,8 @@ func (c *compiler) BinaryNode(node *ast.BinaryNode) { } func (c *compiler) equalBinaryNode(node *ast.BinaryNode) { - l := kind(node.Left) - r := kind(node.Right) + l := kind(node.Left.Type()) + r := kind(node.Right.Type()) leftIsSimple := isSimpleType(node.Left) rightIsSimple := isSimpleType(node.Right) @@ -727,9 +727,44 @@ func (c *compiler) SliceNode(node *ast.SliceNode) { } func (c *compiler) CallNode(node *ast.CallNode) { - for _, arg := range node.Arguments { - c.compile(arg) + fn := node.Callee.Type() + if kind(fn) == reflect.Func { + fnInOffset := 0 + fnNumIn := fn.NumIn() + switch callee := node.Callee.(type) { + case *ast.MemberNode: + if prop, ok := callee.Property.(*ast.StringNode); ok { + if _, ok = callee.Node.Type().MethodByName(prop.Value); ok && callee.Node.Type().Kind() != reflect.Interface { + fnInOffset = 1 + fnNumIn-- + } + } + case *ast.IdentifierNode: + if t, ok := c.config.Types[callee.Value]; ok && t.Method { + fnInOffset = 1 + fnNumIn-- + } + } + for i, arg := range node.Arguments { + c.compile(arg) + if k := kind(arg.Type()); k == reflect.Ptr || k == reflect.Interface { + var in reflect.Type + if fn.IsVariadic() && i >= fnNumIn-1 { + in = fn.In(fn.NumIn() - 1).Elem() + } else { + in = fn.In(i + fnInOffset) + } + if k = kind(in); k != reflect.Ptr && k != reflect.Interface { + c.emit(OpDeref) + } + } + } + } else { + for _, arg := range node.Arguments { + c.compile(arg) + } } + if ident, ok := node.Callee.(*ast.IdentifierNode); ok { if c.config != nil { if fn, ok := c.config.Functions[ident.Value]; ok { @@ -1162,7 +1197,7 @@ func (c *compiler) PairNode(node *ast.PairNode) { } func (c *compiler) derefInNeeded(node ast.Node) { - switch kind(node) { + switch kind(node.Type()) { case reflect.Ptr, reflect.Interface: c.emit(OpDeref) } @@ -1181,8 +1216,7 @@ func (c *compiler) optimize() { } } -func kind(node ast.Node) reflect.Kind { - t := node.Type() +func kind(t reflect.Type) reflect.Kind { if t == nil { return reflect.Invalid } diff --git a/test/deref/deref_test.go b/test/deref/deref_test.go index 0b228ca16..4bfb76168 100644 --- a/test/deref/deref_test.go +++ b/test/deref/deref_test.go @@ -3,6 +3,7 @@ package deref_test import ( "context" "testing" + "time" "github.com/expr-lang/expr/internal/testify/assert" "github.com/expr-lang/expr/internal/testify/require" @@ -253,3 +254,69 @@ func TestDeref_fetch_from_interface_mix_pointer(t *testing.T) { assert.NoError(t, err) assert.Equal(t, "waldo", res) } + +func TestDeref_func_args(t *testing.T) { + i := 20 + env := map[string]any{ + "var": &i, + "fn": func(p int) int { + return p + 1 + }, + } + + program, err := expr.Compile(`fn(var) + fn(var + 0)`, expr.Env(env)) + require.NoError(t, err) + + out, err := expr.Run(program, env) + require.NoError(t, err) + require.Equal(t, 42, out) +} + +func TestDeref_struct_func_args(t *testing.T) { + n, _ := time.Parse(time.RFC3339, "2024-05-12T18:30:00+00:00") + duration := 30 * time.Minute + env := map[string]any{ + "time": n, + "duration": &duration, + } + + program, err := expr.Compile(`time.Add(duration).Format('2006-01-02T15:04:05Z07:00')`, expr.Env(env)) + require.NoError(t, err) + + out, err := expr.Run(program, env) + require.NoError(t, err) + require.Equal(t, "2024-05-12T19:00:00Z", out) +} + +func TestDeref_ignore_func_args(t *testing.T) { + f := foo(1) + env := map[string]any{ + "foo": &f, + "fn": func(f *foo) int { + return f.Bar() + }, + } + + program, err := expr.Compile(`fn(foo)`, expr.Env(env)) + require.NoError(t, err) + + out, err := expr.Run(program, env) + require.NoError(t, err) + require.Equal(t, 42, out) +} + +func TestDeref_ignore_struct_func_args(t *testing.T) { + n := time.Now() + location, _ := time.LoadLocation("UTC") + env := map[string]any{ + "time": n, + "location": location, + } + + program, err := expr.Compile(`time.In(location).Location().String()`, expr.Env(env)) + require.NoError(t, err) + + out, err := expr.Run(program, env) + require.NoError(t, err) + require.Equal(t, "UTC", out) +} From b45ee4ff8901ec41aa12b3e6eb9f06d91a95ce6d Mon Sep 17 00:00:00 2001 From: Ernest Micklei Date: Fri, 24 May 2024 10:12:54 +0200 Subject: [PATCH 002/113] =?UTF-8?q?Add=20Melr=C5=8Dse=20to=20"Who=20uses?= =?UTF-8?q?=20Expr=3F"=20section?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Co-authored-by: Anton Medvedev --- README.md | 1 + 1 file changed, 1 insertion(+) diff --git a/README.md b/README.md index 5a587162c..6c56c67b6 100644 --- a/README.md +++ b/README.md @@ -164,6 +164,7 @@ func main() { * [keda.sh](https://keda.sh) uses Expr to allow customization of its Kubernetes-based event-driven autoscaling. * [Span Digital](https://spandigital.com/) uses Expr in it's Knowledge Management products. * [Xiaohongshu](https://www.xiaohongshu.com/) combining yaml with Expr for dynamically policies delivery. +* [Melrōse](https://melrōse.org) uses Expr to implement its music programming language. [Add your company too](https://github.com/expr-lang/expr/edit/master/README.md) From eca9bd7adefbe01fc0e8b7af25b4a971ba666b76 Mon Sep 17 00:00:00 2001 From: Anton Medvedev Date: Mon, 27 May 2024 12:05:19 +0200 Subject: [PATCH 003/113] Fix function calls with int64 params (#663) Fixes #661 --- compiler/compiler.go | 1 - compiler/compiler_test.go | 22 +++++++++++++++++++++ test/mock/mock.go | 40 +++++++++++++++++++++++++++++++++++++++ 3 files changed, 62 insertions(+), 1 deletion(-) diff --git a/compiler/compiler.go b/compiler/compiler.go index 205d60234..720f6a265 100644 --- a/compiler/compiler.go +++ b/compiler/compiler.go @@ -345,7 +345,6 @@ func (c *compiler) IntegerNode(node *ast.IntegerNode) { } c.emitPush(int32(node.Value)) case reflect.Int64: - panic(fmt.Sprintf("constant %d overflows int64", node.Value)) c.emitPush(int64(node.Value)) case reflect.Uint: if node.Value < 0 { diff --git a/compiler/compiler_test.go b/compiler/compiler_test.go index eb7f3d323..ba5d6dc54 100644 --- a/compiler/compiler_test.go +++ b/compiler/compiler_test.go @@ -628,3 +628,25 @@ func TestCompile_optimizes_jumps(t *testing.T) { }) } } + +func TestCompile_IntegerArgsFunc(t *testing.T) { + env := mock.Env{} + tests := []struct{ code string }{ + {"FuncInt(0)"}, + {"FuncInt8(0)"}, + {"FuncInt16(0)"}, + {"FuncInt32(0)"}, + {"FuncInt64(0)"}, + {"FuncUint(0)"}, + {"FuncUint8(0)"}, + {"FuncUint16(0)"}, + {"FuncUint32(0)"}, + {"FuncUint64(0)"}, + } + for _, tt := range tests { + t.Run(tt.code, func(t *testing.T) { + _, err := expr.Compile(tt.code, expr.Env(env)) + require.NoError(t, err) + }) + } +} diff --git a/test/mock/mock.go b/test/mock/mock.go index 5c0fa9e3f..fc91652fb 100644 --- a/test/mock/mock.go +++ b/test/mock/mock.go @@ -65,6 +65,46 @@ func (p Env) FuncTyped(_ string) int { return 2023 } +func (p Env) FuncInt(_ int) int { + return 0 +} + +func (p Env) FuncUint(_ uint) int { + return 0 +} + +func (p Env) FuncInt8(_ float64) int { + return 0 +} + +func (p Env) FuncInt16(_ int16) int { + return 0 +} + +func (p Env) FuncInt32(_ int32) int { + return 0 +} + +func (p Env) FuncInt64(_ int64) int { + return 0 +} + +func (p Env) FuncUint8(_ uint8) int { + return 0 +} + +func (p Env) FuncUint16(_ uint16) int { + return 0 +} + +func (p Env) FuncUint32(_ uint32) int { + return 0 +} + +func (p Env) FuncUint64(_ uint64) int { + return 0 +} + func (p Env) TimeEqualString(a time.Time, s string) bool { return a.Format("2006-01-02") == s } From 55ff9aad94a176a11f9f9f333e7ed9f59ec5e37f Mon Sep 17 00:00:00 2001 From: Anton Medvedev Date: Mon, 27 May 2024 12:25:09 +0200 Subject: [PATCH 004/113] Fix coverage reporting --- .github/scripts/coverage.mjs | 9 +++++++-- .github/workflows/check.yml | 6 +++--- 2 files changed, 10 insertions(+), 5 deletions(-) diff --git a/.github/scripts/coverage.mjs b/.github/scripts/coverage.mjs index 330d8d873..c00242894 100755 --- a/.github/scripts/coverage.mjs +++ b/.github/scripts/coverage.mjs @@ -1,4 +1,4 @@ -#!/usr/bin/env zx --experimental +#!/usr/bin/env zx const expected = 90 const exclude = [ @@ -6,6 +6,9 @@ const exclude = [ 'checker/mock', 'vm/func_types', 'vm/runtime/helpers', + 'internal/difflib', + 'internal/spew', + 'internal/testify', ] cd(path.resolve(__dirname, '..', '..')) @@ -24,9 +27,11 @@ await spinner('Running tests', async () => { await $`go tool cover -html=coverage.out -o coverage.html` }) -const cover = await $`go tool cover -func=coverage.out` +const cover = await $({verbose: true})`go tool cover -func=coverage.out` const total = +cover.stdout.match(/total:\s+\(statements\)\s+(\d+\.\d+)%/)[1] if (total < expected) { echo(chalk.red(`Coverage is too low: ${total}% < ${expected}% (expected)`)) process.exit(1) +} else { + echo(`Coverage is good: ${chalk.green(total + '%')} >= ${expected}% (expected)`) } diff --git a/.github/workflows/check.yml b/.github/workflows/check.yml index 63037cd61..674e07c7a 100644 --- a/.github/workflows/check.yml +++ b/.github/workflows/check.yml @@ -11,9 +11,9 @@ jobs: runs-on: ubuntu-latest steps: - uses: actions/checkout@v3 - - name: Setup Go 1.18 + - name: Setup Go 1.12 uses: actions/setup-go@v4 with: - go-version: 1.18 + go-version: 1.12 - name: Test - run: npx zx --experimental .github/scripts/coverage.mjs + run: npx zx .github/scripts/coverage.mjs From a601192193a639ddc7789c0ad6fb4e929e23f8fd Mon Sep 17 00:00:00 2001 From: Anton Medvedev Date: Mon, 27 May 2024 12:28:18 +0200 Subject: [PATCH 005/113] Fix check.yml --- .github/workflows/check.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.github/workflows/check.yml b/.github/workflows/check.yml index 674e07c7a..fb4b102ec 100644 --- a/.github/workflows/check.yml +++ b/.github/workflows/check.yml @@ -11,9 +11,9 @@ jobs: runs-on: ubuntu-latest steps: - uses: actions/checkout@v3 - - name: Setup Go 1.12 + - name: Setup Go 1.18 uses: actions/setup-go@v4 with: - go-version: 1.12 + go-version: 1.18 - name: Test run: npx zx .github/scripts/coverage.mjs From 7e6e6f576031e19c1b41a4258afdb7610a9c021f Mon Sep 17 00:00:00 2001 From: Anton Medvedev Date: Thu, 30 May 2024 21:45:13 +0200 Subject: [PATCH 006/113] Improve compilation for detached tree parts --- compiler/compiler.go | 8 +++++++- 1 file changed, 7 insertions(+), 1 deletion(-) diff --git a/compiler/compiler.go b/compiler/compiler.go index 720f6a265..29a6d4cdc 100644 --- a/compiler/compiler.go +++ b/compiler/compiler.go @@ -403,6 +403,10 @@ func (c *compiler) StringNode(node *ast.StringNode) { } func (c *compiler) ConstantNode(node *ast.ConstantNode) { + if node.Value == nil { + c.emit(OpNil) + return + } c.emitPush(node.Value) } @@ -695,7 +699,9 @@ func (c *compiler) MemberNode(node *ast.MemberNode) { } c.compile(base) - if node.Optional { + // If the field is optional, we need to jump over the fetch operation. + // If no ChainNode (none c.chains) is used, do not compile the optional fetch. + if node.Optional && len(c.chains) > 0 { ph := c.emit(OpJumpIfNil, placeholder) c.chains[len(c.chains)-1] = append(c.chains[len(c.chains)-1], ph) } From 73cb42d2d97f1efd524aae7263e2835024634c45 Mon Sep 17 00:00:00 2001 From: Anton Medvedev Date: Sat, 1 Jun 2024 00:09:22 +0200 Subject: [PATCH 007/113] Refactor checker to use Nature (#665) This PR introduces a new concept inside Expr's type checker - Nature. It's an abstraction other reflect.Type which carries additional information about possible type, methods and builtin function. I was able to find and fix a few bugs in type checker and optimizer. Implementation of nature concept has proven itself. As well nature will allow to bring more feature for type checker in future. Why Nature? I was looking for a name to replace Type. Type name already carries much information, as well can be confused with reflect.Type. Nature name should be understood as "nature of the node", same as "type of the node". --- ast/node.go | 38 +- builtin/builtin_test.go | 2 +- checker/checker.go | 779 ++++++++++++++-------------- checker/checker_test.go | 474 ++++++++++------- checker/info.go | 11 +- checker/nature/nature.go | 142 +++++ checker/nature/types.go | 13 + checker/types.go | 234 ++++----- compiler/compiler.go | 11 +- compiler/compiler_test.go | 73 +-- expr_test.go | 8 - optimizer/const_expr.go | 8 +- optimizer/filter_first.go | 4 +- optimizer/filter_last.go | 4 +- optimizer/filter_len.go | 2 +- optimizer/filter_map.go | 2 +- optimizer/fold.go | 88 ++-- optimizer/fold_test.go | 82 +++ optimizer/in_array.go | 12 +- optimizer/in_range.go | 2 +- optimizer/optimizer.go | 36 ++ optimizer/optimizer_test.go | 41 -- optimizer/predicate_combination.go | 2 +- optimizer/sum_array.go | 2 +- optimizer/sum_map.go | 2 +- test/fuzz/fuzz_corpus.txt | 11 - test/fuzz/fuzz_expr_seed_corpus.zip | Bin 2827397 -> 2827225 bytes testdata/examples.txt | 36 -- 28 files changed, 1218 insertions(+), 901 deletions(-) create mode 100644 checker/nature/nature.go create mode 100644 checker/nature/types.go create mode 100644 optimizer/fold_test.go diff --git a/ast/node.go b/ast/node.go index 03e8cf622..191ab1886 100644 --- a/ast/node.go +++ b/ast/node.go @@ -3,13 +3,21 @@ package ast import ( "reflect" + "github.com/expr-lang/expr/checker/nature" "github.com/expr-lang/expr/file" ) +var ( + anyType = reflect.TypeOf(new(any)).Elem() +) + // Node represents items of abstract syntax tree. type Node interface { Location() file.Location SetLocation(file.Location) + Nature() nature.Nature + SetNature(nature.Nature) + Kind() reflect.Kind Type() reflect.Type SetType(reflect.Type) String() string @@ -25,8 +33,8 @@ func Patch(node *Node, newNode Node) { // base is a base struct for all nodes. type base struct { - loc file.Location - nodeType reflect.Type + loc file.Location + nature nature.Nature } // Location returns the location of the node in the source code. @@ -39,14 +47,36 @@ func (n *base) SetLocation(loc file.Location) { n.loc = loc } +// Nature returns the nature of the node. +func (n *base) Nature() nature.Nature { + return n.nature +} + +// SetNature sets the nature of the node. +func (n *base) SetNature(nature nature.Nature) { + n.nature = nature +} + +// Kind returns the kind of the node. +// If the type is nil (meaning unknown) then it returns reflect.Interface. +func (n *base) Kind() reflect.Kind { + if n.nature.Type == nil { + return reflect.Interface + } + return n.nature.Type.Kind() +} + // Type returns the type of the node. func (n *base) Type() reflect.Type { - return n.nodeType + if n.nature.Type == nil { + return anyType + } + return n.nature.Type } // SetType sets the type of the node. func (n *base) SetType(t reflect.Type) { - n.nodeType = t + n.nature.Type = t } // NilNode represents nil. diff --git a/builtin/builtin_test.go b/builtin/builtin_test.go index b99ed42ce..97f249896 100644 --- a/builtin/builtin_test.go +++ b/builtin/builtin_test.go @@ -235,7 +235,7 @@ func TestBuiltin_errors(t *testing.T) { {`bitushr(-5, -2)`, "invalid operation: negative shift count -2 (type int) (1:1)"}, {`now(nil)`, "invalid number of arguments (expected 0, got 1)"}, {`date(nil)`, "interface {} is nil, not string (1:1)"}, - {`timezone(nil)`, "interface {} is nil, not string (1:1)"}, + {`timezone(nil)`, "cannot use nil as argument (type string) to call timezone (1:10)"}, } for _, test := range errorTests { t.Run(test.input, func(t *testing.T) { diff --git a/checker/checker.go b/checker/checker.go index c71a98f07..fae8f5a16 100644 --- a/checker/checker.go +++ b/checker/checker.go @@ -7,9 +7,9 @@ import ( "github.com/expr-lang/expr/ast" "github.com/expr-lang/expr/builtin" + . "github.com/expr-lang/expr/checker/nature" "github.com/expr-lang/expr/conf" "github.com/expr-lang/expr/file" - "github.com/expr-lang/expr/internal/deref" "github.com/expr-lang/expr/parser" ) @@ -52,14 +52,20 @@ func ParseCheck(input string, config *conf.Config) (*parser.Tree, error) { // Check checks types of the expression tree. It returns type of the expression // and error if any. If config is nil, then default configuration will be used. -func Check(tree *parser.Tree, config *conf.Config) (t reflect.Type, err error) { +func Check(tree *parser.Tree, config *conf.Config) (reflect.Type, error) { if config == nil { config = conf.New(nil) } v := &checker{config: config} - t, _ = v.visit(tree.Node) + nt := v.visit(tree.Node) + + // To keep compatibility with previous versions, we should return any, if nature is unknown. + t := nt.Type + if t == nil { + t = anyType + } if v.err != nil { return t, v.err.Bind(tree.Source) @@ -67,23 +73,20 @@ func Check(tree *parser.Tree, config *conf.Config) (t reflect.Type, err error) { if v.config.Expect != reflect.Invalid { if v.config.ExpectAny { - if isAny(t) { + if isUnknown(nt) { return t, nil } } switch v.config.Expect { case reflect.Int, reflect.Int64, reflect.Float64: - if !isNumber(t) { - return nil, fmt.Errorf("expected %v, but got %v", v.config.Expect, t) + if !isNumber(nt) { + return nil, fmt.Errorf("expected %v, but got %v", v.config.Expect, nt) } default: - if t != nil { - if t.Kind() == v.config.Expect { - return t, nil - } + if nt.Kind() != v.config.Expect { + return nil, fmt.Errorf("expected %v, but got %s", v.config.Expect, nt) } - return nil, fmt.Errorf("expected %v, but got %v", v.config.Expect, t) } } @@ -98,14 +101,13 @@ type checker struct { } type predicateScope struct { - vtype reflect.Type - vars map[string]reflect.Type + collection Nature + vars map[string]Nature } type varScope struct { - name string - vtype reflect.Type - info info + name string + nature Nature } type info struct { @@ -119,285 +121,278 @@ type info struct { elem reflect.Type } -func (v *checker) visit(node ast.Node) (reflect.Type, info) { - var t reflect.Type - var i info +func (v *checker) visit(node ast.Node) Nature { + var nt Nature switch n := node.(type) { case *ast.NilNode: - t, i = v.NilNode(n) + nt = v.NilNode(n) case *ast.IdentifierNode: - t, i = v.IdentifierNode(n) + nt = v.IdentifierNode(n) case *ast.IntegerNode: - t, i = v.IntegerNode(n) + nt = v.IntegerNode(n) case *ast.FloatNode: - t, i = v.FloatNode(n) + nt = v.FloatNode(n) case *ast.BoolNode: - t, i = v.BoolNode(n) + nt = v.BoolNode(n) case *ast.StringNode: - t, i = v.StringNode(n) + nt = v.StringNode(n) case *ast.ConstantNode: - t, i = v.ConstantNode(n) + nt = v.ConstantNode(n) case *ast.UnaryNode: - t, i = v.UnaryNode(n) + nt = v.UnaryNode(n) case *ast.BinaryNode: - t, i = v.BinaryNode(n) + nt = v.BinaryNode(n) case *ast.ChainNode: - t, i = v.ChainNode(n) + nt = v.ChainNode(n) case *ast.MemberNode: - t, i = v.MemberNode(n) + nt = v.MemberNode(n) case *ast.SliceNode: - t, i = v.SliceNode(n) + nt = v.SliceNode(n) case *ast.CallNode: - t, i = v.CallNode(n) + nt = v.CallNode(n) case *ast.BuiltinNode: - t, i = v.BuiltinNode(n) + nt = v.BuiltinNode(n) case *ast.ClosureNode: - t, i = v.ClosureNode(n) + nt = v.ClosureNode(n) case *ast.PointerNode: - t, i = v.PointerNode(n) + nt = v.PointerNode(n) case *ast.VariableDeclaratorNode: - t, i = v.VariableDeclaratorNode(n) + nt = v.VariableDeclaratorNode(n) case *ast.ConditionalNode: - t, i = v.ConditionalNode(n) + nt = v.ConditionalNode(n) case *ast.ArrayNode: - t, i = v.ArrayNode(n) + nt = v.ArrayNode(n) case *ast.MapNode: - t, i = v.MapNode(n) + nt = v.MapNode(n) case *ast.PairNode: - t, i = v.PairNode(n) + nt = v.PairNode(n) default: panic(fmt.Sprintf("undefined node type (%T)", node)) } - node.SetType(t) - return t, i + node.SetNature(nt) + return nt } -func (v *checker) error(node ast.Node, format string, args ...any) (reflect.Type, info) { +func (v *checker) error(node ast.Node, format string, args ...any) Nature { if v.err == nil { // show first error v.err = &file.Error{ Location: node.Location(), Message: fmt.Sprintf(format, args...), } } - return anyType, info{} // interface represent undefined type + return unknown } -func (v *checker) NilNode(*ast.NilNode) (reflect.Type, info) { - return nilType, info{} +func (v *checker) NilNode(*ast.NilNode) Nature { + return nilNature } -func (v *checker) IdentifierNode(node *ast.IdentifierNode) (reflect.Type, info) { - if s, ok := v.lookupVariable(node.Value); ok { - return s.vtype, s.info +func (v *checker) IdentifierNode(node *ast.IdentifierNode) Nature { + if variable, ok := v.lookupVariable(node.Value); ok { + return variable.nature } if node.Value == "$env" { - return mapType, info{} + return unknown } return v.ident(node, node.Value, true, true) } // ident method returns type of environment variable, builtin or function. -func (v *checker) ident(node ast.Node, name string, strict, builtins bool) (reflect.Type, info) { +func (v *checker) ident(node ast.Node, name string, strict, builtins bool) Nature { if t, ok := v.config.Types[name]; ok { if t.Ambiguous { return v.error(node, "ambiguous identifier %v", name) } - return t.Type, info{method: t.Method} + if t.Type == nil { + return nilNature + } + return Nature{Type: t.Type, Method: t.Method} } if builtins { if fn, ok := v.config.Functions[name]; ok { - return fn.Type(), info{fn: fn} + return Nature{Type: fn.Type(), Func: fn} } if fn, ok := v.config.Builtins[name]; ok { - return fn.Type(), info{fn: fn} + return Nature{Type: fn.Type(), Func: fn} } } if v.config.Strict && strict { return v.error(node, "unknown name %v", name) } if v.config.DefaultType != nil { - return v.config.DefaultType, info{} + return Nature{Type: v.config.DefaultType} } - return anyType, info{} + return unknown } -func (v *checker) IntegerNode(*ast.IntegerNode) (reflect.Type, info) { - return integerType, info{} +func (v *checker) IntegerNode(*ast.IntegerNode) Nature { + return integerNature } -func (v *checker) FloatNode(*ast.FloatNode) (reflect.Type, info) { - return floatType, info{} +func (v *checker) FloatNode(*ast.FloatNode) Nature { + return floatNature } -func (v *checker) BoolNode(*ast.BoolNode) (reflect.Type, info) { - return boolType, info{} +func (v *checker) BoolNode(*ast.BoolNode) Nature { + return boolNature } -func (v *checker) StringNode(*ast.StringNode) (reflect.Type, info) { - return stringType, info{} +func (v *checker) StringNode(*ast.StringNode) Nature { + return stringNature } -func (v *checker) ConstantNode(node *ast.ConstantNode) (reflect.Type, info) { - return reflect.TypeOf(node.Value), info{} +func (v *checker) ConstantNode(node *ast.ConstantNode) Nature { + return Nature{Type: reflect.TypeOf(node.Value)} } -func (v *checker) UnaryNode(node *ast.UnaryNode) (reflect.Type, info) { - t, _ := v.visit(node.Node) - t = deref.Type(t) +func (v *checker) UnaryNode(node *ast.UnaryNode) Nature { + nt := v.visit(node.Node) + nt = nt.Deref() switch node.Operator { case "!", "not": - if isBool(t) { - return boolType, info{} + if isBool(nt) { + return boolNature } - if isAny(t) { - return boolType, info{} + if isUnknown(nt) { + return boolNature } case "+", "-": - if isNumber(t) { - return t, info{} + if isNumber(nt) { + return nt } - if isAny(t) { - return anyType, info{} + if isUnknown(nt) { + return unknown } default: return v.error(node, "unknown operator (%v)", node.Operator) } - return v.error(node, `invalid operation: %v (mismatched type %v)`, node.Operator, t) + return v.error(node, `invalid operation: %v (mismatched type %s)`, node.Operator, nt) } -func (v *checker) BinaryNode(node *ast.BinaryNode) (reflect.Type, info) { - l, _ := v.visit(node.Left) - r, ri := v.visit(node.Right) +func (v *checker) BinaryNode(node *ast.BinaryNode) Nature { + l := v.visit(node.Left) + r := v.visit(node.Right) - l = deref.Type(l) - r = deref.Type(r) + l = l.Deref() + r = r.Deref() switch node.Operator { case "==", "!=": if isComparable(l, r) { - return boolType, info{} + return boolNature } case "or", "||", "and", "&&": if isBool(l) && isBool(r) { - return boolType, info{} + return boolNature } if or(l, r, isBool) { - return boolType, info{} + return boolNature } case "<", ">", ">=", "<=": if isNumber(l) && isNumber(r) { - return boolType, info{} + return boolNature } if isString(l) && isString(r) { - return boolType, info{} + return boolNature } if isTime(l) && isTime(r) { - return boolType, info{} + return boolNature } if or(l, r, isNumber, isString, isTime) { - return boolType, info{} + return boolNature } case "-": if isNumber(l) && isNumber(r) { - return combined(l, r), info{} + return combined(l, r) } if isTime(l) && isTime(r) { - return durationType, info{} + return durationNature } if isTime(l) && isDuration(r) { - return timeType, info{} + return timeNature } - if or(l, r, isNumber, isTime) { - return anyType, info{} + if or(l, r, isNumber, isTime, isDuration) { + return unknown } case "*": if isNumber(l) && isNumber(r) { - return combined(l, r), info{} + return combined(l, r) } if or(l, r, isNumber) { - return anyType, info{} + return unknown } case "/": if isNumber(l) && isNumber(r) { - return floatType, info{} + return floatNature } if or(l, r, isNumber) { - return floatType, info{} + return floatNature } case "**", "^": if isNumber(l) && isNumber(r) { - return floatType, info{} + return floatNature } if or(l, r, isNumber) { - return floatType, info{} + return floatNature } case "%": if isInteger(l) && isInteger(r) { - return combined(l, r), info{} + return integerNature } if or(l, r, isInteger) { - return anyType, info{} + return integerNature } case "+": if isNumber(l) && isNumber(r) { - return combined(l, r), info{} + return combined(l, r) } if isString(l) && isString(r) { - return stringType, info{} + return stringNature } if isTime(l) && isDuration(r) { - return timeType, info{} + return timeNature } if isDuration(l) && isTime(r) { - return timeType, info{} + return timeNature } if or(l, r, isNumber, isString, isTime, isDuration) { - return anyType, info{} + return unknown } case "in": - if (isString(l) || isAny(l)) && isStruct(r) { - return boolType, info{} + if (isString(l) || isUnknown(l)) && isStruct(r) { + return boolNature } if isMap(r) { - if l == nil { // It is possible to compare with nil. - return boolType, info{} - } - if !isAny(l) && !l.AssignableTo(r.Key()) { + if !isUnknown(l) && !l.AssignableTo(r.Key()) { return v.error(node, "cannot use %v as type %v in map key", l, r.Key()) } - return boolType, info{} + return boolNature } if isArray(r) { - if l == nil { // It is possible to compare with nil. - return boolType, info{} - } if !isComparable(l, r.Elem()) { return v.error(node, "cannot use %v as type %v in array", l, r.Elem()) } - if !isComparable(l, ri.elem) { - return v.error(node, "cannot use %v as type %v in array", l, ri.elem) - } - return boolType, info{} + return boolNature } - if isAny(l) && anyOf(r, isString, isArray, isMap) { - return boolType, info{} + if isUnknown(l) && anyOf(r, isString, isArray, isMap) { + return boolNature } - if isAny(r) { - return boolType, info{} + if isUnknown(r) { + return boolNature } case "matches": @@ -408,43 +403,48 @@ func (v *checker) BinaryNode(node *ast.BinaryNode) (reflect.Type, info) { } } if isString(l) && isString(r) { - return boolType, info{} + return boolNature } if or(l, r, isString) { - return boolType, info{} + return boolNature } case "contains", "startsWith", "endsWith": if isString(l) && isString(r) { - return boolType, info{} + return boolNature } if or(l, r, isString) { - return boolType, info{} + return boolNature } case "..": - ret := reflect.SliceOf(integerType) if isInteger(l) && isInteger(r) { - return ret, info{} + return Nature{ + Type: arrayType, + SubType: Array{Of: integerNature}, + } } if or(l, r, isInteger) { - return ret, info{} + return Nature{ + Type: arrayType, + SubType: Array{Of: integerNature}, + } } case "??": - if l == nil && r != nil { - return r, info{} + if isNil(l) && !isNil(r) { + return r } - if l != nil && r == nil { - return l, info{} + if !isNil(l) && isNil(r) { + return l } - if l == nil && r == nil { - return nilType, info{} + if isNil(l) && isNil(r) { + return nilNature } if r.AssignableTo(l) { - return l, info{} + return l } - return anyType, info{} + return unknown default: return v.error(node, "unknown operator (%v)", node.Operator) @@ -454,11 +454,11 @@ func (v *checker) BinaryNode(node *ast.BinaryNode) (reflect.Type, info) { return v.error(node, `invalid operation: %v (mismatched types %v and %v)`, node.Operator, l, r) } -func (v *checker) ChainNode(node *ast.ChainNode) (reflect.Type, info) { +func (v *checker) ChainNode(node *ast.ChainNode) Nature { return v.visit(node.Node) } -func (v *checker) MemberNode(node *ast.MemberNode) (reflect.Type, info) { +func (v *checker) MemberNode(node *ast.MemberNode) Nature { // $env variable if an, ok := node.Node.(*ast.IdentifierNode); ok && an.Value == "$env" { if name, ok := node.Property.(*ast.StringNode); ok { @@ -472,59 +472,48 @@ func (v *checker) MemberNode(node *ast.MemberNode) (reflect.Type, info) { } return v.ident(node, name.Value, strict, false /* no builtins and no functions */) } - return anyType, info{} + return unknown } - base, _ := v.visit(node.Node) - prop, _ := v.visit(node.Property) + base := v.visit(node.Node) + prop := v.visit(node.Property) + + if isUnknown(base) { + return unknown + } if name, ok := node.Property.(*ast.StringNode); ok { - if base == nil { - return v.error(node, "type %v has no field %v", base, name.Value) + if isNil(base) { + return v.error(node, "type nil has no field %v", name.Value) } + // First, check methods defined on base type itself, // independent of which type it is. Without dereferencing. if m, ok := base.MethodByName(name.Value); ok { - if kind(base) == reflect.Interface { - // In case of interface type method will not have a receiver, - // and to prevent checker decreasing numbers of in arguments - // return method type as not method (second argument is false). - - // Also, we can not use m.Index here, because it will be - // different indexes for different types which implement - // the same interface. - return m.Type, info{} - } else { - return m.Type, info{method: true} - } + return m } } - if kind(base) == reflect.Ptr { - base = base.Elem() - } - - switch kind(base) { - case reflect.Interface: - return anyType, info{} + base = base.Deref() + switch base.Kind() { case reflect.Map: - if prop != nil && !prop.AssignableTo(base.Key()) && !isAny(prop) { + if !prop.AssignableTo(base.Key()) && !isUnknown(prop) { return v.error(node.Property, "cannot use %v to get an element from %v", prop, base) } - return base.Elem(), info{} + return base.Elem() case reflect.Array, reflect.Slice: - if !isInteger(prop) && !isAny(prop) { + if !isInteger(prop) && !isUnknown(prop) { return v.error(node.Property, "array elements can only be selected using an integer (got %v)", prop) } - return base.Elem(), info{} + return base.Elem() case reflect.Struct: if name, ok := node.Property.(*ast.StringNode); ok { propertyName := name.Value if field, ok := fetchField(base, propertyName); ok { - return field.Type, info{} + return Nature{Type: field.Type} } if node.Method { return v.error(node, "type %v has no method %v", base, propertyName) @@ -536,35 +525,39 @@ func (v *checker) MemberNode(node *ast.MemberNode) (reflect.Type, info) { return v.error(node, "type %v[%v] is undefined", base, prop) } -func (v *checker) SliceNode(node *ast.SliceNode) (reflect.Type, info) { - t, _ := v.visit(node.Node) +func (v *checker) SliceNode(node *ast.SliceNode) Nature { + nt := v.visit(node.Node) - switch kind(t) { - case reflect.Interface: - // ok + if isUnknown(nt) { + return unknown + } + + switch nt.Kind() { case reflect.String, reflect.Array, reflect.Slice: // ok default: - return v.error(node, "cannot slice %v", t) + return v.error(node, "cannot slice %s", nt) } if node.From != nil { - from, _ := v.visit(node.From) - if !isInteger(from) && !isAny(from) { + from := v.visit(node.From) + if !isInteger(from) && !isUnknown(from) { return v.error(node.From, "non-integer slice index %v", from) } } + if node.To != nil { - to, _ := v.visit(node.To) - if !isInteger(to) && !isAny(to) { + to := v.visit(node.To) + if !isInteger(to) && !isUnknown(to) { return v.error(node.To, "non-integer slice index %v", to) } } - return t, info{} + + return nt } -func (v *checker) CallNode(node *ast.CallNode) (reflect.Type, info) { - t, i := v.functionReturnType(node) +func (v *checker) CallNode(node *ast.CallNode) Nature { + nt := v.functionReturnType(node) // Check if type was set on node (for example, by patcher) // and use node type instead of function return type. @@ -578,17 +571,17 @@ func (v *checker) CallNode(node *ast.CallNode) (reflect.Type, info) { // checker pass we should replace anyType on method node // with new correct function return type. if node.Type() != nil && node.Type() != anyType { - return node.Type(), i + return node.Nature() } - return t, i + return nt } -func (v *checker) functionReturnType(node *ast.CallNode) (reflect.Type, info) { - fn, fnInfo := v.visit(node.Callee) +func (v *checker) functionReturnType(node *ast.CallNode) Nature { + nt := v.visit(node.Callee) - if fnInfo.fn != nil { - return v.checkFunction(fnInfo.fn, node, node.Arguments) + if nt.Func != nil { + return v.checkFunction(nt.Func, node, node.Arguments) } fnName := "function" @@ -601,240 +594,248 @@ func (v *checker) functionReturnType(node *ast.CallNode) (reflect.Type, info) { } } - if fn == nil { + if isUnknown(nt) { + return unknown + } + + if isNil(nt) { return v.error(node, "%v is nil; cannot call nil as function", fnName) } - switch fn.Kind() { - case reflect.Interface: - return anyType, info{} + switch nt.Kind() { case reflect.Func: - outType, err := v.checkArguments(fnName, fn, fnInfo.method, node.Arguments, node) + outType, err := v.checkArguments(fnName, nt, node.Arguments, node) if err != nil { if v.err == nil { v.err = err } - return anyType, info{} + return unknown } - return outType, info{} + return outType } - return v.error(node, "%v is not callable", fn) + return v.error(node, "%s is not callable", nt) } -func (v *checker) BuiltinNode(node *ast.BuiltinNode) (reflect.Type, info) { +func (v *checker) BuiltinNode(node *ast.BuiltinNode) Nature { switch node.Name { case "all", "none", "any", "one": - collection, _ := v.visit(node.Arguments[0]) - if !isArray(collection) && !isAny(collection) { + collection := v.visit(node.Arguments[0]) + if !isArray(collection) && !isUnknown(collection) { return v.error(node.Arguments[0], "builtin %v takes only array (got %v)", node.Name, collection) } v.begin(collection) - closure, _ := v.visit(node.Arguments[1]) + closure := v.visit(node.Arguments[1]) v.end() if isFunc(closure) && closure.NumOut() == 1 && - closure.NumIn() == 1 && isAny(closure.In(0)) { + closure.NumIn() == 1 && isUnknown(closure.In(0)) { - if !isBool(closure.Out(0)) && !isAny(closure.Out(0)) { + if !isBool(closure.Out(0)) && !isUnknown(closure.Out(0)) { return v.error(node.Arguments[1], "predicate should return boolean (got %v)", closure.Out(0).String()) } - return boolType, info{} + return boolNature } return v.error(node.Arguments[1], "predicate should has one input and one output param") case "filter": - collection, _ := v.visit(node.Arguments[0]) - if !isArray(collection) && !isAny(collection) { + collection := v.visit(node.Arguments[0]) + if !isArray(collection) && !isUnknown(collection) { return v.error(node.Arguments[0], "builtin %v takes only array (got %v)", node.Name, collection) } v.begin(collection) - closure, _ := v.visit(node.Arguments[1]) + closure := v.visit(node.Arguments[1]) v.end() if isFunc(closure) && closure.NumOut() == 1 && - closure.NumIn() == 1 && isAny(closure.In(0)) { + closure.NumIn() == 1 && isUnknown(closure.In(0)) { - if !isBool(closure.Out(0)) && !isAny(closure.Out(0)) { + if !isBool(closure.Out(0)) && !isUnknown(closure.Out(0)) { return v.error(node.Arguments[1], "predicate should return boolean (got %v)", closure.Out(0).String()) } - if isAny(collection) { - return arrayType, info{} + if isUnknown(collection) { + return arrayNature + } + return Nature{ + Type: arrayType, + SubType: Array{Of: collection.Elem()}, } - return arrayType, info{} } return v.error(node.Arguments[1], "predicate should has one input and one output param") case "map": - collection, _ := v.visit(node.Arguments[0]) - if !isArray(collection) && !isAny(collection) { + collection := v.visit(node.Arguments[0]) + if !isArray(collection) && !isUnknown(collection) { return v.error(node.Arguments[0], "builtin %v takes only array (got %v)", node.Name, collection) } - v.begin(collection, scopeVar{"index", integerType}) - closure, _ := v.visit(node.Arguments[1]) + v.begin(collection, scopeVar{"index", integerNature}) + closure := v.visit(node.Arguments[1]) v.end() if isFunc(closure) && closure.NumOut() == 1 && - closure.NumIn() == 1 && isAny(closure.In(0)) { + closure.NumIn() == 1 && isUnknown(closure.In(0)) { - return arrayType, info{} + return Nature{ + Type: arrayType, + SubType: Array{Of: closure.Out(0)}, + } } return v.error(node.Arguments[1], "predicate should has one input and one output param") case "count": - collection, _ := v.visit(node.Arguments[0]) - if !isArray(collection) && !isAny(collection) { + collection := v.visit(node.Arguments[0]) + if !isArray(collection) && !isUnknown(collection) { return v.error(node.Arguments[0], "builtin %v takes only array (got %v)", node.Name, collection) } if len(node.Arguments) == 1 { - return integerType, info{} + return integerNature } v.begin(collection) - closure, _ := v.visit(node.Arguments[1]) + closure := v.visit(node.Arguments[1]) v.end() if isFunc(closure) && closure.NumOut() == 1 && - closure.NumIn() == 1 && isAny(closure.In(0)) { - if !isBool(closure.Out(0)) && !isAny(closure.Out(0)) { + closure.NumIn() == 1 && isUnknown(closure.In(0)) { + if !isBool(closure.Out(0)) && !isUnknown(closure.Out(0)) { return v.error(node.Arguments[1], "predicate should return boolean (got %v)", closure.Out(0).String()) } - return integerType, info{} + return integerNature } return v.error(node.Arguments[1], "predicate should has one input and one output param") case "sum": - collection, _ := v.visit(node.Arguments[0]) - if !isArray(collection) && !isAny(collection) { + collection := v.visit(node.Arguments[0]) + if !isArray(collection) && !isUnknown(collection) { return v.error(node.Arguments[0], "builtin %v takes only array (got %v)", node.Name, collection) } if len(node.Arguments) == 2 { v.begin(collection) - closure, _ := v.visit(node.Arguments[1]) + closure := v.visit(node.Arguments[1]) v.end() if isFunc(closure) && closure.NumOut() == 1 && - closure.NumIn() == 1 && isAny(closure.In(0)) { - return closure.Out(0), info{} + closure.NumIn() == 1 && isUnknown(closure.In(0)) { + return closure.Out(0) } } else { - if isAny(collection) { - return anyType, info{} + if isUnknown(collection) { + return unknown } - return collection.Elem(), info{} + return collection.Elem() } case "find", "findLast": - collection, _ := v.visit(node.Arguments[0]) - if !isArray(collection) && !isAny(collection) { + collection := v.visit(node.Arguments[0]) + if !isArray(collection) && !isUnknown(collection) { return v.error(node.Arguments[0], "builtin %v takes only array (got %v)", node.Name, collection) } v.begin(collection) - closure, _ := v.visit(node.Arguments[1]) + closure := v.visit(node.Arguments[1]) v.end() if isFunc(closure) && closure.NumOut() == 1 && - closure.NumIn() == 1 && isAny(closure.In(0)) { + closure.NumIn() == 1 && isUnknown(closure.In(0)) { - if !isBool(closure.Out(0)) && !isAny(closure.Out(0)) { + if !isBool(closure.Out(0)) && !isUnknown(closure.Out(0)) { return v.error(node.Arguments[1], "predicate should return boolean (got %v)", closure.Out(0).String()) } - if isAny(collection) { - return anyType, info{} + if isUnknown(collection) { + return unknown } - return collection.Elem(), info{} + return collection.Elem() } return v.error(node.Arguments[1], "predicate should has one input and one output param") case "findIndex", "findLastIndex": - collection, _ := v.visit(node.Arguments[0]) - if !isArray(collection) && !isAny(collection) { + collection := v.visit(node.Arguments[0]) + if !isArray(collection) && !isUnknown(collection) { return v.error(node.Arguments[0], "builtin %v takes only array (got %v)", node.Name, collection) } v.begin(collection) - closure, _ := v.visit(node.Arguments[1]) + closure := v.visit(node.Arguments[1]) v.end() if isFunc(closure) && closure.NumOut() == 1 && - closure.NumIn() == 1 && isAny(closure.In(0)) { + closure.NumIn() == 1 && isUnknown(closure.In(0)) { - if !isBool(closure.Out(0)) && !isAny(closure.Out(0)) { + if !isBool(closure.Out(0)) && !isUnknown(closure.Out(0)) { return v.error(node.Arguments[1], "predicate should return boolean (got %v)", closure.Out(0).String()) } - return integerType, info{} + return integerNature } return v.error(node.Arguments[1], "predicate should has one input and one output param") case "groupBy": - collection, _ := v.visit(node.Arguments[0]) - if !isArray(collection) && !isAny(collection) { + collection := v.visit(node.Arguments[0]) + if !isArray(collection) && !isUnknown(collection) { return v.error(node.Arguments[0], "builtin %v takes only array (got %v)", node.Name, collection) } v.begin(collection) - closure, _ := v.visit(node.Arguments[1]) + closure := v.visit(node.Arguments[1]) v.end() if isFunc(closure) && closure.NumOut() == 1 && - closure.NumIn() == 1 && isAny(closure.In(0)) { + closure.NumIn() == 1 && isUnknown(closure.In(0)) { - return reflect.TypeOf(map[any][]any{}), info{} + return Nature{Type: reflect.TypeOf(map[any][]any{})} } return v.error(node.Arguments[1], "predicate should has one input and one output param") case "sortBy": - collection, _ := v.visit(node.Arguments[0]) - if !isArray(collection) && !isAny(collection) { + collection := v.visit(node.Arguments[0]) + if !isArray(collection) && !isUnknown(collection) { return v.error(node.Arguments[0], "builtin %v takes only array (got %v)", node.Name, collection) } v.begin(collection) - closure, _ := v.visit(node.Arguments[1]) + closure := v.visit(node.Arguments[1]) v.end() if len(node.Arguments) == 3 { - _, _ = v.visit(node.Arguments[2]) + _ = v.visit(node.Arguments[2]) } if isFunc(closure) && closure.NumOut() == 1 && - closure.NumIn() == 1 && isAny(closure.In(0)) { + closure.NumIn() == 1 && isUnknown(closure.In(0)) { - return reflect.TypeOf([]any{}), info{} + return Nature{Type: reflect.TypeOf([]any{})} } return v.error(node.Arguments[1], "predicate should has one input and one output param") case "reduce": - collection, _ := v.visit(node.Arguments[0]) - if !isArray(collection) && !isAny(collection) { + collection := v.visit(node.Arguments[0]) + if !isArray(collection) && !isUnknown(collection) { return v.error(node.Arguments[0], "builtin %v takes only array (got %v)", node.Name, collection) } - v.begin(collection, scopeVar{"index", integerType}, scopeVar{"acc", anyType}) - closure, _ := v.visit(node.Arguments[1]) + v.begin(collection, scopeVar{"index", integerNature}, scopeVar{"acc", unknown}) + closure := v.visit(node.Arguments[1]) v.end() if len(node.Arguments) == 3 { - _, _ = v.visit(node.Arguments[2]) + _ = v.visit(node.Arguments[2]) } if isFunc(closure) && closure.NumOut() == 1 { - return closure.Out(0), info{} + return closure.Out(0) } return v.error(node.Arguments[1], "predicate should has two input and one output param") @@ -852,14 +853,14 @@ func (v *checker) BuiltinNode(node *ast.BuiltinNode) (reflect.Type, info) { } type scopeVar struct { - name string - vtype reflect.Type + varName string + varNature Nature } -func (v *checker) begin(vtype reflect.Type, vars ...scopeVar) { - scope := predicateScope{vtype: vtype, vars: make(map[string]reflect.Type)} +func (v *checker) begin(collectionNature Nature, vars ...scopeVar) { + scope := predicateScope{collection: collectionNature, vars: make(map[string]Nature)} for _, v := range vars { - scope.vars[v.name] = v.vtype + scope.vars[v.varName] = v.varNature } v.predicateScopes = append(v.predicateScopes, scope) } @@ -868,83 +869,81 @@ func (v *checker) end() { v.predicateScopes = v.predicateScopes[:len(v.predicateScopes)-1] } -func (v *checker) checkBuiltinGet(node *ast.BuiltinNode) (reflect.Type, info) { +func (v *checker) checkBuiltinGet(node *ast.BuiltinNode) Nature { if len(node.Arguments) != 2 { return v.error(node, "invalid number of arguments (expected 2, got %d)", len(node.Arguments)) } - val := node.Arguments[0] - prop := node.Arguments[1] - if id, ok := val.(*ast.IdentifierNode); ok && id.Value == "$env" { - if s, ok := prop.(*ast.StringNode); ok { - return v.config.Types[s.Value].Type, info{} + base := v.visit(node.Arguments[0]) + prop := v.visit(node.Arguments[1]) + + if id, ok := node.Arguments[0].(*ast.IdentifierNode); ok && id.Value == "$env" { + if s, ok := node.Arguments[1].(*ast.StringNode); ok { + return Nature{Type: v.config.Types[s.Value].Type} } - return anyType, info{} + return unknown } - t, _ := v.visit(val) + if isUnknown(base) { + return unknown + } - switch kind(t) { - case reflect.Interface: - return anyType, info{} + switch base.Kind() { case reflect.Slice, reflect.Array: - p, _ := v.visit(prop) - if p == nil { - return v.error(prop, "cannot use nil as slice index") + if !isInteger(prop) && !isUnknown(prop) { + return v.error(node.Arguments[1], "non-integer slice index %s", prop) } - if !isInteger(p) && !isAny(p) { - return v.error(prop, "non-integer slice index %v", p) - } - return t.Elem(), info{} + return base.Elem() case reflect.Map: - p, _ := v.visit(prop) - if p == nil { - return v.error(prop, "cannot use nil as map index") - } - if !p.AssignableTo(t.Key()) && !isAny(p) { - return v.error(prop, "cannot use %v to get an element from %v", p, t) + if !prop.AssignableTo(base.Key()) && !isUnknown(prop) { + return v.error(node.Arguments[1], "cannot use %s to get an element from %s", prop, base) } - return t.Elem(), info{} + return base.Elem() } - return v.error(val, "type %v does not support indexing", t) + return v.error(node.Arguments[0], "type %v does not support indexing", base) } -func (v *checker) checkFunction(f *builtin.Function, node ast.Node, arguments []ast.Node) (reflect.Type, info) { +func (v *checker) checkFunction(f *builtin.Function, node ast.Node, arguments []ast.Node) Nature { if f.Validate != nil { args := make([]reflect.Type, len(arguments)) for i, arg := range arguments { - args[i], _ = v.visit(arg) + argNature := v.visit(arg) + if isUnknown(argNature) { + args[i] = anyType + } else { + args[i] = argNature.Type + } } t, err := f.Validate(args) if err != nil { return v.error(node, "%v", err) } - return t, info{} + return Nature{Type: t} } else if len(f.Types) == 0 { - t, err := v.checkArguments(f.Name, f.Type(), false, arguments, node) + nt, err := v.checkArguments(f.Name, Nature{Type: f.Type()}, arguments, node) if err != nil { if v.err == nil { v.err = err } - return anyType, info{} + return unknown } // No type was specified, so we assume the function returns any. - return t, info{} + return nt } var lastErr *file.Error for _, t := range f.Types { - outType, err := v.checkArguments(f.Name, t, false, arguments, node) + outNature, err := v.checkArguments(f.Name, Nature{Type: t}, arguments, node) if err != nil { lastErr = err continue } - return outType, info{} + return outNature } if lastErr != nil { if v.err == nil { v.err = lastErr } - return anyType, info{} + return unknown } return v.error(node, "no matching overload for %v", f.Name) @@ -952,23 +951,22 @@ func (v *checker) checkFunction(f *builtin.Function, node ast.Node, arguments [] func (v *checker) checkArguments( name string, - fn reflect.Type, - method bool, + fn Nature, arguments []ast.Node, node ast.Node, -) (reflect.Type, *file.Error) { - if isAny(fn) { - return anyType, nil +) (Nature, *file.Error) { + if isUnknown(fn) { + return unknown, nil } if fn.NumOut() == 0 { - return anyType, &file.Error{ + return unknown, &file.Error{ Location: node.Location(), Message: fmt.Sprintf("func %v doesn't return value", name), } } if numOut := fn.NumOut(); numOut > 2 { - return anyType, &file.Error{ + return unknown, &file.Error{ Location: node.Location(), Message: fmt.Sprintf("func %v returns more then two values", name), } @@ -977,12 +975,12 @@ func (v *checker) checkArguments( // If func is method on an env, first argument should be a receiver, // and actual arguments less than fnNumIn by one. fnNumIn := fn.NumIn() - if method { + if fn.Method { // TODO: Move subtraction to the Nature.NumIn() and Nature.In() methods. fnNumIn-- } // Skip first argument in case of the receiver. fnInOffset := 0 - if method { + if fn.Method { fnInOffset = 1 } @@ -1013,15 +1011,15 @@ func (v *checker) checkArguments( // If we have an error, we should still visit all arguments to // type check them, as a patch can fix the error later. for _, arg := range arguments { - _, _ = v.visit(arg) + _ = v.visit(arg) } return fn.Out(0), err } for i, arg := range arguments { - t, _ := v.visit(arg) + argNature := v.visit(arg) - var in reflect.Type + var in Nature if fn.IsVariadic() && i >= fnNumIn-1 { // For variadic arguments fn(xs ...int), go replaces type of xs (int) with ([]int). // As we compare arguments one by one, we need underling type. @@ -1030,24 +1028,40 @@ func (v *checker) checkArguments( in = fn.In(i + fnInOffset) } - if isFloat(in) && isInteger(t) { + if isFloat(in) && isInteger(argNature) { traverseAndReplaceIntegerNodesWithFloatNodes(&arguments[i], in) continue } - if isInteger(in) && isInteger(t) && kind(t) != kind(in) { + if isInteger(in) && isInteger(argNature) && argNature.Kind() != in.Kind() { traverseAndReplaceIntegerNodesWithIntegerNodes(&arguments[i], in) continue } - if t == nil { - continue + if isNil(argNature) { + if in.Kind() == reflect.Ptr || in.Kind() == reflect.Interface { + continue + } + return unknown, &file.Error{ + Location: arg.Location(), + Message: fmt.Sprintf("cannot use nil as argument (type %s) to call %v", in, name), + } } - if !(t.AssignableTo(in) || deref.Type(t).AssignableTo(in)) && kind(t) != reflect.Interface { - return anyType, &file.Error{ + // Check if argument is assignable to the function input type. + // We check original type (like *time.Time), not dereferenced type, + // as function input type can be pointer to a struct. + assignable := argNature.AssignableTo(in) + + // We also need to check if dereference arg type is assignable to the function input type. + // For example, func(int) and argument *int. In this case we will add OpDeref to the argument, + // so we can call the function with *int argument. + assignable = assignable || argNature.Deref().AssignableTo(in) + + if !assignable && !isUnknown(argNature) { + return unknown, &file.Error{ Location: arg.Location(), - Message: fmt.Sprintf("cannot use %v as argument (type %v) to call %v ", t, in, name), + Message: fmt.Sprintf("cannot use %s as argument (type %s) to call %v ", argNature, in, name), } } } @@ -1055,74 +1069,82 @@ func (v *checker) checkArguments( return fn.Out(0), nil } -func traverseAndReplaceIntegerNodesWithFloatNodes(node *ast.Node, newType reflect.Type) { +func traverseAndReplaceIntegerNodesWithFloatNodes(node *ast.Node, newNature Nature) { switch (*node).(type) { case *ast.IntegerNode: *node = &ast.FloatNode{Value: float64((*node).(*ast.IntegerNode).Value)} - (*node).SetType(newType) + (*node).SetType(newNature.Type) case *ast.UnaryNode: unaryNode := (*node).(*ast.UnaryNode) - traverseAndReplaceIntegerNodesWithFloatNodes(&unaryNode.Node, newType) + traverseAndReplaceIntegerNodesWithFloatNodes(&unaryNode.Node, newNature) case *ast.BinaryNode: binaryNode := (*node).(*ast.BinaryNode) switch binaryNode.Operator { case "+", "-", "*": - traverseAndReplaceIntegerNodesWithFloatNodes(&binaryNode.Left, newType) - traverseAndReplaceIntegerNodesWithFloatNodes(&binaryNode.Right, newType) + traverseAndReplaceIntegerNodesWithFloatNodes(&binaryNode.Left, newNature) + traverseAndReplaceIntegerNodesWithFloatNodes(&binaryNode.Right, newNature) } } } -func traverseAndReplaceIntegerNodesWithIntegerNodes(node *ast.Node, newType reflect.Type) { +func traverseAndReplaceIntegerNodesWithIntegerNodes(node *ast.Node, newNature Nature) { switch (*node).(type) { case *ast.IntegerNode: - (*node).SetType(newType) + (*node).SetType(newNature.Type) case *ast.UnaryNode: - (*node).SetType(newType) + (*node).SetType(newNature.Type) unaryNode := (*node).(*ast.UnaryNode) - traverseAndReplaceIntegerNodesWithIntegerNodes(&unaryNode.Node, newType) + traverseAndReplaceIntegerNodesWithIntegerNodes(&unaryNode.Node, newNature) case *ast.BinaryNode: // TODO: Binary node return type is dependent on the type of the operands. We can't just change the type of the node. binaryNode := (*node).(*ast.BinaryNode) switch binaryNode.Operator { case "+", "-", "*": - traverseAndReplaceIntegerNodesWithIntegerNodes(&binaryNode.Left, newType) - traverseAndReplaceIntegerNodesWithIntegerNodes(&binaryNode.Right, newType) + traverseAndReplaceIntegerNodesWithIntegerNodes(&binaryNode.Left, newNature) + traverseAndReplaceIntegerNodesWithIntegerNodes(&binaryNode.Right, newNature) } } } -func (v *checker) ClosureNode(node *ast.ClosureNode) (reflect.Type, info) { - t, _ := v.visit(node.Node) - if t == nil { - return v.error(node.Node, "closure cannot be nil") +func (v *checker) ClosureNode(node *ast.ClosureNode) Nature { + nt := v.visit(node.Node) + var out reflect.Type + if isUnknown(nt) { + out = anyType + } else { + out = nt.Type } - return reflect.FuncOf([]reflect.Type{anyType}, []reflect.Type{t}, false), info{} + return Nature{Type: reflect.FuncOf( + []reflect.Type{anyType}, + []reflect.Type{out}, + false, + )} } -func (v *checker) PointerNode(node *ast.PointerNode) (reflect.Type, info) { +func (v *checker) PointerNode(node *ast.PointerNode) Nature { if len(v.predicateScopes) == 0 { return v.error(node, "cannot use pointer accessor outside closure") } scope := v.predicateScopes[len(v.predicateScopes)-1] if node.Name == "" { - switch scope.vtype.Kind() { - case reflect.Interface: - return anyType, info{} + if isUnknown(scope.collection) { + return unknown + } + switch scope.collection.Kind() { case reflect.Array, reflect.Slice: - return scope.vtype.Elem(), info{} + return scope.collection.Elem() } return v.error(node, "cannot use %v as array", scope) } if scope.vars != nil { if t, ok := scope.vars[node.Name]; ok { - return t, info{} + return t } } return v.error(node, "unknown pointer #%v", node.Name) } -func (v *checker) VariableDeclaratorNode(node *ast.VariableDeclaratorNode) (reflect.Type, info) { +func (v *checker) VariableDeclaratorNode(node *ast.VariableDeclaratorNode) Nature { if _, ok := v.config.Types[node.Name]; ok { return v.error(node, "cannot redeclare %v", node.Name) } @@ -1135,11 +1157,11 @@ func (v *checker) VariableDeclaratorNode(node *ast.VariableDeclaratorNode) (refl if _, ok := v.lookupVariable(node.Name); ok { return v.error(node, "cannot redeclare variable %v", node.Name) } - vtype, vinfo := v.visit(node.Value) - v.varScopes = append(v.varScopes, varScope{node.Name, vtype, vinfo}) - t, i := v.visit(node.Expr) + varNature := v.visit(node.Value) + v.varScopes = append(v.varScopes, varScope{node.Name, varNature}) + exprNature := v.visit(node.Expr) v.varScopes = v.varScopes[:len(v.varScopes)-1] - return t, i + return exprNature } func (v *checker) lookupVariable(name string) (varScope, bool) { @@ -1151,59 +1173,60 @@ func (v *checker) lookupVariable(name string) (varScope, bool) { return varScope{}, false } -func (v *checker) ConditionalNode(node *ast.ConditionalNode) (reflect.Type, info) { - c, _ := v.visit(node.Cond) - if !isBool(c) && !isAny(c) { +func (v *checker) ConditionalNode(node *ast.ConditionalNode) Nature { + c := v.visit(node.Cond) + if !isBool(c) && !isUnknown(c) { return v.error(node.Cond, "non-bool expression (type %v) used as condition", c) } - t1, _ := v.visit(node.Exp1) - t2, _ := v.visit(node.Exp2) + t1 := v.visit(node.Exp1) + t2 := v.visit(node.Exp2) - if t1 == nil && t2 != nil { - return t2, info{} + if isNil(t1) && !isNil(t2) { + return t2 } - if t1 != nil && t2 == nil { - return t1, info{} + if !isNil(t1) && isNil(t2) { + return t1 } - if t1 == nil && t2 == nil { - return nilType, info{} + if isNil(t1) && isNil(t2) { + return nilNature } if t1.AssignableTo(t2) { - return t1, info{} + return t1 } - return anyType, info{} + return unknown } -func (v *checker) ArrayNode(node *ast.ArrayNode) (reflect.Type, info) { - var prev reflect.Type +func (v *checker) ArrayNode(node *ast.ArrayNode) Nature { + var prev Nature allElementsAreSameType := true for i, node := range node.Nodes { - curr, _ := v.visit(node) + curr := v.visit(node) if i > 0 { - if curr == nil || prev == nil { - allElementsAreSameType = false - } else if curr.Kind() != prev.Kind() { + if curr.Kind() != prev.Kind() { allElementsAreSameType = false } } prev = curr } - if allElementsAreSameType && prev != nil { - return arrayType, info{elem: prev} + if allElementsAreSameType { + return Nature{ + Type: arrayNature.Type, + SubType: Array{Of: prev}, + } } - return arrayType, info{} + return arrayNature } -func (v *checker) MapNode(node *ast.MapNode) (reflect.Type, info) { +func (v *checker) MapNode(node *ast.MapNode) Nature { for _, pair := range node.Pairs { v.visit(pair) } - return mapType, info{} + return mapNature } -func (v *checker) PairNode(node *ast.PairNode) (reflect.Type, info) { +func (v *checker) PairNode(node *ast.PairNode) Nature { v.visit(node.Key) v.visit(node.Value) - return nilType, info{} + return nilNature } diff --git a/checker/checker_test.go b/checker/checker_test.go index 1509045e3..ae42392c0 100644 --- a/checker/checker_test.go +++ b/checker/checker_test.go @@ -149,427 +149,541 @@ func TestCheck(t *testing.T) { } } -const errorTests = ` -Foo.Bar.Not +func TestCheck_error(t *testing.T) { + errorTests := []struct{ code, err string }{ + { + `Foo.Bar.Not`, + ` type mock.Bar has no field Not (1:9) | Foo.Bar.Not | ........^ - -Noo +`, + }, + { + `Noo`, + ` unknown name Noo (1:1) | Noo | ^ - -Foo() +`, + }, + { + `Foo()`, ` mock.Foo is not callable (1:1) | Foo() | ^ - -Foo['bar'] +`, + }, + { + `Foo['bar']`, ` type mock.Foo has no field bar (1:4) | Foo['bar'] | ...^ - -Foo.Method(42) +`, + }, + { + `Foo.Method(42)`, + ` too many arguments to call Method (1:5) | Foo.Method(42) | ....^ - -Foo.Bar() +`, + }, + {`Foo.Bar()`, ` mock.Bar is not callable (1:5) | Foo.Bar() | ....^ - -Foo.Bar.Not() +`, + }, + {`Foo.Bar.Not()`, ` type mock.Bar has no method Not (1:9) | Foo.Bar.Not() | ........^ - -ArrayOfFoo[0].Not +`, + }, + {`ArrayOfFoo[0].Not`, ` type mock.Foo has no field Not (1:15) | ArrayOfFoo[0].Not | ..............^ - -ArrayOfFoo[Not] +`, + }, + {`ArrayOfFoo[Not]`, ` unknown name Not (1:12) | ArrayOfFoo[Not] | ...........^ - -Not[0] +`, + }, + {`Not[0]`, ` unknown name Not (1:1) | Not[0] | ^ - -Not.Bar +`, + }, + {`Not.Bar`, ` unknown name Not (1:1) | Not.Bar | ^ - -ArrayOfFoo.Not +`, + }, + {`ArrayOfFoo.Not`, ` array elements can only be selected using an integer (got string) (1:12) | ArrayOfFoo.Not | ...........^ - -FuncParam(true) +`, + }, + {`FuncParam(true)`, ` not enough arguments to call FuncParam (1:1) | FuncParam(true) | ^ - -MapOfFoo['str'].Not +`, + }, + {`MapOfFoo['str'].Not`, ` type mock.Foo has no field Not (1:17) | MapOfFoo['str'].Not | ................^ - -Bool && IntPtr +`, + }, + {`Bool && IntPtr`, ` invalid operation: && (mismatched types bool and int) (1:6) | Bool && IntPtr | .....^ - -No ? Any.Bool : Any.Not +`, + }, + {`No ? Any.Bool : Any.Not`, ` unknown name No (1:1) | No ? Any.Bool : Any.Not | ^ - -Any.Cond ? No : Any.Not +`, + }, + {`Any.Cond ? No : Any.Not`, ` unknown name No (1:12) | Any.Cond ? No : Any.Not | ...........^ - -Any.Cond ? Any.Bool : No +`, + }, + {`Any.Cond ? Any.Bool : No`, ` unknown name No (1:23) | Any.Cond ? Any.Bool : No | ......................^ - -MapOfAny ? Any : Any +`, + }, + {`MapOfAny ? Any : Any`, ` non-bool expression (type map[string]interface {}) used as condition (1:1) | MapOfAny ? Any : Any | ^ - -String matches Int +`, + }, + {`String matches Int`, ` invalid operation: matches (mismatched types string and int) (1:8) | String matches Int | .......^ - -Int matches String +`, + }, + {`Int matches String`, ` invalid operation: matches (mismatched types int and string) (1:5) | Int matches String | ....^ - -String contains Int +`, + }, + {`String contains Int`, ` invalid operation: contains (mismatched types string and int) (1:8) | String contains Int | .......^ - -Int contains String +`, + }, + {`Int contains String`, ` invalid operation: contains (mismatched types int and string) (1:5) | Int contains String | ....^ - -!Not +`, + }, + {`!Not`, ` unknown name Not (1:2) | !Not | .^ - -Not == Any +`, + }, + {`Not == Any`, ` unknown name Not (1:1) | Not == Any | ^ - -[Not] +`, + }, + {`[Not]`, ` unknown name Not (1:2) | [Not] | .^ - -{id: Not} +`, + }, + {`{id: Not}`, ` unknown name Not (1:6) | {id: Not} | .....^ - -(nil).Foo -type has no field Foo (1:7) +`, + }, + {`(nil).Foo`, ` +type nil has no field Foo (1:7) | (nil).Foo | ......^ - -(nil)['Foo'] -type has no field Foo (1:6) +`, + }, + {`(nil)['Foo']`, ` +type nil has no field Foo (1:6) | (nil)['Foo'] | .....^ - -1 and false +`, + }, + {`1 and false`, ` invalid operation: and (mismatched types int and bool) (1:3) | 1 and false | ..^ - -true or 0 +`, + }, + {`true or 0`, ` invalid operation: or (mismatched types bool and int) (1:6) | true or 0 | .....^ - -not IntPtr +`, + }, + {`not IntPtr`, ` invalid operation: not (mismatched type int) (1:1) | not IntPtr | ^ - -len(Not) +`, + }, + {`len(Not)`, ` unknown name Not (1:5) | len(Not) | ....^ - -Int < Bool +`, + }, + {`Int < Bool`, ` invalid operation: < (mismatched types int and bool) (1:5) | Int < Bool | ....^ - -Int > Bool +`, + }, + {`Int > Bool`, ` invalid operation: > (mismatched types int and bool) (1:5) | Int > Bool | ....^ - -Int >= Bool +`, + }, + {`Int >= Bool`, ` invalid operation: >= (mismatched types int and bool) (1:5) | Int >= Bool | ....^ - -Int <= Bool +`, + }, + {`Int <= Bool`, ` invalid operation: <= (mismatched types int and bool) (1:5) | Int <= Bool | ....^ - -Int + Bool +`, + }, + {`Int + Bool`, ` invalid operation: + (mismatched types int and bool) (1:5) | Int + Bool | ....^ - -Int - Bool +`, + }, + {`Int - Bool`, ` invalid operation: - (mismatched types int and bool) (1:5) | Int - Bool | ....^ - -Int * Bool +`, + }, + {`Int * Bool`, ` invalid operation: * (mismatched types int and bool) (1:5) | Int * Bool | ....^ - -Int / Bool +`, + }, + {`Int / Bool`, ` invalid operation: / (mismatched types int and bool) (1:5) | Int / Bool | ....^ - -Int % Bool +`, + }, + {`Int % Bool`, ` invalid operation: % (mismatched types int and bool) (1:5) | Int % Bool | ....^ - -Int ** Bool +`, + }, + {`Int ** Bool`, ` invalid operation: ** (mismatched types int and bool) (1:5) | Int ** Bool | ....^ - -Int .. Bool +`, + }, + {`Int .. Bool`, ` invalid operation: .. (mismatched types int and bool) (1:5) | Int .. Bool | ....^ - -Any > Foo +`, + }, + {`Any > Foo`, ` invalid operation: > (mismatched types interface {} and mock.Foo) (1:5) | Any > Foo | ....^ - -NilFn() and BoolFn() +`, + }, + {`NilFn() and BoolFn()`, ` func NilFn doesn't return value (1:1) | NilFn() and BoolFn() | ^ - -'str' in String +`, + }, + {`'str' in String`, ` invalid operation: in (mismatched types string and string) (1:7) | 'str' in String | ......^ - -1 in Foo +`, + }, + {`1 in Foo`, ` invalid operation: in (mismatched types int and mock.Foo) (1:3) | 1 in Foo | ..^ - -1 + '' +`, + }, + {`1 + ''`, ` invalid operation: + (mismatched types int and string) (1:3) | 1 + '' | ..^ - -all(ArrayOfFoo, {#.Method() < 0}) +`, + }, + {`all(ArrayOfFoo, {#.Method() < 0})`, ` invalid operation: < (mismatched types mock.Bar and int) (1:29) | all(ArrayOfFoo, {#.Method() < 0}) | ............................^ - -Variadic() +`, + }, + {`Variadic()`, ` not enough arguments to call Variadic (1:1) | Variadic() | ^ - -Variadic(0, '') +`, + }, + {`Variadic(0, '')`, ` cannot use string as argument (type int) to call Variadic (1:13) | Variadic(0, '') | ............^ - -count(1, {#}) +`, + }, + {`count(1, {#})`, ` builtin count takes only array (got int) (1:7) | count(1, {#}) | ......^ - -count(ArrayOfInt, {#}) +`, + }, + {`count(ArrayOfInt, {#})`, ` predicate should return boolean (got int) (1:19) | count(ArrayOfInt, {#}) | ..................^ - -all(ArrayOfInt, {# + 1}) +`, + }, + {`all(ArrayOfInt, {# + 1})`, ` predicate should return boolean (got int) (1:17) | all(ArrayOfInt, {# + 1}) | ................^ - -filter(ArrayOfFoo, {.Bar.Baz}) +`, + }, + {`filter(ArrayOfFoo, {.Bar.Baz})`, ` predicate should return boolean (got string) (1:20) | filter(ArrayOfFoo, {.Bar.Baz}) | ...................^ - -find(ArrayOfFoo, {.Bar.Baz}) +`, + }, + {`find(ArrayOfFoo, {.Bar.Baz})`, ` predicate should return boolean (got string) (1:18) | find(ArrayOfFoo, {.Bar.Baz}) | .................^ - -map(1, {2}) +`, + }, + {`map(1, {2})`, ` builtin map takes only array (got int) (1:5) | map(1, {2}) | ....^ - -ArrayOfFoo[Foo] +`, + }, + {`ArrayOfFoo[Foo]`, ` array elements can only be selected using an integer (got mock.Foo) (1:12) | ArrayOfFoo[Foo] | ...........^ - -ArrayOfFoo[Bool:] +`, + }, + {`ArrayOfFoo[Bool:]`, ` non-integer slice index bool (1:12) | ArrayOfFoo[Bool:] | ...........^ - -ArrayOfFoo[1:Bool] +`, + }, + {`ArrayOfFoo[1:Bool]`, ` non-integer slice index bool (1:14) | ArrayOfFoo[1:Bool] | .............^ - -Bool[:] +`, + }, + {`Bool[:]`, ` cannot slice bool (1:5) | Bool[:] | ....^ - -FuncTooManyReturns() +`, + }, + {`FuncTooManyReturns()`, ` func FuncTooManyReturns returns more then two values (1:1) | FuncTooManyReturns() | ^ - -len(42) +`, + }, + {`len(42)`, ` invalid argument for len (type int) (1:1) | len(42) | ^ - -any(42, {#}) +`, + }, + {`any(42, {#})`, ` builtin any takes only array (got int) (1:5) | any(42, {#}) | ....^ - -filter(42, {#}) +`, + }, + {`filter(42, {#})`, ` builtin filter takes only array (got int) (1:8) | filter(42, {#}) | .......^ - -MapOfAny[0] +`, + }, + {`MapOfAny[0]`, ` cannot use int to get an element from map[string]interface {} (1:10) | MapOfAny[0] | .........^ - -1 /* one */ + "2" +`, + }, + {`1 /* one */ + "2"`, ` invalid operation: + (mismatched types int and string) (1:13) | 1 /* one */ + "2" | ............^ - -FuncTyped(42) +`, + }, + {`FuncTyped(42)`, ` cannot use int as argument (type string) to call FuncTyped (1:11) | FuncTyped(42) | ..........^ - -.0 in MapOfFoo +`, + }, + {`.0 in MapOfFoo`, ` cannot use float64 as type string in map key (1:4) | .0 in MapOfFoo | ...^ - -1/2 in MapIntAny +`, + }, + {`1/2 in MapIntAny`, ` cannot use float64 as type int in map key (1:5) | 1/2 in MapIntAny | ....^ - -0.5 in ArrayOfFoo +`, + }, + {`0.5 in ArrayOfFoo`, ` cannot use float64 as type *mock.Foo in array (1:5) | 0.5 in ArrayOfFoo | ....^ - -repeat("0", 1/0) +`, + }, + {`repeat("0", 1/0)`, ` cannot use float64 as argument (type int) to call repeat (1:14) | repeat("0", 1/0) | .............^ - -let map = 42; map +`, + }, + {`let map = 42; map`, ` cannot redeclare builtin map (1:5) | let map = 42; map | ....^ - -let len = 42; len +`, + }, + {`let len = 42; len`, ` cannot redeclare builtin len (1:5) | let len = 42; len | ....^ - -let Float = 42; Float +`, + }, + {`let Float = 42; Float`, ` cannot redeclare Float (1:5) | let Float = 42; Float | ....^ - -let foo = 1; let foo = 2; foo +`, + }, + {`let foo = 1; let foo = 2; foo`, ` cannot redeclare variable foo (1:18) | let foo = 1; let foo = 2; foo | .................^ - -map(1..9, #unknown) +`, + }, + {`map(1..9, #unknown)`, ` unknown pointer #unknown (1:11) | map(1..9, #unknown) | ..........^ - -42 in ["a", "b", "c"] +`, + }, + {`42 in ["a", "b", "c"]`, ` cannot use int as type string in array (1:4) | 42 in ["a", "b", "c"] | ...^ - -"foo" matches "[+" +`, + }, + {`"foo" matches "[+"`, ` error parsing regexp: missing closing ]: ` + "`[+`" + ` (1:7) | "foo" matches "[+" | ......^ -` - -func TestCheck_error(t *testing.T) { - tests := strings.Split(strings.Trim(errorTests, "\n"), "\n\n") - - for _, test := range tests { - input := strings.SplitN(test, "\n", 2) - if len(input) != 2 { - t.Errorf("syntax error in test: %q", test) - break - } +`, + }, + {`get(false, 2)`, ` +type bool does not support indexing (1:5) + | get(false, 2) + | ....^ +`, + }, + {`get(1..2, 0.5)`, ` +non-integer slice index float64 (1:11) + | get(1..2, 0.5) + | ..........^`, + }, + {`trimPrefix(nil)`, ` +cannot use nil as argument (type string) to call trimPrefix (1:12) + | trimPrefix(nil) + | ...........^ +`, + }, + {`1..3 | filter(# > 1) | filter(# == "str")`, + ` +invalid operation: == (mismatched types int and string) (1:33) + | 1..3 | filter(# > 1) | filter(# == "str") + | ................................^ +`, + }, + {`1..3 | map("str") | filter(# > 1)`, + ` +invalid operation: > (mismatched types string and int) (1:30) + | 1..3 | map("str") | filter(# > 1) + | .............................^ +`, + }, + } - tree, err := parser.Parse(input[0]) - assert.NoError(t, err) + for _, tt := range errorTests { + t.Run(tt.code, func(t *testing.T) { + tree, err := parser.Parse(tt.code) + require.NoError(t, err) - _, err = checker.Check(tree, conf.New(mock.Env{})) - if err == nil { - err = fmt.Errorf("") - } + _, err = checker.Check(tree, conf.New(mock.Env{})) + if err == nil { + err = fmt.Errorf("") + } - assert.Equal(t, input[1], err.Error(), input[0]) + assert.Equal(t, strings.Trim(tt.err, "\n"), err.Error()) + }) } } diff --git a/checker/info.go b/checker/info.go index 112bfab31..3c9396fd5 100644 --- a/checker/info.go +++ b/checker/info.go @@ -15,11 +15,9 @@ func FieldIndex(types conf.TypesTable, node ast.Node) (bool, []int, string) { return true, t.FieldIndex, n.Value } case *ast.MemberNode: - base := n.Node.Type() - if kind(base) == reflect.Ptr { - base = base.Elem() - } - if kind(base) == reflect.Struct { + base := n.Node.Nature() + base = base.Deref() + if base.Kind() == reflect.Struct { if prop, ok := n.Property.(*ast.StringNode); ok { name := prop.Value if field, ok := fetchField(base, name); ok { @@ -114,8 +112,7 @@ func IsFastFunc(fn reflect.Type, method bool) bool { if method { numIn = 2 } - if !isAny(fn) && - fn.IsVariadic() && + if fn.IsVariadic() && fn.NumIn() == numIn && fn.NumOut() == 1 && fn.Out(0).Kind() == reflect.Interface { diff --git a/checker/nature/nature.go b/checker/nature/nature.go new file mode 100644 index 000000000..a7365998c --- /dev/null +++ b/checker/nature/nature.go @@ -0,0 +1,142 @@ +package nature + +import ( + "reflect" + + "github.com/expr-lang/expr/builtin" + "github.com/expr-lang/expr/internal/deref" +) + +var ( + unknown = Nature{} +) + +type Nature struct { + Type reflect.Type + SubType SubType + Func *builtin.Function + Method bool +} + +func (n Nature) String() string { + if n.SubType != nil { + return n.SubType.String() + } + if n.Type != nil { + return n.Type.String() + } + return "unknown" +} + +func (n Nature) Deref() Nature { + if n.Type != nil { + n.Type = deref.Type(n.Type) + } + return n +} + +func (n Nature) Kind() reflect.Kind { + if n.Type != nil { + return n.Type.Kind() + } + return reflect.Invalid +} + +func (n Nature) Key() Nature { + if n.Kind() == reflect.Map { + return Nature{Type: n.Type.Key()} + } + return unknown +} + +func (n Nature) Elem() Nature { + switch n.Kind() { + case reflect.Map, reflect.Ptr: + return Nature{Type: n.Type.Elem()} + case reflect.Array, reflect.Slice: + if array, ok := n.SubType.(Array); ok { + return array.Of + } + return Nature{Type: n.Type.Elem()} + } + return unknown +} + +func (n Nature) AssignableTo(nt Nature) bool { + if n.Type == nil || nt.Type == nil { + return false + } + return n.Type.AssignableTo(nt.Type) +} + +func (n Nature) MethodByName(name string) (Nature, bool) { + if n.Type == nil { + return unknown, false + } + method, ok := n.Type.MethodByName(name) + if !ok { + return unknown, false + } + + if n.Type.Kind() == reflect.Interface { + // In case of interface type method will not have a receiver, + // and to prevent checker decreasing numbers of in arguments + // return method type as not method (second argument is false). + + // Also, we can not use m.Index here, because it will be + // different indexes for different types which implement + // the same interface. + return Nature{Type: method.Type}, true + } else { + return Nature{Type: method.Type, Method: true}, true + } +} + +func (n Nature) NumField() int { + if n.Type == nil { + return 0 + } + return n.Type.NumField() +} + +func (n Nature) Field(i int) reflect.StructField { + if n.Type == nil { + return reflect.StructField{} + } + return n.Type.Field(i) +} + +func (n Nature) NumIn() int { + if n.Type == nil { + return 0 + } + return n.Type.NumIn() +} + +func (n Nature) In(i int) Nature { + if n.Type == nil { + return unknown + } + return Nature{Type: n.Type.In(i)} +} + +func (n Nature) NumOut() int { + if n.Type == nil { + return 0 + } + return n.Type.NumOut() +} + +func (n Nature) Out(i int) Nature { + if n.Type == nil { + return unknown + } + return Nature{Type: n.Type.Out(i)} +} + +func (n Nature) IsVariadic() bool { + if n.Type == nil { + return false + } + return n.Type.IsVariadic() +} diff --git a/checker/nature/types.go b/checker/nature/types.go new file mode 100644 index 000000000..1f9955e92 --- /dev/null +++ b/checker/nature/types.go @@ -0,0 +1,13 @@ +package nature + +type SubType interface { + String() string +} + +type Array struct { + Of Nature +} + +func (a Array) String() string { + return "[]" + a.Of.String() +} diff --git a/checker/types.go b/checker/types.go index d10736a77..2eb5392e0 100644 --- a/checker/types.go +++ b/checker/types.go @@ -4,204 +4,193 @@ import ( "reflect" "time" + . "github.com/expr-lang/expr/checker/nature" "github.com/expr-lang/expr/conf" ) var ( - nilType = reflect.TypeOf(nil) - boolType = reflect.TypeOf(true) - integerType = reflect.TypeOf(0) - floatType = reflect.TypeOf(float64(0)) - stringType = reflect.TypeOf("") - arrayType = reflect.TypeOf([]any{}) - mapType = reflect.TypeOf(map[string]any{}) + unknown = Nature{} + nilNature = Nature{Type: reflect.TypeOf(Nil{})} + boolNature = Nature{Type: reflect.TypeOf(true)} + integerNature = Nature{Type: reflect.TypeOf(0)} + floatNature = Nature{Type: reflect.TypeOf(float64(0))} + stringNature = Nature{Type: reflect.TypeOf("")} + arrayNature = Nature{Type: reflect.TypeOf([]any{})} + mapNature = Nature{Type: reflect.TypeOf(map[string]any{})} + timeNature = Nature{Type: reflect.TypeOf(time.Time{})} + durationNature = Nature{Type: reflect.TypeOf(time.Duration(0))} +) + +var ( anyType = reflect.TypeOf(new(any)).Elem() timeType = reflect.TypeOf(time.Time{}) durationType = reflect.TypeOf(time.Duration(0)) + arrayType = reflect.TypeOf([]any{}) ) -func combined(a, b reflect.Type) reflect.Type { - if a.Kind() == b.Kind() { - return a +// Nil is a special type to represent nil. +type Nil struct{} + +func isNil(nt Nature) bool { + if nt.Type == nil { + return false + } + return nt.Type == nilNature.Type +} + +func combined(l, r Nature) Nature { + if isUnknown(l) || isUnknown(r) { + return unknown } - if isFloat(a) || isFloat(b) { - return floatType + if isFloat(l) || isFloat(r) { + return floatNature } - return integerType + return integerNature } -func anyOf(t reflect.Type, fns ...func(reflect.Type) bool) bool { +func anyOf(nt Nature, fns ...func(Nature) bool) bool { for _, fn := range fns { - if fn(t) { + if fn(nt) { return true } } return false } -func or(l, r reflect.Type, fns ...func(reflect.Type) bool) bool { - if isAny(l) && isAny(r) { +func or(l, r Nature, fns ...func(Nature) bool) bool { + if isUnknown(l) && isUnknown(r) { return true } - if isAny(l) && anyOf(r, fns...) { + if isUnknown(l) && anyOf(r, fns...) { return true } - if isAny(r) && anyOf(l, fns...) { + if isUnknown(r) && anyOf(l, fns...) { return true } return false } -func isAny(t reflect.Type) bool { - if t != nil { - switch t.Kind() { - case reflect.Interface: - return true - } +func isUnknown(nt Nature) bool { + switch { + case nt.Type == nil: + return true + case nt.Kind() == reflect.Interface: + return true } return false } -func isInteger(t reflect.Type) bool { - if t != nil { - switch t.Kind() { - case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64: - fallthrough - case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64: - return true - } +func isInteger(nt Nature) bool { + switch nt.Kind() { + case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64: + fallthrough + case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64: + return true } return false } -func isFloat(t reflect.Type) bool { - if t != nil { - switch t.Kind() { - case reflect.Float32, reflect.Float64: - return true - } +func isFloat(nt Nature) bool { + switch nt.Kind() { + case reflect.Float32, reflect.Float64: + return true } return false } -func isNumber(t reflect.Type) bool { - return isInteger(t) || isFloat(t) +func isNumber(nt Nature) bool { + return isInteger(nt) || isFloat(nt) } -func isTime(t reflect.Type) bool { - if t != nil { - switch t { - case timeType: - return true - } +func isTime(nt Nature) bool { + switch nt.Type { + case timeType: + return true } return false } -func isDuration(t reflect.Type) bool { - if t != nil { - switch t { - case durationType: - return true - } +func isDuration(nt Nature) bool { + switch nt.Type { + case durationType: + return true } return false } -func isBool(t reflect.Type) bool { - if t != nil { - switch t.Kind() { - case reflect.Bool: - return true - } +func isBool(nt Nature) bool { + switch nt.Kind() { + case reflect.Bool: + return true } return false } -func isString(t reflect.Type) bool { - if t != nil { - switch t.Kind() { - case reflect.String: - return true - } +func isString(nt Nature) bool { + switch nt.Kind() { + case reflect.String: + return true } return false } -func isArray(t reflect.Type) bool { - if t != nil { - switch t.Kind() { - case reflect.Ptr: - return isArray(t.Elem()) - case reflect.Slice, reflect.Array: - return true - } +func isArray(nt Nature) bool { + switch nt.Kind() { + case reflect.Slice, reflect.Array: + return true } return false } -func isMap(t reflect.Type) bool { - if t != nil { - switch t.Kind() { - case reflect.Ptr: - return isMap(t.Elem()) - case reflect.Map: - return true - } +func isMap(nt Nature) bool { + switch nt.Kind() { + case reflect.Map: + return true } return false } -func isStruct(t reflect.Type) bool { - if t != nil { - switch t.Kind() { - case reflect.Ptr: - return isStruct(t.Elem()) - case reflect.Struct: - return true - } +func isStruct(nt Nature) bool { + switch nt.Kind() { + case reflect.Struct: + return true } return false } -func isFunc(t reflect.Type) bool { - if t != nil { - switch t.Kind() { - case reflect.Ptr: - return isFunc(t.Elem()) - case reflect.Func: - return true - } +func isFunc(nt Nature) bool { + switch nt.Kind() { + case reflect.Func: + return true } return false } -func fetchField(t reflect.Type, name string) (reflect.StructField, bool) { - if t != nil { - // First check all structs fields. - for i := 0; i < t.NumField(); i++ { - field := t.Field(i) - // Search all fields, even embedded structs. - if conf.FieldName(field) == name { - return field, true - } +func fetchField(nt Nature, name string) (reflect.StructField, bool) { + // First check all structs fields. + for i := 0; i < nt.NumField(); i++ { + field := nt.Field(i) + // Search all fields, even embedded structs. + if conf.FieldName(field) == name { + return field, true } + } - // Second check fields of embedded structs. - for i := 0; i < t.NumField(); i++ { - anon := t.Field(i) - if anon.Anonymous { - anonType := anon.Type - if anonType.Kind() == reflect.Pointer { - anonType = anonType.Elem() - } - if field, ok := fetchField(anonType, name); ok { - field.Index = append(anon.Index, field.Index...) - return field, true - } + // Second check fields of embedded structs. + for i := 0; i < nt.NumField(); i++ { + anon := nt.Field(i) + if anon.Anonymous { + anonType := anon.Type + if anonType.Kind() == reflect.Pointer { + anonType = anonType.Elem() + } + if field, ok := fetchField(Nature{Type: anonType}, name); ok { + field.Index = append(anon.Index, field.Index...) + return field, true } } } + return reflect.StructField{}, false } @@ -212,16 +201,15 @@ func kind(t reflect.Type) reflect.Kind { return t.Kind() } -func isComparable(l, r reflect.Type) bool { - if l == nil || r == nil { - return true - } +func isComparable(l, r Nature) bool { switch { case l.Kind() == r.Kind(): return true case isNumber(l) && isNumber(r): return true - case isAny(l) || isAny(r): + case isNil(l) || isNil(r): + return true + case isUnknown(l) || isUnknown(r): return true } return false diff --git a/compiler/compiler.go b/compiler/compiler.go index 29a6d4cdc..b4ec6dbd4 100644 --- a/compiler/compiler.go +++ b/compiler/compiler.go @@ -377,16 +377,13 @@ func (c *compiler) IntegerNode(node *ast.IntegerNode) { } func (c *compiler) FloatNode(node *ast.FloatNode) { - t := node.Type() - if t == nil { - c.emitPush(node.Value) - return - } - switch t.Kind() { + switch node.Kind() { case reflect.Float32: c.emitPush(float32(node.Value)) case reflect.Float64: c.emitPush(node.Value) + default: + c.emitPush(node.Value) } } @@ -1202,7 +1199,7 @@ func (c *compiler) PairNode(node *ast.PairNode) { } func (c *compiler) derefInNeeded(node ast.Node) { - switch kind(node.Type()) { + switch node.Kind() { case reflect.Ptr, reflect.Interface: c.emit(OpDeref) } diff --git a/compiler/compiler_test.go b/compiler/compiler_test.go index ba5d6dc54..526c5d67d 100644 --- a/compiler/compiler_test.go +++ b/compiler/compiler_test.go @@ -442,10 +442,11 @@ func TestCompile_OpCallFast(t *testing.T) { func TestCompile_optimizes_jumps(t *testing.T) { env := map[string]any{ - "a": true, - "b": true, - "c": true, - "d": true, + "a": true, + "b": true, + "c": true, + "d": true, + "i64": int64(1), } tests := []struct { code string @@ -497,36 +498,33 @@ func TestCompile_optimizes_jumps(t *testing.T) { `filter([1, 2, 3, 4, 5], # > 3 && # != 4 && # != 5)`, `0 OpPush <0> [1 2 3 4 5] 1 OpBegin -2 OpJumpIfEnd <26> (29) +2 OpJumpIfEnd <23> (26) 3 OpPointer -4 OpDeref -5 OpPush <1> 3 -6 OpMore -7 OpJumpIfFalse <18> (26) -8 OpPop -9 OpPointer -10 OpDeref -11 OpPush <2> 4 -12 OpEqual -13 OpNot -14 OpJumpIfFalse <11> (26) -15 OpPop -16 OpPointer -17 OpDeref -18 OpPush <3> 5 -19 OpEqual -20 OpNot -21 OpJumpIfFalse <4> (26) -22 OpPop -23 OpIncrementCount -24 OpPointer -25 OpJump <1> (27) -26 OpPop -27 OpIncrementIndex -28 OpJumpBackward <27> (2) -29 OpGetCount -30 OpEnd -31 OpArray +4 OpPush <1> 3 +5 OpMore +6 OpJumpIfFalse <16> (23) +7 OpPop +8 OpPointer +9 OpPush <2> 4 +10 OpEqualInt +11 OpNot +12 OpJumpIfFalse <10> (23) +13 OpPop +14 OpPointer +15 OpPush <3> 5 +16 OpEqualInt +17 OpNot +18 OpJumpIfFalse <4> (23) +19 OpPop +20 OpIncrementCount +21 OpPointer +22 OpJump <1> (24) +23 OpPop +24 OpIncrementIndex +25 OpJumpBackward <24> (2) +26 OpGetCount +27 OpEnd +28 OpArray `, }, { @@ -650,3 +648,12 @@ func TestCompile_IntegerArgsFunc(t *testing.T) { }) } } + +func TestCompile_call_on_nil(t *testing.T) { + env := map[string]any{ + "foo": nil, + } + _, err := expr.Compile(`foo()`, expr.Env(env)) + require.Error(t, err) + require.Contains(t, err.Error(), "foo is nil; cannot call nil as function") +} diff --git a/expr_test.go b/expr_test.go index 8b7856a43..3724467fc 100644 --- a/expr_test.go +++ b/expr_test.go @@ -2296,14 +2296,6 @@ func TestIssue432(t *testing.T) { assert.Equal(t, float64(10), out) } -func TestIssue453(t *testing.T) { - env := map[string]any{ - "foo": nil, - } - _, err := expr.Compile(`foo()`, expr.Env(env)) - require.Error(t, err) -} - func TestIssue461(t *testing.T) { type EnvStr string type EnvField struct { diff --git a/optimizer/const_expr.go b/optimizer/const_expr.go index 501ea3c58..1b45385f6 100644 --- a/optimizer/const_expr.go +++ b/optimizer/const_expr.go @@ -30,11 +30,6 @@ func (c *constExpr) Visit(node *Node) { } }() - patch := func(newNode Node) { - c.applied = true - Patch(node, newNode) - } - if call, ok := (*node).(*CallNode); ok { if name, ok := call.Callee.(*IdentifierNode); ok { fn, ok := c.fns[name.Value] @@ -78,7 +73,8 @@ func (c *constExpr) Visit(node *Node) { return } constNode := &ConstantNode{Value: value} - patch(constNode) + patchWithType(node, constNode) + c.applied = true } } } diff --git a/optimizer/filter_first.go b/optimizer/filter_first.go index 7ea8f6fa4..b04a5cb34 100644 --- a/optimizer/filter_first.go +++ b/optimizer/filter_first.go @@ -12,7 +12,7 @@ func (*filterFirst) Visit(node *Node) { if filter, ok := member.Node.(*BuiltinNode); ok && filter.Name == "filter" && len(filter.Arguments) == 2 { - Patch(node, &BuiltinNode{ + patchCopyType(node, &BuiltinNode{ Name: "find", Arguments: filter.Arguments, Throws: true, // to match the behavior of filter()[0] @@ -27,7 +27,7 @@ func (*filterFirst) Visit(node *Node) { if filter, ok := first.Arguments[0].(*BuiltinNode); ok && filter.Name == "filter" && len(filter.Arguments) == 2 { - Patch(node, &BuiltinNode{ + patchCopyType(node, &BuiltinNode{ Name: "find", Arguments: filter.Arguments, Throws: false, // as first() will return nil if not found diff --git a/optimizer/filter_last.go b/optimizer/filter_last.go index 9a1cc5e29..8c046bf88 100644 --- a/optimizer/filter_last.go +++ b/optimizer/filter_last.go @@ -12,7 +12,7 @@ func (*filterLast) Visit(node *Node) { if filter, ok := member.Node.(*BuiltinNode); ok && filter.Name == "filter" && len(filter.Arguments) == 2 { - Patch(node, &BuiltinNode{ + patchCopyType(node, &BuiltinNode{ Name: "findLast", Arguments: filter.Arguments, Throws: true, // to match the behavior of filter()[-1] @@ -27,7 +27,7 @@ func (*filterLast) Visit(node *Node) { if filter, ok := first.Arguments[0].(*BuiltinNode); ok && filter.Name == "filter" && len(filter.Arguments) == 2 { - Patch(node, &BuiltinNode{ + patchCopyType(node, &BuiltinNode{ Name: "findLast", Arguments: filter.Arguments, Throws: false, // as last() will return nil if not found diff --git a/optimizer/filter_len.go b/optimizer/filter_len.go index 6577163ec..c66fde961 100644 --- a/optimizer/filter_len.go +++ b/optimizer/filter_len.go @@ -13,7 +13,7 @@ func (*filterLen) Visit(node *Node) { if filter, ok := ln.Arguments[0].(*BuiltinNode); ok && filter.Name == "filter" && len(filter.Arguments) == 2 { - Patch(node, &BuiltinNode{ + patchCopyType(node, &BuiltinNode{ Name: "count", Arguments: filter.Arguments, }) diff --git a/optimizer/filter_map.go b/optimizer/filter_map.go index d988dc692..e916dd75b 100644 --- a/optimizer/filter_map.go +++ b/optimizer/filter_map.go @@ -14,7 +14,7 @@ func (*filterMap) Visit(node *Node) { if filter, ok := mapBuiltin.Arguments[0].(*BuiltinNode); ok && filter.Name == "filter" && filter.Map == nil /* not already optimized */ { - Patch(node, &BuiltinNode{ + patchCopyType(node, &BuiltinNode{ Name: "filter", Arguments: filter.Arguments, Map: closure.Node, diff --git a/optimizer/fold.go b/optimizer/fold.go index 910c92402..2f4562c22 100644 --- a/optimizer/fold.go +++ b/optimizer/fold.go @@ -1,20 +1,12 @@ package optimizer import ( - "fmt" "math" - "reflect" . "github.com/expr-lang/expr/ast" "github.com/expr-lang/expr/file" ) -var ( - integerType = reflect.TypeOf(0) - floatType = reflect.TypeOf(float64(0)) - stringType = reflect.TypeOf("") -) - type fold struct { applied bool err *file.Error @@ -23,20 +15,11 @@ type fold struct { func (fold *fold) Visit(node *Node) { patch := func(newNode Node) { fold.applied = true - Patch(node, newNode) + patchWithType(node, newNode) } - patchWithType := func(newNode Node) { - patch(newNode) - switch newNode.(type) { - case *IntegerNode: - newNode.SetType(integerType) - case *FloatNode: - newNode.SetType(floatType) - case *StringNode: - newNode.SetType(stringType) - default: - panic(fmt.Sprintf("unknown type %T", newNode)) - } + patchCopy := func(newNode Node) { + fold.applied = true + patchCopyType(node, newNode) } switch n := (*node).(type) { @@ -44,17 +27,17 @@ func (fold *fold) Visit(node *Node) { switch n.Operator { case "-": if i, ok := n.Node.(*IntegerNode); ok { - patchWithType(&IntegerNode{Value: -i.Value}) + patch(&IntegerNode{Value: -i.Value}) } if i, ok := n.Node.(*FloatNode); ok { - patchWithType(&FloatNode{Value: -i.Value}) + patch(&FloatNode{Value: -i.Value}) } case "+": if i, ok := n.Node.(*IntegerNode); ok { - patchWithType(&IntegerNode{Value: i.Value}) + patch(&IntegerNode{Value: i.Value}) } if i, ok := n.Node.(*FloatNode); ok { - patchWithType(&FloatNode{Value: i.Value}) + patch(&FloatNode{Value: i.Value}) } case "!", "not": if a := toBool(n.Node); a != nil { @@ -69,28 +52,28 @@ func (fold *fold) Visit(node *Node) { a := toInteger(n.Left) b := toInteger(n.Right) if a != nil && b != nil { - patchWithType(&IntegerNode{Value: a.Value + b.Value}) + patch(&IntegerNode{Value: a.Value + b.Value}) } } { a := toInteger(n.Left) b := toFloat(n.Right) if a != nil && b != nil { - patchWithType(&FloatNode{Value: float64(a.Value) + b.Value}) + patch(&FloatNode{Value: float64(a.Value) + b.Value}) } } { a := toFloat(n.Left) b := toInteger(n.Right) if a != nil && b != nil { - patchWithType(&FloatNode{Value: a.Value + float64(b.Value)}) + patch(&FloatNode{Value: a.Value + float64(b.Value)}) } } { a := toFloat(n.Left) b := toFloat(n.Right) if a != nil && b != nil { - patchWithType(&FloatNode{Value: a.Value + b.Value}) + patch(&FloatNode{Value: a.Value + b.Value}) } } { @@ -105,28 +88,28 @@ func (fold *fold) Visit(node *Node) { a := toInteger(n.Left) b := toInteger(n.Right) if a != nil && b != nil { - patchWithType(&IntegerNode{Value: a.Value - b.Value}) + patch(&IntegerNode{Value: a.Value - b.Value}) } } { a := toInteger(n.Left) b := toFloat(n.Right) if a != nil && b != nil { - patchWithType(&FloatNode{Value: float64(a.Value) - b.Value}) + patch(&FloatNode{Value: float64(a.Value) - b.Value}) } } { a := toFloat(n.Left) b := toInteger(n.Right) if a != nil && b != nil { - patchWithType(&FloatNode{Value: a.Value - float64(b.Value)}) + patch(&FloatNode{Value: a.Value - float64(b.Value)}) } } { a := toFloat(n.Left) b := toFloat(n.Right) if a != nil && b != nil { - patchWithType(&FloatNode{Value: a.Value - b.Value}) + patch(&FloatNode{Value: a.Value - b.Value}) } } case "*": @@ -134,28 +117,28 @@ func (fold *fold) Visit(node *Node) { a := toInteger(n.Left) b := toInteger(n.Right) if a != nil && b != nil { - patchWithType(&IntegerNode{Value: a.Value * b.Value}) + patch(&IntegerNode{Value: a.Value * b.Value}) } } { a := toInteger(n.Left) b := toFloat(n.Right) if a != nil && b != nil { - patchWithType(&FloatNode{Value: float64(a.Value) * b.Value}) + patch(&FloatNode{Value: float64(a.Value) * b.Value}) } } { a := toFloat(n.Left) b := toInteger(n.Right) if a != nil && b != nil { - patchWithType(&FloatNode{Value: a.Value * float64(b.Value)}) + patch(&FloatNode{Value: a.Value * float64(b.Value)}) } } { a := toFloat(n.Left) b := toFloat(n.Right) if a != nil && b != nil { - patchWithType(&FloatNode{Value: a.Value * b.Value}) + patch(&FloatNode{Value: a.Value * b.Value}) } } case "/": @@ -163,28 +146,28 @@ func (fold *fold) Visit(node *Node) { a := toInteger(n.Left) b := toInteger(n.Right) if a != nil && b != nil { - patchWithType(&FloatNode{Value: float64(a.Value) / float64(b.Value)}) + patch(&FloatNode{Value: float64(a.Value) / float64(b.Value)}) } } { a := toInteger(n.Left) b := toFloat(n.Right) if a != nil && b != nil { - patchWithType(&FloatNode{Value: float64(a.Value) / b.Value}) + patch(&FloatNode{Value: float64(a.Value) / b.Value}) } } { a := toFloat(n.Left) b := toInteger(n.Right) if a != nil && b != nil { - patchWithType(&FloatNode{Value: a.Value / float64(b.Value)}) + patch(&FloatNode{Value: a.Value / float64(b.Value)}) } } { a := toFloat(n.Left) b := toFloat(n.Right) if a != nil && b != nil { - patchWithType(&FloatNode{Value: a.Value / b.Value}) + patch(&FloatNode{Value: a.Value / b.Value}) } } case "%": @@ -205,28 +188,28 @@ func (fold *fold) Visit(node *Node) { a := toInteger(n.Left) b := toInteger(n.Right) if a != nil && b != nil { - patchWithType(&FloatNode{Value: math.Pow(float64(a.Value), float64(b.Value))}) + patch(&FloatNode{Value: math.Pow(float64(a.Value), float64(b.Value))}) } } { a := toInteger(n.Left) b := toFloat(n.Right) if a != nil && b != nil { - patchWithType(&FloatNode{Value: math.Pow(float64(a.Value), b.Value)}) + patch(&FloatNode{Value: math.Pow(float64(a.Value), b.Value)}) } } { a := toFloat(n.Left) b := toInteger(n.Right) if a != nil && b != nil { - patchWithType(&FloatNode{Value: math.Pow(a.Value, float64(b.Value))}) + patch(&FloatNode{Value: math.Pow(a.Value, float64(b.Value))}) } } { a := toFloat(n.Left) b := toFloat(n.Right) if a != nil && b != nil { - patchWithType(&FloatNode{Value: math.Pow(a.Value, b.Value)}) + patch(&FloatNode{Value: math.Pow(a.Value, b.Value)}) } } case "and", "&&": @@ -234,9 +217,9 @@ func (fold *fold) Visit(node *Node) { b := toBool(n.Right) if a != nil && a.Value { // true and x - patch(n.Right) + patchCopy(n.Right) } else if b != nil && b.Value { // x and true - patch(n.Left) + patchCopy(n.Left) } else if (a != nil && !a.Value) || (b != nil && !b.Value) { // "x and false" or "false and x" patch(&BoolNode{Value: false}) } @@ -245,9 +228,9 @@ func (fold *fold) Visit(node *Node) { b := toBool(n.Right) if a != nil && !a.Value { // false or x - patch(n.Right) + patchCopy(n.Right) } else if b != nil && !b.Value { // x or false - patch(n.Left) + patchCopy(n.Left) } else if (a != nil && a.Value) || (b != nil && b.Value) { // "x or true" or "true or x" patch(&BoolNode{Value: true}) } @@ -302,20 +285,21 @@ func (fold *fold) Visit(node *Node) { } case *BuiltinNode: + // TODO: Move this to a separate visitor filter_filter.go switch n.Name { case "filter": if len(n.Arguments) != 2 { return } if base, ok := n.Arguments[0].(*BuiltinNode); ok && base.Name == "filter" { - patch(&BuiltinNode{ + patchCopy(&BuiltinNode{ Name: "filter", Arguments: []Node{ base.Arguments[0], &BinaryNode{ Operator: "&&", - Left: base.Arguments[1], - Right: n.Arguments[1], + Left: base.Arguments[1].(*ClosureNode).Node, + Right: n.Arguments[1].(*ClosureNode).Node, }, }, }) diff --git a/optimizer/fold_test.go b/optimizer/fold_test.go new file mode 100644 index 000000000..d3f44fcf4 --- /dev/null +++ b/optimizer/fold_test.go @@ -0,0 +1,82 @@ +package optimizer_test + +import ( + "reflect" + "testing" + + "github.com/expr-lang/expr/ast" + "github.com/expr-lang/expr/internal/testify/assert" + "github.com/expr-lang/expr/internal/testify/require" + "github.com/expr-lang/expr/optimizer" + "github.com/expr-lang/expr/parser" +) + +func TestOptimize_constant_folding(t *testing.T) { + tree, err := parser.Parse(`[1,2,3][5*5-25]`) + require.NoError(t, err) + + err = optimizer.Optimize(&tree.Node, nil) + require.NoError(t, err) + + expected := &ast.MemberNode{ + Node: &ast.ConstantNode{Value: []any{1, 2, 3}}, + Property: &ast.IntegerNode{Value: 0}, + } + + assert.Equal(t, ast.Dump(expected), ast.Dump(tree.Node)) +} + +func TestOptimize_constant_folding_with_floats(t *testing.T) { + tree, err := parser.Parse(`1 + 2.0 * ((1.0 * 2) / 2) - 0`) + require.NoError(t, err) + + err = optimizer.Optimize(&tree.Node, nil) + require.NoError(t, err) + + expected := &ast.FloatNode{Value: 3.0} + + assert.Equal(t, ast.Dump(expected), ast.Dump(tree.Node)) + assert.Equal(t, reflect.Float64, tree.Node.Type().Kind()) +} + +func TestOptimize_constant_folding_with_bools(t *testing.T) { + tree, err := parser.Parse(`(true and false) or (true or false) or (false and false) or (true and (true == false))`) + require.NoError(t, err) + + err = optimizer.Optimize(&tree.Node, nil) + require.NoError(t, err) + + expected := &ast.BoolNode{Value: true} + + assert.Equal(t, ast.Dump(expected), ast.Dump(tree.Node)) +} + +func TestOptimize_constant_folding_filter_filter(t *testing.T) { + tree, err := parser.Parse(`filter(filter(1..2, true), true)`) + require.NoError(t, err) + + err = optimizer.Optimize(&tree.Node, nil) + require.NoError(t, err) + + expected := &ast.BuiltinNode{ + Name: "filter", + Arguments: []ast.Node{ + &ast.BinaryNode{ + Operator: "..", + Left: &ast.IntegerNode{ + Value: 1, + }, + Right: &ast.IntegerNode{ + Value: 2, + }, + }, + &ast.BoolNode{ + Value: true, + }, + }, + Throws: false, + Map: nil, + } + + assert.Equal(t, ast.Dump(expected), ast.Dump(tree.Node)) +} diff --git a/optimizer/in_array.go b/optimizer/in_array.go index 8933d9b91..e91320c0f 100644 --- a/optimizer/in_array.go +++ b/optimizer/in_array.go @@ -32,10 +32,12 @@ func (*inArray) Visit(node *Node) { for _, a := range array.Nodes { value[a.(*IntegerNode).Value] = struct{}{} } - Patch(node, &BinaryNode{ + m := &ConstantNode{Value: value} + m.SetType(reflect.TypeOf(value)) + patchCopyType(node, &BinaryNode{ Operator: n.Operator, Left: n.Left, - Right: &ConstantNode{Value: value}, + Right: m, }) } @@ -50,10 +52,12 @@ func (*inArray) Visit(node *Node) { for _, a := range array.Nodes { value[a.(*StringNode).Value] = struct{}{} } - Patch(node, &BinaryNode{ + m := &ConstantNode{Value: value} + m.SetType(reflect.TypeOf(value)) + patchCopyType(node, &BinaryNode{ Operator: n.Operator, Left: n.Left, - Right: &ConstantNode{Value: value}, + Right: m, }) } diff --git a/optimizer/in_range.go b/optimizer/in_range.go index 01faabbdf..ed2f557ea 100644 --- a/optimizer/in_range.go +++ b/optimizer/in_range.go @@ -22,7 +22,7 @@ func (*inRange) Visit(node *Node) { if rangeOp, ok := n.Right.(*BinaryNode); ok && rangeOp.Operator == ".." { if from, ok := rangeOp.Left.(*IntegerNode); ok { if to, ok := rangeOp.Right.(*IntegerNode); ok { - Patch(node, &BinaryNode{ + patchCopyType(node, &BinaryNode{ Operator: "and", Left: &BinaryNode{ Operator: ">=", diff --git a/optimizer/optimizer.go b/optimizer/optimizer.go index 4ceb3fa43..9a9677c1b 100644 --- a/optimizer/optimizer.go +++ b/optimizer/optimizer.go @@ -1,6 +1,9 @@ package optimizer import ( + "fmt" + "reflect" + . "github.com/expr-lang/expr/ast" "github.com/expr-lang/expr/conf" ) @@ -41,3 +44,36 @@ func Optimize(node *Node, config *conf.Config) error { Walk(node, &sumMap{}) return nil } + +var ( + boolType = reflect.TypeOf(true) + integerType = reflect.TypeOf(0) + floatType = reflect.TypeOf(float64(0)) + stringType = reflect.TypeOf("") +) + +func patchWithType(node *Node, newNode Node) { + switch n := newNode.(type) { + case *BoolNode: + newNode.SetType(boolType) + case *IntegerNode: + newNode.SetType(integerType) + case *FloatNode: + newNode.SetType(floatType) + case *StringNode: + newNode.SetType(stringType) + case *ConstantNode: + newNode.SetType(reflect.TypeOf(n.Value)) + case *BinaryNode: + newNode.SetType(n.Type()) + default: + panic(fmt.Sprintf("unknown type %T", newNode)) + } + Patch(node, newNode) +} + +func patchCopyType(node *Node, newNode Node) { + t := (*node).Type() + newNode.SetType(t) + Patch(node, newNode) +} diff --git a/optimizer/optimizer_test.go b/optimizer/optimizer_test.go index 0ff4b4901..56a890492 100644 --- a/optimizer/optimizer_test.go +++ b/optimizer/optimizer_test.go @@ -2,7 +2,6 @@ package optimizer_test import ( "fmt" - "reflect" "strings" "testing" @@ -92,46 +91,6 @@ func TestOptimize(t *testing.T) { } } -func TestOptimize_constant_folding(t *testing.T) { - tree, err := parser.Parse(`[1,2,3][5*5-25]`) - require.NoError(t, err) - - err = optimizer.Optimize(&tree.Node, nil) - require.NoError(t, err) - - expected := &ast.MemberNode{ - Node: &ast.ConstantNode{Value: []any{1, 2, 3}}, - Property: &ast.IntegerNode{Value: 0}, - } - - assert.Equal(t, ast.Dump(expected), ast.Dump(tree.Node)) -} - -func TestOptimize_constant_folding_with_floats(t *testing.T) { - tree, err := parser.Parse(`1 + 2.0 * ((1.0 * 2) / 2) - 0`) - require.NoError(t, err) - - err = optimizer.Optimize(&tree.Node, nil) - require.NoError(t, err) - - expected := &ast.FloatNode{Value: 3.0} - - assert.Equal(t, ast.Dump(expected), ast.Dump(tree.Node)) - assert.Equal(t, reflect.Float64, tree.Node.Type().Kind()) -} - -func TestOptimize_constant_folding_with_bools(t *testing.T) { - tree, err := parser.Parse(`(true and false) or (true or false) or (false and false) or (true and (true == false))`) - require.NoError(t, err) - - err = optimizer.Optimize(&tree.Node, nil) - require.NoError(t, err) - - expected := &ast.BoolNode{Value: true} - - assert.Equal(t, ast.Dump(expected), ast.Dump(tree.Node)) -} - func TestOptimize_in_array(t *testing.T) { config := conf.New(map[string]int{"v": 0}) diff --git a/optimizer/predicate_combination.go b/optimizer/predicate_combination.go index 6e8a7f7cf..62e296d1f 100644 --- a/optimizer/predicate_combination.go +++ b/optimizer/predicate_combination.go @@ -29,7 +29,7 @@ func (v *predicateCombination) Visit(node *Node) { }, } v.Visit(&closure.Node) - Patch(node, &BuiltinNode{ + patchCopyType(node, &BuiltinNode{ Name: left.Name, Arguments: []Node{ left.Arguments[0], diff --git a/optimizer/sum_array.go b/optimizer/sum_array.go index 0a05d1f2e..3c96795ef 100644 --- a/optimizer/sum_array.go +++ b/optimizer/sum_array.go @@ -14,7 +14,7 @@ func (*sumArray) Visit(node *Node) { len(sumBuiltin.Arguments) == 1 { if array, ok := sumBuiltin.Arguments[0].(*ArrayNode); ok && len(array.Nodes) >= 2 { - Patch(node, sumArrayFold(array)) + patchCopyType(node, sumArrayFold(array)) } } } diff --git a/optimizer/sum_map.go b/optimizer/sum_map.go index a41a53732..6de97d373 100644 --- a/optimizer/sum_map.go +++ b/optimizer/sum_map.go @@ -13,7 +13,7 @@ func (*sumMap) Visit(node *Node) { if mapBuiltin, ok := sumBuiltin.Arguments[0].(*BuiltinNode); ok && mapBuiltin.Name == "map" && len(mapBuiltin.Arguments) == 2 { - Patch(node, &BuiltinNode{ + patchCopyType(node, &BuiltinNode{ Name: "sum", Arguments: []Node{ mapBuiltin.Arguments[0], diff --git a/test/fuzz/fuzz_corpus.txt b/test/fuzz/fuzz_corpus.txt index 7b0174923..59349d3d5 100644 --- a/test/fuzz/fuzz_corpus.txt +++ b/test/fuzz/fuzz_corpus.txt @@ -6262,9 +6262,7 @@ get(array, true ? i : 1) get(false ? "bar" : f64, list) get(false ? "bar" : i32, greet) get(false ? "foo" : i, ok) -get(false ? 0.5 : i64, true not in String) get(false ? 1 : greet, ok) -get(false ? div : true, min("foo")) get(false ? greet : score, score) get(false ? half : list, i32) get(false ? list : 1, i32) @@ -6350,11 +6348,7 @@ get(map(list, true), i64) get(ok ? 0.5 : add, f32) get(ok ? add : 0.5, ok) get(ok ? add : false, div) -get(ok ? array : 0.5, Bar) get(ok ? array : i, add) -get(ok ? div : foo, filter("bar", ok)) -get(ok ? greet : 0.5, foo in String) -get(ok ? greet : f32, Bar) get(ok ? i : f64, greet)?.f64 get(ok ? i32 : "foo", score) get(ok ? i32 : add, div) @@ -6365,14 +6359,11 @@ get(sort(array), i32) get(true ? 0.5 : score, foo) get(true ? 1 : f64, foo) get(true ? 1 : greet, greet)?.foo -get(true ? 1 : score, String?.Qux()) get(true ? add : score, i) get(true ? array : 1, half) get(true ? array : i64, ok) get(true ? div : foo, list) get(true ? f32 : 1, greet) -get(true ? f64 : greet, String) -get(true ? f64 : ok, Bar?.ok) get(true ? i : f64, add) get(true ? i64 : score, i) get(true ? list : ok, ok) @@ -7595,7 +7586,6 @@ i32 != max(f64, 0.5) i32 != min(1, 0.5, f64) i32 != min(i) i32 != nil ? half : 1 -i32 != nil ? list : half(nil) i32 % -i i32 % -i32 i32 % 1 != i64 @@ -9647,7 +9637,6 @@ map([i64], #) map([i], max(#)) map([list, nil], i64) map([list], #) -map([nil], #?.div(#)) map([score, "bar"], #) map([score], #) map([score], array) diff --git a/test/fuzz/fuzz_expr_seed_corpus.zip b/test/fuzz/fuzz_expr_seed_corpus.zip index 0fd46ab3a7ed432a2219e2d07e064dd839d54010..d812de92e3a296725db055e96b7a03d87bc86d43 100644 GIT binary patch literal 2827225 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%0A0F1IjYgaT3_M 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≻T289J~=(JG|nwjZajI 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

JM9;4&yKvINuik>C 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≺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

sg)VaN9Svc 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�^6^RI0?F~^ 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 Y#aY>ak<0MI{)hcP;L%G*ff^YY02c_`{{R30 literal 2827397 zcmbSU2Y6M*whm2@-g`-?351Z7lL|-`g-|4fD$PIwgpx=IO;8a*ih_VBMG!%djsc`f zmlAp}B1M{rfKe|YS?Bg{H&&H3N(bwfbpw+1o5EvqsinM1wkw7jMkZ z4u8#=t&dByGva@4pAtrC*Pow(-5j@N2&_?)*#R#kt1%w_%qNhyg#Iwhy~!$;b4@tL8P8M=9` zx59wHehCBn@W|FTEh#D8ex`kUmw3icf&aPB)T!mRWhh*1Y%I;nes-51DE||{WP)>G zuLe`1#glOr7I2Uz~f;{p095Afa7`~@tF5l29A0z3yYk|CZI*~7uq z30FQ;oUBvp2Ds3Nk9W!6u4S`z{Os|;@fT@&K2|yYa0-EqgJL;` zI4AM^RYP+fQL>?M?LoPpA7w*VLYDuim{d5KsXWC%qTcO3s=InrWTs}obSSN z2`4jEL{TL1tD&bZmt+L+NQ%O>jJ1?2Qh*^5_R{dokSc$va+7H*g0qlY_=GRQn>SF% zt3SVhz|;Z$scHVaJhqefn%|?h6;(u#$=m#BOIK)9RdKTZ!o~{QBD55?*oFgs{ugp~ zRIkDOcL#f+UctGTq32GNU}oWwc}8fNY?(!7>);m0n%C~=_e5zJgw4E` zO-b7#v~0Fi!GpYai_U%9IYCKmBebUB7G0Ov&Ro1_q51%x9QUGj{s73dh3*%gFI+=? z04?7=9>8sjATw{&^GPxOYy8ihr9@~cFP{K5$j9CDuTwJ62r}V4GEiZZg7a^mJv~op zhIuL;HpBWP3>;!_h8+mG63&xAk8C-TOm?2lx{drpH4_}XEp>^K%0`k2Z%<`~HiVhH ze0+NqB_EH}(qA?ck91be$FKjkur=3_N3tBLbpn>5$hkOrfb;W*99DAiNUbNZ9>7C* z^#o?De<#}N%DAmOQtJi+0z*S0cqY#N%U-&LjLzLQKhp>Q6OeiXv>+XJzy^hj1gbJ> zneLX6HIVF(JLWYhr$Q3Q?Rso?H%id1dX8mb>SGgV?Sf3U%h+|o?X?!5JMs2>YUDrz zI4cB~g@6wxG+v=RbCf5S5ukN0$*LMt^A(+=LK66EJ+sx+6H>mv>B&VEQp;EOVS{|T z#2btADEW4jCqc7(@H+nNxmo{FIiC5yy`DQ4GjaasJ|4XV1*8tJHSy;j?9?+i1L1#e zAidp)y9=SbY|%TX7ho{_FF)%knfD-}#4~0OsUGo&X}zynkOd@2PfQR{Y8!S_+aIuR z-qO=+tk7Ce#uT9ZJiwU@N_aDHVDgakVE-!I`+&p#;&SKtR>|UlEv%A&%?h_Fc0O(k znmYqZEsT?f%&IsOTSTb~6}qhAMF4m79#RV{%>w&y>);ca2ZKXS#E(3GhD;P!T=|phk}%EiGZB?H+Dkm2UO9f_Q%I zfi5CR7U+^n&b7~Ab^Tg<&9!gZtwPX9gnP{bTUJL`Mwjk3GB+!~u|7l=o`HlM8E!{z ze(FSCt2pw|hj0}nWIOJ&@}c)E(~t=+_>#r-shi-c6K~!6!ZxG@hc5(g7}6vm&2DpT z>wl8UNn$68Lx`)_Lc@@_p(D(8XpsE}vfWB=0Y&$P<;D-#ksr@1_mfqK$_MDsa$GXH zh9U9kX~`*l0~NuuZ=ZFDbH&aVhc6Vj;O(+EeY-&&WPA=Es9qc7id%Q?X<|it51nX9 zE_6~`Nf=YxWzP?#^?}~CL5jC-*C2l=tqTDpYQvJtV||G-A$zLaCjDv>T? z^|*}Vb~AqW^N=ElBhpo@9ycojwn*O

c!8|2%~Df!{86+vWbJ!2LB)ZXdYKQ|{XS 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

Zn~bhc~CfFp=UH2s?m&tg0U^FM8p6pZ4L zCWEu_SsGyYL5_Hw?b~lVwB4&5U}76X;J{z`!> z1AGmMp{p6b+_#sWKzOe*fd#K7ni0jOrb3Os@V&=mpsdE9_&9JY3KW_&&USVja|M%; zI0iDN>5o%UJ4aK;$=Js7ngjiVOMQ|dx>q@Xc^D4kwR8PHgy>#10wy|3>kivT`fo@N z(Yp;&`GNwNYL7HOD<#)p~yvK9EZ#}TR3xpRjNJzf?SYA1!6?4FE%NtS< z!h1!3J`vzSsW@lUfa5t(_L43`B3RGXuoyb(VAj8PIUgKaulR4`tJd%B*tH+(1%z)r z(%-dWFDmt>hlO|YSrNBc?gjK}I=NCGJaV*2a+(>=I{j(uqoWN9 zBS)x&ep>D)w7^0W*15qui`?~d;0oh_bTa3=?jxv2(Pyzv=)qVqF&{^u5#BGkS3 z0U(WCxc%YOcxQChxF22}r2%2O=QN{ibe_=c?e1g8hK?< zjxFg?{-V9=Y3y1UQO@r!fX8G8wk_HT%>+cB;V}m&TL5Qs2VX!dcQnPGVQ>(7QY+K& zzJ-yOX?i^am#>T9jl+uppZlTMqlxwmaAT^4(H|84AUn7!B$B4xq26Zh`8jZ#jOpq7Wcz(BEtronaRaneAdtUB`B3>-OV}eV>5x8AX%p8KY;L3kpd3P5sd|*-hcX}MiLeqDhsQQY4tnMutWus7X3_UBj-8Y zQSjXS17PY9MN{fYz#y4sE}zvO1vE{oXJYe%tjr^7@))|ROm66GYD-YrY_J%(bJJ}8 z(!#f3WYalr&cVx}*66Q$n>#_n=`^?YKa{26;=P(YMI;x+OG9#{oPXsz3#~*%(PVq( z5E>gnsF|JJbz}na1WmaofvejGpJZM94hlWJcF&dl?M)z+=l{h#O@`ofo?Ck~An^@o zcm>^r9!0xa&TtCfQBhM!^;1)G1C>dXUcKjX2?quyr@ueH2^>dav(HMcxgDXd{p?(x zx+a9Cv)tS)P)Bk3g}X%{G@a$3Mr;%v)qGO~7Y_oM|r0OOCeVN#7JY2faRY*s!FP@TuGhie*qE}dH1!^f5aT?e!@Vmylzj%)=c8z{JquK< zpmSF{=Nhwvt1O0gi_XUL)W|sY=dio@j2}Y5Dr;1z$fa6PBQ7fQEgTlt&ffaw!A(f; z7DaoO)NNA%KGd|Pay_&(9~DZQnhTf1O@%hUlpKu`RVa<`0$p7^pLL*5bCh6dNR$-Af^@Uc1tF zK0zs)rqvVH3O9?iSE^Z>P@Yuz#-E%@^f%J+wC8IamulMdU}$(u^1Ad*oSXme{u%cX z8pJRX;Vo90JAUf?ZmHh_v_>06)8|>>d~wL0cL=Zi88&?p{};F2%_|~nr;t-zUSZP3 z`gM>XVo>=PC!tS7h@^mRFVeF{+gyB78?_HZI~hhRhLhNC`NUq&aVEml#Z&(SHi)BW zubMi*?M_}ey>GLvi+LzIw)>;Pw2YUXo|0ZP^YNvdq4A_<-eJ6|%6T(p&HHH1F8r?H zy|S?1Wo7ssWH3#Z=QLPZN&LQK?)Om`(v*1?JnM@Yf7JQjuJX5AL2z$)Z?5jEuSpZ*+2C-2JL|#w{{U%E6itk0LGz}K4ItuW zrRn=?qsb*rj^~cAI;PH{9_x6R^FKMTBfMd~WxX@}Cf2H60D8t7%3Ih%S16z4f3!Q0u9`?al<}i>NF|+LJ<&8jdd? zG>osXJ5z&RQ)l|a5KV1V7nv5;zp~b*uMpHpTicwyoNiE12b%A^+nWd2JQHhp!IJh( zmk-p2{!q<2FI2BG%)l~9gOZwkoH+@Q=HOH2uTC5PDy_Gd?z zt?&v)uC}6^2J@85@`0LjYv0>BS5=!clSSS27`YtSxUSMMa9;(bFNEkT2%)2|-I0sj zwW#d;hidK$4%DmU%-j_n!WPIu?wZ>=4m_pGaD}m2AFyGw7s&+C(mt!5sCFO>n8;tg z_@+{=dX>@tq9N1YV`s&JfvTp3a#N2KLoue;#R**Q2IZ*d(yxkvyXKi2h$QB2;14ER zz#<^_1l{;kE$$3hOJge_%=-;Cs>MCiy5vYZd_~*9kcmu=<7{(k3Tj;53m&9ophOZg z2VfF6uATELj0hr$Ik53uyo1D};-4L{<5#Z1B78lQ7;dEf`NM7S+(&Sr)GK&on_({O0q=n5i<`C1l(R@;XwTgtbDz(gW*U>0fW&cUxS3-Uo=B9Sd%7Re4bSD#$< zKfC3VnJhX!9g~%}cW?1+UO zrN&G{wM{Q=V*|$!iy-~+fEDp^d<6NQ%;OMkDYifr2YlY>zYOYfH1jNlz06EsbA>F0 z>)F@uyWA4GmqKBV&dio?_7u^ZF8h&#D5L2$Y^Eo~y>99vS-`RRm+c%Z(^$lWj>fK; zw&!fTTo4BuX(M#G28lO6zrP)-Oom?CFc|%forCUd|?PLFU|X;(B$I zIrS*BGEUei_H}1`9nS6N$*Hzb`{Mj_$tI%*IbkaUOXsthKoq zL->?hx%8y$xQ&Zo^ie3zY-c;~{PI2apE6C865`^!JM!osxhHgiu|X-;m3;#EYLWr( zz^(V};Q~~vMW3Z3xv~^Ks8S_xEnaY-Uc6=uV*sD!8xk#c-qYE^b&*BH4~Y4oZ#ZIu@Bx)EX1OY|H=7IFIh8S`LLBT`^`4&3+>n^ z46TO4_^>Vs4b|mg=5mp%Q*I1w6|A`cpe`)j-go$CRRY4mMU3ddjdL@wsagHSn*wl1 zDaG8jJ^< z&ys&)RGg_@5#Y(YMqPp6TD}|ED)8gvG@bg4s~_@y_PE}A(>rz(UbjBd3RQODaV_c9 z_3lZ_OV&Ws3B7vF@HUra^6XbFHo+0xn|hU+${oZ1WD4nZYi__&S`}`-c%;tH+!LJn zZrIwQZn!xG!RN&_53WL2Q2KOR>WMmpUKf6Pg_4wBtY)}^H8sr3>d}_Zf~G8nur!97 zuy(~2&1vGZt4YueBF;P|4igroyN+|F`=CihIE~mQuyeueRFOxop%Z8o+yYf5!#~#; zz6!!>i7XA7nv_31H>W3}u<(GE!uFcC7_dVZ>h(oUhF*gv+3HfC2;7Xv%Ve~Tm06~j zph>t&yI6S9_>3sL^x88M)w;=6rNcL6d@?~`B7H4jbtxzQ$KQ^lCQ&arbF;Wx@4m4~ zzHHsasUfViBTXRI&nyt(-UQ03a_Liz2~CQrJB#U6QGTAU^k zMXt)s^40kj>O~#?)r-r_B4-NhW7s_=2ah&A*uei}s>y$(N^d;{B0f`QclFb#mJ&2( zydR1_7=PBf9kbmhO14zx>}poHoSEe!qPZy!771qrF_dk)N<-Cbd#;+ zG?CgBkx18lyDl9HX#JgT5llq5W>%v%-Kuy9;o zWl4Be`MhW02nwor${HrLnloOsA3qMl((1JZs|3cDuOesLBPa7(plWy>0bj4n%FhseCEJdgQhm$4OSd4V*^SVLeiV)GK8}o{Ad06K){3`k^;?+ zRyHR`JzID}-RdCk1d&8&HZ~|2-_=}Q722$wkQ-^i94%82q2%D^_v_3Dkq|_ZqS-d9 z730+p>jMFMgYq7z|icDhj@Bvr@ePfdLa!gMG)9=+}Im984(EKQrj( zCAF7^)hwc&n5AP@j6!afQiaEiX58y!S0PR|^ZAx7ZLd59Sv^RyH3e8RtIOvr1#0v! z*AjUL$p1f5IS$gx(qz=Xhcuj6(|NwHQS8{uh#w?v8soF!2gHvmVUw!agXU&4Z8_Zp zj&l_GgO@*ef-)OPm}XmR>}{zjsMwZwcfp7t658;D3fu7Nf*BB&$Y&E)$-}#zReuC_ zD}qSUG?ynBtJ}M_`9!klxNKhql-q)coHlF*4e^uJMa$VSA(v-Smvlr{OMddsrsu$x zau7+KR@tX}*ChM)ayE8;EO#nvWT_9IUWF(^lBuyTBy{b{&rjOPLb!STMV~(*u<%C; z$-*dlHn81W3g8l#2Ym|G$bv{xHDNKYC2SkmUN{x`C~kiFx;#D{0)!yFWX;S+W$QKw zXab%t_%`j`EnrC~h@@B(c7v)~uUzekh%O}6nm~^8DeF?T3U_DrNxBcmkw$TQ9PQj8 z{Jgc-I~~AwdyxK(RoTyMyFH{yn+sjdAAJ`l6+{C_lClY0u&}UcdZx+HVp{R$1Z4hD6H|DZ#!ule(zd4ws~1a{()D*Q39B)B^iuK}02+6%HxgoshM|!Ip6BXf>N(5)zH0z7@>mewu4d%0BE!6zP!!JkiQ+RhT5QZfQk)z=`vjVy6SZe1ZjcYZvnDPcriC-@Zk9qr z7*1rcVY%90Prn^s3DHe|Wt!2Dn1-V?Hg#!{U}&#spFGmduvg7F#|O^(4OJig^QDr# zTtC=kz#vDwRqWLXyp#|e6fOdeU@>3gRk8mX|Kmy2@DP<~rkeprGVC~U!sdvaEcExH zN$xPynwXMb-dxSljPc=f1J%;nY$f@XpX#>VgAUUc+WA+evq)B`~{^4{k>oGMLuzEeB9U8st%p!0Ix}G*V*TSB5u8|2WY}F8$ z4VRxI=f2INw3yaSTgd7}<tbGlrE_1Bu2 z6h7o%hH+TAE$!f(C#?{NMP=7tmonUe+hJpS>Sg%t&(s5@M6$`o>$IbfoA$1-||SO>IaQpjGzaALFj_XOAYcAA{UA zBUf@s)EPz5INv8O-j|n_6wv21PclRWoLg?rqA{PN$EAe5xmkx799O}nv7g7haheG& zKUXT=vI&fO!BtP0g%t)?Xw=yG#{b$t`!ud}Cz_Z=@&v$vp&m`yw7TU}WDn@-rJZR_ zLQxR!F1g(Y(30K$M7R&FGTYi_znd>GmR5Elj#X^e0_19T*9{#Rwa5ooEw^^ zIncUQu>Jv2257|sPd*MOw0g9(5Oe}9B^bt{MAl$p$?w4=ESM-jGay;?s(oCpYdIT( zRSzb!CPkPF7&LNo$2qTfz{1gsm{4%!a3p9{KDVqHQ5CglvoN@r=P0~$i;=&0qOT9W| z8@fg@n5amzjdre{*X%s>`R>cEqo621dZM{Fi0GW9+l_-QeIg8h@;`J1#fBQz|&W9Z0=CdPv2WCyKFQ zhwr5HEykO0kCrgEV5Ip z(1WI#m!ZLN2=>$QJD&Ixj z;1R}yLFQqImf99MjC&@)WwO5}b~}&i7U_01Zmzih3qB?I-P1hF;pk~uZBc`oKt1>dJ_5A(T4K{bAv%@z!VKkn=F!s9fgA>W!3B-)(r= zPWsZ?yCg=|5LwwgJ9WMCaa5y7N;Ja-#;F$OTyW*rqK{h|Vl?gvIgs^YG%FtBm=Dyt z+UQkcYZMM7F&ej-!J;&o|Ih4cATE{72CkYVMil54g~E&^M>FhYv|t`q!|dHZx~+o9 z)QZiV%k`zK*f|nrx7huIATpK892t6f-STGGW-6KaULy3y`(r9LgX2e~Ge-up)m=+l zXGLVzKL%=tF(h+r`buw5RTg8XAv4RC=0=(*9oZJVD9(qC|9@o0>BVSP={RWY7;H>` z#@UZIeU&{7IhUkI<3ViAcAPo*a<@x&&{UXok(z`H(oeg3OTeR1!NH`<)C_3xG^%>v z<+{&${DW#gNug$Y&($ zV7We6|JWyEg{5#x?3-YnNiqXjEF>08t`lsN!_8g_m)X6l@FLild!>p&Cs3*~2UVPK zV`87~BZDtnaEu}Lr=!I!4FB~iz zV_j!CN|~m|?Ae(c(U+u0W5${{S;BPw@P0>hTX--@lg6O=42}V-{ll1vk87bB9O+s# z30T>!_5bJ08%|yhE(fh%m1cU`c)$j{l3aB~@j<8nktAuB!LE6R2()7vZ#RIjluB&D zvJ&si=wnB=-vMEX)J@@Kn7)$|_CQ!7d5w2b)JA7q;*G7Sr4~NWFj(2SDzReh4=9C` z^k~ejy!A&f9u&I%$!ds8*|&1xs_p5YelyadL{3tqaomKyeaxk>PO%9^or(PH@yq8> zf*>i<7`l1(j`3LC4vB1-dkyMQNt!eU%@+rG_pA2RbH<$>%~Pc_U6N#J60)%p>*%aY zj*CavN(7TGM`PH=Z53)94{N#dIjR~FB9K#V91K|XHJ6w5*7Si9M`SXe1E2?ZI{aA% zJYE|dtQV%S)`8n<&RQ5z9KKEdB7Oua$HHD6neCQZWXZ?(y7?d{khE!*v6a9KtJdKs z@u&)s)M*^ooCc{2l(jy6y%r@(k~qx*2G!zCx)}x^oSYzu(-^EFlwr7NDgIgBaf#3u z+7&M|AgsBC%8G`?x^#wvM`@>-(Y#MZPYNvWJ*b%-XmX_|U4UlcD$Qi|Nk{I$fg@7b ze(Kgiip$H(U9hDdZng?mc+3onomcYq`~&4(y(rBbE%v|c{Z{1Gz(N)4+isQHX;I>J z{8iiOK6Bpo1_yD2NxC#PRD2F-#H_!u#O17S0lm}DDalF&|C7B-Ql&9Bh&_|eedCj2 zHfrPd2`HXPVm0gvCehb z@+K*Du9bRj%YcYYlBiksvYeqdE!7fo4Mkib$Q(mR|6EUL}d8l83>cXsoD;Go6>Yz58ffqs{# z1lUcsq&5@ls+`sw7OTzFq8u}<;Zl2?q(mWYK6y+O?Ku&g-0D^A-=9IJ8bVT>F@LfK zmCrX(&$s!?vNm9qJ%l7V#BX|}1B%!hHokGX<%W__9t=+-T6kgw6W zIcvzKU(+?U>yq2=(3g7FX0{1x=g)lO1g)GHI{;M=!Ubp?l*KZGxwzSvy2T7 z<0>475+{V9HRIq$wevSuY1mha@k*k67+)l^;(4gq$57{^P zpWAnYSE%2yc2k(v%KV7n)s(iok8;HazqZotBiaOTJmNYRI#ds!HVsdxmO3{c^dIg#^AvB;t zEBSClnqCl`lm@IAGQfG>am?p;bV+>)g6nI$!znB$IKj_+ynY1)*H?H4IGeCI!H35r zj751s1fwnwsNOg2+;p^D$YoOIy!n@JN*xztsfBGPF0mRn# z@9rJ}q)ENyo%zrs`X1gLTiNaj_&dTMTJ0Uzja3<^N2X2AKLO=Gf|ikEY>`FRR5m!MN~nycoJIb(7?M{XwQ)EwZ7-8HN1 zs0i)$rpgGF#d&hGI4U$O3#?k0`k`Voypl->Jfh%!xxk~QG&~ERFI)_$^dYhxQc0+LQiaG~Z z$&*m__%_6KF_tNFolP%GsAD+rfBU~ixmqt`b8~YgwdOW^y)p~R)dUfnOmsuN@66Td z?kxKWVtdDQL-6Xv9^32H1c>b&(T&9|C-%5fr}iN-5_D{CJ^?kRX5tSIP}~uo0(C%x zBr?BU;w5OecT8t(J$d*IwA;Iq&gHKv8D|!~vIW}h9n-n+#yOOcwdak1c6-Nj z4z1cfq;c#8#BxFLe7;oflFzy^$r%^LI`1ox(_b8uD* zl)2LEH}BtvUJ<20-!pJxJ1Wy)z7!X>h?mFogj^q zUBTu`PHQi0|7;U-GU2i|H)Jq=4@z8yQxAeZ&H>FL#A)}i_{+nf-QKW02+}cYj)tdE zP!r^Fvfa3){5<}%-f$$n;X0FKs#)Yr!A7s3M?|5~XAwi}snDgus2SIwM?_2$p+OGm z{K{tq;$nn1b)DfdHYyFtv(ExbK*PP^xq%JhJNfDGVTkC$ZXMCpNx_nzC!I#Cas<(w zh&{_-Fz0CUasP+N9|Y~3J3K05`_k3l0d4oDk>|EEaKQLR#m>N)9zjQ^*scW1e+%JU!y!y?Anbxe8C@H(bv3QiSLkVg;$+fJKq0QgH zS4#d0oEu8eh7^Y2-t-S_0R|@Q!x;ynY7k1$&kCcaA@n+V*!GTw%w2dnc zvAyXXOl*ZgtzLI31D)bc24N)Z-3MGj4MEF?- zyRtZzUkSkQwSTDu?IPQBz>rJhdBw>KIB;@JZIQ^CqeQEb*T-uhB>nu8VVr zMn?*Ef4Cq9x%9F{KyRDV}WEeRIlul%CGGbP8Dec6_jQ;F+9>lbVJptH;}C-hTkvz|bIXIB#@+oIOTA=#2JJS!Znot!yYw)n{ph z%uld@WFl_o2lkvU^9l~EH~i;A%1`UqBOvHBAy+r_RIzjki!KA$91^4YX6ECS++^+- zX-6PbFY1#<)z`07gJ#Q?r#_>|$;yAc-Qs#Du?v~aTa1lRM`F!Xcl<(8 zMkm}V$GFPNewi}7`9|2M8`hf%?r#c}F7om~RU11zl3$&(_@-mn z9SP1r-1WoqG(f5uN>lM!uqe0OT>9BEa7SP$O~Ypbi}P3P+HqxG(!JX2JMasnJYao+ z)uN(24M>V%5%MM9q&dJhHk6Rpb^tu&`E@O)EP-b7C{;lDeUo}0K>JBKK(^n~m?|Dx zc_64Y>ios}wI&THUFdg3T&!iKq00t6QO))z_Cst^@t3T2c|=6^u?;6W@PF~nMNa1W+vcRm zHgv0Te~VYzW4GVKhd29>*i zY&1%SG)bRnIp48U+Wi&j+FU}#jV9y4BCcl`iD|$asy2wmNcDw5r&i*!g zf$H4R&IBl}9i$N6!r9SBSC0Mh$$Gnw6W~D^v$o<5g+u=yD$P@9;B_a}1#M!xW7%t> zFqE306ySMtYx+Fpor3j&-UT& z&*hNwKXb41KRGE9o=p`IW1=e=;9QxuPa(D!#h%p&xCqi}Ot|YZILY}#r~gp%LsR?7_$*T3QvT%Km6xF@7UA+b*Jv8I(6B&f z$A_KiHu^#JE@(gr7udPrjg11}oSg$Uy$i9usQhs$EQQ?2ys00e5KZ@II-W0T$<2Zt=%9vfp4R;{Xt)>LH=rT+tL{E~lxJIK#tqZ9`XaM%bmK&(GgdmC zn(!8S#S8MA;7VQ@`{VY__SsaK`@-Lzxi9S!@`y7RaHcQ(J1ciJr;nTnY2rU~-jixZ zmPwnk44xZhby)&^>aseUxtsYH+|adaeWJJ>JaV*2;|=MXC@tLFU#`E4@)k|~XNEUp zBoA+xRqACg^dX`q;o>_N?KwW0Of>3Qx(Qm?BHVo^u-#YY%t#cz@87piBmOU*dfj|4 zYK6A3IC$i^|4b(^ zLybH1l>_8Q@}3>Z$Idy6(Chys!q-mz(Vjwxko!8a>Ngx!K_+eInP$6|X^rN3-6c=e}bTZr!?mH2?fAUI6HD{Mfel6{Q&w2Yp!kTC8l({~=4UJ!tBVf4IZiLNlaHJx#4pgL2`~d2`LO5S!pv;`CkHA` zJm@f+PxQ=7Xq+9>hBn1Jqvo9^B6NI4&7kuey}1B?1u1Vx@O*2>x>*7A@fk|~n+c^S znw(Jj3`-d7GwSb{RBvKl_yKRzhP7p)tRU|={%Adl(nxK;!21yX3(O>IF0Z4X@b~G_ znb6W0;kG`vFK`-Ijhpf-9-nT|6g5^fiJ|xvLB?1cSHw62_CTeI6X4GfY)c^{xjTw4 z2JwJGN{X`^=B|OGO->o+V3-XS`-<~NEL$*Y7Rnd`Uz;)1m4w;LR)2-&Z8XWDaDJS` z08wg^uZK`zQ zWv-(*E;syYel}y<$2srTiwjFPJYKeLv&I{mu@`kxHz`r`hvm*2O3F7se-qJOuP&4g z<~=aPef!mOMFZM5)t|)(UlbLkZoTpT~^lEa!hxu!ZR*hHgIKuP!JT zuytG9rzhCv3DYYKUD#|Xwv77j+b2WTzkx<;lZ6{_Q{#?N$EbyFy;T@YfW!3SLK(X< zu=>oMvD3i3Jxs4GbVr6}-^f~UERZdP>F@n>fg8)nj{ywlRJc%IxPnkS?-rWv9~|0CC&w{|^r3qtKQ!(}|5R61_HQ zhN{gOF57)G1Z{Cli83x}Hjjb=TGn;5lE zDJYLdP0I(S4Pkm2p=>cr%zWZgF2xJ1mlXL2T~rsQmlV1_V;2?Sm^|N<+|8RL$E-h0 ze=VSJ%pw1#>^|Y>BPTLG9+@kzgDgFtj5?08s$NX!vKnXAi1W|Zp{%Nx6S@Jz^i(JR zKY37A)oTf5Y?M_8oqB&d%Bp$^p*u1(d+d%sj-#xqzZlR3F0!g%&nW%4TYeh?MNXKOwb^7fzkI> z8s&$eBFSk%6_@&-?3fni;}GFfJ*e6tt!f(*2w`dScVF%RzI5oAN(@<+`~tc_OJUou zrPS5te*biO1gY z&2*SrLbX-a_A3Kb{dy$l6_^P1x9~}@s$aJ+Iot)!E%eGf3)YVdIs#bHcBI0wqCM~mhE;5D_y7lhM){Xf#gTob# zuGSrix?H^?Pj*F|1GP%(VYLy_^eQ|TDyw128s?twqaQ+8Du4Z0Sx|><&HjtOKv*h& z4OnG*^6$BAw;`+u2i?fABBsEWi_Q5Fgr#zrSzF2{!1+|i-62m_Ax`KYk97?hgH@e- zI$Ns65SLnX4RcjDbnBO^1at$n>iYSV2If{MoMWw>c4Z0+=jte|a_pVl;|3s8^};%r zYniD^APk+^;3hhbUt8 z+Bnx}vE6)ixYEzM`U}LRvzFs39;k3A?JTsWslOA?WiMM=5AtcRJQa3l`k^Y&VtUnO z$ZG!DzP0@)XsuL#8=h=&9Is|7_?4ICqoL7s1~a48;am6ZihK}P6bM~W=eWx74fyiS zaKsD!W3eu0pog;Z{*_z=noDOfJ2j(L^&zv1^oO`~8gpF54Smw(EMzBMx%>)qbv#yQ zCk3y*?1Wley?9NymJOLBkyZWe%wXgJy;jW)Rq1j4$5r!#xYU&@_9zkxuw3_F!2r{% z(p>ho2Z1nnV$U)tZX@ZvGlNy);B9ik6FUy%0<2e{N!B`ttor0;Q&Ec4i_To2>_ob8 z8q*OBi@SZh2O^95<2ftvB`|i1L?v4GE4dcJ;1!JUh#cD~(KpD?&tY%7SF6`TR3d#j zYMg@lU_#XZd(dR^3Q!$+)!uo<>w*8GH2}Si%p5beSL_?)&z4u5F1T~~_}>tiScffO z)eD7cH+>HgSbtxgWpP46>|plpnA6~8exE%?F{W3I$+)bdDah$wyju_=6FF=!q7AEQ z3Ubqq_tHXN5Ua3-tl++^)1e!9sVhvcA2WT?x$l7ZB>P-7%Ra`*GpEC|UT<9k2+6{T zLNZ_XkMJ7~l_1=iar6XmZYfNETOIfvOepO93C}XUMVDoSMF~oJ%pPt(!B7i3zi?{l zoqz0&DoIu*x*<+^{tYZEQ`V?UrGN7X@kM~plzy-xf^`}HUPtksxoUJWfiT{ z3v(*84g`yI;Y4kj+ZVtvemw1~;(Yg&|4G#_T>qY|946)ufTOr}-5+m3G7Klm%zT;f z1ZUY1c}_osz{J$Tf!QXZn!Y>FZRHD?6HZi^`I-;4RyHok;%9T5Bf4+>p387VMPz$q zPPe%DE_Q+eBRcC;s?|Uq5w3q{)*Mj|Unjmx*Fhe>abWk{=3Fi3xR5J6kk~pX-+-Z0 z>R|h;AWMep6==?1;*v}|$6|e#UnYUcz4UH`CMPIartjPh(V%{W6Gdpg!ZjX9RjyQ- z;YFDL`Jc>My(mq1rhaUqt4>+BqZCuJd_?=fAEF^33e=2WBYz0QYqcs99{RA~!T;QT z3vmsAJB)uq7qjWAJk3y)eS`nGeTSGY;CEo$R!b^b0jT=IiNZCP)68F#V(b>~R{J9u z1YYD3;W!V`HoyL0^Z-gYQPakLPl6q4N`QSca?=-Jr6!!HYV+;h)fL2QCO@+@+t(1B z*rQ0`YBQdp)UKnboe-00P3mCHp)(zQ`QMt)QE4Db+hlLBZd`G8xw0jOL3rZCMD_(0%e8~Wo^E3TwUS>trl|cFjxf$*Q?shRA+#yD>o~$O}cB3o|~=2Y{1qA z)s6L))fZKOwi4$g9F&inV@h56#N%ubmPm91Rt>ffO5Xbwx`4Q{5XW}8l=7FeRn1Kh zl-L=u3ykR|D%b;rg5E+)$Op>=r@0(L*-U?yQcyc9;n% z^7XZW5Ba|wO5t$5ip`KBpFQ~N$BmmE3=K~+qgzSm*}>|cb-RX`p}(BY2UAP z5={p}SSpMCxNb#RB!AU-;RpyzRQH+IB>n?*u zUP!wtrai=^7G48abwj3^-`t08pc5GhOh(pT{tL?JR8bqtKCJjUhOGUVHyfa>)Y@x+ zDv@x0`waBpT(}r99evew9&)?)O=K!n&u0F9CAxC=J5Ub761!#wi^MQ(^X*1DDjUo)l496%S?59!bqDJF$s<81VD(qWxpJbag(m4o_wyw+y2utUz5Uq%kvpFWL0xvg?)ZNWRIJ)8z-raJd(F8TuHC+@9)S~X?b23Vo+7_UaPnt zAugT0P*t%qJaIC_r59c(f5_YOw>v1#sB$)z7SOJDnY_`z+e0SLccp$w=ic^8ZJ71H z-gBW3L>Bi9%J!zwe6RHOZSUL1|J{tGQWzZj*jet_Z)m$ff8U#xYs`IgwZVc3bKYV0g2jtxeTVmku++6Hw%cDqT@rhp z{Zv*6t7Wm}1Orxyg)&KL}yAuDFL5k;as+x_%0xkr6Hfjp` z{Zu)d39J16(4`$=&_+@VuwgA@gqd}@(tur;IDSxz*{2$wf%a0l%YebkXjt*AZ6Pdm z?#o~S7b><{SP8;Xxof~G-rY9$KsS^UsDd^=XvR#!>D^BE6UU>TL4S3c#RgU@*>^e~=`1>tsG4zze6! z*?M=4_ciZYbUNcn<68|OGO-97$n1iaqKeH+vgGUrk%?61$cDU6L5^HoVQJrVkQ&&@$-}?1fF-i)`5>2cZD0OD8?z+ zDp1R1aRG}0cRBjh7oba*=B*k6$C-IoI3T`V!S%=idV!hC)VZny((GLH9sh=79Wp|% zC=;mrYh_s>d>|~Ym1=Dsj>|Kz>|DKw%);hxJSMjY{5Ux#mHIkZ^t?+MIJ#mvk;Z(Z z)wGWC^XTGAPB@NrOW#Bj z6C5xY?$hp`J@Rtt6=g@qT(v!a{ceqA$WDU3%dnGO%d7nMgvIT$KumpW&N0nK$r1Ib zHlIDj`OE+0Q70(51SVGl@IJwTJ*Ii(t3WazK@fCtY+GH;;-87Dq4h8F9!I+22>q31 zMl@JYzZ%f~*5e`0wD3>O?nB^@&=+IlN0_h6TAzR-(#|c<8ILOPuec2Xjm&QE*P8cp zJAcF6p4l4P0q*t%8nxqKYO6E88oIG4BACW*0~DmTniFbF2CEzq!8C$fJ-d>K->%Af z(RP8%aZx&S99JvGz6*1{L=7N81I9zco?fWQBQa_B25>GRf}jH9!2IHKE8y^iu2`pk zeuwxX(=`#SG3yUw;W&=`wzYkJdZixNcqlm>6~if2xpB=RKi= z8h+%Gsn>=1wNho#wW$b#V49i5}3gvyfdkoZ$^Fyh<`{XxL#N0_5-4i z)$_}G!v9d?REgFT&*BqxW;b2u!{8kUnj-Yqrn!CM;E}RT#An`#Q!Zd%_4a5envRQc z*3e#QA=)jUJ%U@#|77P7L}&5{@E6zZ2e!;i?qKZpF3)QfW8dI^Zr{Ve1mK**Cc;4b_Ky)w;hFnr6@@h@eK_&Yt6p$Hyb=@AND{d=cYwlupKekDcH z;C@|wjrAyJ=>9S2xAXkKR|%)rM4nHfr;&fk>5pAO)wu4F6D?v+jz8(tS{2?tAsU=D ziXdp&r1A0dVb?&g?#VIuqbqh>0Kv5>#P${M$oPcJ^{ABKUc1phT}D}3e?6PaN8Be& zhUUuJB0)7P^0o0Mw==Wq^=)pJvq3h8+fi}aM}66q&ye_mS2tE@TLd@T4>s_xb38hr zd8(&Y*%3b=uy@X)s8JA}*JKRWs=n}ejrxCt`Y?-~*-o!@bGKTT?YfLA-v%7+j*yPG zrV#yZ&gZ$w3`-}yt}nRy9dBOwkCEN4ztBzjA+8~qtfq=y34Wzek4(_SS==(hU(S1- zViSrwo1&U?JLE?!BWUEz&jj$DX}0%|b~@`!UUArtBR5xx(&Kq7_+_I`i*w}Mk<~6| zZlEGMHK0m8yXCv@60}plDquOm74U*YT^E0ePTNHgG;%hmI?>MGCwp)BOJI0IKqM?b4EAW$p6Z9f<-is+v`wZ_VVR>F1YzrzPXo3#br9T)`dtE7N>5Sq$Z z%Vu!SH)7P|0?-{)-dfPs=8z!T{tjPHf;Ni?_8e>$u&YfF(5H?~cnNmpBO>%Gdm=id z*TDtyu=qRoATpK6+-T#1SSL*ukLujqP7yMng~=K|D-OxT{`l z?ty$j5XrgWs;Oevtu$YukRa&fBxE>n@iklRLSam}_{|MkVfD|aDyD}vd&6pWqzh!u z3hm;w^vRqSz&cK=9GNqG<{M-!K{h7>8D8Mu;c3~*5Sd!2 zd2WMOPi0viaUR74K{_XF27=O0eotNoEf$+1`j~)6d|DryG8rO!!)oJBWoNW?8rSj! z^o2L1W=F}KxRH4`PlCAKFuH;&0GN2-?nCGaZ}@DSQgd1y*dyN`&|+^G%?_$Laa%Ut z+8bIdXs3?~;{co!x!USGa-7250# zyBRP@9G|w>^bkUO!)^|(2K3;d{&%4}yx}*4RuV@*{f!-<&EBw^1FMOn`L2xP?Os4; zw$HRBNZ2ycYS$V#}?oVW7{v{-mSpO}pc z)t%(~u>QSwpvB(MnjHgo;?8>S^M24`Z%EB>)qr@hXz&icOXAomi469lX8RfMB6p4N zVs3dFn}v$gQ>Uxi4QMwagQ*-3;wzsDY=Jvx&^u$1ga<;+7%^Z$;+WrSWDCS@g3e9` zR{4^7=)-i-5ma^?7AqkVo;zj@Vz!99l$p({H9A*%xZfBLxOT%53-mY4&3?sz6lXThIBzc-7O%>0FaXbwIg-ps2H* zV7#;D#GRG#bZ>}DWpoN}kRB=#{~h!KoxtGi@~+mqc0*KZeTJ`v4jVXc9`pgVG^g;c z=fan3VFyIGYt0@rwz3IYtB)Ip|CFB5jQ`1XS>*Q=*{i$;*LX)QbP-x4StZAQJQ%5| zXJ;-$36ZRlGhjg<)pFPJHOo2Nj^bbn4=XVoW9UdRL@g4d?Q& zaUGa5F`gQKqaR8&dI_9_tAtsm&ptkcm@5V?W#+~?R^Ff1sR&B~S?U(VuLMwAj`3|; zBqN3q9tyQ10G+a$R{US~LZo@WjocsTWo#~o@^ikqu-9h z`2^vTHQNnv*?sGZX+2P2k(Fsd=(3Q>)fb{isv^Va_13r&>HDXNzQk*3xMU7V`fW z85;mm=@l0&if4{Fuo|Tp!u@LYh`}ZC4{vT?pMga#|C7tDaBYgDWr^Ft+KJa@eS?hD zi_Kg#U`DE}ZO}2zOvD4SxGack^Fg7hkvsE6#9O_nOc)HNVmJ2m83XO57hLNsfy2SE zjVdKWV9_1v`ft235cqM$)DT!CZvrsLG-o<4Gfq2ma5*zd7x?Lb*-9rEx*PkO<%B~= zCocn5X3_sOn)NAk1f9JM7W8&^x4!HL?WIq48L(0!ew&%PYdYpz{wMQScp*jpI^Rw% zb73!fJ|~i_9y2bJ2K3$CrNnmRQ|V+nAqK!CcXF<*VJOv-Rb)ZzwK^pP9{-wY3(8_- z0U1XH>nMTUKRN~7KqoI-$^=wsv|-mQ6j~8<@-kq>4`1(%Mv|LI!i{Qn$zia-5e1_Q zJb{i7L92@g4y@LR+DGF5hK`_-G8}Q>6`Qf@=YX_jj(a3Q9^ z?cmsQ)gi0J3|uw9ju)JH9D0FHVX&sXFWbX)&u zg?42K_o~^6foc5VdHV0G7i`MUZ#d3yL`sy)fbg3yr#lKQCo|cPzYtlD{k3zn zW}oHkk^wc+0y#x4vjBF0z0UM-C9;z&65|(aunPsi{S~X9{rUoha1>P~)`qdYIKz=CD1Zr%g_?oZrh7uyu1SiuyHAvR&5y|NKRG=_QEA+UC3AnD z9UJ7XH zzx$MdLq;vZZH&Wp3U2#s?=(S$jc}cs84A2$^4`f=f-YW&p3U{){7=$^xzm>C9IOdb znuU7k7nagW3<4d;#4- z%>@Q5YeSs&zWb_m5U3APgsapncXa8(H<4K?cS28S)8$u?8>0wsdb&Y#XFIXC+)8W& z&88*?X0O}HQsL^ztz(ve19ee^2Rz-(mX7uc@SkgR&I=~lQprq_({YZ@;o72Cow#EDhszel7{RQIT{jv3Yd{}Pee^Ql*BI~|5ra1L)NFt0Y9UYE2 z{k+w7#PA^Mnwjw(aemYRpFM5Yx!@M1s30=Kd-t~Qw83{A&A;CMEI0uhMb?DHiZ8%x znmT>ha0L7b)E*!3Em8FYvrelQT8U>)MiCTLPG4|HbLdoR`hbA z_e!8bNw}!Z4O(d%Qx^!|0&OPK-msa^_ngT#!-Kg?z@-vVWWAW%v-HLI4uyKz)W%0Y zAAy5P<-FTRz>~kS!l&Oxga!^?Hn3& z{papqW<^{Vg(zjND;<29AGU8n{v|8NEIVOea&O*{OQ_zH)ng3Y8P?On?^ZyLB@4&c zM4kr(Sf|dmxX?Vra>A`_Cd(~oWf`&P?D784W-7}qVD=xUI~L_XTNpx9TX-8zW&wlM;G)Az4n^apzlqJ-L+8-oz;NZ`Uc7wWhtfKp{xsoQ0thrQu4!&Ot;nOr|#fXLM9 z%q^~fYRIomwhpzYDAInn^n681Y-R2be&j1;I9YdQ8V+{m z*7%I63z4bo?j|zWMNG=s;xghkS$t+7!-`#ZV{_P-lLcrNv{JDztcyGXZT6;OV~tF; z!~f^(I>W0fx^C!Al-@)LJ%JE%b8i|V9i*3p0MaB#fY1UVR6&Z;RX_oyBMJi2i@t!M z2q>M<5l~SOX;P#p{hK-WoXp&rm3#L2e#H0T{jtuzd-mFU&&-;chp(d?O4gv6Hfx0> zSH)h9q0LU{&1?okc&)(Gq7d2%!&x^Anyyb}*?-jnc&c(~bizJ{e94)KtSA06#V4b!>=^RBW?p2CdlOwHe}TSmQnG6z>g6h& zG6x2R2sZ!AMux?ZdP~24Wio_z!fGs`sZhPeRtW8c)mTK6TBdm(29h{hnMlEAD4LPNqcOPggD%LG?9C1htK~Sxoc3R2{}jjgPdl$l~(@ z$Q1Vi1K(VIX>4OSl4Ob-$0R|wvHe6ycWWeNh6|f*7|xm_#lZ*r4(W%&nJj5z%{V&K z*oA3uU7leLpiF52YeQ+{nK?a{?|eB2t|UrI8Hy(W|5B@O2}hog z_UkFg8cPDh_KiYgN4^G)^O_y>)0=_C-_C_Aie#aiiL86Mr>o-o&}JvhhL^%MEmdMI zM0P@Kc05tHxkR?&r695sX2TbOTLf--86rC&Haz*(?WOV25ZMW@;e~S>KRvk>A`1fA zM>AZdD|4!QkX5XO^iA5C;>70I8A#vsIKF*zR91bh-7U%0{N)N`TR^G)H(xvjG|UV! zEHrgkYJ8hq0a@&SJ-8OnHF;xy-Kz|jyd1~4%&x`Lqqplv>wbgC?`7Z9 z%M!EMN%hC)zotycbihjTqS<87PSONl+fuvOTZcFGfi^qI5_n~+QssZTL7SbV3AD0R zuiv@1q0LUR1Oo=8Y1i+Q8bN3$X@W!RaaS$Aa{zRQlRUwowITfa>as1l*er_wi3Y$e zF~vWrlN3sS^l0isx?9-5k5ZMW-8M5x>eJ_oC8zMX5G+XD>ktetB zaS73btZg&K56sgS_ih7Lmf7$*p)_9Q8(V4L1ZcApO7o>SH7g&OH|+&fr$vdfp|mzj zzca91eZ)MnrpDf0Ax8E^MyCegx)juL0FWo_jHHZ-*jf_J)0g3ZV}%q zE)G2R^XJQL#_4ic22QTh34I6g=a~7%aCKBoy3V>k4}O8nZ1W2)hA+J-Bs8o03on>r z?PmKpolJ1)3!vRt_N-JV#B&jcHayoh$p097vo!LFG;6Tw$0duQs4eN=73cXIOTOh!HtX45uAF0jHy#L8T98-ojNJu)g-C$3U%`CNzQI1BX4unZ*X7ma?Ce(v*HgZb z(7$`2c>YiXPE@|{@9Mfx22aidd>Dd_Co7YaL+d7_7#qs@E4FPz4u{buiP9cTUW38;eEs{x&|((e|JkS5AYZFe>7Bo zDT)mNIXf`?#{Ih|4zoTYY39X9FUY>+45R}&MWlZwLs#X@eWaXKRpbs|1e5=G);Rf#vuce7a0J@Z1+O(OA%RbINz{5sxv` z#}`9mL08c!p8;X@$=_*{_zRf)&&Ort#9@6S!{IJ-=-h}P2G9R|J|V{2CO4U%Xe>uB zKYD}RHf~Uxm&>qk@jsvM+2#^UA&9;Qd^aY`&nf!DmF_U|{cb(bhafErmFkrPeu~_E z_4ll6iqv zuPNsn5f6Uzjq(1HQqk8f%Dq(A*}KE&!o8#vE6oI}X{_1RM<4Uj$p2)|kZ+CaVSsbb zYuHz>t?{6V6J5R6H#s2{9&LVbXLw;WeWa`R3~2qC^2xn_y$)?AClCXeH>|3wD{PI= z4xvSC*yJWJG@Fd5(A!RZ4_-oJAwupr3~2qB@9msf{)IM^bAcBa*!FsnfuAf zTwMUp2qgDj`Z4N{$T!NduGcy&W<<8a$oJ1QX~EkV{wI@Mc-w~LNebYK7c0)TvWCn; zx`a<}(_8ntvm31d(6xKs?pcksSHAD;g1F=f2E%PVc$gPgwB0W;K{N|te_^Fk|{&i9x z=yw(XC41eZZx?k-#aIPgQWjL*zlXsc3YC0{jzZwlc)Xk^ZX)% z1gzZDhlBf`!FGp5k$GONN%N|$@fqy@g|?awEvIrl-EvT{%8iOx3B69`dpbB=cj{HB z-yUeYh;jev#0$@MkAT;E9H`h9dfm2;Tf8^CzHT#m_`Kr2mJ1=1$kgYzB=IdZbZJMf z(@E(n0h#*3ay#m4i-_lQ*WZR*O_ubfyBdT^gOXoq`fRVN$!y{wmORYGpUz zO)aTf((*+;9|gf3F+a$==Ba{b9ai`={n`O{7+K_JSgxWj3%ma(G}#g5&1==vOV!@a z)$1uwU23_Erc#~fPar99(C{|ZA!R7?L}O5)iH2;ID2IS8PdDmXJ=9K@w24FgvXgmUf1x7TmgV}78v1`HS6Ww3rx78i^LYSJ)Z z0Tot!<@o?c12t77p?eHIJ2CGTM5U($rWsdBR;i%pM>uBmd>|>&MdxyQ(kfj$0V ziA+GQD@ASw46e$BP>f|tIp4G`C=>E3S=pDw?;g>s!>bqWy@|X^mh~ku{k?W7?CXlJ zT!z-tYcG84zUTVp-61Y@X3nhzqjhK5&KN|oa5{6D>>f0XQBU{3iBbYt&&Lb~YS-jt zeeOeh>C9zQPhjt^Y+3(=z;yC5U{KWyeAK2V1g5i>0fV7)&-^<9h6J6!P!Ha}(ea;9 z|12WShQQiVd&iBQ3W#cC(Owd|pQ7}(qjk~mCkypBDrm|Nhm8Fm;?gM$72q{GWd<(> zxm{#Q9b68>jyU_P;70=HLxnnI7%fhxTtguK6mAR(o%+ttftf4dwfEje#pIK-5fKLFIa%+oib)?E<_8m zR?dXhY`(er_9|$z$d5KHzt?84R`h%0CN070nTveo9Jd*sg0J`K^Ersi9x|5=WUbw4 zeyswyBgpL{E8e^ogR*(3#}IHw5JM*O*{~QyM#(!BZ$dAV3$lR>TFR?M`>%(gL9WOg z84h62O!=Q$%bzlx#rXNBGk@t;eQ<40bnHjST(V}(7(95H=DAn5uSe`7E7nYCjeW!W zWkQF_Tx7W#2ZoR61`WxKj()kwYBeu1`>$F=cAXeE7X=*owNs7^mkH{%Ke_@Ui?FcI zMeq!Kw#8Y%n|W>*S**rwMoR^waW`t#PKq@;TRuK~N)u?a6IOFz zJrlijbYOY3v@J~b&uVpPyV(F>efVGhOAGJ`D~dUKx8M=YIw5z^Jh=80EL)~tUKf0$Y>SkYMCw*!7)-7`Fc4H?(fOau`~DG zvDR_qK7%YlV;@i_BxAn&p*N7dxX2Hva!g)Qjn}l`$?`{oJ>iIj_6jsBkFrY>uoR`q z#=rkUnS(4qW6b8zT0b!8t10Zz(LQVFqBHAXEtmq6@vy^npfSOk)X{* zmYs1&Gc}D~OkVl?$OdRJxo9(FAWwO>eG#}q5<{-p1}>ON#U5$c2&L#4QUC0H3>84f z>J^4-FXY!%xtAHT?&Tl;xHH5`pOU;x#4@Kew;IUHSb_r^h3<$RFIpR$(n_4P9c`N> zxT(sd{lI zT8~wJXy~WVVkg9gDyc6XkNOHCiycpj#egG;abt=>Uyv8%*ysTT*5JNXgQ3MvIsmv( zTWe=>XK1mL9ssDD0$NWwX)#2ajD(Z#n&a65>xEYR^XDE2?S$408f4ExBMzir?=SOO zgtC8LgRSr!zvQlt3ZK*k*asV5?o_8{qY^j2j@&?3rFlIJW_?euUQUJ3!Vff?^)74W zz=t10cQ|1+Yqzv?vE;?JcObA6QZr!9&leL*Ple8K!f6hyPoSp7uYL@nozR*=gIUg- zAFV}l<8bnwbDV!*)w9cmiQp{)cX+syY7MXI{I&0i-YCa~JE1jPPYo?m2Ho{6J=yD@ z)htmcJ$Spn0~(;LNtdY^-qm7l+R)SIkPqlWH7~9nYA-#0?+QeALTM;gYd!qqO(=-z zVl{3v+$tJ#b5|sUcEV}AKwI>sESgTUlU&4Ga<{+Re* zSu1tQ?YGFuHoQ*1QA?@Uqu#v#DLC03PS&sWO~2Vu^G5L9wXpt?1#AX3ym9UGD?vY? z`bUA?t>#-&k{DW8Kd|lgO8j5SeF)+9YBtOIeIcQ(`RynA zeF!hN*gOD6A(iKr<)Gi+aO9&wmg-Z^)Dcv&8)K=^rrO6h&VyS-!^sz~8K8Uz%{=wa zNw0k4z2d_@1Uu!@#oPWlpQPa3Iur#S9&?A2HErDHj;_wColENcSklT(vV+O@uNk<^ z0Vc8txr)b*m*a%to5McHwyn7oa+42x+>=k{$)2ZIN+#tRj;g<18iCq7vaYRf^3cST z4DNv$weM&M1gEy>Cb)6;wd(V<&zcnkmtTjIFJ$YNFu=O9*t_?veqmf*_Xw0s$T~Oa z3;Jch56WK|4=yeYx4)jv+}f7V`Tmk>{p^p*je*uvNiX4BU7Co?6Mui$k6X`2z$Y$k z%e)nr%|p@}g;Z{`>O|{+xVhT(Folzkqo*CD6$%^XYhC<;SH=%S{w6EmB!BR`a#Vl! zTYhE(ibt~iO~UuyX`_DO+~&C-q7fzE*Cu^I?+EJ^Is6s$4|VZPMhA^y-tnu-p=l0T z5+~t?Kq?Es_? zz>HaM#*J1e9Y;CI2;N_yr?bXU>(;>GwM__8I`e{~Y*wRs{$tkihTQ!N({1yCaSMmi z5VU*o$x7rBvUE=P+{%%n8TIU*o)fu*te+F${4PE=etgfS z^C7&GeBd2WG_S35fAuXC?PNKfa1Oq2eExt}wp=0fvtBWts0uAla+P+JygWht)-VfM++8Y zT^$G3$@FsXx5lDnJ&|7gB>>|x1cm#PYE_kbWLV|psn*j`#ZvKrfc?X3ASyjh@^^WDi(+8QLy>x~% zSdjXTuiTm&r4I6aZicYEcftMxyq=o6E&W`$q_Gp_h7+7yk2QAMrtgrK{y7RVhO`Z5 zlQFa@M8|b|ii0?2?~4*&apg|XQ`;veSE1c$`Dse~K|>yWHCv^UAR5@?Vh-#@#kuh{3YASSNJdo{!MmpX}um2lgUDk3IW-A24%bk0v++#%#X%&A`8*o5_s;3k$^N zha;bD1l=jS<(g0{wd93LumqbeqFL5axqy_XS!HgFBTJk*BUR~fm}@1)tTVwSMv(!9Gwc6htO1N zo6wxyic97c$`%P-LM68aZM@B(2ng&MhH~3?}#Yma+A_DC>Zz!V-hj1%%29%#Ltlh@tap$>1 zlywxhG!Mui{;YMB0|$?K9{_zpdv0j&0QX3~=>LlEB8}T#ljj4zF+OO*fa6nRDHmp7zPZZBB0QK2u-KBY5-OkdY4!zJ@pqHOdHs|7Ct6!*U`hT#{ufJu zX|$VsrJRB9T|$IQ@>e=HoQN3erndFsu}8%Jl^cv$|LB{V4G}TPD!t@BffXy74__+2sB`P`NoX{c^j>V;8%5T~8SixQ@Rk`b zT0y^zXT_ISV57<_Cf8kEI|u~^S+U1VX3(5E3UZA{z3wAAlCPTcBBL=}o$bRqh%RKI z9)q@?0f$}Hwx^l5Aik3Yd(sEc4|r5J_f&{42GoD5GVnPvYuflUUh)04snznJASa9W z7=CgJ4)WZydZVKUZt@LuUTi(cgHzf*N9-YAK*xYbjs&@6XYk}M)?8T5B_3*_*KIxX zXhag&!ghPeOc(V4Z_4}`)3CZF_?0Oy61ENHS?{Vu#XqiD1;93pn=Ie+U&QjndG;Vy zk`;Usyg?c@s{hz~_6A}NS;xme;HO9?yBe264Ix>~XH5V2G7?CKFI4Fi2f?Y7_ky!r z3)VRD6z-f8f{SSJpHI@kf#sLWJ)VVlX|Lro`ziw*tmb}|weCC!Ol|JHz}D)hXk_ot z-g1xsiwBELczYF}*=q*1I9#pC_>bny)pr9ct)1BwTzl&#i}?(r)zF^Q>2z15!PKSdehx3 z@U?QNh(%H-@q?06%oi@rEqmdd6))`F&6^Xx)GbGdy_nB(&V*J?8c%M}#0n4r{jkK- zk07)y(Ix1lhYtaCa)ma*oG|=jK33b(TtH_Zu}rsl_LfJ(coWY%K_6fde;MQt0X#v6 zEpRGz8noAz-~x7XaIg-%x_0iZ(8snFT>@^uw z0-hYRXN3;EwbkNq?{E=uY2Wq!;vw z;0tLyk%*&4zXjtVwk^kfEk`HOEmTz=*~lSOu>;cOX8g?_lJ`5@>Mhh&HAHP454+W>t+ z=6Xs}zYN~C?on^_ezX8bR@tR;Y|}ADf>mA9zs|xQ7ULz6ou~|)@H|&xksVJ^%KFh00lu_rUp#Pzhpe{a&S;gA*du9J2Itc@oqUo7enIGo zY|^&$1z0RkuOEG_6f2bcPbz30vI0-~4aP00Mukv^;N#?t^WpCx=NI-n;s*CnJ;lS^ zyNO!%Sivg%U&<`OW3SA!TA|>|&ExS);0I#=*aZmXA&c{j9Rs{wbLFkSP?GVGZ@jax zt;KTTlF-s?>HvMd$6lN#yJTIvur}*r16=0LvS<;r{q?Z2C4upY9D15z`zW=%2btM^ z3Se%o@TxVzT9=0`(=(h?i!a^s4I5qC6#b-rYyOM)pPU*5y=+oLl9Cc89yvS#Ifbm& zGc9JDOI#OZP*(Xw!O;^Mz)uLH?Q(+Qckd^lOzrBu(R1M^Z08kLN5{9wY6TigjqG=% zD=Be5jC!4>wS}ZtdzoU87UeKU=$d9%fF~qjyydA0$KEm?NADrwK$Sg0b zI^MSRkSsshrqQ9M!7m;O+1Dy)!lWK^=ji9Qi~acCSg>p4Azz`#e}$i0W19AypN;=2 z{^t`wVrpPBz{3Y5X3*v2C>y)m>OthRAj01+EoifjPXY>Ex0(>yT(X?cD6VKqy5xiF zyHL20^?U}hi@p7VCSVIb7&*W?*63rm@CCum`gHf&T~Bl94{}GqhYy`PEd5%aswgnX zaz4W!cpCjAW_W36HF>(htwx8l{~goa1ChxK3mn;KzLa{=vDGc~fR9HysZJO{6dP|p z{i+f4G`RyXY&K+*YR6c2@P*sZACBnF>ZdmM>iznznTXsX@a)K~9lKdQXU8MHYN)In zdh8W^R=wno=#|j7hh}Zs%02HO{@LsIWN2%zR&;M=!^6=77ap=|&tM7Hz^Ehl;U8O& zw8=vj?Rk;G*|C|6Gh;WCYdUu`Tt`S)-Eb@lH?mOAFdD5Q%+2!QCcXmB|KtQp7U~(u zU=1Pq)!oNYheMX?8NlAXe3qZpVazgVUMoayvS3fZYuL3K{DfY0@Q`oSGq8;YK{Y$y zfv*l)q9eIa)Ef<+I1IL)D>1|_oz?dG4@{S`9 zIPZME=tpIW2eN;aVSh4h>@V3fy}rC{lO`dt8)El*B9FCh)#SjD9P1A?>#faVx&B&TP3!I0#h8}k3=|PmU?1g)&$#oM3B}RIJ z*tmw)O-NBm6t}7VmngN^EBAbmnEvMKk`4sDovS;*Ms)O2&ZPyg7lttLi>eD}AXq$~>##U^!Q)7GIu74H&2HRdA ze}Fkk{S8rXZ(IbKX4~?of5MC+yzAWX+}@ceH;5UQ|J=YFuS~6a_M5N|S!}QM(=3L8 z)96mON2q?-YyDJwv~V#0`y(Hq4$ofbr=siAdw0~p-=Sx0djl04PsE323mL+XG%3fL zJoc~Bs`zZm%wK9iGnt@)1u8)I)6;?(kZ4~1-e+^*GN1kBecDd|bES6wu73{>06igC zw!``Pg7;?s4t+z<2Nphe0#!Z|jnKx-3<2kyFoN{GE0 zP#sOU3~=8|=G&`{co0yS)~9MHPpkr;^XI1?aoL16LG*zNSj zzzjpUEU=?f*mP*T;|ze72I`DS-G$~JQKBN*wH>DMV0ob0xUusQg`z}^6T!WLakW}c zeX{jy81Rl0fHaR6^S>fZ-uxf;jXLX&vdsWh_6=U|U0OArsr_IhuP-lE)rJK=iv5oj#!6@=*wH6<6gGdlIu z9Rl&`lLQMN_A#fgw(5>(WUnSv?MHpgic3)&QEs%qs82=L`E5Lr(yvXK)|$ zO;X@C=oxwnF!51~@$#0h+Cp@C4zSQci*dPU)&%GqK_j~iW1+(qBlG+(MnmguQ-C_I ze6peDuPYNS6+v770^BACBq@`DOS?YYj>6DhSE!n+m*{TihBQI0uvZmo*q}ro&hzw3 zi0+vFs6_w0wDtR_P}pDEr`irnbeZ~@UxdcfI{-5ZQHgH&?Za89MB6`$s~QhVbi>*+ zPeIQ(Ccjid#p>gvZ3$7(GY;6#)q1#QoLSu_0iru#zkv=b#y5r6)&h6;d+c?F!tZv{ zx0{C!#amr~q%;(nohJaE!7@-9>T;sF(Od6Zh|=bRv{Y!9Q?w<9>1!`629AiZ*BJUZ z0%+$%pnSjOpH0sNzu_Rqctu4>E-bZITBJ7oeiq&Awa(86e5}==p za5=<2}0?OsoEfy0||C!lDR!)u68{K=avt&R?~WC+uZ|zR|5Pb8u&Pyeq|Mj}`}+VbSiPtEWy5=G!Mz(1_Ub_k(+Ch{ zt{hru%q2L0gxcODu4N1FoJ6@fnCBy}c;sQW?sfUUc;)eNge}Xf?E5$OgMW{=;@Xke zw6+1qHN8%y&kmzqL}|m@hU8jpKRD#;-Ka*|s|QUNdpqJP__)B3QfZOM)%F5HA9S`w z22Ue2JzOCi!V{P-jU;>KR)QBJnfCbNw|v`K+2@O}7Zdu7WTV4Jsx&@$uu9v2LD~(8 znLnSAm#;GO*@+x1_Ll(qd}43&kj94_Rc#w^*SsN7{D`D_w?=V+M43kOHyH4Y4hTK#yu+EH@wTbKqJx3X>44xz{rb2wcn?r|J<@-6 zP!|>V#P)QfDs3-5^f4EoJ&P$l^<%J!9$_y%^Z|b>xqoUxQhydL!XqO1^XxeHKBAYs z1Tj7M4;*P1n;!TUy+k~QrWC4$%C-Hifj&Qj$G!I!QZ*v45B+ipB9^@tQTsqTv4pF{ z54rtXc68h=!v6X|`8(_(XMUBcA&*naZcMcT=n1k2dp)A>2ZXDX51jh=(>CB8&j^Yn z(MSzd`TB(dT0ZjiFl)13PS6xJq8C(CGmQxQw?4F!ngy!ziL_#8$rCk@_E37+)rR|8 z`~T?MFNPvBr3J+d3WqsfRr#D;F*Bs`m009Xir~=e&LkD`t1rL&5!y*@0;=+Ppkim0 zD);U~P(qV$+NuBeV-rdZM-wV3LHqY8i%(v;K$u1qot6rO{t?pnlc2R=eW${}Bxp0W zuA4T4kbSnIYzGKUE#(%p?&(^+0*gR*P|LUptp(fK4P~xFo2lHjfc20YxPCP{JRs>b zZ5XWe_PJ+vxrbI@C<;L%h`F(qQMi3t=b?j5=~p$D{>%4M&`fY4Wp zx|X7Wv%mb$%w`61Wpssq|KpX`pkSlO0fjRvvlTie3B`;_s03}cZQXrs24~NAEDDZ= zj&?%pDkwAx)M!{2B0FKVapj%rj`vnRbU|b%q^^o=9GJ6RyaJ(k`CoS^ZQZA}H7FGROrKpBE+(Sgx<3#e`k`bYE0MULHHM!+417gwYIH_wtpE z=LSJvI3aX3JqM*tdjlN}j-V*{Bwv7x+$u}%9MBg|=*%qEeevwIR_OR{guQ%Eii;X3 zQC#k@W`0gaX8tD=TA1vY&`AoNHHy(D)mv{{rS`*{Le&|%$>3Vr(IJoG$ag#DAbQZO@UEt*SY zN~{ZQc2b=gFc`vv-4AU-1zI5c=d)Ize_QG4h6awJ!%Gi0W~(-EO-uB+i=03a;rRgT z>GD|0y=I8h_BZ=U16NZYx3{M)9*VLMMSGWSvT-O{4YkKv?$(FMP6{+b)_t+E*zNle z*$Jm>qUSl{mySOV2ha(n*-iyu-taG9ngD~&38@*h#=M8wuN{Ooi+X3DEf_Fh-tZ|~ zoSB>vlGX`7b53(`EUnY1m+RJv-4;KjqA$&&?UDqWL^BsC#ed+L z#h1XSMN-6df*v4M1kKpm0=PCZ%tc>MV>&5o#cuxh#aL_HaG&2MGV`MgCXl){$xbb zH_#VOQbiZNJhg1o@EvHelT5*I^<}XmX9}acnj-D5;ghNpL)LvU^;w@QV7p9O!^)V~ z6}YJep~YrX?GC-WR$>!_D(p{=Gkckwx!Dw!=4N-BS-Ztv8Nj-U$J*we%%3e#FPZyp zb-&>#f7m~tYdXeQV*ur(;ES1)ATX8W-o*=jDA%mGfZl$Iq$uVLA{xM4DX*l`lP~70 z3v?op6uF!UTtTmX3%6&!h`2(L$EBl!h|c|R@I;79Ww#42$}a0r;uDBVoqt0QH7N{nsVxA<1^&G}@6rDduSNL!<+aw+|68YcMPw&M2WQ3svs3^5 zD+<1Y+O|lF2+qQVtMk8CyZb6octuhKZ~|DXciGnEpN;ZDICW2qjTa2C@ipo$g}~Hy z-V3aI_*u7I=wbUvveeB0P735Ltd4%7Qk_E3YzI7s0led%%w=G}(TR+g=3Do3L0meK z;llh!ztqeOap^>6xVnR9FJHRRO6zjtE#fU>B3EY5U$SUpv{PzDy(ay~AY;jbHy3-5 z2eA3QpN`dqxYVxO6$tkx3N`4OVmU$XD(vsdOE2?aXCkQk_E>1G@U8z2lUoaF#qujR z6Cf^~$_!Tzg@(7hXbx6sGXS~_*%R>ZNg_XD{9)X&>Bj z792Ve3wCJ%?Px69-tc>9FP*;}Rv)^GuEKXAFrC00SRcCmAKY69f$9A-0|x6Cr|VoQ zgi@LP`?BffwHMlp_VC%jX5SUJ2zQ>?vhVZ)_Bvi-k>xb&$n+^lFB(=RW?r4tx$ zDQvD;6XMbd3^x?k*1d8M?T*<$7Mq^N*%=V;T}?*&B=#2ekG)=lUw6chn#ijFgx6xd zhYG_^v{|<~e(!;UnOgHlH`UFAp~Wv{MwFx62IuV}gU$0RO5aze;qczz3{fOmKj!lH z3`^8EGx$?7%5yT2QDi;`2M$V2NJ$;kE-AGaKe!SaXI>kv{EP=VD$N3?TO-MmvW~9K z>aNAntm`TQFtC6ce+)G4u&aLS!*nM^=+GBimj++X)2*SxT1BZBP)eN$RgJ zF<^QTRFv$Wk2T4{f%Qv4B73ZS7urkZHizYNdDY&zUzh0*fvN4a0nDnt3f!(;a53lz zYIWwo`Xvb$PdrJ1_EM{}0Sg?_GV9Pq5LnbD|7G6*29DSsJ+cc*pJV|UyU2yhra^=K z@;|f7p)3?lEzl;k_cls}c!e_;Uykau!1m8$tv#FD z-{e(=|H*ZPEF&|ajeBAh?4L{aLazx%l67PzHW3PvG1C5}Sj~KR zokr=o<*xEGwEWK}WXOE)KRn22YBKWA!Z+Oy;Q)wAXp>RI7o?vcx~JQrbzb1%!_Qv( z`~*SK3_f5gGa7|dZnCNkf1uNC9Cy`9#&JP#K3Cq-WrS$}4JCb55aZ=Y&Dxxw!OP*ctM z%*$UX$G*e=e7;3)CX5Tq0@J@`-ti13)0?}MZwy0<++cV=bXC_I{pCeA)Q8Zv=|}!C9oZOY z?fL3ynWumiKIvxm3{pi^zKyMKuq{kWtO%OBD0>Z?uc?}$H)da74z6H~BCFNjN*>%l z{W3FrBir+mAFl;u<^HmS(X5eS)=ybb|N;BC2S_N z_sIc;O?{?SHy(@SACTEZRh8D8h$xLa-X>z#R^Ta9v2vw#VW zy49D5X3d63NxA4vHXC%Sd2cR%4UQ$1@21(%-EW-ydWA`A0e_6 zHbbFL`EG5|nY<{n>dk92sCvKjjXI0c1X=cGAj3V(*^h3ILyftJ48L^N)&&2WcJ3l7 z&}8KsH()3l6l3Haw67aPc0y?=pNOrN8|{-uk#AP>+N`;`@za)xaQvK58Yu@B z_bKox96u-JnE^Aq)gEhizIywimz|VnxXHh+Z^urE(PH>AX0)M|R!VfyN}oJHDW0r| z#-R{xg-jS6Gcj5DpDz=cR`C z=?;;}oHmddzM3ssROqk~Wg)Um&TF%lg^t{O6;5r)DmfEZxA@b^->!iJC_>Gi*z7P9 zkoI{hAKw9?oe&$J%A37s(N2`-Bz+3WYR%D!uC$k+&EyizLjxYEygV{GE2`1L8-6*h zsn#D1nso!knzR*X?*lN|ul%efTnUoa?J2k*(?5Hm`iIbBa*bxrWe40;);&%tJqYoc zeAgOh2gB7nwzd;az6C87Qzd&}fFo|xUqAR6v{*E36kL#jx;z|_30mxg&+Isw>f@cA zj^u+Di}0mb417FmcyeKg?4(G;g^HN70ofq36EefoQ&WqtXoI*cO!muVZ3ca%d8>)Y zQnEgdM=(5()jc{M=}Du=8aa*(PEPgi6d4CCcEV-2q_XWmkE0OTNp)tYoOCw7`g+74 z5ZMWv8M0nQQw!$*8kG(5b!&!~p+J60zR_QxQWx!n(C8FZu1cZhq0LSh&Ce0(j;^+= zTr#v-@WVb?par3#U!6V&ZFa(F1`LL!;v>8*HpNCau(2t8o!es=qPL4+e zvlKMOS^LbYk5W8YC&!_|ooKsuKKd8YgRGJB;agInWw4}s6XtR*^AwbU?oAKjQJLC)0)(_u zf%cysv>Taf&i|wr|NV;YFWO%9W-TE!Js8{~zExaYy6#V`Pkd0l*&GONJ1zGCXQwjK z!G);s-m0nHf#@>YUi@b5Ss5c&i_aO^bEP1|9bfe0VIUigCX3$;4NhP!cF#t2v=CeF z(WQF)@g)8yExkpPRc{tPUyiIEXuNr6&(RG%O=6WCH@uX<`XG?uYpxv0Xwz=p0 z*ic&{%3t@?uW%H|S;QO#LzTmRg|_>$qUJL)gyQa86~U$!=Bi-xm>m$x=6; zZ%C?ak>d{SYM&o|f;?47>fhaRlQAa2Y609-an4?ps>o>~{kM1n3;dM#UU^alylWdx zc>&eikSO1PzvR#6xe8j33`tTN>10{P8G~si*n+l8nQ6GQjvR-EfG&??b~j5HWFuf* z8|ZF~!ig@Hvp(Y;0qC8rgJ$Ic67gudZqEEjV>xc&r$YOee+Pbwyv*S9DS!E@(1_uE z0$DG>|KxUq@@#5)WbqO5{;CWk_~R3$15v3XUn$okDa8r{EnSr=F!mzQyGGN+b_O^% zUcH6M3diA?a?j!eiri<_N0sQ-y+vvg@>9G%gtY&j3#l~}8Qig%Wo@l!2&U}Ph!96l^(nM56 z=%PF6ssc5N->mWNM3j#0A3e3!4$KEURp6=xPjmq1Sfj~rowDGqm43s5itg!uZaze( z^15eYdV8gplBQcn_eV1U^7Ez=I$y_Bt9&WO_Y-q2{v(}ZWHECXzYmdOn-iVTK3_)Q|mglAW1D$GW`sT3O$lDRrlI}%k zg@&D&S7ZFY(XA38IJKy!gR=upUU1>`+@Foj1)Xk7e;=pg<iydq=od2gQxX~by)Rg+PIr&I_8$Z%bKeVYoEBEW^KY&C0Q!a6xpQ~$X3Fr7ioW1R z^}DEhuvhSzg~&n&oymvWkIqE>yKuQb=Ii}?c)wLq$P;A!o@FaMwAcJpj%CObb`UFnfKAAGZw^#r%PiYFZ5m*H&xU0=sLkmb{!$OmLSpJ8m0 zYU(?0&ZvWYK$i1)VRav5TTwX{+^i8To%Zz~XGwwJVUq#J&J{C`u5s9 z4SIo2Um!@{{YQsx5S30}AR4Y;uFP>%AfoByMejj0>-6Dz2rH;y7YOJ*h~(MJUw|V< zXD*c9Zr)pNJ|eDw^-ElB$Nle#htD88$wIv(CXWTmhJJY#T!*+q8(`;FC^enXZ}e6) zTx69Vvlkq-jlVIvJj!2WiJk!qn0vBoNKpt(XD+iB2s=J3kah+-f=*qoURC?0_uj6y z4BAWQE*8a>czb+r2u!Chn@)g8oBQvnHy|*bz#N#hw1B zzf__DC=D^>`{+2X)-M*$l<5#iHZf#L9!CY_eXmi(5D)<|WFemMJ{jmfJ~;Tzzks|k zWCfl9tob46dWRm+UV2WzN4LjsEQa2hhzX--1%B7;C~xOz`zjo*rv=I$eNpHPX6+ml`dp*i?v_> zo64KU3t_CcGO&|-4KZs3A$;?qnyzJ$o+>g+|KDxFSHQO7CGt| zO2%Yi8plPm%Le}>x+WW%TDMF&(p4b68{Gxv{>8mOK4`YQl(w< z4`e~6l7(s93viWSeHS-+P9}z|OYrU4QO@ne<+IGP6*9r%V2^qs{7r_5ZXzN#uM@0C(;TaQj;}lJT_R{ zsda_ncXM@zHajWN3>c)&ZeNWa0Bv?cY6h(Zbo0OJlti2sv5_&Sy`~zR=3AvXjVtG) z4? zmghxx!p4vVY8)EQ{0~fYp?fuA$O<(tGFSQylw%I-AsDH)^$L`QMW^l zYlwp6yW&_+2Sq4xdD^(4&17zSfz!JJQERXKdUq{fMdfzOGi=c#Wx#Is7>ikATV;(? z-`i_a;p0ij6J)uW=?Sf#jGLczJ@N!uX=VZIp?7oD*E=CJndDw4gN~qK=92HD{1Hj! zIfDl4W-Uf-ya{nd>t)mM8@QU6yIwxC4rNmEU2)vYOhcnP`9klhNdFZ>R+gE_IY?sowfZdv3@%%L9{S&GIC!FV*k>QO z^l~dP%NNjM5yBK?Ew8PKcw7lu?1am3=_Me~XK4`G376s0%lMMTe+FU|>E0ZFY-SZ- zA@itO3+p0F=_)f84N$IjYs_iU1{cp*66&V+O-qVW+#=I z*__^4iT?XP&(%Z-?W8#KLTWJbwye71-bDS!2Woh zF0fbF{mZ#`AEL}DsaWhIqo%&bH*D(S325}BZFT}KjJOxBeT$CQ$I#ViZ1mW|g%)w+ z-3Kc{o1Ji*uZZXboW5#(SLkLZ+y)B**~=GAS2f8~YVuR6z}B^$o_vlNO@2T%i9Jlm zGlkl`z2!DscH{ zAwkxKEJBMWtyXg;b7-JNgX_Gj-rrD1zq{Qd3CH~9h9o5?gceE4ua6T$3kyvhmKx7) zq0M6dyY+*$CHkNJKzApDCHL;kojjYX?hFZCyj15c1Ex;I`|_J;;4L9bhX1)5LQ_*h z-^BhI9Ax|_Iqflorlte~8XjX@7E$Rqgr=5z4()wqRrU1?$@#&nEzH-{a?hb9SBr(E zs8yY=@PG03O_3cKvTb&-HgWcagc^s8k7^g!HQs#Kc;cJm`(RU31h+VYieL5g;=iqP zSw7g*EMa&)c#lLCzl7GB_}G@$&gg5q43A1_!${t28+R7eO-NA;PJFxx zyh6Y}KqWW-Ku7(p*pqwbJ=gmwhD+u)$7NYVdx7=(_n-X6<3WuHvNp}InAK14!tL;4 z`3gX*$=o)qj`V0&2c6HmU2i0qKgiTJkTu*FXWn_P?<_D}GOv?|vP=5#ne8s)cCUco zw$wHk6#9C>VY1tnbo7jVvXxm*<#xY>0oHAE<+R#zYt6=;`aKy8oyu+r9rZ*zlCB>` zL>J-hm+0DF+1dv?%OY=(^=gv6daHG4Wx0j=Zi^?3d?A~Jj&CUZGZ(Ak>W;A%Ap?j#p@t=EIU!7n{Sb$vGrekZBG z3yx+RX|9?#EO;@$_ejScY%&46d)VmN*qyX&VM3|TSM%Q3WuePm3R(6h+%9G`ymWdM zI7tJC{>I@sxqRSl%fHpUH4jPK%Nn?&tpjGv)%v%l6*HAZQwQ>6sQnU#!6|8;Y57W^ zsSf!qR1U0%N|j{;pF(@7^`FC{AelJiQ9cMv=RX4mQ__aZR}_Mdp!0rMke+a#6{_?C zw3k}>xg*e=FLw8;-ytxa=?oY+;`z6E%Ryi=%ai&`p(ZGjtJ1!a+{3(klld(|A_IQ& zjq{E1VQKF8w9GTqjq^M02X;mEQd&%~sh3`J*}cc0o?QzZ@B~E#S@hPAq3iT`)}{GS z)E<)sZw71#Tfx)nV~tTy(CCo`ZyXtU!hPdGeh4gv&)(07cwgq&_YZV2nbFK*op@Wm z+&>@Xd$QP#JAxArYn_{XSS2rX2btFc^}@t$~NiYgSXa z*2X)-QL1a&(-l?q9dwU$@qPx}<~!)dW{?7SHtKpLvX(4)v#d3GFa^10Gz2 z&{TR`(E8<`adV5m2cfAY+l1yUSFEnTs`|@lZG^0OGog(+jDlTjx_a!%b}V zKdRaNT9q{}D&)+OyHN54YbG?j<7)e-(W4N@g}424T$`$IEg5hQIhm|^Gp#k|af*|h zObLGt#RggS##Uk zfG%-T!C73OT$=5tZP^f4$Z|Mtct)D|Gkd=K2(7n8IpMfJ(f#06nFpaI&nOYu_DRJ2 z01B9W176CnKa=7Ki*i8rV5WC91^7~X&BxQby0rP?+IT+6<&Ki;y7W+D2EV~tT{>{^ zC|92cjUA9TVvBOJYjCBr3#|(=rE~q0`zKl(DsYYY+ds;TKrt^p zHj%+_n%hCf7rZN}(g%d|Cy!p0!rzVYJrC#!lkUCG-~;K-uhu%PRg(ip+QkOA+;D#<{s4@iZtkWl>OetNqoxw-ae?@AbcN0Vzfv`7zJ%^SA$j`5Gy6Oq|T*uruQSBt( z<;G!Af*dvVg-0m)lI3*CeT<7qP%rT`ZCqaHWop6qV)JlUynKC9#|o(83t<1W*ZTQI z`^Tmt|B|J2UQ_jfyK<`BbwqZumW}~etO$p0&b`?ck$cHnItIFGBmN<=*%J?^xg~mXj8~(+Gy5D3<<{9)nL#fuUGt-o$@kzz9Ox zLXR8?^4^1h^~u&2yQH=gJ5!wJ92%ZgZw_2Ol@B9>W#V)ew&gkQL-Ul>kU$xs% z5XCNOGt~bNNC$@(tv4IdX&JPgI$KDGPfvWJ`FQ)$#jiOyx8G+xZ5IU0<|C-Z;c89d z@oO3LYbV@=mQ$w-Udvg^2CF31x;8!q!Kt|;9UKg4P?ts@KyYg2NC!{%Ij`Q{qsuq< zSN;^_4j1{BI0GE)RBaeC66x?HRhwV3Ydyl}e}6n187gHDLSTdao^~g%)B!!1OR|&% z9Kx1H)S5WGSLGg{;=0HhJfFFpivImOrNbaPwNbFpq1@!PU#q`pbfb4y!2^Dp zH4G7wEWb0s^%OYiMy{dI;kHHHoa|f3Ags&R7&jMUJ0v^W_5SwgM(l2fR5w=sRCga3 zG|CMPcgS^K&{gbmV>^a}iH3_Twlf{hnqw8Z|JFB$TGxwS{$J7cO_%eV^LC(S69 zh&V%5*O}HDZHQ*@=rdpb0+w)Hs&*7TdC2z)o(^VDc;-`iF-7jDwNfJw6uOl3hS2{n$_k?mzqT zecrWdz_vt}fO}Nbf$O9$_!K(BwxUbGlVkR*u%JbAw!LBKKI@=_%yJPJ8M9p8PcfJ- z0&eKWtLKp`?Dck%#Sb4^_6p#Li~Sm+aI=@%3E(+8Y|(qKUWNABa$AB$F|n=uI^)i0 zH74wpb`mg(iGlqVtm2&GU4k6N_BYE3;FvjkD(Jpw)2HQX=nDso9zG{V2QI(;RCgY0 zJd}M*cEIU}KkK+>C$%@OXwzIlCvl2#})qp zV%u`s2V1Hng4758i&~FJEe0?nQYUm9#OHAQi7H(Uu`hPUEU@L}BCGAVJ6feA_DC8Q zgik%}cy_%L{DN48^gli4Ux*vrL;V7Gw7Ez6^Viq;ztmWpJr@vY+G0`%jP zI|5@Kyv(rqpB&%hYv=f`k?-*YwJEF6q$WB!<04-^XMTb&S4u1I!arwweEu>Y0qr-4 z*vVi7WdE#d#}6sAUKbm1$D{5euc`F#JoJ)n7Dx|#!%N=9ckk3)=`%;I9s2-mAGpZ6 zJkv{T6~4Ok2)Xdm_zk^Z;jJL|l+Q@pCI(+G1;n+@oy4-cDpz-P%yOH5jsN-J(~|@9 zQ9}RjV4eTBHKUL6RKfq`iZ9%6lN{8TEdSc%OvqTWK+o7L#k=f{ryMH>vB?Qx_<+O= zGH~(ve+`D%wl&`hL<1XU;AU_9@F$vLlW(R=<=E&XWYKNU4_dih4h^zK&p_7K(p)S5 zs0S^!CBEzpzFe-xNAn-^b%uTx5tl(q@j*^WNf@qShy1*uI<(rh^vl?26>Uten9~s1 zmf}9hKw=-9JuMpggG_E78~9vk%F=ETIT^9}pG`vO3Rz))&qm_PKNbI$F%b z2pr)Ob(MYb+mexV!9|wkc`XKUJY!T|>}E&2hD&B!?@gZu-67(b;10B4_R+OBxA4gg z|C7@vS%+u111y)d9&{lP2DBqq@!Ss zw;?tlZnM@qZauN<1oS?&kiTur&8qWT>_(|W+iduZ9T1$#c?+CzQwQ%-I3bX^h5yOi zBrESM@Z>)1SbevIl(P6o?0EUkJiZ2@u0s%ncw#;;_p4%LXMXb4*F16Y|HtPi*k*w$ z!TS%M^lB;7+6ElghILThd^=IwE`a^z0N&v!3E*I(9*vRug`mUZUNHI(Hd!@FFq zytQgV*FqK_T;PG*>jW`gI&4NJ|2}c!f6yEDeCOE4_+>CdT0djL8VGIAb_rU_v?4Oz zAHHA(gto8n9NN6;hI3pS!>SGA_n_IobhT?n&4Yk8i<~h7Q{!(!)XJGib`>MI=+z7SaE_H(qO z8BWmRaSxljcz6jg=jiMcK@0EepVnMBmGIQ=R@9rHq(-ZIf7{3yt~@dO%R!uGc05<-^ky4?>oG% zDz!D-{^mPl8QwyMN|9f3|FZyEEm~}Ul(w+JMEBsWF1w-Cv}9o-o5KmZI|*8!H*aqqxEzg}BuFBR8=5!g zU+@)p^o=>g5v!5dq-KrZu$vvR8qS-a9cyy~y2BBz(Y$%u(86znd2=}7;yY;o!Mr)C z^nX1NKU}m%z~l#>H_!UH#P^`d2q)ZmCm9XrxP`y@VLFhqgcB~jPTgXOsm@#GN{{&AB~y^{Xt{6g$(O<-2&f(XG%TcgvVN?F+>a0$1|T#fYCv# z+osie#VT8*-~dEzQC9rcY`qyT8($z24IDvKC%FKXzz@gIIR}yLH{WDr5E6IC+yT!Q zdcp}8)k(;(1Sah70efb96`j!~n&XB_;H0LXRz)Sy?TFW)1h!A~EJkID@K&qj4XI3V zws{vc_eNxE%5CPuC@sK*yKPx*tVac9%I~8n6!Z6D54Md3V#sj9ORa{@>_3(g1XjRC z7d|`<@o5b?A4>~gDp|rY{|>LalB*E-3Yd>$Z0T(}ra-0!E0X3EF0rTfkS<#rE?c%t zdkQsE{JxIXJYHJ0msHjnGQE5EAQ!*4O<5U8?y$2Fa*DmG&KujzDV8_}I=xo2d!-;g zk?<0}WNf|QRfCoP8-(`d!tG^tUe9E-+kWfPzT98|Gu&Qf zCvf!+;dIkDLkP#~iyVA}*IU#5fYu9!^^6$@{cFp1VJ+@Ec8)C-iK?N8Si`x0(K^Kb z=q#^5Tq4blop7-0+2hKj+Yr~5-og{;{L8%G3T;E27VVcmPA36Qm;CbKUuet-qPp~0 zz*>OOhbI1vd_cIrP9TF7jh$taJ41_!9XTH}yq=MD!}BGm!V&~@=@!G~hb6lPWJNS4 z$mY_4^;WL*l=vIa!6F*`PEEKYP~Ww&!>^ejt^*pQg@@Os*2C^~Kw{W))%a`PT2wa( zch#l4mvvnHlrzNdRJhD?=nw~NMjc(J_22eDy}0mmhHU0)B=!!2QlKv`d!8F?AB7X7 zaOsW!4Py6W`_StS;e>1I(qZumN#h2oFQatgLztPGY!@NOFnjctY-iZVEaj)b) zv=q&T2`{xW)6JfibysMcv0(XsegivS;e_kze6izL6=bJ*HNU^|$NFfn{U07lD%Zkz zxJf$Y->WBq_&Yq3#Bv!tBl8O_`uHh0(k9)h@1O51S*wiyE_^AH8ix}Ua>C{Q_F!+7 zpS~E4DM2WweE>G)PYahA8^{8l|H;iLK`p0#fQMze@6}{*?BLWd;SUijAAYK(IlTV% zeaD^MaR+{YG(Y$K0QA(iJr{1`_hs=vA5W3$z4-y(-Cun@^~#D{y~*@)Ik{c|1FlCuC{@q4!1e~M>6CY1q-dHzyCQ3epYwolWfK!-m*Z#YJSVg$) zPWym9mDyb8l|(oIq^W`L0HY~Q@jJ68L3}|g`{Zv90Gir#oxBgb|NoH{;1s0I;euJw zR6*d|qy;r8JlK&`26==gzw`Atn%j)HF?t3NDTULdcfR;wN>Xibg=>gWG!33FJf525 z?Koi`&?kn|qkIHVEXtGXBn(z3>B0O0Y8gsg-I9iq8%?s8KGqp*$c}5(H3j-dkeBQq zTz{X9E|nMDohPanPY(PW%65I3Aoj3@e#>^Yshzr8(=2J{K-$sEDA~M~Jea-yY8c6$ zsxh`qm1gAm)Zw|oP`YW_JzrO&QXbdwpT8hJX%9ic2U~}ir!OuF2GdPb@hSLlPr1oE zPY=UiAcm71E{sjuB)Z+pXGVOaH)uhm9@49O0MJ`Nh#myv)f(+D6Omo z)d`#RQGuy5J=&p~?7sv*f$+9-6b1g+KX+&8@MU`Tc#F3Rn)S9>L59y1{%+IbwVN&d zVt3gJ)?L}cLjwoKMZj;^wj<~po1TnJ|Aq+9)YpG>!BKXUANbYH&ot?0*@I-;vl-QkX!2JU&(Q0;3GI~`i@Xm-NU@!HOv;8~5pRN74w8OkFIS9X&2 zJ}ixL0pSimC2;g^@Z!zVb*vpYITwhS^q&j(T1W`EL}XsW$#Ezgr6~%LN~p(-nw@zE zL>D~{6&(co-h9DuIBDWTc{t%p(V3s07KO$OpA(Ho?Q5DRHoG-7l=dLpG!dd~JXqA} zyW?IsA`(rAD1+lAox|^L{uTA!_G&~aiTOLf{r<#c;|K5wqK|iMGl9`Sg*I<$Y~HdX z+_BQ;t!U74UMe$(pAWC3;@eIheDK-X?PG1$t&b1NlskK&rDe0KS0tUAnTT%ib-PJZ z2vg$6G9}t0zB;f(eoJgBX9Q74C>a4Y2m2>HyNpJcrcRWsj>};8c~+IR6H)Bj-~GqK zM|=S8J~#Pwe*>@-=%#5CW$@O6+4W{{xv~9>-zuZE3z|w%{zgVF>M?!A5jX~7c>N?F z^9%mAqa!EGp94QY>J)rGAk7lR{G?3w`^JMr%A-VX!i&6OkiEaaoTVG94C)LbPydMv z;qS1`6jCht+l}rxY{Opo0ozoee*ikFckr!wXre`UsaH5EC2>GvLaO)Z4Z735eoI#h z&^t;6A){=;T4bnU{_|RyB8USty`vdG=1vf1*~Ofd>!T`0(>?lr0WDVFJF_4!D)9DK z2udSs{sMh}d*S2Ue?aR=?SrrNXp;5&vWvZ-|D9wA(|WuZ{_dm>^WZOVk|NA6ps7%` z_D6?6e9~mX*F$J-KE6k}ywF2VQiEkbTw#tJ_3NAP7dXic))&AEbNh>%zk$ENN&jHt z<0(21`b4X3^%r`h zA*Bf^6?7nIe{^l)M2P?YNDFA$eM^-+*!};Hv;e0?g_jNsg+Ji`krmLy=xM=%g;C7Y zbd|mXfM+kE3)XH4WQ{-nlP4E6b*1kYCAX$9-nlPi-fiKN+#fn?#plpZHmZ-h1Qd)5f$`qbuN^G5swq4&z4Eq#*!!{eBZ^+xO z;&#R82HjK z3;XA8bWOAl=*cNT!23xF{M?u;uv%b}k{j+P3|fe?Fim1#!URP=VE zL)+Fz0qH$7^`z_qy{)Sq7rzb+o`-hxp$|4#K)CVlubm;fKHl2ZKb*;amQ#$!$?<;59~{iDQHjHh@u#qT|Eu=Vm4 zt%K?eP&ZNs9KF;8WdNZgu*(42i={Vr{#VtKUrKXS4@D)(-eh5VFcyM=6)Q4Ph0?CP zn{9O;6e;%lNFEvNDrTc~V|U7O;anH38;V_!d>>5T<+ociy!T`dV*g|80W0{wXY#y;@&MtXV($QO z#~bLOY!6rg-|^k(eGr_G2Mps~96HhySS3&|OYLKuZiSv9^cCsgJTCc*=e(y=jL-UN zTq+DrLJ~0W4bTjI)Ba}ru`o16`|m$AW%xMOi1qKO{D6u(Cl)}7KomclM8Jxk0V!s5 zE9$K2%6-n0qnrrrwU9>MTGy^oNaZH0+N_J+>xqm_%P~WJ1M2nrA5Z4*5GZdEup3B2 zQ-`I-x5*Wdh2|7Ku8dFp5(XH>H6*Z{y5fAN`^(8F$5ZZD^ci0BQ(9^}+q>6Y6rYr< z7L5YQ9qyP4u1flMKFGVv5m$)!BYhP2}*pP z%GGl#$_^BPq=BDgVpj>YB2|>|NnO4}Vm*&^?}7hFvcPLH!?l7~JJZ+Gq3P7zz=qT7 zdoEW}{Iap=7u_H@H8U`KGX#Gpw#Pc_S{Z54K~m%ROA3|QnnUHv>A@%x!`f+s_wi)O z<3&yk_S#4@F_>@XHFCRKgS@bB(MxZjP$WEa?5$Fqq~1V;RraG^lhz@ZQ{<6GD0=Z( zjRjS(aJAO|LE{O_kqS8E=_^^+{(vS56nUhC&qFdaRAXt-fGtx{8IJy$kQ0HZ9{v-7)sP8`XQb6{#;xUDjXadn+Cv7B;$!i{hYv>Vtk7W2@T*>v#Ro1G zTA0Xhn&MJUpAXn}2gU~)9cme&2tL^E}*9OYK6Ri!OJ^74(g8%t|is8$^*Ty8 zVax0)D?%Ev2aULvdR^=E2aQAok2x4RjYls}No|xTz?6d6F_{n@0 z!{?XJ?D1o5?z#E9C%I5nB*+$pkJ-Fga9KEN~)j8s<xUI*KD;!9qQv*iuSZ7GO~9F5=Q=+s$A!wq?-}T&-J&iw()@! zOQ-${JLPoh3-D*#65gmmRWQlR$4$9_1rpn zJGdFy6J^U=!=EOw7EC!a-yUhXK(6A#Tz^zWTPewVD*lEHB?t;Rg-k=W;a~pn=|kjL zf{ajx)q`O7zLt|AFpZz4yP6K?E%e|2qwG4vt17lOMG)yAML;n$Nq_*UCqcT@5K5@hLJbl+ zA@q(QUApulO;CEd3R0vaMI;mjqzVEGh;$I)&g^~mnK?6W&a6Do7w&iOk9V)LX0=)K z&YFE$pbltG>qgZVZQbCh6(KIobKSVQ`|j&=awaqe;Satdf`tngEj;z->7ZB8-IwJ> zZPj9P&M1o9SD^ZKU;QMg=g+%FBMlHZe~zCqK|zkGIIPeoNCO1Ap9HK~*shxQ(nERa z?#l}f-NY&$-5CafX=&DN3Lr()>3Tf?*)HKNV@DBI+*Lhz-peiDKwP>9v%@c45&3)F zoC9&`K5QMTsq$X@uVo8}OZVYG6d(T${~|4lWQ19Wj(!96%QKJe>^}~r6|QEA3}ukC z=W0|Q?|868+7oNW9hf6y(w-i|Li(pkbO5D{F7??AAwjFXXXJlg04Ow!z}a&YT1F3D zzwUc>4=6N@z}6F}pzxd@*K{D1mL3oo6IwOaJx{llhp6;uP+r%;#OgnN2X#PC<>jsM zSW5Bz!3x_qH<7LdLUq^y2Td$W=|TB8Nvt@JjW6^p-Nq{Pov&m z00MXzVNjt23o==W(>>ZkdFi2m$*Y-I?yIZ6Mvf~Eq9z#7PX2|PMS;EK9-mo|`RnIGrbKQci=$4*M+gja0%o$N8VWEW_M22xr_`~dSKEd zaI9_!hh}b>4W*^$-dMDMs`<{%<ddri-H`JW$!HcR zNb{p7)Vv5`sg8=fq;I6pbq~VQs%cAFu)!=nv*l9ctRk)&oK>r)j~AU%5*e1%7xQgc zB~c04ZtRs0A*$H4n@~YoxteKn28c>^SJofaouKT3-zPv+s=LB2?$aD?YC%-0!@?eJ zrizhiP-r32%7Xj?^;C7CVu!9!QfgLZEf!s?6NM2zGy2s+zhLEdH<70brTX&JGN5a9w^WWrD5MZcU_sW!1AU>o zc7HwqnG})s#ph#a8ckTX{sb~9Guz8u0a(9ZRq2B=FJD4bs-rSg{r5+X*wzOAeyXE_ z{&k^ZbLT=yMV$5>{#f@~H~yg4c`86jg-w}IH8b5dc6&`|R8%)*9a|u3WTxAR5SE%% zIjp``owNUW0K!r|mG_r*#nx(&W;gOxp#$H(${>~P<*fzVo*+Sqv@Gi;G)VuK(##oz zA{CK_WxX1rIqTV>u6H0PHLIfDa=!&{mxBtR`YH$24Pc(%gMkp1>a2D%K#eTRXU7*r z{z{k+XQvg|u5Ny6U@_#cgco-mRBf>`gr?65B^9>nI|i^;weA4pzH3qeqEg)zHo!X< zxt|*@7S&r>+mq1+)Ws?mHsf#PtwL6Vw`w(TuU?s7A`c)^v)EI6pz&QT^RaOB>xslH z3lxOF0oj%aDmzJ!}4gEfALKtsGVl0#zTH#-D% zizBEmE8o#mt*l0qO~J@<1-388wGQ-^G&^z6nGe9N!Z0E!D=2{XTHOOHL8N(WP~)kb zoX`K{#vqZJ#o+C9!$zpMhioYF|L?-nMV#8s|GYjxbmjm-op-;j!0Gy`-ivR!b`-fG zVJw@KhXVXy^Z(Zy&oV>h6TRDkwbp>$AXjv=Vd<@7fY}}vNvxsOa}xejK=b!%bp4lp zO#S@NYYB*MZ-2&fgTZY~`qj^^PxCxN$5fHDK+uv;HY?>9)LLEKN8L}tB7?~4YROch zVWzM1+bn1>!c%>Pmv-&@z`=%vZVY?o)I$=bODLMVKL^q|9 zh5O8+x8{TN8cyVN@t>|wT|82t_*X!m;Y3Oo2j!K3y7cGL#>|4U(xL~4)rZAx9{A#W zC@ZZLus~UXsml8P>fTKuEG<}Aus{V_yN?eBi7=cnVU5QFHpG%gA3n=ci9R1jejE+X z2g3=|)g)m1jROTb_;!3bFz73sNb7RTY)v{;kehwHuopz8l?5D`B`kz|so9oKpq_~l z!A1t*H+%JyU62QhKC!`rwPL>Bykh-8pbaOIyO*l=l4Mzjc%Xe@LgeUqkgXhB-op;1l zMJF`M`WlRK2`93=+VvRdNRMZkb`NR$Cm7`tPIySxa&3lhi!UihTy$-6?{!vi(KX!s zf~<9q&^@~gUUc0!u1q;_(KVb%{jz77F$cFMVJe|x(1F8ao!snY-9!hs=JhI=sh;+& z?|6*F4w0I`K7E_*{S?6e4eNRn1!W@h%ii%|mzg=DE3|1M_sb3K-u` z^hX$kX4xE9Z%e)STi?1zQxrjn3@}S-PGiw3z@LV8_#4Vgba6}Gcn!8{o`!{x>jl$l z`VKw&_DFO)ADD>x{@{N{qrgF!b;gw}qf4$Ws8qv0I1ZB_VcZ$VXEUdHvB5`AE7oz~ zgFf|9-X@a5+`uSr4|wNTd1xRsw{|0gyj{Kd`_-IyA^Wzd5>39X^~_fl{wE&EN+f@A zSy^xcc{Z?Er-mqO5V>A%U|7p7nLRcgS~()u%MFcIZbXeiR;i(u8$`MnLsqS9WqkAB zKyN3UFv84jzV==hHUlOtDOU+D9?i2^Pn!D%=)p9*@?$KDM1-eZxzui8t&i@Pwn-T% zFKs*Sh6Szke`cmz3xR1hxEmN8Qmxp0a2u*?iR>>949PlQRn4>=d9sM~zC4+E979&( zS=VoC-3Lw2a3TTB7FAoax3aHZjTAs6fZ3?*U)3+hFL*Hz;?l}+H?H2K?Qr`2ukrT#cg{-g(i~Nrxk06dCvvD;`s4#nSc_=O2e<3gI)YY-;p|o`WWy~=E{5Qr=6z!VoC<7{x(&Q+lnMBCPktF77C(pkGfY3bf;UF=h}+b7o{ zKPWBTdBGj$rrToCmE3UR+%Rspkj=K?Qtkw_K^CetxNf|Xc+ZAqxro#%HN?$}12F+%sO|r zaAA#`^PiEhI}lFyT}EuuoNQwGTLYoI!oEz_!1+>ot#E5}>0A()?!ByT1jYWhg)f#s zxz{}E%cEfitSMsFh8&+kdFi>A!2*l;r(x%7DEA6Im>gKEodZ7ek3+6TWR7to19x0c zuZlod)WeCyF&mZrtH#^LMZ3O*T$u3qsIxnR)S*nDemM`Vn2Vl!8FvI&*ut7uzk~wQ z(=TL?1YQ4pBgCbif#~XUr$a2ap?&d zGG5AEp1ayfm2!WYIOYqO?gH2IO~`kJpeEnd>gE-V>bFH!OXQKUW#UZ`uv&@x-@gWd z#W9)B)v|#>B=4H~aVfN1ghxUx|7E~%(-$^rzy%b=h%>&pCct&AJYh#*?HoaLUJDf% z?HAkTPKH__I!V3pT|fi8Zu^3nI?s^WTm}4ou{X+45=&cB4|m+fWO12Zo!}+6yW? zhq!bHhTF*>v-daxap?{WFGmHId724omzaIos)224^|W)|hNyJ+1$TMs4srE{sKU!k zK>^H-I-kDGb|;@pTrlzbx#x0R%mvdzSKUX0hJ#QbRn3M_pe6IgtN!%|Ywsd5!MF#M zM-^z^d%q$^u!~3rvvIZGzj^GTOi)^S9DsZ2_St8Thq%N-+|mLlJody%fm>v!oFgQ^jUvSPnFiS+*q5AeT^H`ngSU>^3ZOy3Jp>n# z}4$$bK#&wabQPuK`<3Cgqr5Vu8SZfVJWx z4*0UMSrpfAIeakxgCT%|rs~ z{VNJQdm}AeaAH;9`HKBh04ulL$G=YmeRh|yC_~K9<3-6{WmoaHdibAgLsWj5A~f`b z;{CqZ51!m|QQ2nf8`16hB>L8V`W{90A?*`h#dMrO{s_?i zNq7lvYPv$j68qf3y1!9dwpQ>{rrh89T_LvO{LgFEiA_HA8MyQXs@>>~Jdes)^ZHP- zelhiMgU?azNStTZDL%omE-m&wY58<0N_L^t(7~a(;2QE@Lx#H0?mv_mF1qz>mk95M zHmi_u0YwS1wx%edZzHy@JBjv^R2G{htA3et;>#?zkP4_IHVc-YN2(dCc&X3QL13|y z^65r4Fx#Z4z`sw=i(Vdb5uelSWC80pMPuu=%m?Kqy1fkx6!Bou&yOImFb1a$%udgA21IQ-1xbajz3lCxpsp!;jfr_iHp3q7qNj?FZ;p zy&h|OC;-KC>AIUwt7WM6%k%!4-QJ9h?1z?&N@(*yt1@Ssw!Iz-kyJ)o&z_agYk?m{ z=0SJJT~t0Bhh>kotI|%)(q|uPiG&LaGibO{vMP@3@tq5KF!3!*=4TGJD)sbUL()O1 zY03DLI8P0!=c3Ea4rGGZG+&mm_3%Du(fhEkC$=}f+}R>CDc&4?X5~oK{E!ame661> zEyx<_l1fiS{wEzEn9%K7O;_`qi-wH_H>X@gmKzt`hUVN8)jk&2%yb3HO{>tYYiT?! zfo|DvXgHW3C+`O zaMqyo=!9z_L#m>m4QTdbsW#|3(bI-e}a#K%8ZE$ogZI^AkqA3!V$b++%&);t2 zslra!y(t~qF%ze%+0fm3_Gf)C_XpH3oZa1iqf^Gn212C7Szk~w_x@dfEoxg6>2Nlt z_3i__e7WcQxVKUABJ$#_Za8yuaCNrtisZ>H}ZVZ=rQWH5Seinq!@$dp1-9XjWjyA zDnF`pi9ES@o(2Kiq^^JcabN_Ki%65RU^Q7^#~sQDWu^mBCkMChc8O5yLol&bS zaDfOSPtN-NnhV^%aQZP&Y6OuaXMqA0#5Wsz5W>=0Y&NV;1ITsfW<#g~S_yB##;fic z5k0y;l$9C<_$_2T3JmV{(L%?rqzE2C0!BEz*!@R zQ_{Gc;Md3enG_0@D*Vb<29Hl>hW>`%qw+vusWAXPfxE+1d|ox`C&$cBqYQ~v88e7gbq)kH2_Jmbd#A1!z>`&Eca^-=hi>ijCF3ZaE3jzo*+ z$IL+3sI#9ggRoR5Ww5|ZkF@xCDukt#-IlZ>-FqNwgnKD>Zlx6SHZ3hzg%{_OZHS@vOYZ3I#bXb zwoF8mR%oq=B)E7+fdlpG{hv9S2%i{n5qEP}{-i+6VR_7pj#zM531%6{y1L-lB7#VEV{tK=UDx^V_rl;nx91~>1U0S&Sa>gb z-Ebn*0@06cTs`;HES!X1@s1$!&@6f3GlqxOjhqIpmzaXNzzkTI_|xHC`l2LEoMh&f zSlck&>a)c&!c=x&VGSnt)sk?=m}xnYg%OEnTvD)I8vOSM=nhE)ky>V>g5u`i4t>`n z3nQ}0+_?IBr72wzZpA|B{tGsEUk~V45K1f7%M=yh7O%vkV(89G1aXj=tpyOps+@oF z8p=!eUwFrKYTcDE>JoWiTwXX_sP*;J=&7U#A_>zPD-8L1Wv~=HvyY#7Xua-h->E6rs>1u7-rD>}vP+DOICf&l_f635N z<54OLqx&wqy$Mp;pfY75ATaH$i5nTd7W!h@kW3Jmo_sm59?a(!*xm^O6L-K&V%D<& zTg!}Xr_XSHA2 z%-UF*8d~-G=O}Vu5y}h>%tTcj`0VZ$&yax;8DEwLU>|Qm;@wI}1w^u!8(4FQH~ljr zZfpdR=;grbOV)C8zF=eu(#<(jVuSs>omDbdK@LG=cyWQjRpAfDey{{eOHae_s_@E8 zeP=*ikt57n0O97-)hqo0-zdV&>9RY}Obd)x1G{g3)%vld(-V?=A}(?sR=qc{`JRlZ z|0c0A3`z*_>yy|nA+b-h_{7eBKKgG#x!cZ14lP7CIkdJR&iS-l5#)E$A+k^5+0|@D zq|idoC-=7J0(a>mh^#JV5*#-9=PVjm9#;s(AtI;CjSn(@{&BOaKz$Gsvn{w5hi>2O zatg{zOw2YcXdG7frs8!JFNjZPazzx=>xgX?0uX;GB7*4GHmY7mtbLqiH;Na;F=t#_ z*f>nxv^{K;5TDPqae+0AJRbxbJH*#B-MG3QeyEq>KH40MeDBMV*>GzuF*m5&4mMwi zJT6;O_OBY;K8mg|ANd23%w^$%!GHN)4a$cMfy&-uh5)Chg`KQ{#-c`0>01^qsQg;x z&e{^WStQ+mLC5TRjXbb3O(k$y(t<@Ra`fv#P`h;Zg;UvPtttgcJX97JlNWWM27UBX zDHI%uFJ5vRW3a6BQH}S-iG}Y&VBu$`$@ugG$ws^@Z}#N`sO+`&vNwDfQQ zT6@c{_skEa728XbbHUbLvp*6Lqa(7csB(?Cpdww@G5jEi1(9Wi(-L4ojqvY>FP)~Pjk*HK^7q0ZoX^$5HuzBvWlGoo6(}rF$}@Q~f@ud>5o$;`}piWuX0ZD=c>y zl$M@`Vf(4q?k(p*n<$bv_KZuLT$?D@@LK7>1+Pdd1B^kt-wuUcsIL3xy#u;Xk;JiQ zz~6R_{VFxMiyKL0fiVxZc#G~E;7T!BqdMN*kx9KA!&9*OPZd-P$= zu7vm=pZN1p27ZTLf zyC@;9*9S~H{7=>pl^W)VD|G_pTaC)sUjOr=3(5vmz8HITm7n;j8>YK)tEPi{50O;D z7=zU>TQBZCVJnnXDBEY%!9aQ0rOF!eW$KS1EHQ<1Sf+Fpc1hJ73!n;!37o;|SMQ_t z{Zy!nuQxoZ8maK5>(u&~7-4K|Tzq`ftNapVM zQxv-|(FNgiR2LjW)m;>9HP_>695u4va#Q|~H7zc(bUcP_dI&gVE zl1Llln0!+L)AyGzzgq-uBu5eliaFR|!{cAG%q7Q$y)2Gak6W5haz&oN$Ze>mBl5;L zBzUQO(&EUOaM@^exP{6bPJ2=O`}hnWItq|0aS?ufIk83XQhvW*{Y?Xrq(t7BEh(E% zsTyv}j3d59dL_;cvvD=lEaP^?pqiG*8gthS?b{{jF5G(2#5W-{(S_w93yO}TI~4yI z4Cjmt6S3DG9G&Z4jz{K~GOg(< zhwGO5xmKwXQEN`eq-r#8UaM3M>ZE-`%wPENTB}jui2&)Qxo>BWSIlrphpgj}l@R%5 zk}m8izN*Vl>zMmjq-!G4OvY!M9~C|6@8}z7&q-vPN$A!L1r@&9iOXA&i4%v8N$`4s z+xlU2DySHm|I65*CSO{w_(y0fNMxT$=x7RQ(ZL}obP*|N9NfM|91>j0YJ{nJ?{M&c zgHhNeveEblc&;err$?4QUViu!R1DqsZD@Ir2VOL%u+*A6Jjiz3J1 z_uBS*!@X+jk?#w-)!eWw{DUUV zFBe{(LkmWvs#(~;uPb)QwF!z$^=qby@X%5g@n7}3!!J+HMaDoJKgLCNJWkYl>$Vj- z0QEq1W(Eq>Tjo$gf2aqeBU@BaOV;EvcbfRG{h`PrPx;<-Fpn z+k^6T$HWZ1;i?hyHG|b%_`Ce~e?S$w!1V3H@rnaid)&Dw>YPYK7t?PK!bbaLbovb_ z(Gi(yd>9f#X8(r*#EEHx!_bmR2ZScE5p0Jl_kV@3L??C+a8ms@pwY(R$P$QbHLeQX zfBUaHlNq&9h-5Vjl<8O7_2e%SxF70(=)hc95EtI8+HnSo3q-D(B`%K($kYD!aAg1# zneMx!cXw*nV^c>B@G<$t8?Bc2y0RYjC(N$$Aq5(e7;xjo8+wD8L6$9@I3Te}6sQD+`#NVRNxk6KLfXE8E}dM1lv?70&iG!=^XNA;UFe&*7oBQBCi)g>qg|TaUHP3 z7Z}TSM}@C|&_Y~Opy1HfDVL&%x_j=GK_)@uvALxNF{n+g^NaM15muJSV{-#*G3eHX zsLfDbx<~UPF4p%|6ft(h=>|~8bbn6n?Cfg$k(Hp#bdP4xyqZ#EZg(#!GX$plGY4h` zy8_(I)%PV_Ji0$KU@eE1eS8uo5F(S!Z4)5=O#G|VN#xEVF&W&MVJa$Ub)ds>q+247 z%`GeY4^_8U4n8ZRSCwI9iSx_czF%5ypY6@N+fM17IwmyTp>;kRudnSP{Lxcf*24sR118#O4BqI}c029p zv6GD(Y-!@3x_9QVZOS3h+p*QJ>1PWJo9Nd)d&D_sf1sbX`@L3e^dlpNPIPVw9lkv_ z{=FhK^=&D`C+2L9Z#OZ4@bUK}${BD8Wnxnu(9CXHTxkaGze#w*`A0i_rzP-tiEAfpqf1y{;+fN4sRYLwvWU)!$ z+)va5)BBU}2cnote09@84`PCYf@4y_EKQ)R&|KSsX0;c8;nw17C?)zxYn`SjW(odq!AJJWM5wi88~qwnk73kZ7#d6n5L)ie+3mo z_IJjTW`y!&?4;Sc^oLLeBNE*#*}3O%e6%TAc5ZGRs2gK$w>s<=KKrK}dhwkkX zJ9LioT)F^pJN?Q(ClzBsmH&BZgzDe+hxCgJD5=%@IA>xK-)a5So_dZD>|!f~M2NLWB0`Pk}K#(0twl&61e=SxB`Q{O|5>eUXU} zDR7=IKodE6H|tJhBE+{hJ>bYhN>+Unwo{1=I1jdGK}B74sa)$Vd_lQhWcN4o->kaI zzur$}qMG3M^LBkwDhBPJh|D)jYH%j~u=1=n5SF%Ow_)`I&IjKYKZ&wrcnVzHKOP-% z?mFJG^!VfTULqU4TiDr|#v2;>mku~`tj^d6YMbbbvw5eXz(kzL<`$pz&zSs5INg#1*zt|lGm#aS#tsIf}<{&2|v>T{d+^%(@Ay8_g zzsnZK>paya@*P_G7$S?dC&AwMMqNd2`eMp;s1Mps-K`IMBdTJjy0-Q=C^fB~cd!8q zcjEATu~2GJKoazUDY&0Ks@xt$RpP`px76@H!oeI-6;Qq*4sCNovqz`wktC|Vn@@GU zjr^N9yUl^uY-H|~D)pSyE4SrDmEhCAtrJEizZ~oP=nZ5VL{gk1Dlq8X$6vzbBa-6W z$W~uf)o+n;gAXSlz9vSP0_Wr~nZf>E$aY^YZyI&$lA@btfz;-%Ug&y7e zhw-S3O{B*q_N>~jPh5DY^N6uxA!GlD$PXo_xw!igRh+(mxt}E(V$;&MgALR7_~6?i zP%9!E`U*{MY<_gWCs3(6kDAgI9(WK5a{^sMZgsLs7stsZzMRPC2+< z?Gw^E2aEm3jhefR6gDJ2Ofq5PRNat}m<^koq>AaCG5w&G>J_>|Gx`+)VJ?VBn{(?x zFJnIa`b9@z6+uMSoEsP4rYVuFz-J(I1eK+Q4mUO;)P8n(YFCI%D-9fE5J_)#DVG}R zgH{?i$X1V9wd2Jv7FUH*(@Fye8C>ky8{m_@SLDbEEDD=RxEYMGZuQP3WDJ z29z8@MEaat8!%_>C>)7u(jX#%&JB%nR>j3*3WCEr>E+C1+&hrfq1I$BCE^!(k`cUV z5Edi_3_|1tN$}jvydNX=N}>{gt=76~6S*(8$cSu$NS|YSweHD`wWxlyXDf(I^lJ+l zW~k-!cYF#Cpn`&ke$9{@B*b-!ACOGu&edV+)Aw1-=YLY$BPfXI+XCNheYWOR)qh&( z;k)o>5FMR;rcvKc*3W>m1OAQvy$%Y0#5X~?(8;n3dSCfF5H2pUNN{6&dYfW@JN2VP zKmBemb0Sf!`?PhAT**G2X9tXc*SY2Q9v+LAv${xRzTDm#aL3AMm?CBbq(tS~eZDTYY9bHnq{*$GQ8`4a3AJ+@??e||?lH`gz|6<9nlEm6=21+3E0ZebndZ#k zJD{!)B69M)@Ez&J@{THYeJ%fQ{0mikI@Z{NXy6|{<)D_{IIcTpxN|C5C!lJU5j1N`E8bhKZVQ1+PC zw}jHa+_&7KBlAe?^)0dKNhVg>ib0sPOIX@5C8A1`1LBu&8a&z}R} z+*#Xx&d-7P_QwmD7zI-2VEZXu-j3Z94st4?J=^EqRGs3x#kC0v3korMzoUrHbkNTK zRkp5@YO)&300(q@K!6UrVoIldP`Adk?}4peef%sPc$h28AgEhodG7!R%#G7w`+lC? zIuX>=K=ka?IpPo2&|%NT&ffv0B|0^O?eu{IE6Rt<-}Xc2c2a3*aAqhT zz04FmN3HSWBM+>0L>0h444yd)X~6shsR#J^a~*blw(igQT5*|W7bBAH{8Q)1H$F06 z#|?-&dKmebnQ!NaJ68u?QohC#r~|U&&PB$R`OfjW5SHw^bA@q<75gImBvviibtC5< zD5h)S_hrG?p}1tv9XK~qhuvGVx%Fl&hxW1rvgbZOr=xBw_r)&g4`jzZ@ZDL17v^Hke7kPEk{v6Y%C(IDbkz~e6gs!TzFmC<5VOk3t;5h}oXDT++pAYx zLNZ(C9EV1LH?+cnh=b(Z&~VQ@Cuz-dD77*1TGi!Xs}F7Mr-rKg*d`C-qq&YXJsW-4 z3pz*xu2&-VdqDjOBGTy`nXRJU4K94S+5Rl|3NoqHO}=@0oMj!WnntmW&ZdTCe-1el z(;zCURGLjA3vbm(%1QrR{T!;@=-F=F@Wm|0H-(yZmXs*84MH2e+Y6fQV>RgdahI|~ zXrqgJL9@Mx27P_+XhfWoM&cWsTr0Tu#O1$$ti(*5lU$KKO$7IR$CeIj2l#D4=IL<~ zxHYZU(hTT#6uYYdBs=>9zUI4bzce8d zHD%0?o!Z!pjW3#=@v7tt2Y)sYS&5lnXQR87g3q9jci&tFf*aGmH#jU;hAzyK8)YCf ztIi7?k;poK_6K-}GAzhUtMh`^k6-7ys=WynV$Ahk!1(+%&+@icp+blb?_Ns8&3f;> zp+_Jz(cRt9=xq0cNh{AfrJ-EX3!#(s_V^whr7OTnlWpViC&iJ-W_q2Msu7=T)vf1Q zA+)il<_!%_cKs4^{)!C5JXX#N8neEdPF%blMX3m4a(AyHqu2SNp4zujMb9XwtoAY{c#03q&}rqs!{!VaGYZ6 zr3Jy`px6|)jA3HNF!KsC%C?Xx7`-&p9dvuH&kbK1u{YlVR zu!6y6&Yia=AQ{Yc|L9b(g286uoi{kB8M2T0Du+`+N!}7{=G}Qg>#4WdxB1XWuHdr7 zdckdVh-dciC(~;|b)+nOpwzoGYnJmMs0NoM77T8wVd~B0-yN0M!P2EpO7uXfH{G%^ zWkBi;E}OFW0aEWx0kh1`U$XuR*HPqk-wLrPT#%czXGWGy4%tEWbx~xK zeO;6dBD0@dHNOOh=dC;0Ys^eMcV=hz)z0v)Zo?$_2*%w#AELHyu$hqO_DV}Lc;`Dj z*Amdq2sRV)1hm6$gQ^dVFZ2X{fa>^y-i8x=##24w;RmShZz8s}IMA{Z`~WowNFRV} z5LF}Na?te+mb%mi!}lVg@yx8$wcC#lS^>X64G3pinwH~&cUi$>gHl!mc47?!y9VIFy%d=L5nn08 zCX`C00>k&JaN7T#JP-d!& zTQY-^aLW%Je}Xcn#Itb|X?%-oOHiF+o_r^%1GbO`uDJ3DIkqr4UkN|j^MWLD?1A%K z{gD5eDR+|8dWGEU;)>pA0nKyoWLRKy8#=^7Et?15Nx-m#T|B+TuTW&6W^>3u1#FJ8 zd%GcxIopnVkhZ2k*mbLJ6v60}smiYjp0x-Kg@GXG!XD$qOv&s_zko8iTe z6f#H6&W;XNg3a^q`nBuUH?EJr!%bkpPCFtWJ7w8tfJYu|9)G8R%ftsEd&uMCagHZ? zX~mem6?nuPSX6QQU`KX2e~Sb_b#qbH3(-U0?pP98p_z*35uH~Z<@|K6N!!rClSnIO zGM)mBs2ab=9j@zWMOL|)lBa-MnZ|7}!p?{ISt-~&5>Nk5?}TA7UDn3Bmsorwb@?qn@ZX{k z*MrUD@$_%hj*0KWe$2|91*e`!r79 zPD&T*2PHP12ucz^8B}k4brm`7rB5DmGf^(T1e+)1c_H7fzIwH$joWPpjN(?I8J)4( z_rm6!ZdL38)!Wa8iZ)gPUeI%GT#=?L%=~^Hk5>Fo_Hd!+6nVI)1cWP=o%r7=6cEj% zKS%TioWGegvO!aRLm#?(wkk>G`7}p0Aey;<`Zqq?I%rR^>T?I)elkcm%%`UUit)%^ znElBHZ>9k1AF^y{>man;c@CX(@kCWp{R}x22%SAYSNVf#g^wRwem3?*z{YWztQaqr zXXNZJYVeAL6KuVHk+EFRf6?=ETL+C?ky|z14*Mtn1TBCZCB&~O#)#fqJqsfYdBe_@ z&rrQ-p0npv4OWMAXz7@~1Jr^fTNXd(u**wB#>zo~Ze%eJ74%Fee}4!CHwFy_owbh? z=$X4m&On8-dE}l7%|}ov;4dzHv&-r1%8^4Tg%&xIYXNTCo5LEMsHRynS5Oh2Rr!kO zO-g?77gD*IC8$8NEujLv^s6;X(XQT15>%k$72qDRr+I$)qn*$A7bEdCH-RWyzZS}TyGjY(t4rJ#R_U2V+ zqm3(Uqr>2ky~xZM^q>Z*n7RL3oDW45GgDB)tW??}$|&ZMzR;&}PzlC_?}6ssHU)Kj z`V(iMz@k`9X0zd-GR^vx;BN@1&@C7IxekSG^Bg`Ix+H5>DKa-L()CLyv+xvx%z^yW zP=!9bK4LnAHf{-InHjXMj;;TMzT>Q)?A`)7dG}7};|xhvRIw&v8k$WWY~}~b^0Gl? zy1Z?^`TQf~&}Md^49&)7vwpg&=KW`~uR__;%ng*WD>BpYWH2tOO>6w|@92{}y{N^v znH=a8-`1tJ5u5fjUK=|sTW=n0QnK^=z>Py+T#oU8bhE^)wv#Vv8 zVi5{oK2@7f=P#jZNtCk5_^8+K;CqxeH-$`|JfhpU0qvur*6v)?sC^E#JNr0Yjx{LK zM5ZJl4CVKX6!%(MaA-CNESxr(Um+<=*r-^Azx$8d>I4I6Sf8jnc`V@2$}xW-{~-SK zf=#4UgpDm$=PbBdB%J~#8(_NiY?tUCsLgghmvdZa5CTHXq(QHr5396%2?x;IxgloG zpcl5jLHnki>m#scA!f#)7qDLYy&1jfU8k)h)e9kJ#-Ix9PVlAm8nEWLRPRFJjg14Z zZ|Hld5_hMeOUfZ;;-ELMR+~*2vKbA13o)|>y@9oIc<$7BSwJcdF>?mJfUQG7#Zz+3 z=}--7Ic4!eFM`Xa4h{#`9Yf5+`n+UzM^h0lj%27i#wk^$+Ce&r_wCx8wWH|Zt9KgQ zMd~$E1ieH>`@3FSZdi?GrGXt{W(Ug9*1b7VzVfKnR^25*(<@osPAqp1)%C0hel8|c9( z+wq!+@(?23f+gugkDo&}SJ>h-(Bv3xX8n0;2r8B4Bq7DP zH}_rh6?b|5Cp)<~0`u+UTKe9-<@rJsjm(5UZ)K=$vzY<24Zcje>oZ&p5|@!Smt?j`Z-YS6#6&YD=90N`NPI-P(BGJXYC-i zg$CQv@Qv@+1IP9u=8=1jrY&G~`}JMfBF~|`WX}#_V-SG6jixVq2Lc-aSr$jctfjWh8^^alX?rBR2iOcFij{y7y=TJzeR@ zL!9=Y?8-yTq(3k8oD(PHEXlUEVC!74Q}JNlKUH?NA?BxVy}po?v(JP^T_0N?vZri{ zAMx+RyT|zvVksp)nQ4IDpP1ONQJoPxw!9qTm#x&tUDwZ!@3hyZiHJ|_DLMTws4rt) z_xe=u@#rphdY7u zq#t7U0dh8Kc;!xLhh;4W?~E?3G*0f6T3eCpi(7!4I?Sv=?K2}fu8ocAluvE^M3v}r z5q`lKDzq=~Re3z(4YiNa>6^l{P?;~%h%siUWxn6Al5e97Vx|mw78x~0`p4DW0Ab19 zeyMdQOfq;umfI*rn~8#ww6M58_SWm~p}-;@CllNxWWBNL?$alqx8GKj25ZqwZ?`M%#%|t#SDB4Buxa=AR zaZ}*DXq)@0dW-F7cWxfvC(Fy63~jtNMispa2qPipM{s3u=4zEnb9RK{8P|$EK=0d! znAv?c2$@ItdEsiFJgNWh{gDlur}xRYs%LBon^qAThA~xpp=tz|`kpQJap>y_XMb|#bD(qQF4<63y@_1C83BeDOyox*Vu^Cfh+i|_{ zhP52z=;S^3$E3!(Cq&e?P0Hwr$=3RFb=*`F_!U8Fp@vh zv#Z)s__lmPUQ`GOZ5iT*ewX=T#?M|k%ph50I&DuD*=pIVQvXu*uM4QsqSN=-Csfdl z{l963>P(%$% z+;OF$HbjYN*elq;+DTcV1_jXbNFj8}o&}5w`!xS-h3AoUs-6X{_tE>O?%fOR^js-% z_Mxbh`{-n<;iw9wQ}npVUd;?)9Ig$8iX!J0QX8CGukuSa{v|Wg1f7&;%gg>%irTp~ zi`9Y1ld`=Axfk$VD@c(hO>2A!B^ zON`DtyRZAK3kuH>bjR*7&>7uiU#3?hY3rYIE(Da>kO)zYnqmk0gohSx!;3N^$FFyX zaCo(OW~SpIqj><}UrO_;SM89SDSi4kq%&4Lx#%pt71y?yF^6s#WqnV22eu3w}IPy}#4>-49=KB`G(OLg*Yn z`78f4Y?!NC_bQD8)yleUkFC7|*=P8lY_8@}fSxjjGXgxdb%&mPdnCHO+~R)^1!ROa zx7!tP%-8Fq^iaY-sz#{253(U9YDlE0drc9_f(0zRS+_gfcaGA$Bo5-TOiY&PmpbgbjLs5D5lHIk6C#i{ zExYuX3;zN&htk=87A+CkT(98;(M6k3I@!++t#{Z~&Kgn~Fg`-*bU!yVZ$C4#idJ3c zJ}~MhP_~ECX@BkysKrj5jCatDsnD{*K4@mGS3BdfeKm&%W&S65Oemf0XUmMb$7j2a z><_V17(dYUnh8;t`U7_irE~rqxzT3kg=_5?urmlXztZdN?69rSZTcB>Co7ar{c}Xu zH%n>fRNU>DpzQCWj;Hv$-d9Ndw3;7UN;(J7BePa;Hy?5J9*QP(5}<>v9ktxq@yl~$ zC3F@b+tK(Hs^DiCiCPQ)F)`^7&;3eL4wc?SOvWueCCrbdPO&!ao?HuNf3djDH?w1B z&TFBa@4w&bN*Df_5{iqOIf2?|rn1juyPogt`M*-fsrAyE73Zx3Wo4-OEnnp`r#NSU zb!tIbS$@*aDEJLyL{PrLc>dmG1#X=7rH;-cCR_oH&QLRD(CZt#>KnU(@kbI^-&Sqe z)+sZ5C0~vpbxDkMhW3p&H(C0+Qhp!Xs9d}La%p2}zarWRH3zmB%nNemq0Z9E#zSWva!{~C*mEYh90Vr!Gb~{Ck76`|<hQ7pwVa)!T(C1vBr^O9iMi_gm|W?a{iKNry5t zs#J$HZaxe&283e&SXXPLU#Xv9h(T_$vUXE@Nu!vtNWbQ(f{vGPWa*~1CKE-3v5QKLCb zaq&xPWo*!v{}P245-P1|GV1sGCH5Kq!_8Ntm-Jd2Tcdrw{A#;#;G%yP^Nyy{)eNN% z7i6p9`6YItQwj0`Fa7J+4Anbyq9OZ|TJH=kUU>@gC_2fIgM$9zrk>kS6EKv{GPHnM zcM+ABBZl`v<48j3bVCarvRczW-PRMu0ujr7#sXGwt9AXf1~ZEzCDS>FmbCg|WRh(_1D-}Y5oF1y-o zNCDf>hJF~_hjo}n6jrC{9sl%W>sV1aI1UXL+ofcDMdVFQrSjX(~2=|Q}Q5b!H?@?h? z7@4_;90oxJgM}uXngJtpfd9(JT>_(>+ zT9Sh{Qo69xKR74CvQ^V30$RxG&U@&KJmt`ip3W?^V6_vRaZ6j*hl&tpoJ_ctb&O6Y zFK-LF1Chx)dM+^|e!GPFy=1hL1R#@L#Gtl zq5?zfR;kQaNDC3-ERwWxy3nax?0O23>1DjNa(aWYz>z+cP{^kb`m@y`I*cOAW~sdG zO+OZk)s$}L6?(EPdxN0f8OEH;{3!bBoh>h4w%ECUW-gW4_V~crYWxPRdMat=7%Jbf zc~43FH1Eoe=#UvLcFsH&toA%=Kb(IZ8jvVEO{>fwibRJC|6Yk-2BGP$Z$q;zsrb>L zZYS12XyHgSsdX1U|KHs&AT-_iZK-vB$;G1+x;t07MVkqP3br0#w$6QbF%;Wa<15f$3s|mx zi=8NVnF)gmww5XjY5+(egh9?#vCIx*Mp#9nio>=;GhSy;bJ%z50 zdyH2)C0w>p$<$KF_y;>UNM$3v~3-v#V80xHtD&IbZwjuy&5~OAJA= zw%qr5(9#%!ti#3&diEdc7GdewnnOW3A$9P42NbP7xi=#03|Pl7Ix*1E2C~7_!~5L; z1|CM|26l?)^HI512B^Ee#O=SLdCg&Tc3>xKHX_^JxUog*f0Cn7QLw=dGZO2hM?eoDj7}kB=vHKhhwMK^MXpCN&CDV6ByA3FORs9C_>;w(KwB)#%p8=! zRnXH7zv>3pQKX_|Y)=LSS2gEXsF((%=`izK!d}4e_^a@s6-z;}7-l8~dSP2cQ>B2u z7ci;qUeNj`rPY^p%0OVFlY0T{Ta;&cR`qy``85BN{aS3FefqUl1BH(A&k0J} zFgnAJxd=S4J5g|CB|b%q|H(m{&g%0Z+Z{ZAR>1|pq4`&)cUunnVqtV{pYW!H* zy)M)ZeJjCr12z(Y>vH}HI&NWfQlBNTwvFg|>0m!7afQ7AEJ@zqP9V z#EOIHf%GsspU>8=$B0ECb8vhif1X{H>!e|3MxUpUDHByUkR3KYV53g7)4()W{)j+z zv6e1+zki12I)|Cx6IP@~sl4^OO9n!@ z$*%5}TTkXgQWuSe&}46SLo-)W3Xs8D79K+GE@&aiyE}W1MN8)c=3E(q>JB=|&n>E& z3vb?dGz{s0&hc}AHJM`~3+6(>)Xecy%tA|t6XMg1LG9;_-fsvb06r>Ljw60xncDA}TpHRI< z9JnMFMxP-lpyfur&`-PHYSrO$%E~C-W1c4HrJtA)2{ZXxz1tX2zfTtJoK`-sV5U_w9w~ z#*m<*v$m!iT{uJF@>h#dOb}t%S4?mYG{g!|sq~w5kxn_#2&0q#9Iaa?$NV0sJ`-@# zJ5xVFWj~z&=zN6V&eSxXc;?(CZaK;kco>}o=)hZ}MXv6MPS>*K7(Px~wb4)3eVPjl zPYk280lmKD-oS{}T@zAuJ>V6GnR$RtgytUYq0ZSCrIk!RuSV+A;0PfGjhTPVqV|v<(&L^eaaX=V(qw=1f zCs5oFC6>>)q16&?-@W`8Wqdk2kSjhJy5xoTUAd9v&>4a_CyvJcm$-T)H%RnP^tm%zIJ4-#miQ8(CGw?zZ*QK~<1FJl?M&5;*Xm`;o}M z1+H)ZcBgXTB4+Ag+JTceYA!@f+e-H*LVb zp;BPXR6*%C*!QFCjr-#ta;X=T%a@60!dF0B1yQ~l3Lo)1_)qXuK;ma?-RY{xy+CaR znV$;QeulFX9#LMUPZwHQ;|5BlbowAG3R#5YuPP}!p%)?VRdcot5@ApTULF;=l9D3~ zvO|mj1vAg+G(jNLNWB4{p~fj-g_7Sbo9YZGy2H(cL64F{!y9f$JxzO*;dH`tRA+|M z$%0(7?DaEX;ioHCF2qek>5+t+xq_0^e4>E;K7;)HwopyFJQ?uwN3&{-kOsoK75+J~FcCf-Je#v&v}tlRa8fsAZKr%tXYndz!vTw0L zx!{%b8o7GLfQmKT%q#Si3(}|r-tAW7>5q5z+=MC<1w8p@Y_i^nxXOl&?cBd~>Ha9y z9?A}D5(X}hgqvp*>MC=8YsaIdr%z9puBwP^H2CU_b|{>P8$!OriB`F!+O_=^Z~T=| z%-PH_OkRA}p|0RJ(Y7ridbV!8&H!p%IGuFJ!iyTR*W7yE0F;Q~bgm%>1#>H27y9cq zpb&)9S%wy{ddgEQd;VKcUSqW)*}llVLc2p}|Mmx{?!(Qq2)%&8+0mXQ*Y|*Zd^nwC zXlcUgKA?U4k(Gb_2ijoabfO{0Pv*>Z#>sIPp<0ZQKvoOt5e$#mJqjX=O++#=#v57R z(O>#xPiD|(lv?r0`*=yfPS|uT^DQJPoor|;Sm#m1r0#f5)^_UWRL4-n%Gt(BCVzrPlh3J;$#Lf~#mu`rei-`inv(HCr9b$9FZ#Sfp?> z%}}T$B&NZZCbg`AQWznOQ1zBR58`d()E6X@o;?{+Fu`g6jg(QJ61JSIsZmu>~i1eXX3~g_}u-lCJp>l0CVsskhTspQ*#=`Cm_? zJO^8K(&o`;)RieBFtvB|m^q@o|1_+l$)RfL=85PG58do1=S z+M-77wdbs(Hx+AxYEm;}5qyJR(sD1<;eNDMi!4~-Bt?=K`hQZ8n^s)!7@@{yo+g!0?jS( z-(<9@rt=!PE|S?)zZ(1A8>regQyOJ;$aG1O1?pVRSdH(W)IF4$!U(WgyFv4mmJ55u zK%J+^w^2vn+r*lPv=UAqRcPy64;%YN&pD60TSU?1vw9%t2uw=76^&dEmrf-}cBlKG zUy+E~C~lZ(ir&iyoG|{&;s;UOkoqDdp*1h;(&T1cWX{qyj07z9zrvgs9+_}D6EkQ2 zC+8_T8_|7SDmXs0q3&quQcO(6rwnEImo1_cqpDeQN@8Vxa|}POPQ7DN8n=Lt@hDgKWX{_*kUL zxYua4=)^$=i}HTq0kNHcR5zT+GOB-|kd=LKL)N0tw5cKTQ)|}y8$Bl2!P}`1)Eu$a8WfOL5 z6d6@07q7IcfHDQ09>|~MfdS`)>(MhPata(6U9zhAYTxguT_?hgFAr8ttX1Tw2}nvh zCy*;Zci__B*ZU0xaylW9<0234`16JNC^VRffWm{Nv7o|!-@TboOrTYmR~5+v>MATAg{`wUpDanFr``5cdbrb(JNruf5OvIwe$eqgSiw?7GU8JA81U zcq~C^Y45s`5xj2^pngV_fysCx{0uv#MZ*x&CH2jVn!9G2p!OBUpm@w!TWSk2-PgUo z^kct4?J1e*g4!3X2aBzDz(Spto6uLuecye9db;!nix0aOoxRJ3sSMBl>5_zUx(GBr zBZ77se|qPY5`5dH?tW6hBXo=WV6%3$|4NE8fMo;ur<6yj!&5*hw0?*EDdx~ux=pQyAKp0hNm!I0`xO6^UE9nqbb=D!Yk2yG zZZfp~n(cebZoY$#!Rb>7y}qNdF!N-;_%*oT6>jDk>Z>z0LA&5Jwef`sh!T?milMY3 z4>n&t7RtiZ;GL89F9=n8-7yDGA9HwgUQ0qQ8Mvxcs>jN?`%|O5W@Z=43yrouQTMX1 zhRDK=lL@Te$oj(^!~VYLd9_Jm6be1?@W8Q?V-#9xI6!H1y?yPsSiTG5f70~?sqjxe z>evi!1u$2xGaG>dTxL$8w*vIe#lYUxu0mu%SR$#Goy#gRZ@IHIj>mfbCmET`%qaAh z85KGcIu0KLv5gZ-ys=S7pkAI=gFxNuGV=$$uu**)l(~LMK&*3_nSwer?#{hTml+l9 zF7wbq=KXyWDy;@<-qE<}h zolUtzAi8m@;g||XXLp(lv;ApdHIw(QTcjA&IN8KI)F1QZ?*xdvLpWVye?zFABZiWhMfmk9B!$4G~cH zjTf8G_zP6XE;A!g`AA4t(IXJ*4;gUnr62nZ{Lf2aZmZ0QYp6_r&6}5n{)?sP(wB%n<_$DqhThL2cHc!V*Y8vsbTIm-nx8Y6XZ^0>v z6UiJKbe~eWB*z&c zA!zo1)Z_LU8?;9BtC8W&k)UR-ptqpf@#^XwU0$NtZsrDh0Rw8&s?kgPLu4_8)g0TI zudsQ@O17)^u-|2foD$EMyimlHG9yzVYOTx6`IEJQ<4FFuHXnjg8@rC)*t)Ux?^bv= zL{5=cv);6}Y5V2BRBIt}N-{swwBGf;lzP({o*ej}?9?GCa%u}%l=)&I$6P2o2L(F% zi^D8AFu~Do^I?OfXdaRDaFtKr)|9+0XDRf^mdni9^EM3NgVFhZUX0d{&e5~g;OwJ> zf(s3)asnc!(7Sa?LWT@qTtyphIvLNFnQsA=z>$B#po%Dp(kXd1v_?r7a=IFNY0E{Y z*N zk?xQDm}~PErtIGI8H9%|aP~%Ju5R6P^J|H4Htp*7vd;q4W0(0sVfjZ`RZ}pl^Vwy~ zvU9#Zld06&D>jK<82o=ta^?g_2hy~d*d5>Y@DjS>SM!dd#sXWvZD)oE;>=q2G&lAD=utSg=bpcZU$mkdga!ynyz>i#Td?M=PnBNK3zJd4{doxTs z1mTSiuEC2D`6AxU&bFfu|8M+HK7JDl^5NucI)-+JQ04x!L_kz})l8+2qhJ z=>71~hg)7l#hG-NK>ma_ax+ubz;}4}Pwk9Koy%mvok(q+D0q5Wmh-EH>(AAq5ZTiu zwLmBzQDLJ}m2Z#Ym9+aJ!GgBJ%Ko>GKxpy?-BJrGJ^rY=@LRr|{7;SmX2PGB#&HuX zSI7L5q1?j2X)4hV`DWePF$zMHcj<1G=oxL@!g>=Rw9)AmmFRoZJ?~#Gi5y-C?bG3P zzyEO})8iWd7I{(j&?XLC2<|Se3C$G3d zRC}fq0IiI+_DtGFDu4C-_UlKXLdfae7Mit&v<(04<-YSFb_zWlwaO-aJ$44f7PTbF z3sE;K)52GSQ1~!&{Jebyk~wE~>3o$7uAX|*>3#NEvLo?R>SFE;dTR*k@|h`p9>Eh6 z;(L7JZx!#_A@ksjIj%UjHRQ}LLP+wC&JH^R*`bfpAyAkyXKM7MtP`J#*J?$H8T*2MP zqv}iuewbt*PKu)NyZ^mfi)tV119~(lajm$`(?vB0ow(#(gqmrDxs6_1Zt_b)?k|Xx<=6Zkx-Zd40I!FM;KY^O^*Qu zQUsmcXCs3nj0ZbE-wwK95#}L*vZLzVwW!OPvw;8*LFe_^BJ;Y-x!0nZUBbM4TezF@ zKgqHq=nOymBf{y0KW6UN0u`kZbZ(!8jSg7He7+5BvLfgc|J=}ey_;$Fh_X;4!WAjL zE>$u@BW1SCJOize9!CcDit}fC6|K@}_WIp!PKQ@^bwP_YxVkmKRPpq`?rj_mQgsBK z;FrkdwYJ|HneEBheLHwQ2v$tbOz?AZ!m6fG?ER;tw(CAm(>T|x*|X<1YI!uBGFoWR z#bMXE7x}4QF&+c5uN*zmY*WJqQBkEDCXH;+G~?WZHMS1QH$F1nE@?!1%h7(!Q(g@y zFHuC88Grgm2F{J#`ee}ffPg21=63o(EuNAN)c68fkeLBE*kaC=^DErGT|!}$s@pyBPjjUzIlH|ZlN^ZvZhQ3F0p;K6=S z;e>GD1+F(3&i8mPD~dE`{-3gzASpe0biNHZH;^{g$%liAo{pl3TyKW89t?Wg5oYqA zBCA?~wydzCG}5n`=%)f}IlpV-S20MxW_q6j4LTPwx0anoH4tUupO;x^r&O*&sRNEO|WmUkbjxclhyftDCtEi-(u)VRX3A#cNL1FKC%dUIN@-qF~K)o2Z z5UT9#OG=)*TRo{i%5%XfbaLsg02kHXQWx5P>J<-s%Hc{xurcX7$stvvj1&HsF{<|X z>QUN^?eO$HzXTj#sn6xh(QR)OvgS(2SKg1w%Fq4fa?s4;6S9`GB&{49+o|5#ow2=Y z$8?G7h0%h-VJGn=oCT{-tH^%tDV&}=AgG-#SKQvAGs!JwEfU23n5Z66cUzL@%r{}mqf z2r#ZA%w#|BZ+tLy*36IJ=(r;9ij`lSKL3|B^3wengjo7ie}CJ9lVOx$j}fFPf0Dvh zZp<-tA^+T0`3ju*)B0vF`~5}nt+x&}d(2%zX$M4*X8uXv>a=!e!Knw-lJDqy@0Q~C zUH#afmk}Eyg}2)3b?VJlX5L0^oZt`hPHy1IkmoJ04;aIR_`udd^~P6M>&U6|N_OI) zJQjHYryx{p9W=gr_3^XR!g0y|lpTNyw^$eFkhGM70shvmo`8!+)A%%nf3$_mu(Q1$a$(#&a1$W}~Y_t{lpAZyd8 z=j_$ZxmvmEh%fW^QNgsUXEm!ftgEg`jz{I8rRI^ zKF2TEV@^$ePUk$cB9OYBX8K4E=H>^m*&1zhC^#Y8=cuvGFJ$D zGD}~-#rvX1@&ZaZX^Nnb{5-m5#~ZwzQO++2PI5|f{m?knLZvYN^lvc2ChD6craw@c zSD9+1Ntx28f5bXML5+x8Su5{At}a%>r>pCnfeCMR$XSTV&HrS#q)-8Mxfwp=MoRq| zVV_B>-dV^WG*K=NMwqFAl6{_GujoXTN@G80GP3-*%yXK3Gke;c83)zs?^*9_S^1hP zwB-mhU(oAoBQ|BZy2hIFymRKUV09eH`Af5Y0W)nP%*;XMBaA-Ib}x)`rZU>HRBbQ< zenAv$W~XN7n49b`cpiWjp?=fDiv@Yr!vDP1-xxL|-$o8`zHe#+P z(e+U@qC70@u~5%w`R(qmz;=ZyJco^Gzc=nOcnHk23^hxy^0oe&NpQfrtkzM zgHUzxVWx^J(V9`1fikSNX6Zg(h)$>@DBM5^81y5@_c&1#9YRXCKavR-UOLvgk;^x~ zzaDkQD7-)+v2}#Uctc9t?O@HM3J_e_FhOXqtRuo(^9vug<@FZ-^RkT;c{J*xj(&0O zU!L96ddrm}m&SK6_bl2Cx9LJ?UtX{c5 z0t-(uN?Zo*OB#N+bR_REs9gpMBhc1ykY9Q0jbOBbFaD~V4YlD!=`Z90^L8t z^AT(Rq?cjas@2QF-^t;BayBsY0`=d)(1(_`s9fCnC8CGe@{CH;b)?+~5hDB+f4MgvDvw;oixuMAbkDJ#_%%7_?%Kz<>D&;! zlxK_%p52b~Ypgje?A7JHYICn%k$}|TicJKGA?Rq#elz;9XB3Y32_O8|aU?nuFmnT? zpD<#R{TTAy$3KLsXEjG-cKyLa2H&%J=}35XGV#dk18mCXU9DvonXMri{fMULb{ksLBCSfS~b8}Hu+qjw|C>_9I? zL`{flWWP(L>SA1E?x&#WkED^PD_2=oAhqUi4b3g3i!Fvbu`4|+w^{6@Dv zP+WR_F|;(;PZj<(LmS88ywpH1FTf4t+lLB%1*H{^oJ^1qNpLNprqSyBpZ^E!ufLy0PUK-T^3Ob;tC-Nzg@op)-ozvUWl6lzeQJZzSy;6D8x;H z<66^Sl(5?@ZtNnkJBXw+_=1ud`||Q~@!cpU& zeW>6RxGqE03^@L7-Cx0a>as^k4QRqPyPg-Tq9i`5yj7-drjT| zdz?r*k5B##y8^FxWck!xZu_yw$^Yb7Pv`Q<`0g8t9ybz|(eA`bO}V-h%21?vPM=d5 z)rzjo=RMAvo^#?%c5EPD91@@D@zCFTf>I&!M4Cx{%4hhHzAFo69^1sGa`SfBx zUv|tgg)fY(-seESR}A$VdPwV3>2d7?jf z>m`!T{9|jc8q}BbGSxtV*v$BI(mV$R7r_5l?A>!HOo)_Z3KLpO>Gi9?)ksz|S*`F8f)bI+dL_ugH;=ec}O{PCXI*?DJX zcV}l^z##qI(DTMa6r1%0dM;#TpRv}z%g2Hp|5*J)ydtij9sfsFqAHOaq@U==O*-~j znJZZw-j{FvPT2)e)#jm}W2-#*smJy#WPi9=s4~SYMy#hE@~8a=-ujAM!*d{rW_^@LIDIY5%Ohp)18E z=^}8fd3j!KdJf&YH+Fm1Fjk%BtB7>mQgF(Mk5DFO(!0+qKeYt&<#OzlNRC)vO}ktX zZ1cuO7_ZLxzOL^R+;-%T%&1UlGblKT)z|O&X4o|j@>`6q>YmGmGz<8PL(*PctiHD& z{*awAIy1j{-f-T|oTf!|HAY?i_->_l=2QPkNKjg_Uy1x^C<^n=j;_uncteFF@Y4m6 zebBC)zOK)gN?E3wdi%t%JY|_zB z;DKzG>rRi%hkTlO(Vum4LPr8ps&aYlq*oDh^)-JkL-d|D2*p*7QeORb-{0W4D%Pa4 zpQseEbjv|6S1hRo)Xnqx1-65!BrjPe{1t~%0rUDlui8bP1QXPE!P{^#j0>4-Phyn2s&@0F;b%+Q#2 zC!pL;K4&PmnkuH*u+r-m=L0az0-;J{WS6A3+aWqdfe#V933?lrG8}Gx~}?1wGw5{uadD zDn;ZI)p4y->VOC4V)ey+;3L!n`bz%v6;HCgtX(Iv$~#S+JLax|vKM{DpX*zx>vD}7 zo3j+`8ua*a>16l`tz(cr5$E@0wC{-4FQLsW^CCcIr?PEMYQ14ET0NOp01_xjj+PBh z$d8;tv}5%eZ^nVSXOQ?bs_@e>P-f%s&!O2r67Z5rgHUO6ta<4l2WE+v1ROMWNloMd z9DxIQfRfQ}H$B z*E~b<&Ai^vLWW8Bie^QRK!s?zEd(JLdS)K%GZG>jhkQ$HHQ?XfF>WHX598F{LI&af zQ%&S z2U){xW##mCWYh)Z-Gs^=BQ+?w)P`Z7BqRNr7yGfj7&?vgUaWI6?q&~u`-_lC$6^Mh zukiB)KTlMGbNS85&8kev+X&^v=7oJEGwZeJt1)$?{=905PlA}l@`0Us6<=*n)Cq4L z-|i-UyCG~FG9?n!*Tw2v{R!H!zw^?+^;msfI{BvPFI95QLpiLly3`mA(~~bxW=l;u zPnht4vqNjJM<&1?Ahbnu&9^*SzSHMnBX zLHYLB%%znFQkanQ=2(ZWe$?ce3hPZixus*9nARh0zvxu)35#*^1O)G|ijSWy2TQ5L z&BJ?sS4)bcgnGNc4#x7bj+)11&5=YrrNzC&RfZQ@rr&^mO`E)sCcT*oJj%LZ>Ygjr z)FMv?tvwTzw0mbgs|{3oe)OM~cLXg<+&3B-ymrq(f{!ctVnXC}I%SVgdXpb4uydiB zWV4Srhp>LsBiOl2p0goSX3-4L&!uzY1cH&r&ub-T7Pt6B4Hryc;}n8ptIOh_M)l{0 z;&$o`*f@i*fWdnuV_MId0A)5_8*pg$k3^OlOUwKQfsIoL3s_0uYyVJlmzqH^WoR9T zXcq7}ul}?5zNuyqQ37c+1Xr{$;%L_|)j-b>wG?*=3sS#?_H`Pod-M!h%WxO6ocUd< z_w+QHHj~GCt&EaSo4P|9dFsb!P!rF^W|a4hytld(M1C$xqeaq*n|sDU-_@A2avqzChQKTBGbBXw$AyoQ34d6}PujC#bT6deuN0AoUxEKy8@wngNRo4reh_E^W2Ga1PCx&9Ey~ zRHZJH+GH`ZWqqlh&o49NwzSV=DTGvDH8z>{G^!S*-?>j$+4f{nvGf=5O8R!F>HmThB5*3%@a+z~{4 z$0{|%SLxZKR{9g_$}TF@yn>HW$R{`Lyht){d%yWr^%R?Zz&xf4AAqGH-QVigAc)xz z{lxs&yrxea1LY-nGp6yb$5qiBn^*XW-(htjPPx28h&5}rucCW~?tUjsUs@00GS<|! zckT@RbK%}XLFKEp@o~i9?<=bb^PsjrFf*rH&OLzT7u;vJf90;%}&-|JzUQ-jV{0fVLN zwsaN1tCLZo`XWIg@}dHoeAC`M43(kfy&G6r%8u&wUQ?(H^Hl)Z2|78dnsM)Vv^+E~ z0pxm?mxoVg7KM3}dBGotMZ5Q3HD7`BddS5v&DZs8=KNITRrBPGZR)IUu0g)XUVLTSobfq>^@Klp7HyvR#~luCa5~286mo}}@yTA%@aRH(kP&*w=jXt1?; zve~~;$i}108E;|BUb|+6=AWr0yi92GK+b{j&6O*izi5lxiFsk4HI*pgn~>&Z@PY-C zT${JM)s1%FN>3>r0p->*U%^&f?8R4lHiOvaS-V%`YL5DQh3-Eho;xbh@LUNsT`G0m zj>xF5<&!nxOK=?5SFwAM@5t@ROE2?MzBE(49sm2YZv2y9dTsUTzI8)>N++#SNBwiC zF)fNqOD@*Dn$P*phf$MX$kBlABdk3AVwvFY4#)i_f3D8jNhOG^?sMFzQ1gO5`dpU& zrRA!`Qh&9Kq<~aX9*5Qo*r9@e8}+AFKA%r(JAHPmgcYAE$IuDwAN3~D-3{`Y_*$3X z{)+Vm188C2Hr;#uXwyJGD%Dr@xj#@RKB+saYY?6@LHK$#jzwZ?kn9b|@I51lHRY{$>2-$*pVIPO~IWWh{rtkjyGnCSr7xr;v zr5I|;^sT&Hi4-E*Sd5nFKCesWfDS#H9`C*gIdte$x~2li*XW7T~^4! zQReo)eTPBslBiJg!ahrIl_S;4{7x*5*qSLU+xhHr6|yj@`?& zACzzm?_`~sr%|AHa5c16R;xWHy%U3`&b+YCQZFK4%i*&xB5prNZ67xakQo0yD`*6S zHqYldG$8joN3QQeuI@Ri`#7}1?n()9ODMR?0ajnyXS2I&=YG~3${}>|DwxsH&IKLY zYk70wNqWGitYmx7QP@|uZvE2U!?D}h{;hYl=bB;c3d8ulpGR1C7#w@dIAl?II)jtX z;mj-ixZU_pg7^tmwe~5}#>eRS3!k9VAoDsu_h)F~FMXoTzKq3!*huInQdVE+=bN0A z&Yk=DMna!(N;I758PsspaJpeqQvQxZVLwjCb`7<~=?NbiGA3p+yA>AaiSp*Z&g_(q zE?C#@p(ND)IXmOzEa+>n_KzJGvrX$@Nl!) z2OG^{LWPANc$W#umf826Y?pwm3o|eNr(sXVsToQ4^b@rqcoaX{mV^bNe0ss$;BD`yF!Rbl zubC*Zd~TzNflzAW{KG; zpmRUdw{{CbmK>yfpMEtp77G5HoJalp9$ikK1hKW0mjzc1{C?H2TVUlC7N(`Uj14UO zqkPw!LR)!Gs^jK^)iP8$K(k9f;k;0&fDIJv%al$uM9$!!MS7 z-W@qT^NK+Z&GI(o)$q#~8?2;_D=Bdg(-#cd4*LM})Yi@BbSc@`HG(SMyE0^RRz=&3 ztu99pzLZIa=^Fx~Z?JaGtXE%ZPWeX8liHu|151!FeLFzg7D-7?l1mo=?CLOQEMsd% zJfHw42T=2FfTF%qt9hRYb3U+P+^%ydk<(Wes>&LcqLc=GoVQ9P+N3PWequ;6uPzkj zXU)`K>B+ACRQxipynHIuXv|9W{t}~uv1@Qm2lG90^7!F^%X8s`8~X>>7pPyRuUWg} z_bWuccN-KA2?0yzC%kEaGsQzP{}xV381YV=1AT>|dx}#z-)<{O*rka3wa9VGHmWZ$ zl=0a^T8agITP^)yaPknQuPv0(dFP|l?NpLi_Q<)VXWEtxD>_mx$E$WDZ(H@Ae^i*h z#8Cbm?}K#r#Nm2!PTBj{BX{hzq-#Em(*`mm**x2qE}k81!G)Q36Xd9%ZDps}_xO{x z6nS0p8fOa@GF;hIu9NmE6x%pmu)x(l$sOM=;g?pWox?Emf_62Y$6Hb0go{;RA>U5d??Yp^riyxH0Y7H3gk zJ}4UYiqq+*$dT|_%Mz!-7Jis{S3yhB@v6;4WXZp z-l)Q0(8|#-LFng-_$&sqU3Y0`ZtuCfbJ04(yll{`Yrejdz@L8jALtblB`oaxFr2UZ z%lhsPIX>g-x_`V%nxOw8Qd?g)=%P03hZQe#J6ogpIs~ggJG&H`Ed{S8z=G>hqskv4 zEt@w4^kO@QbdF9|XK#HZhzTy8kca8p0y;Vg$zGyv{X;8{(bJ^~C*sqL>v1L}Eia64 z^0m~@-Xe|u2~Y|Qs0_HwVUErKKQh<@*!q$LIYT-IXD_9Wk` zg=^l*L>$#86@2Lc{iS?B%Xy#bPsOLM?S9wy>ZyahwZs2bQ%s?r+mg#wpB5rOaoLtxTdvC+}Pg1F81=~3QNk{q ze0_t zg)(5rg5s)`Eynt4S=7od=jaFOl zY&tLyB5QdrDg!lXSlpw;G<59ec&Na%R*#B)xzIZW$!cCuXlX&cSJ&*|utgLQ>K^wb6WaC3W3t81hri79G$lcLTj56j0g%&bex((Reyc;rQ^P)lvo7OGTs<6$| z_Fp6RnHLpW(DEkA(5AIIKt-Ep`5{TLP6cW9uQ4d zwQZM_(ON?|zItSVP2q&Ee8ZgaLK^~JY=Yha-O+DoZn7LX2RAP{WLokqB$(rpb#)_S zpO>k|N?v*COAmprPEI~|y~eU-MK_{{LniEuS&ojh^yP=X7$gjZBECG9E}c*AMW=K6 znnTxE_@rES=qv2#o0}{MsevgIDB3<_08YV%1B>zD1C@6UX+#5H=nOMOrKJw z{CS)Odzfu4d&W$@_BS)r_B<$^)i)Fr=0Hwozj*D1WcvU}C?<4>K>mUJn^gEyumlUy z)O&`RrCdySYjE5lkX8uQ0Dhbf-&N!i0-I+Q zR1vDCD>rt1oeVr=xOvqe<34`l{L@FFcR?5pH?JHdXp|4msnmP`*aZzYFC4Ux;ptjR z&-&;HCEUDj&;nP}terETj)w{{&nvh>)Xn$w6Axzrp*dV%Gbq{}zCc}MNSPf_YOSkq zW3w14u_g0cm*zv;bE3YVjKz%%7G`tayzm*KwnG;UwUt7_ikUL~j#O-3C}^1lT9d8n z_v>t1S|R@qH!l=ant^S&{$E3TC&UHmcubvc(Q}M()%LDH#vs&M=wTu4ZcO;`ODM4U z>L1-iJ2biFClJ>BNB})X-f2Pg`p6#(o6~wdpyg7#O=EIGGc#Wy@R}%eu(&1R^iDg5 zx@^Ln$>4?WR;4Dcf~qiQF}^dl>cW;}ySPwT69{E*0XfXq89|lloG7TAcTdkrt!J10 zu^?DGh6}-8JAr5ur0Tj0Bj$aCt#9f|kG{dW{f{2Yv~4DM>y*xzP1#5Lc~ zqXS{ZVgB0eqyHf8a}XLGG*7Ltsz0(feR-cRYA|`hc0#VRm1aSK&BHSTW?o(jbEiv9 zJOxeSIVg>n{IAvcp(VH~5Uwxa^DPk$hLnk4voYgIVKqhW$EphbbHePG!EK>%eSbg^ z-@C|7VV71?dyc8Tcy0WuHz!}QuCF`hefsMWlRy!lP=KmoyPa=2;=i)!)roZc7Q}v{ zzk7}%KBgX9d{zj0Z%|M{xrlPt&NsdVE6#9zC7*4Ml)m^@&y*xc_ETfPN9|~*L8?Uz z*H`nwFTnHXw6#A80rigI&r!n1Rh62;kARdG;=O8W`UZjG7-Y?K9D4LRVwQRR z9$(>uLyl9`KRJh182aviE_v}2gOl#%tqR39b_kZ(>T0gyufJ!4$i@-gLRL4Q^FQe6 zfyl;D-a=N_E?ds!xr~VKgb5w-6^}cjbB1+jVWF?vbI%?K5~K5PPmAM%KXer_bg{&r#S zEfXjHX1*2I3Ty(0o7e9N@a!C2`9QhpMGo2Nm6*;u3o$*_ij=zc*80_&s#5{kZj&0kdVWuZGoLC zI*R}G)P)|%`I>hLWc5>iTAaUJxzYRJ6erxgQy|0kSq)Vu!WJuyVye6y#O#KCF55AV z{o-d>Zow3V)}bql^_T)0N{8!<{%ji(zeA@*ApdH==}s_83LFO=$XT%MetU|Y)xam? zn-wDtOJzvm&r$w&=&*fYck*yOww4)Cw@b@aZ5OZg7XLZs6j`EL2AT)@iF2VZ{zE#l zZ@k+1o-?MG-YU42=7NgcT;I|93*Q3G8I$KoJ-W50bdmn+Vv8@4{pu?K(O~Sz>D>)> z#xml&jKj$9Nr#=`&ru0TV@X}do*iq;`m)IdnVH`i97KUaD##3fj$%Ly|0P$uOJ@LY zZ#et~tX$d+n7~~v1^ppJt*fJ-M{@`Q8)-~dLey-CfoUd zW4ZgXw+KVKE9Q?2Gj=0JPstO3dX0sfzbMRs)tea6izoL%uENoX##N}PcuG?Ie9}4n z#F^9={0SCsclDN5^WXfDYd^|8&5QlG9*}3A+5N*yXzt8Q{y4Oni1!;_XD9?VUOsSO z+b28L_Qthy$04xs;=uw|((rl1KD>((Df5y)4$M6-+tVu{A002xSiT;_*K*xuAvV5p zG}d!ryWA*^GA{t+@`D9z_V*^&MF%40^?w{$UQ#u@x9wv%lg9f47OXOpMYC;*2Dbo& zEzUsnuB7w;_;JUDIHXzg%0DhBg)xcQ?|!~?E<|jv^+es}6PYTjqzV6S>MS}JgTqx1y z&ouddL`I^2JJ|gVv=z8*Pjnd9LZ}0Gk%+Z(m`NU?>?1>=> z_x7f5sv)~JFX~I~5mc-gK+f^rkKaRO7>99&%vPIZEt1gfX6F3}?Mvy)_iSY_=*mI; zQr_##j<0E%EPdem?#8@Nn7mhH-ZC(`hi_MbIV%gF%+5Oe8@?j)Q@Xa}etS47TwliL zTWWlN#(Lu{+{5|=wi^`Ry?Y(FT+SQXf2N(22*rJlMH2tXo%<{9qdZ4W(Pr$-c?NhD z;qXu6Rg_dDrdj#}AnEg%SN91TXHHhu_|ZmB%7Q)`9`go)2bjiF!|A3STRn~&o3oUB zBW_>V;^pARrbl1yCr&E+M31}a;!4S@)4wurE=kQlOS#ug9(~218{Lz$?}^mU>8e-p zqU%>STOAX-v&1KIeeCKA-}9O`$^Je1B0%Y5Y$YtKsZEa2Ay7@)>_Wv>?>z1=9hws? z;ywEIfo}9W;eFYLjc=F0Sys(yJbk~tBo-X8$GjX+b;1*igv$VPrq(V5B4@iG!2ho8%RwZi#B&vA{Ac?AGobiWO zR)x663kSkgD{%Igj+p@BrblR?W}sS>Y3{i9C_gyP_n4OflEm^F^5LS}??QQvcLN9& zB|YoPHLea;ryik!gkBS<5_w#k$t^*q<}t4WWFq@nK5eV*(wa=T3sNpm?LWbAKm{-6>O^Sw0c-8o%o=HRko``~KmN_%cib97Tl34Sa!4eIQmaR+Am$ByWJy3eH|NQk=kS}nr7sww->ji#qhrJbT8^0s<3rXE} z(ZRTMkmeCq3x15>_63gAEca$j`Q+Sq;v20Ck(p8l646wJgv9g^s&M99m58_a(Y};4!ZwKa`Q?Av-g#<_tP8ttu4s@WwgQGak_5_j<(5@ z=VpFlhek2wckCokj?gx!L=tNePGvJvlxecM!UIrww!d7inE2rv5EqmnU4sy4IbP6V_=9 zn~Z>ho0Gm@N>Z<`C0N>_VZY?MjT<&7!APlq->iRP5UBC< zn70V@g0n1%zwx7-t~4y1vn>?gNx=N1GIpZs{Q}!ISHv&SVbo08cBY?bm#lx9Z>6(#;ZA#G z=M#I@w=YjgUx=(UZ93roL~07(H6Cg;d_Kt=K38TJY2BR(Lbt7{fD$tE7m7>p0i~v} zY!9|9>{xNY4O(wWwR#?XjiEfA+v~3$-aCDItBOIagAfhFNk!(Jet#l5AaFdj#%(CX z$k5`O9*7wF56N15wEiJeqW=YhB`?1i9X6jw*R5sD&}zDm$Fg?_g57H+NfFEkLx z=1kel5KwE(K_yH2-oJAk-YX;1 zCD=zfBCtciK)^}8f>35PD>zGp4JsVyJCjG4^)b&dv$x7iL- z1augt17t-cNvwiIy?9w>biLeQ8&z0f>!6k4r+sC21Xzg)%j!UoMU~O_=+wO9lX{qtWV zVB*43I3OaMZUyrG)tOlkq!}T}1uKvXvj4BVom~kQB&>J?NmoBPw*XuutzVZ9De@#l%nry}nwEHDE>vX?;=#Ll;d zBmx^3uAv1+lx@6Sp?1hm3JXdNp4TFs-JWON20SJEA)g`m3!&e3pA&5juvD+HBhM<-JD(yREfw~$Smv5~#;q0CPDYE>H|L^C$>S3@Kj zOTK=iKZuU*Q3E!zTs0-7{Xk0EK(?AY%dt0r6$vXvKXb%=FY7HSNf{Hpz7`m_usqb@ zDVl7WQ0O&;XqKun2^CLS|E*KifB{9Dg+|sG7=*AvHF6?I_ez3>jzSngDpIb_uxmSl zG>eMD)nX?FtX%T*QNU3OUEl*v4uh0u`(f?{zaSaiM(J42QVjjuq{!{k&(?wK(- zD?&8ORN198WqST@RADzTp%^nZQca8GFgj(AI}PSrxY!kN(8z>d=y72rf;1zePg{N)QgjLEc1G5k$tU14I zc~Euk(Zby(KZ7sbvvV(Ror7eR#ZQiFh#>V*l0&i`%R=&;uS+_Ugdp`)B*;Vt*+zzZ z>y4zZ5Tu@r1j*L`GUUcj`dqf}h&r<#E!<2Bq)T41z;EyqsCzr{0n;4b>ES~(bOSP4LWa;1SRVSlp6~IL-JP~a3)h4K4PD{Sj#BC8p@HkO zSl%cQ`nJk%)f$3kN1wW=d|1nk(dUoBvjS=W~%vN1|+5d zAuT{CX7;Ilx`IsBZAF1t$x|fRjF$hJBR7y$xXKgAjM(7e%>VZ^=OTovPiFbd6Dsga zPjg-90D_QkStpRJN)Q^hEz1HBgoN8T0pXa4vNHb~^V(BjNkZT5fQTx|zZ!dWIbfwh zu{Pl0RJA3eAlfD>){x`Cb{SA3;Mmqb8W_;yd#Gio`TyB?E+pxg@;K8H8#^ zO$${e{Fnwam)NL666;Qm0#OsSv=Q8kF$Z(Nc5dl=7}MF$ zr}sse`X#0hQ(;k==KN{_ByI!)$LXYik@zJ`aElx#Ib|7XAA0YP>5jp!~L-(9}mujPFHU(Mr6+fP1o~Ep5p|&R~Vd=8?&@{LItfF+89b5L+aj+m2 zuEh8WG+sp{QHLj*#!AZj-DSTz9!rMpJ}-~fR{?qDJ`mwa8~^aUd|v)_-5IBVVGF&q zH4-ynD+iTkNg>%rr%uugX6ktAEnpe?svxgI*aQY4%Q&+mg&x zUpgeh%JWsD&7ML?R&8K*K+*B=mc(<9?L9?t!VF0pM%8?ZUhki%zX`ZpeI1b{D}ho# zM(f3U*=Dap@@jc&L!(NaC#w>kAyA`WTrwz(g$C7T_nrIlJ_0ogz!s=#v46L&U(N;< zSnD3WU)Hi?Qm_SFZ2ioZz_O%sA968L4r!^B!c19k7JVek*})*pNZZu`VTF1V$8*2< z;n5!{LnV;~ilY^4N4ovPFgpA-ZxE838)UQpJ3hv`F#GOdSne#@3u;H+ER zK%50z#QDp$+X9S0UwLFrR}%FWwf(k3tvgSud_brYwPLhk)}q#dh^T}$X{X5P?82=y| z@4$v+#vXvlE*9{wpx^N$P&cZLg0_LSJOX6m0ODmh#fg99%27A>@m_G4oLw%~Cbru8emqn{dE8xN!M?zPj^#^I6ZEwkjMlOCd85nbFSk))L8A zRRfOES2qa~6EnOM=QzrZhrj3TYu#==MrhgWhjLy=Nqb^r(ksDu;?|03)tQSC+BExt z734*gr^~+|kq6LrPOfws?;yP|69y9F%j03$w`cBYC5t#KD8mzfhmU>Dyq8vyH153NLXzs z_Nq3Cmc0sv&lPUzL8zt_PGUK<%?8JvCsylJUCp7T#553heY?&M=C>uUp8(X=mp<9! zXReXbM}@k#=I8u@xIo~773fQ#Y~!Ll8l+?~pYDACIHs?E5(H+-Ri>=VlepKAB22mK z&39GcxeLcWL;{-zVFGsUVmjQ92x~-N`@r^6`58O^4k(`3QF3Q#~ z6Sr*;k3PXt?w_G~#vr5#BMMs=acM=NOkJHmwK@UU5N5<-3)fMwLyeRS8+#&HBNE%N zZ1yBA#1-lAnGGvMVE1-wAQrT}U3B`K#6M{&ic?0zrh1%K@Uih08Xcl=*9L zDcw~ht`VQTu*`}T++Pn>nV=pz#|X`q1Bx4lR@;lx9el}-7@`V{LUAc(4=56EI&>=; z32I1Vwo$BZ3mmQyG#CU-{X1lqZIRJ}&4z86E7nlg6fr`xo)U72q$Q3C z#-*>W;t{?X+k=i@qvqy6#(lHT)~kr>RxC*jHsaZGRmjI2QBPc3vJ{D`<*X$t+tW)o zrAsk+cj&u$qjmrXqc66yri%qK$gg@|RTzR`4M|J+0_rZ2Jm&8X2-c9c1nV3dIjRla ze4#jPY!c7J`O*eoTeY+Rimfw^v5 z2*g}(Ev%!1HNW54O{yhn1s&)suLK>eS9c#b-0X7s zyXC24z`LttcoVotp-*uDhfZH`cF-NrwfhdwM4(z8Tj~g-HHu2fKPBhWt|>ezp^iBf_@^TA!#X;Td6(U7L=yzg{W?5<0{f9 z?y`el4z0SGZ(iK|0@AD@U#;XrmUZm(uR0>rGUO`R$)mM{KZEKse!JCgwG?6Wz3 zyYb+aBZ1>GtFyAy0M-msD{jAnq&4DgSzj5WH#j;z=5(fUZ>mL%G5U5*Je)U2MT|ZE zyOBb+C8ZtuIx7cKEn-~ww0LXVU`69HBCR!k^}wh`uPyb_R2fm$0;Pmj;=#t_CHtVM zGUBX-N(P|hF;QJ^9I;g(aMrDXfSgrNpHjCTsHz@q#h6uD`DFE8RgoP+>4xYT_B3>i!b9jjN6WW8|V z#fdhkKwr10f#~ZyEONZ}-1i&s-Wa4?!D6M;V_*lCtK~aB;7DiM`{!!_^O6p>0IX#Q zG=AV0Kj_(N0WboyiYs1!Et;*Pgeq0)<1q5O ztBOzGj$jQrOgcbKdn2Mg?`+33fyHiAzbvNhP{s_B9CQ!KbhYev^dcYq1amX1z^cGe ztx(A}E9h+lwpXFH!5;fnvl&1yW(8T+M}`bhFJSGymZv&!8D_OubkNnlS0@$q-nF6= zf|xewCu&5y0wxU;D!UQXB_;V?{(6wrSO&eMwzq3g8~bG(@iSVUTc4pYQaR||_PtBc z%{S|=KhwP&0OtJh-kpMMAoLTzVzf%;JG~SH?RGizQG6_T`sTKF_Ipm^cif9RKi=E= zPG#P>jNzlF%2HPT^$=N*I}r_tk1S|%-pWPE*U(QC+Z`bN!qN^M1s=!d9mmxw+xdy~ zm$YXY>t-#0CdaiVo+^kBlug%o(+IXw0TABr{Su8 zW6g@UShmQNfG)ySy*OmOT2B$HFWursZaFPT(g_PUJW($O#+nsxv5hY} z=z`?KrSLv%c$!m4W;1T{?FuOK+uzlxsk-l2ed8*x%si|qw{q(&FSJ?pM6vqrRX$YG z1KsRoagBVdq>Tp?PApb0L&xenS=sn(2I&h_;HEBz4sKr+Y0}eI|lxsV#zLy_dCa z(!+;!vo^~bJgc*OBs~4ItFwV&>)T#=wZc;f#jt0r?9&1mw!Zt750yngvTGL5QDslf zLdRw!d?T8(xwJA8j!bi@>>n)cmhdNVBVk4%obZ{8V)xG#z2u)Z?U;Jh7Hd}c#c)X_ zOf%lba7Z(K*X4T=Nv;j$Ud?;Iph*7m(Yo_N9Cw>{0J1ZU%W-`3({IY!3x2`6%__iX zD}^aUk@Mut;u{dC+be-ohQ?2zC}Q=_lkN6Ix~F-L{@T%I?MO}Cf0qBR&L;?~YJZ%zSEU2+EhoC2~rvkEW*_a;Y* zGA31fV+tU!JCp<>u(~-uZRVxXz{-{XI=) z;2QMhUu3lwth#IY)U&Y)lGUwOKd!+7Mk{U$R=tC~VAz{Yk*r1w zY#*qyExw^&?N^Z*7?IZti_UYV9@q>DJYt16?MbbERm-;8L4ily_@6&fk40iVM&xbF z91Yu-lIE)Yi(_6yb7d5A36dGBqSW1c(#3(~+CBdP=&H1cO5R=;Y^KKQOTH}Yr*awZ zeH@2T1BX;esn3Z}FBxPSpKG*d3l&%QXkfqjnkb-)q%&Col zPx=@0ER|APfc#XCJU5pBKIt28Ij};xj5AvY3qF{nZlA`Qb>8APP$*)t_)^*0GhmrB z%N8Xv4D6E{gM>GVx!#ZP{8_?XxUT$PNY{qEC0(;h7i9|54}I@%1Z&7$(gv@1k)*xU zGH(zFwr)ooh`nmI-0o@e>1)1d={lw{KNbQNroB^7R|G^hYqI4NSN7m(KTCkRb$eUCk%n~3j7#z1&3Yw0 zMZ&txz%Q(Q)+E{1;vBEcMW}}1mQ|>sV4Jt%w)P;1nH7C;W`W3fbz8*iV5iTlvz86Y zSGj6~?Gi^iH$ws&GMBjm5PjO7u9FM!)~(t=yj7Frve_R`1k+_!^=0XRg*4e>e}1@h zG8nyC%@?;-+R~FOEAs6c;NoAbS;dzZ)bRyQ;Q6!kf|r4hF{}8pa4D)Q{7SuibQ*Bp z`ltDydm<@C;ETR2j2j?JA5e?V_uKWD2eys% zWno-qnmp$K0G<5yob$&rG>cl2Tlh@VXwx`Lne%Ot<+;rnxDFqxeMuI{y!*;q?U2k` zrgL=KE=DpBi@HA)?2+jkbNNtxXP#<_Mq>2K+3aPfKySCif#|Kg4e&;RZM*EaFIbzt zPAn{_C|h$<*?|&9HZ@r`!Io0Q)b2!En5eBr=*D6#5Tte=+JZ!7K;?7)l?Op;SH>13 zT2kC;bNUAP3Hpfx*Jjf;q#QfDU2X6JnjLK(?FHn!qLRZ6s<<~j8n*#e*}L?VIx0)4 zGBN!oB1i+C5+vFN%u|2VCx5e1S-WEv6CV<+5+8i;*0kXs1ZL2)VYo4#OrBWN4-s; zQoN4Ua+JkuesF*6WcqlyzO-ufkx>X#OHvyY^<$Y)b!0I#d^4J|;Uk~7EB@Mt2-J+I z98{(1l^?HF0PNS7WzjA*Ek@YxqU81poX)V+mea@7aH(`EAX8P-|Lew2MHG+1Fhk4q z8_=(5lNZvYCze8{T4I8o<+Ug7#VT}SmxHlR)gH0uW3^g${b&9QEEEi`&}%=2UP zv>Jq4^o?tO*~=ciKu@>T2coBP>{Fubf-k_#>uaiLme{1Tf0Z_DzkS=LB4LtJ1sdrq zsXVOz8ZFJHsQ1@a75gUC9=V8VL`{-Y^>vAPLYn|$h8Ynv2@vyUM8z;9qY*Kags@3c zSv_m3B%~w*Gtw7I(e&`LJoa|2vYdI8f2jIAS9qwtC6*VJ3M$yTM)FJFE-BUl4c~~G zVw)3Z_&cIX=2r4CCa4iLlY#;~eO)h4)~$f_VMhFN=Hz3-}C$9-vEanZo*PK9g{PXt1+(yAxTYWY9~&%P95^6 zR?7iVO(<%iwguZRhpROyX&aTmQMXM6G_U-z1(TE7@c2GDeAvx76zdtYD{R~)>{slp=m~5X!k@C!$;e!yS zNf_nXD8T%!>qqK&Sa_(uvz1p)f%J}nK8k7mHJWxag2J|O6H5&BwI&y5$c&woH112GkQ`=21Q-{XlgCn@CAOlC*LnW**vj@Z7|PF z9Pd2qahH?ipGaImtNPj|=ABRQj5L0h-O0(B{wF=Y_yZ_aU){uQ3g@JK{;qi$cv5|N zlMfTMBEOiSQ86T`+v)k^JxQt_1`nKjrXetXeQ^_)G|BOK&NPkgb95s?()5edWD-PA zBpk?)OP!-TWeP7uBR8Wc-gG^Xczh+oG~*~w%9Z8fgGql}N0?>=6}t*K>Ks3Q?i5O% z>A#5T)Do0iJ+%mo&pRsXqpYK5%a=l){?d5AJ@*1f-SZTPqsoe8&d`4b+N>93)mJZB z*2EkXd1z@tQZwi4$AMDywM#zGN?uGysV}_#26g4ZWv^RPz8o%3@LfTuspFm!6d-1bi<;a*x>Yn=mn6&Z6hQQ*kX0JJv>xjrQ~f-$d+i1^~z*v3R5d{+Ok(;7}Tpx|~AW(yt zYJnoF8nHHaZZutP{}0`&1q%7qWqFz#2-R(@0Z=JTQy6gO&m8f<6X@GekygWk%9H_^ z&r;LBjV9k9r1Czk0P@~vj~CgH0#V(*B@j`S)0b;mGhF}!H>oQkA(=8+E+v`hPhT#1 zj4%!2DPdOPPfSagcSBBAMVJQh)N1+)GRc(PWx|0e>Dx}xq|=rJG|)O5ekg}f4RT%| zs=XEI1nOh?cQv8$6H5i!>pM-cK+WDU7f!Ss%&!N=X8;@f`c6|`O!d9f(_6Mo2Yy7~ zUy5s#d1%zdVP^Gdx6#zQt=J-r=Uy$3W%Ce?ddgJREMfk$w5G>s+6k#U*8DxS!poD3MX(!>okyNCX8dt(X4d_ac ztjtu}_m1#fyaeO~Cas#50l$1&-%aR>W z-|{&>fu`;}G7wE!@xL7To-Li!T|I#eleiBZidRl~Z=(46?!&;y^~FY(GGPkcaOmI7 zk(37ME=fsi9BIn)@0$s>V#7>ojci0^er}IAoDNu~zBQ9Ia#V3~@SjRq5u`x~B{A6! zmlBoF)!a7@&5sc$Da~ijL#{L$KeoBA3{G&$`u0m+K2mLzG(q#`&v^perb(rd)moQ9 zDl?R!&u(6yOu(X?My#aV89BMJL%u3%D^#GR+cy2uvJyHUtzOu3mmnoMjcSaVyOuYO zFD|omNtl{Cgz2k{>^UN4DjL0hYVN1@;02AE)EQaR1h`qfZpd0-^!gr4wxssPt~2qD)E#h0Y*F}RMi5O z{rzrZJA?=ws*KpI6C{hsiZ9tebn1D8YCzHo z{`2p`uP1*_I+f?iAcXSFn~t88=3Fy^ULOY*3?2i5vOOJUpmdj(Cnk1B7RLyF&yq2^ z2ot!tWCU88dRTjQGORVt8`VAZee;9^hsws+J`xw4{rixEsaabFcS=bsHEjQ9)Aj+% ztxske2JB@Xh88FMPOwE|IVq@lVt0m&Jj zpBnZMXx(dL zOCeF+3k66o3luiDe53JtP^cAVQmMq^y5+eQQNPbTIY_VHFHu z$2Fwo%5K05=o>ACc^g}zee4B$x4n%F%pl-eT^%hiF0Do8P5vefB+hOp7=X0O8SBio zb>e`SCN)bwG1YC2JW&I`1{&2jSh6+R7G$K^KAL_M_&|MwB?9#x;z{a^&e~-kf;0%S z7NnXtw@SW013?{hl3z%)$y$0!?tDr= zqVTXNgIG#Z^3zo)Yx*Odiy&Zwc*=pvQ?ZLA>XBIPO8dSBuF9ldiGV3hQReD??U9>p zOd+bel@N%ac1G-Mm;6$7=MOfd;89Jgl}JqH0o9$N%MtZYAx!u7wcq)-ysAW|3*Tix z>rj(orMA3efhkmVCFQ^Pwm*n|CS^(%Y9-!u!ne|J^t$JdbN>Ub&!k$3A+w-DWgE)6 zx#veY@&eaq(k014<+rA}YMrdT;De`M5h#f(nt+zBo+ef|$YUqcdHX{+<6nN|=7Asv zNIwzOZL5B4fL~GQlGLkHz4m?kmEh@hi1m7qwV-o8Gj?2ojCRNpKVw8+;UJ!uAhU+P=T{%m|wg0&U$g2BNK+3=i^@Ri7;m4>PG=A}RUKgv77~>zAX` z9R16A6alT8P{m%){kis%dQmA%|8AazNo%VPebr0UEq^RH70i)I{SuG;w7D;h{-bq& zgL{NwF-DOUC&1Gm&*i)#ZV9%juUz7Tw{mK42yn>yXVsChfUG8^OJf@Iq7cx!^|x%9 zf`PL#sa|6GWX=jkz#j(wTM(hT?cSdYuuxSO_;ZdbucEm(N_|OIb?)muDR9vCsscaV zi2nI0+e`$aCf}rf$xU$$mMB)3Iz)0U}HD>$^j7szqHL7K3VnP1!oLpeDrdjEqGchds ziFn$?H<4|8$zWgP{I?yN8f^?sP79`t5e_RN&UJ7 z73$DFrI3ss@-V1WW;S^Gi3-s2Gm&aFWVF;)4a*}mH;Vw<6HBx7Nk(flV}DiKC>=^l zr=o!YK<(m_L&|8Q@An!)zKwpOfO_uHJ|?>vE(3m8ZE1u(zapTX zd<4j^oXL>SG8a69WYklTAlYG+4EWl*$V#dU57$2|mq>uL!=lp{ zCWWw?3|Z147eDw&&4O9Atk$+kQd)1xh*#RCoL57lR6!7ke_%;8W^IMuV1o1oNPO&U zwJ8f(yHw7-v&X*hJ$ooidHt86#n7R{)?5RSG~cvXumguYcYQD}gZe5s+arw@c4+%5wg1So>~Bn|dyCOb`p(ohWz% zaM5j*0lBEIAIoG9PXtm*0TxATOG@C`KK<-Xpi9YR_(kOXk7ZppTlJ>er#GDaPwUsX zlyo^whI}@w!+A7tJsUYB3%4?2$0~U*qk-$`$PxJ)3Nq%Ht*tYvMF-*fnj<1mNKn6I z{%SP0PlcS{9v$9Q&3nW354sVyENEzziZ7`P{BV6sqeLzo@siF=WY~exwT>X28W58> z$u^7BBfE=u-mS2m#t3Pu+n54TQ#msEy4dv|AO`7cjVy(RSkGR| z`ka0^+b6aQ5z;MvwULdAs5Jd9vQGO9BJcR~mT{$v4TEecP8_mxU$m^b^%- z5H)G+GThm^UDbE`!o&4dM2Yk+DkD3xqd#WOs){tJCnf`hR9{=8kMGP?prw1l1JY8B zn8P05?*(Q@UphoX_e0CLf)jpF*Z1N2iXjWrxi3#@RUCb}0X1fW#8Y27WTC4>npdj- zYNP@^H@ONRjr#w!q8f-s`jR0MQZ~<>kKgHlMyy{|vUtH(mCA}>UFK?FZ!BD27nDeV z{4%#JW6=YlCy@dfn#`D(;EP4tCuCE5N5RrGQH2VHT zkRj>27Fm$g)1C>cko)lawf_LT(H8>|tUTY}q`Q%d6zO)DDCjcLXuYNo=SqdxD!^6f zi+>Wmh+voO(!v|y(oML&_=jWigE@KN%ZF}`MDuMxMmBI>s31d*U)Mba>C%9X43h1| zD7tJvsplGmXuw9=90X>5ru)vy_OJyqx_8O~kx|)QeLZ_>7a*g)(ud}T$(Woh>oIhC za$1C_-(ls5z<$=eULhPI>ho0#QFRw*W~@GI>ru$A^nHn}QKS5~YFu^Djw)Q=m&k&I zF}B`+`OX1fp>In>nDV^59s2c8bkajVam;Sxfxe=B&%T}6O&A7B&sM2!sKrW8F69j< zwlFndBdZmt)2mbG0d}!Kzm)enD?W4Onwc%YLO|c4D6vaYid~4HpkBMNs55YN`a++? zEpuz*FcRz$8&U*+RPRNYAMhFoL7W~siy$3j%Ht!KY11D)2x^>sZK9-@3|wIU@z zMyN09A;>cE?+uWx=bipFLe#q+;n4;ZWq^(Qr6l$0S|Zrbn&sB(FFyk$igw#3Elx`6Nl2Tn&Mh?24 z9k^zF9S_aDJmlol>Baz0q_5yfWEXRwC)Agz^}Av=C(pPgJ~C99Uzlo{C9qheuhh zZD^LSG7?YELf&0V!8qdW+jz@dTgF| zW(4p*`sc`Kc0$!TrB zU4A-xPCDB|2=sI3Q32?uoNau*vr~Wd1kWQSxG3qN1A5Mtkf6d|3nIl??@Nxj{J+=L z!+(!KO^yI--9cyTSJ~#n%U9T?-fQ*fTLC2s=xoWU0Kc>2!&M-d=^FxZV9NqjWwcnj z=36ALo}!u}h-G=#?Lm{L<*6WUat}od|2-;s54b3US{*vj4O8&$y!HqMN{^nV{Lyn@ z0JnD@+hWr|a8L%NI@CFtPTOUZs`PiMu?SI5Q@ar9KY@1dF3 zXRm}u2ZpkFR?m3jZG@;NC2RIqtQe5-)ZFHCLFhE7)!{~@E&`I$$5uol>N!b(Xdj~L zt&$mRvlKY#_LqS;scz=ns(UyI7>_}n4habtyG_zutD2DoQu+zxF(}kg4QGFv+h2l+ zW>BHSMI(xX4Wge9-cJu^#-Kolqk~C66GNlVv^$8Qo8i3te)k2461ZE zqW1;_^lr0W&Qr!VBXNTCZ1h5d)15bl*DQcA^?bB3)y2@9iJufeldoS-dNJW1`s2fy zYN&h4o=80{IjZc4<~|5-XV1LANw+Qoa8jue#fFnMm;k* zAakF}us2Puxe)16PfQNUQw{|*c2nn7NKQR3IVdutSN;gzXgei=o9>YZ;--4|*y!6e zn}JUvmn#W8#kh&BNSj$8Xs5s$tt!q?9^10o*zX6ji zN?UNlj=h=<0lIC`FQ7W$K8s(4hN$Hr4VYOBJC*`=v+#>Pn{37iAwu6_$3az$XL8p; zz8j|k3*CYSVxc?$JB2;aF zbYx|FyRxj+&dsU{_D=L|c6_LC{6kn(tpTIgH{B61RRef7b8QMj zH6|>-TO{kWarsLf5UNoKC9~qaMrG9P6`yti{#swcV{3rDaVBG?3;OXSlGK>43{%zW znUBl-icpQ&$_r*>Sx@Dd@*x_(Fz*H@& zPD0pfglf!Fe!otZb;Y^DU!n0E^OQA1kuf`e@X~lBsZq8|+~*Ai+*()McW1h0= z1vOFqW9?rp(fCby8q5;QBq^~<_&9bi!Zc-RFmrw~=EtXYfIi+4`ffd5o8p*C7uUaE z`3*e57@_ah<3r`|sYv6WIr7cl?5s*)sXMO>#8R+=8sB^0A7J+Nx7UlMBAxO3qAFhXAqNOub16(I}=8q7qXo6`A}y@G1JzAetrC7aFa8Uw@(gDSPGxp1Q3xAWzjOwZ7f@ zWH54ld5|rq5>2L#e)a&2Twfz(BLZ&{{ir2)Ixa$AA>_qmZRF%BuRQWzHaj&Dj7VQ8 z~eCd*DFr6D63qMAF*dT}Yro%F>*mNsFA|5=6>KiOs^aMGQQ1>&S) zMSK2kyaeb{Uo&J&saR3u(*4VUF7@R?HX>l;#v;>aAxyV3^0Qv>KEWqj(Jz%hErBrI z$_#)B=DgGTz4;KPAt(7mWU`!@j%~h$FpYvGb!Y|*+FtBxM>Ok(tOQwo$!FtEA}I|y z33K`q{o95iOfyze?#=c!rD*=RVF>6T5#cdfd4{2UzD~{tok5&*PkBI2s=lM(j_3zA zrVuWqrK~^OWKyD`Pgs=h5m2YTK8O=Dm_-a#owG_zjsb?GuMP5HCP@=Cxn^PrlG2Qp zw2)Dy^cRU!C;&wWhNB14qx1?73ZK0~)#+D}${zACjCq zYqhei`YR!?y4DnUBWqo_Ig{BvC05k;i^}$)kn{)QF=Tlo^u@I&|3Z z`beQhBqh)!1#;ZC#Tz3zjbbN<1cNW0XXOqAYQ#+r3I@Nt*v0ZTs6bD*LjBUyDle54 zy6sx#7i>(yob+WwBqT3{XKfE<(0jXgfS!U8`idb3G)Vz%Ua(a54epV+o{nDPSi%~DCYO2$3{QVsozfs<6p(e?aHn`qt5t39JRUMrIi+bVraZM1aQCuZS z;igW7c4>T<5e1j6?*(Mb%32)A<6ji_3p#4kw*Yc5!Th)O>}rE%%9yC&n00)s!QhxV z!mQMYbPA7IGmYF(%Jx$NOWlG7VksDXwlgKJfY~>zHu6fUT7R1(rQ#8)QSNJ@0!uCY zC3ag%^A9#Uro9vmnlwk4)f$ncaI52+S0li~W)Co*rzWz}!p8I>EPBdw>p(#DabS(1} z`J(Fbe_pAAG~lLypEUr}E8p-@R%$O7sy7ayn#NSxOJUO`t<}!v{AC$ns~a>BTY&`( z8dg6GNGi+1XpPXC?H)`*ZR%>dJk7qi%7G2BQh+I1g9o84^>AWX;yD!VFI0|Ih!FpLN!Z* zxuhVp>~FPYH$pW_f*C4IEjuKJWH$$k#Y=vi$-*n3N9zr!HE3Dzm`u;n)(OemG6;#}9E7T0U5hh*148&Br?IgLX zTzBH`gVCE+91*MFSzoq=nI|Gtvox5Y!Ya17_d3>B6Shcw^C52tl*j%;v2`Pnl%_1@ zNtKdQjO|!sGD0fa2rl1tC=CdVkZOgm*?O*yxG zxkWrEH;&Xl9%ieRY(O%ruQq>l8Y#h)s==0BNvP+~w#|Z2O{vO{mXrxA*>d_s_3fuf zv!WwL0fuTln+(EB^`jrJvE6_WT;0*dFJ&vCGw=3`7r$!9YrzuCYL9Gj<@w54{*xkV z#u8~(e&hpHmIB8o?ei_%MOoeB_n)x@^Oj+f6%6@qM+-1tW;ICsnxcJZr)F*s9!|-u zZevG=n~~SmZ{1g};E=fT&Fn{Lbx1weMRjO{Ehll@;ot^M*ECN()-3C+F2!ccG;VwM z&(3c#VET#RW-(Xp=U$iD0Ou9=Pqi6fAN~rocL$aLv{%x!G@%>XzRAR; zpCGbXc~ciAa=rF_`_&N}_5;-qU%7R95c>fA#E+OoZS)bS{+QfHj}>5_pr7~|GpFGC zj5P&dDC>?MzNz+QiPSeu;xSEld_XqO?q?%^0*=yS<{+K16j!9dpLH7X)m%{&4JrNynRg2khc9z(EZF2I6iQB#J!SmwKE5ZCnmlN=SO z$H$j{&2<>bYDRS~EAoQfu5O$L!n)fC0`Qw6rWDosM$Rk zvtp^Po%`AC)Q}c_`8)Figl$A*5gS;;yt$WBjd_bHUK1^?e{nAm_=yu2%!IZdN#zg!bWPJxIu7D^nb~JGt>I zCOD!&Ri~LJbGj8a zq+pt6lTSwGhsgY*YQi{uLav|wD2$^POQc1zo`pk;;zSX6Z?tL45H6D%L zjF`bz9Fnq9 zv`)b$8*NDihPs`Te}=-25rjj!jtSz(_Sst&pz)i_t5B`$x4-_(HdVp?%_^k4u!>%5W;|FO$!Zo!Ndx@)iX8a1?b$pB$!f+` z3swm%GcQy=VmnoVt8P&Paa9@pr&DL`1EV)9kn*Y&ENt!uFIWi7O8;h>ZLIJR`+TOk zqYdJ6F$F#cjRPXhYNSX7FxkDidMmi<8);S}MW`S(?YJ}lSu}oQvchBBpFItK zL8$H=&0h-5B?UVj;S1mDf>7OYB_JxWs|k+>4g-!g#?62Ls31KbIsD8OglWuFaESZs zu=0y+_6tOHLk1!$s5kj6_T)D}qh{4nWKnP-G4RZtya?53JD5=6QsQ>xp_)LaX4O#^ zs^Y31)$LRSVHyWjcHAs`=@Gr=ZbPFtTaxn811rtjtKDO8gsp!|&FlSSDYtIkQ3y$C z%21y5E7{}^qcXGuu0Ph4p;nHr9JGE~{@acS)|8@@PnTxqFD2>Q|IN@A>A+1X|IFv7 z!U}5V?A>OlJe8J`0eNaCKhF8zwUlP->Cnl2iW8+Ti=y+t0}-r3bWP&}M-HE42l>b2 zYp2feoO5UhY zGxD-pk)rCpO1@K*?;tgpk(XnVG9*J=PB&k`DWvHM6v9Mq%?QjfK|oj$ zohdz%)QrF!RdI;77oN+AbZW+43sco;N{MkG#fmcP&BPom?MvH4bGAYzFPgks&4#5t zn?U4MMxT6ddp^~7MVZw}aXI0-W$>*leQht}tXrbYS~GcJm2fzy?FaWd8Oe8DJ+;g=**czCsSz{&(RZ&2`H@j3qn8rk9dAm&hnyXiX<#3c)m6RnX za4Gu=KL$(ps4!!qGD%hQUqAh0(8MAt%$TZRg;9FwkUnVk&7v%uecsSO)@nqa9>s0@ zcd}t=J2W6sRhKek_DA55FUqVyie?HHpEezLr8yYCS%nm#!W_Hq4=c+cRAZ{bn=P|{ z@_esmnNemHQox>?g*<8j9Ew?06yfoGYb75ncsm4C2}harY2vV`Nyhs>HGC1N)HI^v z9)dqqnAR7mz?7)LLDYOhQNhrid6ptrQ>O9)IW;A2ed-8*ERU!qgcY-%Ou!OVC8iRYM)&_42RqSsi!%=xt5-D%p(eTUn)MBV8vzjHYjig@i z3CjKTi-S8kQ6956%dY&RQmBo;461AAZi4OVUwY%JF7hisw)(0epq5#`C+l=r z9{t$YvOGYeH)1P?3}Jg0GHUNuha&8$5(w*_DL~kQC9L9hRwDo|`ec2WZXnphF)LW| z%F5`)-k<^;dwcWp9{_R9N|y*6IoQ9u76gwwMVXZ@aZn)Xu*nh2>7azYBr7t-y~P;GkgepRPKS4uKk_#`Y_vvbmnC@pv}yuaRbC zwVpmjG^lX*!ZI{dM)8$|Rhbn#F{M2c)r_wM$;=;2){v1~D%pNOV60oMff>tc*rlxP ze(A+Og2|G0p#50@6BbFD_@s0w0yT=T_N%h8qAc^`+9@C-K?sK zLo*X#%NJ#T?8w(0|A%BYqAUldRgsmyNLD-Q;y+uFj*VE$-(m#3J@mNtW&~=)TMJY* zvACcG6>VoAkk+k(z@+8ZTOLjUQX5;<8skO3E(Ru=R>g0XkRYELT<^PmjX`oJ3 z7dFo%GZoj^HC*mIm6&QjG-bK@`dv4eTMg( zv)A*!d%Zty^?g5{cb&D@wAX(2+A*IZM7{T#h~1KhD~Q{_T)vQA_KS_v=U5-2T&w{D zq&CTBK1_BSZ=# z7I8=Ug&FsOUJDj`90j?1m36y;KgVgJeb2RK(| z_Cf;Jwl~1WOYmwjRczUoS3&wdml|a`#^5L)q6iV9T_??pWVwSA%KvUxQEnx$ zyjiGK$Qv?Xu95%~;KpV7vcSbj?%xuthJz%R;N7YDNu3rdjP5hXpQsIz z9D^}sDp`o@BsoV5C6{%70Agi=H_HW-w_159@E30`0ylbM6TD95AK6JqjzjeBc+ucX zdsDJf`2xSSQ?l?0kdl8JTxbEkG83mKP00W$*36JpSg;(^9-%~q=QEP54@rWL2#W8474sNv&W1lG$A=|FX5B$CRzZx`A z#D#M`*-S)I=@mnOUV2^V@d?dyap7EtcEh8jQL^sL6Eyk9F^E)d{g`2n2GQ)xJ8ePI zvubW(gr@X%okceb8~;vU7Fi9~(Ix(u);Z}} z*?|H#x6`w!4mCgTd#>0D;N}d1l}l1t5XnuhV%inDuFC*?hrzOPW6RB$v=8xSn;J** ze>~za@EyivD)$eFJSc0=$^`z+jGe&EzBmT+O2CV=+qS}>)z|4O<(vN<@D~Q}N?`UM zFjV3W88FyB9aA)3tM!RKG=0bE$5n~=A-k;dg&KOz@5rW=t7so6j={n5p$fi?B5LDl zf2IYl$Dm-DpyE;*q;_1dyRW3}CQbzt#~@(|++?8w%tK1`VyntXvz){&VU1IAa^|#e z$i7c(RF_YCtIohaO*`0Uw(WdT)-v+Xr2z&J%hW)!8Y9|ljsxR5;}{$)3s5w^09*KO zgKvJaKi(~;_v>*jBvoqkn~6%trK@xq!~_NjO9*S6Ur0A7XM`Ldao8!gioZQFtt<`Y z|Kk=~o36#~<5*~;!xieCN;#R7axz_Kl|!EY_wVb{A~}vh%j(-#Ji;iQAu6(*$VKY% z#h=|jlJ+j+BK6g`05+)O@1#A)gb z&M*SFBZL0s0S1nKX7;zefax&^UgP52j}BrAPP0R@++?` zLeO5@(1j0U){1H#fAw7a7g9%XJ}%hrD)6(a8(u;(2j}7jtzLz0c;avjh)XfSdAR8N zkhrw;gBxX#vjpeg0@-JHQU#e(m6$l9)tVBGpUQoQ)V9mNy^03@ZMV}`tV{y!^vT=K zWd;&6Xk{KxftjW4xxI-%&&s_^t=Wlar>whOEeC^Q=9aoch#9BtoapHK_~f@v zO0CF_m}@t!e_+s4>ZKfNmTG;BNtJi78#G>$SIX`kHyo#*q26YesD9>Y2kM(L6?w0L38wOVf(_AqnUxnbCyDy(Ym}#GvP<0S{%(Vd-$d- zKai2w?>||XR{om&bFXSJelMj5_4SNtRbNEV!8pDNO)A!JPww0dN_VePfZyBwb>kdB zb)ZqPw>p5{i*h&@*fmXgK_ybMVujSe0+k~H1~`bYZ{Hg71H#rf=e!n(s>*bmkB$Y_ z%^;}}Y@c;IetBm_yElM|FvfCu(LuR$_m}^AAn0IS9#kde7u;xo^zBVM`n5#avPFxd z|A73!n9}8FBm%~%SK40~kC21$bOV`Wo~#|}XGi)7#?eh=JL@?2R z_z1bbBh_E3E4N1>Wdu{fM~IuC7O?bav-Dg0qgXO$G*JLx7)&uVjhKw_=% z6S;;=Z5Bf+p5i%E+Je?OgVW~NN@ww(=JNq&(_c-Ph4(D~8aYugelL=OJS`@6Ga<5o z@7Y0DW$%T?elN(zqUr2wnme&%Zk1n-0eKnxHb*C-Sp=i&?X4x#f;_2bx=AHl2R9bB zI2uwl-TKPESwS*mOa$|ygP?Mu+(-S9Qi5@PDY$Xsq_ojSJUh4yVF%;<5*r1U__b9A zA(aG^-zBy$v^aM1$^4_O!LcNR0_W1U@z4!y5&t^w-F!$Z-s&}Q`H*awI5m`gV=`t1 zfta+yn z^@KRjYDOikNj;M+=H-0ZrrGo)m$Q5CR{C{zkq1Cpf4Fpab70vFTAXVY{bZR5G4oS^ zyEABU1Y5KQ)UXm>wG6;2EaMXoZb9DW0b{o^>q>)~21PG672oqHXR)SnQw zo^C5IZuoc(a3IE*Ge;XH#ao!TAhN0^-g9-8-t@X&JdapsZKDkQ(Bj5J2(&^z^04zg zN_377ieYC^%0v$t8qC^)yEcOu5ERSKFcx^}r`@}|<78XH+nR{yG3^X_#XS%6zK6J; zF0yH{a@L6tRn@G*GdIY9;O$Vv^XPXylKT$rKG@#c3M-Yr0}7c|DRZCMKH#bdyxUK| z0l^c>oG4T8N%8;D?ngY2e&?0kSPDed?6P`kIp7L<3ZC5Y%Ysy}Kn0E4Ix(Qy?-qV{ zAc*!n`kmNYSd?q2cErK^v2KBfU~w7GKML{9u29j={ok+`7HN&sA)wm)jW2~AZy&X9nvk42Wni|9g##}WYs!7_k$p55i`Cqrl!ZJ3*`L|9iO&^jrlqQ z(nb(o9w8DjIE`KL+6PVSvo^P$gK%?+Omaz8&E5aqor>`nXxB2zv&*p>7?X zb^vR~BjMR=Ckzg(-P~2B?t``Caqw(t5jzNPAzlCQnPBaB96TEs(%G(E-nav4BM9#n z$84}E`CGYC59xE`@i9U8w(F3?sHfCm-EnWu1EAK4@tR1$@L?4HGW7YPlT?R!R=D?B z!ezN5QaV~OS~qvnZsLJ*%|t7NwkN~iIJ^Z!KE`Y}U(F!Tz=Yty5JwFDbu9u9!q+9Z zFh!6MUf6JF6*9&k++7}^h`X5Payt5cciB6)C@oJpJ_QahXn7UtH4KxZKmaXo)&3^k zfQj>Hd8YFi@&dnHviVsC1nuoh2DCp5ngqXf8#Al{OUR?;d87vCf}i%7TN=q7gx5>C zW&c`r$>z7->kqb2dP<&?zs$;AZewNPAVRHrC%EC3jJc5bLAbrBqTu#sbi)}3!0wF4 z$}`pOOFr_dzN(&cWzMw(TLs3mmp->Q@r7?14GZ-LN`^FRfpimu>nBT{gHxvM9b$VU zlMKS~<^ENKEC8N2vidE%h;Su)Z`lKUzi4PceQ&MW3fz5<=aKWw^^`J;>V#It+rGV4 z4(Nl&&2wSH5dP8apHbP(7#Qa>6hm-V2$yDICbpv0QXQ36sI>a@>^vv2r5q}I%y>6R z2Hj)ktR3eEww?I*b*UP;X?2x^dV-$w1F2?anYt;<8}ky#DZ=5qH?9H`XAGC~sYW)- zg&mUUwR_e@LvAU%TW)Q}ccPaC4Yq0FwUZ_zxxF?XFk47)w7GoYQR-u$5Q+=J>n&)* zo7BX7bK8IapykwhzO$TmbAJ$NKV0~F`g&02dqofI`9gLz4xU_D(RdI{F>!?-5Lnp* z`ggbcRHEsl{=(Ku3EzVbKaa0xy1(p0z&_RgmKOL0>?C-UJqMe%svb`(SsvIRW9ppa zJ3?rq8dq35zrDBcJ79y1$2Wb@VgRbV7Y$WX>r}Pj_6d;7HTA?j$2F-s>O73hgwzp) zzY9> zpw9a;LlhQ<1eLz`-1k*5~>mIdOzWpty{A8-OkeW4xXB zGm-_mu_vRQ=M#hLEkYlljTABxxjsM$FHVKjG&sCQ%R*pB!z1`fbTeIxf zE3FR{pAHZ#M7;z~jGH|!Q;eEV0*~tFh%Ma=o!vO*v!d6ZS!qm4;4%NaKV*=eY0>)U z(WU!jCh!)m2|V_n^9$HM6UuL1MblUUkN@X@o1O*Cr|Pi}w@~{}&~pH7<221jZqJO9 zVsP^E+m4Q-k$zb10_PL3`IjttGc65u2|O;K18x*l@&izHf3x$W{Is%42xn~^=x?YV ze6MM@x6u-_b)+f*qw>0~KKah&N=^j)n@|?J>=mCk*THU%CN8TbYV-@Y(IDan) z65d8!;2;6c3f|s7`%BvDOkhw1rQ{JpTA97jJ%t{Vid;p=UV;7S#2(n>N>@&D-&XwQ zpR{yK(31n}A6j+Nu1?Iu;ygm{P{YYSt106bnfeaer z1G4O|ilo+u00oT_mrS@aGzf53E&r^{pN#x3rdM#=Iqc%A#rGn01n1!35W4l;IT?}6!TGlUrcM~$H|!G-Iv9*Uk2*lb zbG_Mj(}4>z*nSE!FudmX%4DOvi3A3_Pr;4|=|FcA1IKMxLXQEIiR!???PCB@KA~fm zGA~Sj2dJ7s>{EqS4X;?Y5R}LnbUp={#Q(WHpS%PXkwN5Bk*Vp;+%>2L(noMv9M!7R zQ%=-F$iexzKqi5y)u^VOkUoNQae)lN$E0sYg(9hg^KyYrRxv}*Byf2&AxdAnyH`;n z(^Z`KdzvdqBf({HiA@7)?^ahABkbU^xWM*hac4`s<=q8yL9y;Nk-$z4P*=Qo=R1%B z7|cDlrhRu}9C0`GX>bk!2baYGjcm}AEHglEVet065(CrtEB$Lr5Oi=34o5y!`|a2>fk&aF&;L&dEpL{Iyes($RIA2 z{{H4yNb2A`Tws&9biLEXj!5d@{97W^xO6!8th~0vIPHCE$O|#S zxV;n{q{(R~-hX1>t#En0SKZL-WyLNH8?@*Q?Bhf zW2l}3E}6^3Jbv7IA51n%V37Abz_2jeKjqIpASLMM>ACjjc;?RO|5ZaZ1B1HfmKu(> z9CLs83?y_gwY$kPR`*}w5ferMPh=4GJVL`f_CdZudBNEPgRJLZdr$LAo8mhG@Wt^j zw~^v2X(u)qXHV5E%ce~^Czi^uOu!D^6qx~}h1g(xT{Oj|XM%FO+WpTj0(bXDz<}-! z8t$2{gnR0iW!(_R=*39ZVH(9>5WIU;6JEFy=Uc!PRp~Ee;BVq6zla zsc)7B_N}Mtx!heOb%{-O)Gg2C+=x^XOlFtZK-gT4AW1qj`o;F(e3`-AbAG_C;XqKYkmaQe2tJtPZ^MH`RPW^ciJ-Pn zu8jnCS7R;~iI2JeEu4(3Gnhai$n@gKTD-VLBKz~}29`o{dwohLH`<+S=v?kLLJlSp zxTkqJ7XNm(d5ttSjFYv%7Eu75|k4V4YGO5f?zi(UHK=g0RWrFgwjqZG3=B&HJopRB5HKKwwwCOo@(?v!&>T%BIQ7{~)>+;K9`Q!m4Gv zM>IIpNOGXtzV$@c0zH`Hc8QJ*@J8+AoWuYHb}+qqi46?!pU8vHA?Tny-hd{_amT=H z^s0=II+(0(N)1ZzL4`XeB6SDl?^14%6vm$`l>=c1lhs8T0(WaIy2ZbQj4&97x3EPi zt{P#c!3jr6Ju6fmjKf>#uo`dw%ElF>$d6JyD4^53+V)P7->qQeNT6^Yi_RhhNwJad zjO;(7JHige>n&_z;amP1(wdY}LLI^Qyu9H<8IfNdt#ckp9gN3IWP@_4T*En;`r&7G zCy&`;D+}7v4EfUDOA%AVD6t`MFUeYMUhXPt~4V7iO-4zCa!r&pzDDCLpvw;AA-j~ zZoHFgp`4=VnWQLG&k76fpXt|mXxCod{rpPI)SUFmZt*Lun!x=l))XaDJDyMV?@y(~ zXUISIDzIXO`U69Tb{;%*NUP+by|B*4v~6&QZ1Kd`u!4s9W0;Pdb7zTTpmgG~^IX8- zB5?COZ|pJW90vmY1UPY^%H6Dboi_>ek-7WC&^X7IUbrk{L6cNzd z;Rd7izLS-K#5{_gscYlt+Gl=_rb8}%_AY`BBJ~SYqqU{#IZg3jIs&)h(ezBICA5gD zzBuK`-M@b^`jk~vIOC~XpHE6~w9#GmbjMkw67MR4c8il{jMF`Ea@gki zM=3oW;P+O4UtX`F{ry_^*4G6!iJrFS*dacji5Q!sG{}^C&Yl|>-c(teqkSQStWEI> zG7Z{wC(n8gA$tp{fKDk-Bz)<>G3qy0+(t&NpSR~2wR}tiHdo)QQ-yL|gPLSxDVlPj`WfK;;`&=lJ=&bCIn<2xPo`>kHhn z{VB}PHWFtk6B~3fBDchMWp+JF&%KoRC5?8s)_(=+cyDk89&R=EaS|Kfq|j}!gglm> znGOtHh;FT2SUQR>p5ZO}B4boIkEQ2;iwsFRe4)Dsgdw?uadVl*T(zIGi1()VUL?Vl z(+)jR&sjwOGq5ghUr|&3l>Bp92#>30Dn+(E5#y-I+HAAQgm0nmAbj11u2#O;(80<5 zdxjF;+uoX48-on2r|mh)k;xqftEz8pk43r(!sq1&2vaAmjgZWR>EJ}6n;??A1x;+R z{@MRtMz$D4Vz;1uxxw+FO2uBD1L}FNMgn@htF!Nz`0^e_x`9>H)AhWo26L1`-vZ$4W)=m5UFm#+WjVId;W%0E}IWlY!efR`2r6LLdk$X~u@=fTS9 z!POacrjoHtVrjJz!0;wzwp3d%mZ?yxQjfBUZ!rH}OeGrY-8)8wdxIB@0!IDq+p9To z<-oAb_rPw1$KR8aN$mUnVt5NR%XY7qo&}COc>FyVx)j{saF~AU&-Dkksps&?0@3vw zvWhc)gC>nlqi26k_t`7?zLHwNJFf8 zK%$!-EGH!yq%vQ<>zL7h3)h_n-pix#d4Gah(frsJ-H`gd$L&@WsC9>b=geO`D7^~x07yIZD8=hCZ>zn ztXx_tJR{39VC#%&d-B8OhK3#&E49KKpLaM7N+<^5&;AMNPl}E^{4p~Q?Dq68==zkA zA~SfpK|}LIk`t#ntMA6hdR2BZ+?w{fCx|c(_`yS|lm0oQ5(+jgse6M~1PU|9zuSX8 ze7g^4FQy!&2tCKotnEyqz3@zV>`_s+0~9@Ptb1~(#FqirQALD8Qqrg*X-zA0JZYLi zru{ivnrGqHM^Fk!gu;K&;iptc(`?hGEXn)os2Z=mZ^$LukcwcC{cPityFBrT93h{y z%e|+D{0?u^C_+C;&u1i|hbxphmYD7@GNO5Kh9i%P3uyW0R=U>HeT(|05djTOjui$g zhD3}mPd=j2mfh`WOo`Bs(=$IpG@yMk#aYv3GkZ*uc|z8bZt=AhfD1J0kGvlozjuF5 zp4EA>J!oKtLZ^UvX>7fxG^9i*r8Te`Q$ZrR`9g{Vn)=ZX>yayIz1{;Vd?{IYl5F}b zaWJ+*p_9P*y(eY?oS*hByX8HVLW5w05>J2{e2Vr3!4F6f9QtmWx9PEag#Jxk3ZAQ3 zQ_IF3BU$uH$Kf)@%Kyh@Bzm@=11}p=>6)1y?*J!;_J1!#fO>8TMMW^4)HSlNFln>X z)xr!}t&CIhG&9w}GImAh2ejgfVDSEoz+yIb^v1X+t)G!L+j#+`*{oIsi?aNPR8TK9zFY1k-1Q$Q^vOqGJ*@ZoJl>Zp&kT7}htZJcZ>t9+RRHj3VFE>W+E9Ul2WXC>PMTnGtE|Xx4zcXc} ziQ(mM>%IsA8iQEpLlg?2ZoFY$`5$EEAphKwGTm6Nyz%HRapZs3)=!NT%XDP1R47k$ z>iXwf2$h*~1u9yuf9Gs_9b_~Hjm}iAL{$wd_0DXqkqI!eje zr7`!$=6WrGuX;@&fUnxMv=h9BX4(2SSSAKn&Q@sqkP0EmidUt-m+xDI%Jo&L05Qx| zLH%Rj<$ge|42GN|t4w7i=dA6%vK??)20P9HHb(y_0=IcI;dihLXUwp3;Z_L=69%Cm zFK?H42lxSl8D}D+imA=^ox_12=oxWlogk_()wBMn7_}|42v_pY6|(dMI15q5tC8>f zDWK$FklxI%HoS@|b6)=|SCF-G-L-v4S>UT#)2+%2eAOFO{rjruzo^@ynl-L;28+&M zxY?gieX41uujtVKs0aqR&BhcS)i1ffd^290yr?4IxIO?ko=Mka8 zVhL=qo)33{RuF^EW~e}}7*)ZzBRlINS(){*Wd=mn3Poa;B3NdEHDG}XUVeAic?8RJ zTXPdemC!X?f-elZ>S1r);>T|x^RV~o499_-4BDEpRQ6_3wbyH3pYBADr6Tl%wXOq( z30rL|TY=)~2y^=Z2?^~QZu=DETm5`F^A`-i5HDQWCyh?8>fdy`(#Rc?(kW$d)(%(r zvFtJ5^AYvRH5Eis-}4d957b(_I7>To_XTfon;t6rAolM)k>60V&1XbO1?_fRl=&bG-`l zk=))r5(}EjeST5F&w;P&8EmTDfb=_+TAg>>X8wH!hyO1@Lz-vVVW4E11}JO?IFN zJq3;E7?{VtDGjrNvw1!BOa&M2F4}a&E0M%+WHZ56dUBT z19gYcF>p~4`XO@^odm0I=N)c`BoEf*<%Jz;FneOpe~5G*tjh~@V%@oOd~y*<9&DDE z*i`Z|nFs%l(1Y`Nv6%2e(0~FJnH%^#L^qRd#xv}>XlPwzkW{?{lmc? z^s(EhNIn0|V}4Rt5xI%5ul?9MnZ}ezJ^PHHgUJ2r*2lvUcyMW6iVohI>9*xwLAr>M zdfpk8+@}|r!OT0`F<I1(2Rz`YoB#P!UyN~hGu|o9@%{4W$O2l zdd`_gH4)Hv-n-M`Gn(il^-s4d*kG^SXYQ~q$XtSRdij2VP>h-*X3u-N1IZnn&r5I; z#0$q~xJDCwr1u2Mzr)iabLz@TbHV!QS!b$_eTMCv!rk8S$`FA8mMl)*Fi@% zQYj>KRf;7pvB<|WON|1`P@)zG9hDW=ejVQxp?kH#L?@~~UgU@I2tBwhz9^VshWm5U zKQ90W(vOq#+PFXmIqstzV=E!igG>BUbY$U?7cSmK=)o2I5*;n-^pgplkz#@?`6W6? z9v7!A*+{R+MCz$+UacFC8wlai(8GKE{;Erlu_E>4Hu@8#rR9h(QF<(wO3ckk58{<^ zhyG#!oLjZE_1bU{aP-1upHLQeq@MNW{RMG( z+?viP4-?I_jK_G<(ecUsfw`4`42iNj9z<~+wKk`BzgdU{VOVNP|cC57r?P~NyJFnVB$`%Gr zHf2>4tAB^o9$Y~n+JDF((-kXw3MnSIy?_A@6jOKQ_r{O0GwAavSxiZxPpr-!i%y6IFxm16xafI%d7y7Px}Ddsx?EKIz6e6$ZK47QRJQf z)z-_vdAQs@i+LxsY~1*;)ZxUH;jicZR&Fpt#GkA2r6=}ze_q7UCSxH;I!=!t&hcZ|(rgt*{EcS|J? z?br|6oIx`DjLk2;)=_xN8|%?mc4=yU0KO#4k zqClu1d-{s$o)~+kI(=Orl1uyZjMXp}9?q)STYLETVE@5o047Vnh>!zcK-1%k@ON{A z9fDU+{(}W+>izhB`*I+(aT$PytfEl$BkjPLf0IF|;F17k1#IgA<*IMj=jaGJK>8VW zrh~~!PrxUalS77OG6dVyn5*N;gKesQnw|O+G^_mZUdG)Bnpq{tu7)5mn`Wrkd5P`w zzXFMnO9ix`ZIPYW+*N_V-bo(5>fX6sFXdXgHwW+P~tbm*~fD6$u?dHanu zrrhQ;Bgy^g?xW7xwy_}a>xbBxi|K|B_`JyD{XM@!cFAlKxPQlLVUdm0$2pge1x15* zs}mp&&~{JVw_lqCbkF4mT0+a|P9n%t-S3E4H5}-KOAd6y`_svV*GH!T4yB)C=U!gS zb-!J2MlY}%(a*0V&>+TC*_b>W$sJT6z~jND^dJ8UlAF0#Ftu(#1G%%8f4(}h7-nT) zf{P?AL$7ZakIBXIA-1_tXfR?!oK_50aeowP#-HX6+xCB8PTGpb}I!w3*D&-up|D`Zs9ZZj*TEz&q>eO|1uZPcNLz-3EA$emb2y6bhxt<4B+Q zj=dxuTE7zMCa4lX*8ie)LaN=GQBTf*B&45E=aJpm@l_M`c}38JSbg*`#FXF6k@8uZG;CmfM(xOhhsi}RE)*!B#MV z&8rS6NO!2>NkAPwQM%bNAP0uUw^XV}Rj$6*$5DA{+07>nn#bqUrlBS&o-hjP1N;oL z&X@5&;}tFW0Zx_^uipd%ZailqRu?>$lCAc?Q;_gMRRG2zo=}XM<{lJm{wV?vssfO^ zJR!T~td3nis2_Gs=6)G$+?vrw0(T&j&w04|%MSXED{u6XRw-LeZggz{;6@jZ6NnLq zQ)<_qGKW+cJ+IUNZ+b-OU#fMRz3ii+9&pBmBev2ufN}`$KMIhd;-}vS&Idlqy9Z7c<#O8Qhe{OI!aF@bem$zLDBJyyuY5dJMR`OH-ol##2AI3v?Chsu+@TTGH5QJ?B$D-0+N{P zlspWGrBPhQpaX8a5Ty3FGG2NEETDeaop%9c$`7NR;w4|TEJ3#|Q3^3jQ&UL2$o-)r z`I#?{4*~H+p?PSqrA=EeFsoU4Y451i2tO!?H+$(~&=akPX8!j0I>HYs>znw(dnhL^ z)A%!hG90CUcGkVJCVmH>_^xpKxc);KYP}nzC_Qh`3b)ED6SaM>OgKMr@X~8ZvanDh zx}Gcm^VYwr`DabG3 z3q}XyKK+rl^`p2{Lieu-x3FGX@NJZxuerE+)L&?2m?eYjcZ}d9en^enZ&WV-bBKr= z^3PRFMKQ|;`3q*!lrHH19OSvHr+=28CI1|np+ZgdA3VrT?WZ5|MoPsf;Z9F8bi$o= zH1t!tF6q&;J!ATAs7eo^qqtl{uVVc5v*+xo)iFeThWvABpUXIOeni@iG$XNd1GQnZ zLg%ldZwVrVn2RjSIr%e)*Wc;joKL}qPCwnx%%RS=_%qc`11d}d=|Vr`&-{TQ0|pN@ z^M&{X5vXJUA@1;T<6R$u5|7J8^!$b$2Aw4R-R;oQG8swBbuYJedr`k`xw@yC$WzSY zNvWF6|9j+~lC|f(aZ8;>K4rwF`soC={Bz@L!-dEUO2znb;ntV!n?i0VZCsEC+rkP( zHd7GO=FHv*)DPYgF+d2go7#>#Lzd3ZCAU2C+}S0go^4qFK)Gh(eU-!pbT{**DbY|*F0>Vqy6Hc) zvlN_?kQ~x~WK!?mne!{P->I3kzoc^uqx8c7tq&0HRz7Li2*n~cG^y|<9jF$if8W-H zYCd(T0LKlf*AVQ5^^8IXxEhc*KK-D4bl_x^o=9lH8dob6QA@OZsfO(pZX4#ftn@SR z!o-sgOO*sMOwS#(#57vFf@UU~r1H2y5qR9f4x?>>U76flUj=Yux(x`u{Y4dN%ks~q z0zG%oEpO-k-Q;LJLs-W#8mFza2Sf-xanN!M@dgBn5Y=AIw-flYo-k-hEE|8$yNWba zepR;aV$cfE(*-^F#(;Bjw28y6Y$FOOHu3V!QZ+!t)H4Dlrbxq719P67 z%zzNRW(GDr7NYomZ6XlN%5CtV_Lj7yXQujOE8d1@c#_$=Xf8 ztKFN+J-f63dm25v&n3EeyGYhm;x|mcrYav0va2d^Y_ER&J2ogg&+K2B8DtGT)6bF{ zXN`yd_PPwRhMwW)LWNnQ-ig+=K-SQ6`y61DH4fh?{g_U@j?(k_+^|sK_8TU&1Fo!p zmDWN=`Dm$l)d5NCEz|rvo_T#xBqowL`VKvG2c#uElg}-!d?3dpAS&)%eQ@U9w)MJ_ zi2f;B3mxRqqG6@mfhe!%?pcs#ls6UPyq@bMr-!lq>q&*k-*AhpEwN>CvK}Z}(<&wL zP~B#0(pV25Ijw_wFMaMS;9Ysz8;|_BGn_)U;Ln8-KplFvo<|*a5lef#JBO#QNExJ2 zdb*wq-+7_UQAF3ujkg0Y(R1`HTqofjn_X&i@w)eQG&&>G1V9CFSe;T3R#gir}+nz#XEXNrux$lb|GACBDMsT zxagYQuR9O?WqZ4mf|VY%U*8nqYWQfmGkpmvXtbU;=Mq$0h$3$EYxabC2v^IObKweu zCnewD6=Cb?o-11atg8#x*(VeDZ=QSqD$QikdX}6AUUs&{rb{)pj_H5ffOMkG#4d1g z7EEHx%@PwU(%2Fmu1&uduJOVjL5*B;z6bT+X#F%jA8Hw*fhPBBEI^WS{Wn558@07* z?b;eG85y>nC>X7OwAGQc47g`^x?V?zFjom_CsG+VbWGte{KELia`1+mnoZ_)vW)pOb$MEP(L367Oo+&PYLxehDg(F1nZ zM}?k88qk)?w!B2r<(smVpq-Iu{op$XQC`TUG3(Uy9d9EQa1*a2$BP6>mh6*JlX4(j zuG30fp<04l{^t@e(V|#6RrTw*q|RENyXiR~rk=6p(kn^@yB-`YPWKzpda|00o7}%! z-TvLWkFbv5?E^<=?>p{v@8@ZK9Ia=p*}u?tKxgrelUj$o+oWVKTfZ*n)l=0hST)cV ze_`xPAad#HX*M3rG(T3l)*7L59alcQNyEX#%x6ymx79z$YRgKjb$#FZ;}Ie^&(a** zD|^@>^yOTC6^KHkYDH8$?SxDqd+8}=_LmD((S8>HG+v}v!gpNhc|&Y1xQb;jMZv$% z(qj4AFCVl3(NNDWv&8M&y}v~lP$d1R-|%N;UNP*Kyq_E z*J#;^2i+8PyjVIrgk@#iG9jU|MiiP+VNb;sDT0=c<-Y#3{YvP){wUG6)Tv&pN zs>67OQI&RLn!CpkFe~RuVBxe?(foz5DsD%AhXN6S7P_%C?DU9no)Zy1P#Z!e#oY(dI#Yo|5O@-2%dj{{2-) zUQ}%kA26dRf@Qj@6c^n#XjrIAX#~r3R1=mi+Q-FrG_?=PTzS?TTK&1H>o%uTWKL+i z2^`!+>uFeyTIGB?;sU3hKk^(U*+%PmSSqflI!tD2#So)4uejRI^0gv?x#`(ip5LKW zSkD%Rj)5vn&&o1!?d$D^w9e5}iIrU!NH>;i=n7tXDpvid*rrFDhNtUXULkj#XgTF$ zB&XLT{00Wm<`K?DHlr^U+>vD4nOjb#6GzAmqq0zY>ijemK{699YVpk3yC)9hZvFf= zdyP;#_3tH@enX&4&z0{tP<^hv^G9X7o9^;kuR8tvEh#XPSA2gOth%0cWq&#J*?cP# z3LsQ(&n$o~nZqrVg?}(8{4nrPJ>SZd)o}W@!a>yozno869sxTVJX&>Eu z-}qtWV0*<}9-wDhndsu5it9ID_DT_H|I)VHfLcd2T|Y7H?0G6EFe*sBG|Dvi- zMlm9ehQ6s^#}`AN&h%7j{T(KMw-?FD%&`Ixwg`5Y@0|+4GCftoqPNZ?-acN_4pc5* z^?tp7UlqDlOV(CN4>N#}qNh?>>m&rF{q1$@CbR`#uV+#@pr~V9^+AKIl*16M=TTX( zN>|Ic4xj{tFM98o00M%ZQ)T^x(bf_blB(vx1BdU)B)m)hxjanIs4{WYgf*dl@xEx) zv<_>*!9-B&*1gVX)x4R&Z-`Bnmp8(w%kF7cbs44iMC%DuK3UC&?}b(cy@KxM)}H;L z3qG7?$qrQ~NmFdR4R$AXRqhU(AnQgL6RO8{=Z0`&Lp6d-W0X&y}_mZz8 zmw@Hc)24jiEj^c%SLb)N9SPK_XG>YI1TZ$$D;t4J>1k3vKv@Th)mM_%N8@^Bl1n79 zUCYFvN*VR4oYs7lvfI)YE4~Y9mARP}`h>ofsr{ah!HKe-8|5gWvO&oY1s*V^LC4QQ zG>GRqu8>*eT1CC-7LNK%s#hw*tzK`g0nxzn0-@f?X=kc#u(d&_O`wd^GodU!h>@#6 z0e5b7+=o!L9&4h?zNz>xHD+JRKXx~8Sud!6mlZo?6*2Aq&ZP!&>Pb+RoT3#Aa!ZBN zH;N%tW@+3{paPw4`t7$cgv#tZ`RSBSZ<;S72nKorl%WC9dlTO;H*l(EPoBycPua!M zdJ2>qH%vwu75QTP{VqsiUaA!m8@odqzO&3s)g0mSoYufK#sZu2I@|bfUVFKq^jRe= zCh+|Bc+;baX^&-@M@9e@m~neFQm{9HfpB0eSpK^#Qtf49m_J&G6x5?$A_QnqgEE9XGpnWsg>p2-m!zdVouVD(N7Sw z^Z=%x6wY*i8?9$zc(f?7WMS%Q<&6sYw;>t1jte^IHGi3T0LiHJS^Kk-m2J%VHrLl9 z8M)pXM%%km@0x1GeasEbA9-P0EQ*)o9Ri zWCvU?_1oG@8q;qEJ?)C&aiPR|(X|TcdMcNUtn!wh`}?)dYOPgb+N3P=vJA?S+@qAa zU{07`&}+a!xnN54*U#?qK{q`cGApan*WX$rS7Cd>Tz>1V46)ye^e0Z{K$(?)*WvN> znqv%)3T3KQBv!LJR3mn$f4a;DX3L{PS=b#2Yo&7eRF@H|R}KE_7HPfqwo3+o@jmXv z5v?j0db%5!7mooYWhH^DS5o)JAaLebf1M;JG{=lqIh@t5`{jOK#6-h=93Swui}CqgCOYk4ycGG^}-CD}YJD z3fh8g&r#_(Wy8hrcu_(VYE>|MbOX>mR*nq=`7NniKh3vp3Ge|P6-r7dlNYhr+>^%K zN2t6Ftwa@fZwTt9{Z&hW2%{gUWv!AiIM&?OlI>^40Xb5D*YfyKQV%47@9y*NQdw>( z-leBPS>Ba0-nzKyIBeC+2aI!n6_V?)De0OH-xM-c%?7=*ESihHottUx$l}DnuzR!_^(>;1%MB@wK)GIqmeB(1U!`PiJn-jfMSV$1sXE0zM`S|MBe z&##hZY20a0w+I&({gV@zS2T|SRVG9N%ey@)ZmRV2ry%8eSIob_e%g?4PdTs^!D`*s z@&*HzCat8x^WqUK*KG~5DTQ6pJ>@Kj20SWMSww;BIj-GfkOiYz*;OE_)nMf8=LaAO zweBkQDe%O`nyVr9*4R}Kdlx8>r;>b9sd?4O;G31!l^;_QGOC$B^RHKXf^Sx~ z+5zxLHeFh`&^qAqJZ_WG2Nb$gm!{Rw*B=0zR4Np|Vw%-IU7symug4%+S&k{B6v;$D zD~mp?UB{mhsCU)<%4*zUBbJnVO2&4e^3l(iGHufjV`{;ugpZM^tio4*KO!f7n)%=y z1j=+vt1GT3_5O~d*%2tyHzmQzE~T7uV*jwPX*Q_KJ-vZ0pnKYFRR?o=Od8Y);gOum zhRC~XU=v*Y!+!n1^6RHcnaeLx#eb=JX;qnN=jj1_43FegHpD|lLY#@31s`sanvs95 z?9U@RIV=~apo*y4ys=y`84BEhT7NYPs+N+Dw6Bi3t&F=o`8Fv3^`oRr-O7K8o5(W6 z&`o=VQQdAK4R}q=Z!DmDmC)B4{|^L0{Y)uKSmQK+#;kSkdL6m9qyy^5-cZ_~!lm#cdm@4M?hZeWC z%RpDy;t`!hhfUIPlzjNx`xo}vKH!FACfQ^Wt7ve^lljBTAX>#~-PQVbV*aaYFM4WA z=}NF(As>F_b{~>BrBswQR6a^&?Fe~cB;vixxkEg>?Wa15w4x8%?VWl z$6ap*Qj4D5WQMAgbhE*+NWuK0zXuyi9>d9$6*es2=$mmZSSUTi$yz8ka%w*jRoMnBNWkyQAAS_-~)|MjiX8RVbKQ@x(= zH>Vm7Wkf!T{P?rydIBHdQJcydJr#JKJ9f^_{6M?<0Z*nLWS0VDldrapjYg=fvzxMF zQkfu((duGM*l|E^i{X)*OjKdG>YAneF(NInSst}XprZS`1IAZ8ioT!evj%01+Q81- zy_+IbrqfDPV6)BZUOEN}cRiuWvH*!18!bk1$*EjQJQyC+?GGfeH+A_f-2IT;-l})- zeT3?DGYu-~33Z=$p{Q*Kj_)cvPQShjA03_5q`(&17K-K3nZi)BZvXHXhtbAWERV<} z5Y;@;eQ%R?NJ5sQ3Ori9>FiUO5LJM-1c-y>M>KFyD@`(R0_vL?QHewt5WdDEOsSb2|( z;QksK2TsFd^-mefXyU^a0Y!-<1%~AL+cpE2cY1e#0lbrhrXvX}z@c(1kH};SDzCf| zL05!E=LGA;<1v}IXj3t}{k{SSmg%TgUxirLFEQ!w(ohiMEG#I@G7P@p<0-*Tf1cXg;=CdW>%Hn4+f?7>i5cBd;8=5d{)_O=u@J? zih9Vy(Swk{Ojnfx%W$n^mB>X^sv!elCRdvN4lY}m6?m!s!9X*f3P90TQDaKCJcBoZ zT+QPt3AIX4hp!>O*W|+0-E=t(@Kdj01@cq6nQFZM-cXRHc!VWWRMGn+X=>=YRHG2A zH~sr9f}{pST(xqw%B;Y{tm;dBt6jgatB?;-!!ky?hetO2Spi<+}lq9HKsj1=m*x|buX+tGe z|DK-dsy46)+4O`lCRdduz+HKho21aj4nxU;nSVPH2eP34?L13h60R@2d7&kel9^UT zNeQxG#hPbt0ypLHl*Fe?P{$6OB+$3%mNhb{NNiWp60LPpGYO=mo7JWbWo;Jt^2&OU zTfJd5keAYUviZf%cYs!Tq$N`UbieXh#qYiXA(h8mGC@IIRd2zS-AGjL7Qk=5mTN^> z0Nti{=n2e}$6gYmlCAp1>3s|ygp|~^^7@HPmfefoCpK1!GYxyQRW)Fy`nT~MPk z_|)pRFUKO4GIOfR-n*6>HE{yL290OvRmBbnV-~Q@wf(N2)k0hzvi4S1MTm3c>#~UBv8@$$LJQ*rU1L*QI&(<5nF9xFg)95D76D)6=% zlgis=rP~ZxRd5A#R#Ehu4#vPciRwnwCRXXN0#W=+iLKSUul~o@sH+L={dT`Z2oYAn zQDuYUM-GDT=24cUlq9V@xwmsPI04~JXA+3X%2&U>yvklAAuE|mJWG#G$&4vo||NpJgvfyMzuJahFqw)@mhsJ_UgD%S?+1fS`byA`thv~Y#9VXDUX+Af*R(o z=(I!U|NVhv^+tU^p~Qw&WzBKstZ@NIRjb!Nb)dwa`fYgvSlh9@0ZgW>Rl!M3;=(Mb z_0OXzRS*qjIRcgl`%~X^|Jp5emy3F%i2rO_g`OdInO71_?T+O!m86`)sEC+P7d1wO zkDjMw#wL>pPU2I`b;*B&{wI&9Bt`Xge~7?o@@9_!xsS(HlF*O=m8Zpy)xZsSge8gE z0qjvvzq-A)Z33=1z?;Qnf~uZXedxG8phn?MV5(r8Q;@dL;_DkOAdND;)ejlGdE0Ja zfMP6ipu=EUk8tv;PDqrVbV^h6~yRws@lar%#advDo`?s8FYS`Or*!Uswl@zjyB z(#uz}NK8daJw3^iGVQEbdJjIK>O(MxGnU6qLRVDdqn-^1$s~c9No5-u8GNnI|0RGe zACH$LDhg#O;0AqU-3w-5=ax?{)FFD<*zqc{p}ThgH|H% zH99f7Ldnu^&HAk;a8VvLNx&I{D`+UKpAk&pi%sz6D8Jusms3tBF??KsJV;EhM+E{z zbmzYHW}KyNs??ZRjnfZSGBdPTC3N67p!|nmm}Q)Pu9Agn8Iu$E_Ac%Fg%r~p_~P^vm8@?! zrX-ROUHqM`U8sA;@hD1SokXCj3VKL0o8*bKP0Gp4alFUoOjvr@^W&u9)e$H&k4jl- zuWv-(ZV%AvbA42je(fyf*wp_n#qCF^Tt~%J;)}UgEwbw!C!Z?Yy+FHCaw1dfwW7~x zxf93ZCW&>D4Ky=DJKw(YN%U~=?L1zRg-JE~_qUVYrtOG0-gKo3A$>a!v2v6uZmM5< zE=S^e52yXcR6o4rciZ=Dj}*(?qDoYfN^d{9+6hU@Or?IfzBl);6_+_urILRxSB+q8 zP%EQ$%;1P#KO#hyp9)0bPfB_&()^!~5hBY;B_c`9C5mR9gAiE`DiCRIu97snj~$&{ z&grfA0y-x(`nt8|e-EVOk&&d7*E=Auo?Asrmh(qYKMH`SR5# zml^R0No$g1r)N#8#Bycot!}<%>{0d3XZ35J=cVsS#qowInPQ7~#X9#L(p|hPX0&G& z3#%EQH;&%Wi{s5!vVTBkn2I19rtUv;Dm|x-(+^mZwSWyipbvZ$t>qsDPJ;x_8?t0# zqZ^C8UwJK~ZO!iGWcsktvmvkXuKTG`Z3N16W7%M#u_5cIw-$j&%i}CnmR%dlgW7Rn zcWYZvmoIx$LO@@p6>+OoFWv@n@(4?ooa(lv-&<)8+XaDZm3Z&WNlbADrZ~cawQWAN zKiv)Kjbnb&p@cO0fC}iknD^_`{bd}Fs3bv!^9olGzC{9BSnX5uK|tftl`QB110=K} zbLu6Pn#+S{2#J0rq{|&6RA3$ z4(q%SVKSXoVv-W^ex~DRX&)mlikW@=j&!`(J%evPh|6!iMVH^5tT`1xtq&WFUs3^7 zT|ClKWq*X=);))J24S1WU8)??EqQn-x(3y`Y^mk45|@82@8$8A(1rNwJr98Ub#XlI zk^zX~>(lD*yo0{pyHI|EjEn`SJ(jJ}H;>TQGhLQeiHk$h^+s|s9aXmRM73n)L1!z! zyhh_tX;Ko}y-Hd)m0S5WNr`yOLi+;mZ39llqb(WlNl8w$xWTOi!khW}z6qk0p0;FG zFH#8t*H*Mz?V zRLtWr34C+Z02FhSyVB` zQ?{bmFvi&_@Nt!DKLgQ=M`l9flAax$6^*QlnPp{T6H-I()vK7#R<6r$y+JXM--?i+ zX4y`&Gk`fcaXccE@$n%82HTO=2{F;_hkgqJIFHC=!irjpY-HMWIQcbLDjt(bz>+Gq zXrZi=!BX*POa`D#G&FW+yj^i7`hI4jl?806QuO;j`|nMZzj;h1Q(SaSq`}3PzC+S_ zEz56NAf*-O+N66FS+h9cAH?xyFbQdKGqzgsGAW=g=8a&gY;fdA{;GOyWgk#$#xgzD z&n@;hcRy-w$5)rXdc#&Aebk>7>#!;gDf>RugNPFH+Y`rH0c#gk=} z#h&G}?c0H)@&+#n8W*|7-s5Ol-%BKJ8NIE605VeZ%(`*w67<Rf6f)9~w>Q)F6CmXAhAhdYF{Vt|nZzlsFZE8TD1(T^cCV0j zziJfMYg_o?oUMp&SO-+WJQ9;h2sBPKNpxD0l&~CRQ?IywdrhLU7I|9DrcYZe1QYG! zcuXcsSetO}Xtvpt^u}&T(X5`z^fGsqe=@xSA~lcCWMHDpL4Orl zhfeo-)0Zq%dV;d3_3_u>+v7yTs3led(*naXfmH z1zgP-!C5hcwnu+|rzn^_9miuiNp!2cb|P2efYzVM0~mS24aLHJ7G=33bwK_@Vu)Q{+b7LS{9C2r^b-Kay%8d+h>3qld{&#eq^ zJ?P)ftq&gZ-V>|9E7?M@ZXV&+{+5 zKR(%!&hMV44y`22Kv@_}KHQwP#a&9zkLPiqgdM9z*ro78>uK7F*R!9j0FjLMh!sON zfh#oeJpPjuQ{1DaA)@le^RFXexrMUm>Yy#+-$f7qOmjrMo(1L80lJskbNDYI2$k!@ z#ycgXvioDr^K}p^*Mp6BN=QCC`ryQInkM4Ix$aBz?$etq=1`xC=S^sm1|ZXf&jg&P zJ9qo^`_cqt6m!BrynaHH6?MfkCFsIygUK~F*=3TmomHw(zph%@VeIWf&UoyeI>FRl{HJk(yLvCJ7q$-&36j{tKt!%EL6dLH=2)*1}3x} zd{kygnbqC0YTeb*z~5QKMAa-ULt^tQ8S=yIkGs)K7S9{fWJwG&*^Zet#{yU2jcSs> zq!0JMW?|=$a@j5`lCE$CrL()V{a5QLdnKMXs>zg7^p535M6`~L!%yW0nq8{39e8jA zH{l9J!1igme1nX4cBB`(t%93vW$O&wgc}iZa+{GhoLD0wNK$&50GED6|hs85k?(f$lbWNzN|)9_4psaH1y%k^SE{mFDcugha6 z9=DaTGOyU0hJj99mr|{#(#BdmZ;X?~q&?5C2VHudHvi&zgeVEA4jSmR{H;0mce~ux zYgYl>RqRAmqx#>`cdCKU=8>VKjKXG>82HuhD?Je;E89v)S{UtJHY5%~dIOc8&4vL< zcB1P-GaKF{PpMrtq-R1Id3K}Goov#qS<3jkZ|70-?8+9`vVbhWqe2OBg(=D8MKn8S zaI?$6ouXJ?YU5Ip-O*lg4M2R2VtJ_r3(JBYa~em|4Q@Pdc#{B*FweY1%I(~(o5;A- z)^^{^zt#2#_bRgTt?>)=B0^-FuWy1J#^Xc@Oi11u*zwIfAk%t}76P~~Ir%AgX#X}~ z3p_TIl+u`w7@^KbO#F9f2YR#~&!a;LSkKcov>_4s=l*iG8eHqeqeTgL+X9?=`K>K4 zER%Xr_BMK6l;y{XY2n_cXtl*)_*y(~qLV2oq%O2u*giFF*v0dvIa#>Xgkw}R84OD3 z&GmbQC!oINjdk*&%a`~hHA0R~QGTG~)Rv>r`f)R_-4S$lQG*7>mIH-8k1Qoc78SF- zH*>7wc!pI2rBx{VNIg}`whGDYN>46nMQk5k!VWjC1niB!fxMU&i_Z=u=cRo2cpg*A z`u=L7^(PjL?xIGI$QuT%jYpG`-~r#eNeKCT7YOgX2kR{K2EOY+sDHWq)vy9Z#WKo2 zSGeHOrd+?^?vl#gn_30UI@2{fD6M%sD)Bpk?%if86Z0czKJrLa0$bg~R%qCN3vd`7 zqe|krT11W;#+?7(IivxuW6KeC(iM$&2$i6*r(dS0NMdf1mLxD5I35>x4DJiY^M*qi zdO*~&wc+LS0}uC>LV-M-me^G~PHql9pU0>&1Vv2#qkosW16-R&s4`F;f+Ydw zmF?PgTUu9ESZ)J<5cniOsZU?vVu{vU0CLqg~zorj?Uy6 zvT>1CG5vijCfx$2$zxmjkgd~BXGc}}NrSX9%SdQf(9%<_j2%@ogUn}ds2tR|Hsc#1 zRIQ)7P$`k^hwc+z0(&YR*UD6ZxaVkGMx^#%ebnubKxpAnu557o`T@AwvSi|4m27`- zE86Q2eytb1q|$Hj9WX^Rp2xhZD!L8u_QA|Ozpk>=n9Fg!M^b?tSEL9vFO)fTW2%km z`gk7oN=k~J63BREd_e@t^j>+BmO605b65HRH{&s{q@*G_0!HJlE04Ye`!F8mO2Sr? zmk&hN0+yBIwLVjj9#~0NVvAlW361d)7p8zZk;l5KYTwF?ic}ksy{F#!4IG~E=1Pg- zhnApDsJS`n&%rX(C@mrVWGOS$B&LN!zsGDp2FB^d^Cn9fV#+q562hzJsQ)Wy$R~JR z%Wnv!e3QTAk zfU>Z)(BWjH7i|ibW@h4}3twB;WG_swCMNI(Pl-uZic9n;uz0X-xlUq8;E}Ba9Nde( zR;5HX1j^fftwa96bY5z>r`B~nZWjbDr}bv9Ku$~cif^tw^aL!qo@He& zxe(EHo7(9i_WrOGI5CDZ)#l4AGigsQfyb}1p^a9)Q6DNU@XN^|@6tX`0*_=R&@lz*{*%Tl5GrdY zYoZE8sCC@%10ih?s<$KKH-pLEi7*Eh^`*^KGts=5z++ccwWr~Oj!chEDV349OrJFd zdQl}*Z@HrFTT9ha)$S^Mv!fTTQvRaJB1678QoD%Lv*p?YJC-{tZ{(;2>Q z(PcYuxjcisIaV&U{s70&h{A5UKT3qbOc)-qEwS^-dOpCFh5$^!39EFVSviLKLqo zc1SwT%H1Bja3d%$L~J2{yUEx$iPv*NKVC7LGh4 zQN4_!1U<9LT0B3DqI+v17lDYtV^&!@Fy5b2%EE7F>}&{Di$|%FxFp+DeELIfBq`T- z1)}*#dgmJ${0KdF8PWm==d$ zv?y>ADVgiJ#{D@^dH>vG&Qy9llfdIs2~DU4($=t>Um-bprLn-1TSbt_eth=f5!)DC zzUwWL{Q9mOy65#@C)iA1vHW8Y(s_(3sR7t481Q3z@Q^?Pk4j~tqT}!-Wp6C7LzpXo z^EgyCEbSRwxVe5k(gD|nEjo|lz!`FG6?cl%yGaQ=nv@}|IJ1?kLa}=mU1|lrTak~t z0$1Y^r7U!l2d4o4bG<=r5FvStDG5w^JozsEk_en4hU>g$tAmn5j)#^X4SIdN$y27J zk}Pd^69)`1G~uMS?63b6Bh5m}?zT3qGh3-mTm&3MAMM!naoa9-5#n-XZ-~UMEHZ@% z4}f>@!P^(|f;HojrlclFP4>l-Hj|~NDc`OqOxfQq=Jq$CTb;Oay?O(yJIF(vzSB9#P5yHXBv8{W^9K{oIFZCAM^CmmS1 zp!cu9H+aM;OKvpktIo$wW*|j-%?!wFmAb}jkm69cn7UQF_sxk`w)wi1!F6V%S*3#R zXcf{NfpTkTW2TM@Iy?2#-$1h9ai@f8{jg5jMr`m6FLwE__xl6+FJWL5{PI_nEP33i z4)PsDW5Bff{WmsFx(k%bBTgBx;x$|qv{HEaB|xb>;*2uUgcEb^+(?>(-C`BoR0#@0~pp7qNpTKk8c@!7`mw zw$?>khBQ%Tuj^UEj;Aiy^r8lIO&Xr|rfYc^h^p{6{CbcS)wxOGRD-p?|NV&cc%>TD zPp6XA;ADf^w`OhnW}R}V_h9!F9+Vr&%W5o}E7rlszyS-7Bh^8)t108= z`C=7M*{kKM0rhjK%m{5j66gQ@>sdE|Bk-tEQcf{(LRLa*+q2QU_ItqQo=1(caP2*T zqt$iWVmBfcFq0~N7&LrBA#{4rqer2&zrHB9K^T?a?_MacU-@+bxmSz ztC!7AWQ-uOM2N}Eq_QXN%zJi({r0!6M)mLM3J6$jLUjqdHhq%033gzIU(SU?xLOD+;fqr-VTs1CAGjHWd7nDYiDL<&@| zsDAZHBXf>%r`mu8;!&W4m?Gw(!YAw9o0MTIX&iyF-&TKP5Y-Czqj`WC8X z`l#$CkzMqH51Rjt%!=ut1}5NAeKqf=x9vK@<*43t639`-$$+ZVBO7+621@0zo;p~4 zFG7Q?wP({X(qWAb=gpN8r%!DSx^B4;IWIw_ukT*)_-n9WJnoak7Ftj-Cy#scUvm5+ z}UZJ`)2byf_OZGd_;SA1`DWzO=^vFfK$P*KQ z_cJ(84z6hYDmuM)z4IX~7>dZV0lXrvY`RJ`0Nw>(A zL7`rKdi4Nef0Ya8yy}VOBK}jo@p7aTuGh+6fFq`QO+VC<%qtS2 zbG=tyn6l>GpvxC=**DNP=L9_0lZ`u5Bt8x=S@|N!ybL;&xsr0i6evCFB$l{fxAI&r z?X`~pE=?+gj7`!^1goZJLRqG4&X^K~qMFI-teRTTmedt<8C)n+0pjBoZ*Es`D`i(j zhcj4EK16x>fZ&!r{6bwMsW(pgj}kOKd|SI{eGqpTEGSD-@h|lJ>aKbDPJt-Npg=je zqB*4K^~H&=l_(-ot^9MZ6xVU(1R*)&$320Ejs+V(@VzhP=2`x^e}(JC0hnP?8`ot4 zMH7P$WvazB+6U|)-%EA3GFnV-Vm3C%}U3dS{#@gzWgflr}Z5ZJdi8bPSvBV8T-OAB<+%8b? zGx$(GO-SC7G2~H=KtKGxnX*xZ?A#PAWjD?el*l&v;)v(b>Tz9{_CF@2JN}VvW3K$` zRdOJwrThNxiw^o1WMBpj%2KTO7reax-#35KllkayJsZkO?Z%*HDsP!j#u3qY zjKPL7<@MA4D1I$Im)%ov!*a7Q?0@|JX{F1c3e%IIEEO0O9ohgo8-1ZR@L>l3$y9+T z{NeLC#V5veMB;kQ%YSU}L;flI&-^L~mYaJ0-2Eyu{!R=sT$b0C2{9S~kVWw3qTAyU zFw1Ryz`}Xel-nro-CcG(aCxs+4*|TFw3p&qHopfXWssnx)0zw*gYd6Px@pNPlnECd z&Y(e=z%n92&QkNL4N4)2SzBTuvCyh{z^qCCy_`7Tfk(GJNpsR|7E5@cnh%A2tLj5Va=^5zK9YodN4fJC(F0_T|O zqbjkd<$`;jV-l96_0sxsK5A1j)Mvu1L0RVYD5a7>YcJ~F6GRopkSJq;STObvTmFb>x zIF4-sPOmcSnwoPEC@ZxJZh~u_9J|Wi=Jqw&s#5lIoMBOhT{T~mBy21Fy0=THl#=H6 zzl^diz~%Xjr}+%c%FYQ1)DcvbwT^1KRbo`^ z*cs}Ha_G?aXG)V&F}=1AoZpAp6bv-3{d|!35LxGe}Q1p!8JZ>m5T~Kds*c>HLaO>1j`vQKg*~O9>_Q|0_L>Okax*XV9K} zlKSVWFL<_T8i=e6?vn{_-t$xIla%fGYXh!=em0b81*TdZ^Dl7n!A;xzUH;EtJsCn8 zSLRgAj1~U=3dCu~OehNz-9D?m<+`!{64>!mJ^#VvJqdc6uXW|v)Q!+N!(^2r&#Rn| zkKiz$Wb98#*SWlL$=N~teD#IgQk_ytH=>qMVOps`jLL0dI!lx|ZCgvK&IktU$x^37 zq;x>v_%QNw>huweSx_b@sdrip&s_&e>22wQpl{iwDD)|P@ZX9p>1FKb2tDP=0X4=x zDUmeK{Uv{+k7w4qv@#j^b_wJCXm4gVs!gQU=Nqu9clPT# z`VX3&A{b;RpRC4iSJ7$Vkf(#}b6=N#dJW%y9u@RaHPSWDwju!ts&{$k>kUScB50}O zh1Sxr9Kql`nct6R6HOg7Y%xM*7QC`Y1sdU5{w*~Np)xC81C`b%_e;O9gzlXq8005I z1OCZR13T5AbL*lb7-OGI;O_m6=V4Vtc3roVk+u&)^;W5VgR7s$*R4WRefuew%X&>Vkjny#P05^8j-LESFz8Rx z1gxf)ak{BmLDv$6s?hQ`f6hmH^`bLJjl5USuf9fC9aU$cvr-f*eMM2o+~$5#$1W+Dh&1G zpp3%sc+;baX^)@HQoZTytjbuO?rBPrW%NP zmydt_6JTUKc9g`G&qfm?Tc5MXeIza0fsMzgX}fLerCCoAu2;1I0)uQ`i<(w7-iUSQ zz63_bBS#rp5V$TQbBg-qCAwWi$ZRJz+wH!v?wIe%bDy1-wV2e0%X~RgqQp)~m~TqD zV_7E7S9`C|Qr(P40<-;Cw(+4VR+qg!8Z92%lO?i{y=DPMi% zeuw=ClIyi#;^NfV$+gjEa~+mkVLdZ(^${eacWL}b0B|s};cAsd2$Jif;AG_Cb2p4B z7BaoK7e`wjTd761uam&R$n;`yAu2UK#u*)< zXFAy;r+Z$!8{TB9nhZY)Iq^D(C;GSajGA5^5mXj`&X_zWw8p=8Ha|$S-en8uq%^@? z|1+fy?LJ2EXimbbjKTb7s-^x_u=T~Ew6Pb#<2o7OV)Lx}Y|a}8K>p_Ooor0fF24Cs zf1heycE;m72~_xq>6-K5FM#F&kMLxH3e~FNf6!ZLXpT~0&3J{V?ZU^mk-CJ>_1yTVwvkI*$W>w*0 z3LWDR9l>}W&r+)RmtdpYx^`*v~nMV69%yskQcuilOK{6;q-b(iJm~6YZ9jt+*QC zv%NoTkku_&%G>lLCwI0Pn)$9xxYUNV;|r2=$vV&mT0!d8U=Ofk1lhuY> zE*7->nzeje5u{pw=nfpjNwuhs*x={?&H)FD_P4H7ExqSCMeC_L( z&jS}zVTLp(Rxco!ktaIqN(NM;HKaI^Q1k@I(S$VIDY^WAi?_UpCaZN^@-2p5iO|6gT&&sw1ezFA$5rP!?P27DA`D>YCuABi zrY=jzV`c$VP-Zg^;U>m0?BK3VWl0sJWpN09y9KD=VA%dh7S6}Z!F+hzj7dnrrcO%} zSE)ZMx2?~K6l{8yRda(Kx0ik9o^FJrtp7Aqb6TfZ!u6RWuE1WBD1{n5=gHOQ*aTUb zuQaV*5+I-<b8(lJ-kNbY&2J`qdE#8 zp$uT<148Jxk5_>cs6po^d%K(qAn>tz_wODy0p4oHe=3g(PlKNeZsY1z@K%5KPt9Aw z`e)SK^bwe)8TX0Jl4(~u9dzrP>jRKjn9-h?L^)o66!yvrG()4p6UkG;-@fL@Zy|}= zbeK$uBr0nTkKO#QyEB4!>d8*FM5?@~WQzGUa;^s!Z$@^qimY^HqO5-S*B`7zVvW4h z7K>7qUUxI+1}JUDbF#(4ddibKQS?xFpQ8z%Aff)`k5pEV+8yo8 z-+l*G$LN!3ai&^7wIYAZ(B>(2ySFT#u75d1=2Ug>yYLE{v7yU`QEwu}2tvP`xk@#y zaD%>277j3>sEASU*E1#5LSDET2dcbP9aAm{c2_C$FPf>L&sx-E)wVugIN=78Y7|o0 zOsN-myD<3!?AgmRfsc^GL;aJ=fW{T@!|ukDf>x==>~J$4RQcf7`wnC&kR?5Yz5XNT z0h^{geOAqcC9*5Z&wos!cDsYFJ5uq%BI36@QmmZ1L z`mK#HET@14_+LX8bwkTH^jId`LRWsWSbJqiYk~lptEf-yq1DEhx*2AHJCkb7mfTXK zR=61his_UA0Yxn($X?HPs~u9Rp~I3~hFFT&VUIrFiNqRuEQv+mt462)c{$R8q02fi zoTvaZBwZFjT?`L1jIx1BS07G&^LsZK2ys?xur{^W-Y?nzn^%147|^T~yaS?EpfA`z z{(jvfmHizq;YvWUaxPrC?wIBPu?<>3SrNsD+kr zGhR~#R05mdD5RrWTnaZMHZh4Z0Iuuz`T;aUBX4E$nA1u@YR`hkA!vq1j>;s;U^+eH zjIYoP{r4q620`+asQ0LI&K{mb8?zvLzHx+^V=*dik(DrQU4ouqj$t9jX4glJW%4ADLhrUvUe_riw zmf)5CdzFe;DmDLx|0Y)ld4w5>$(^UX_zRJ}tp~8AjWQ!I`GhK#8q#LbYwDGKxEX)R z7R!P@pm5GD7djFt!O%&aH-sb$m^!!Hm%y&fC`^oVN4caLp}(Jy8QfBZn=zOisVW9^ zD4fs&r2KjolkEf6rw-EcYm8hOj&!PZR#zlSdv-P|u>c7*3ZS%lbdJb>Rh<8VuX}*ts9FfL52fs@M>XL&KdWt9Fi$;o$<-)2>)&qhX*RI)X3Qm8ym~J^ zyz$@Q3%zhXX~~`^RVP^jC8uSJmmF^8<|9H{X7EUz1=Fw{L*2J8{Q&}%Szo3KPQ{bO zKe^^PcWd*Xz$wD4F%$Yav;Y3lYd|zHBP&?~S*?$$SMt$EA8!5$q`GEQC0i_AsaV%F zmS`TU5B@u03y9UxT2HlOHPIqxsLfvPl+8H;>A}!dsW{1;RnfzS{Eb+uPwBq+ak_Lq zPbI1{iL$w-lw5WXn3fq=$yP1o>OA;%&n946W^^Sc*I7H?sJo?OE)c3nv0BemayBZ% zEFT||3yu3~Y8Vo#4X8e$^Y_-4i64(b4rK%Z)vOhhwRB#c;8Q*O@1(XQl{QPj6+KPK zo$Ac3J}x9b>a<{lgv#y!s_NK3!6!&M<6txIi~j z5BIepKvPftK8M}8~f#1P^Q(h zmTVQs>2Qxud*eaiHe)O?b|L#}PEFbN&6u_Y1a33B5(!nSw9_+RuZ%=$z1CSas3=B8 zyqJuZZg^Zxq?dG*b3mJx(|o*e!9vYCGttudeKq&kW?zph>&5_4s5WDB7f%-nlDqDh z@xLzsVi~+oXSq@$X7FeHwWI~Eq*rmK{`MZQ1i(n3zA(U-|J8>vJ3w49qbDH-?2}xL zH@f;15@7#Gotjgs32?!Sxs!k~nURyMInrH%l&Iw1bh8LZRP_8L8~=&$=}T02R2g)l zbvHsfDXQq3GWn!7OWCBp%C!FL5B~tWWY(IAX+X(*zHAs53J}?hsbmRciKTiq^ZxP; z!Dy%a>lA@al$pOvfZ{s6GWnNzBvi^&^bMIDoo1Yss3sMw_7z3vX)~S@Qvj}bpS}G; zcHsDCEG1higFQKXcHBQ9gX>a)6Q#JL?T_%~~ z5@C~wPZ4GuB{og;g3zDOH2I&JlthFYQIu?%Oras<0kT%7hQ-!U_bS4yKU0N3FaC`9 zaq&sDRuy5^psAAGmDVZ%%G3R$Ua{p!uu(*H1Y5N*S@6E@FN{WljeOQ8m_$&$F`PmZ{LtphFR}v;P=py*$(gKA2OPkE+qWy20wNg$ z$FB%IW61*WR;&p@v(Hcuje)l}?{M>fQLfRgO(j$izW>7Y66&o@gu#P#EOIf4^1af{ zOnq{p85%k*`2K#?foUz#3=O?ixmVhrKUYgMLqjJ8_e%MiR2}0QrnoCcXH~0C%W{B3 zDO;;PrJ8lE;-6PV=wGL^O^AIf-{Sbm^v)xiJp0}M;-DxJDU0>bRs-ZK&RkJ}E&r&< zD(;C&a87^23>;lSSGAdO4Gl~+)v_Fpr zSr|Y0a{7d{&MV3Xs?V;t29xzQ_8Vr zOr4wCfWPY7G1=zokcuP1<-+~@&wuirJ6XYB{R<$e`75}#iJtp+6`)or#SW-eXRh*0 z7ZqFty8cF(5tYyf8^30o_cTzc8Bxg+C|=rgtNLlkkQ}Z`1w%D^q|TP>h5;_LQ-Q}9 z0Irzvlx(30SJL(V7m76us&u`;tW~L3{g?HXCIAKW-Ir`@C9&2UpsKz8-9IPjCmvzO zRbqNj9INIJl@B5-F!WZMFl^;ecjWPTXu}KxEXhT;;rV9#_p@tUg1>6hDqr%;1k0KF zUrkPr15-6)DOoxt#-3vYJo#N*uI6c)Dv1{SKu=Y&GZ*$u`)6tc>`~1dUr<}nM3}ur zSIMtduPP!-<#acZBK*-XAaDh$)<0-?pubvNk1%_c&TTBtq2Rsr-B!6KAnMi7XBh_? zc9+WrhM+l;})=1ANPwJMf;@e*h*8lmSek@-7PRdlJdc}+E>07I9hivTsihR-Q9 z1PL|tS1PfyNlWGM=N~WZ=;kbfw`zCF=dH>`&AmQ%rvtb$V=s|Lt5J^SmKwQH#l;+t z0?RieFxhg|w&4;soxn9-Lkp{V`;!7NWeGwcYn_Df8v0#v{KKJ`z^gC(HS^OkI& zf^7Ax*Q<5{P-4bfvL*=)YIT<+&;>ohjJCwYIu^=7I#PkLx&G?0DP*SdR%yM|oi4w-=eA#K@{<;>?F(M2Ed+2c zbt~6guZ_O^IgF|c(nR&tC1;{z71rkEPurq&)r_}fZ9S0zR41+4y~ZSW^@0VMk(X?_ z>`N^P`1W5cb{vEgGwu=-$}Sne!D9a2qMeacZT91Y6Qb3tQUCbTADVz;uo-u$l6A?T z!1Uk090cDfMVQf-m`s~eFDGgZCpLc$t>3V~6oB_$YT)QUK_N^}Tq3PjLB+&%x7TL? zr8=|LN=%|$OpHnlJL!Un;Go)N+YZW367aK!YqMg5z`D%{OKg^IAmKnV;ojPKB+;m* zL=u$*Vq;1<@a%hpo~vZ<4a>+dsrEv#D|f&Rg;`%E>w$W@srNm1&T+5(yMt!ZUzDQ@ zXriYq5$;(pQ?*FRGOK0w#QXPUHq@E?8%KfEU(Z|Ox~R^QpUSp1NPu;2QLWm~u{qOE zoVPXzh{AjH@767u4S-%d?>T$nIRLXUS|jEIsKnDtJ+c;c9YdV8QIxf}v2TC&F}S3R zr!$W-bqyvZuS4pP6M&htP4{W-1#(n=dBGvR5K$t*)rKg=lt{I=4Ak=>q$>sF1t0BCVT&Q^?ks?%qUN`4%mC&)SHCCgSvCyq;K*T zurM|{AIO?V&8*f16c zs`I_Oxmzfx^OtnV8s7riXy3c7$U`xyAek+xF zK?F`Xwf{g!#isF_TLhg@UPZ`0a#0p_rjcg+C$@0PC6y#3)AJc-sOes$83BrfR=4vo z<^(L9NxFS9_=^Fm6GWO(pqOx_hBW%_^cYvK+*%{`>?b?#Wi_N`@tKq}|IO*?z*E1G zW(}IGX%drK@z}Va55dPZk!Bs5Y_Vv^&dq*YKt);h@O{PPA;~S8XA8yLWH6VCa zm=U9*id9NsFerzBy-z;fjiee~_1IFG8OT!aKiC1jCt&YH7_A?Esk{3|%}`+cW(}HH z!A~isy#7>|_uM-PQJ-dB$^^PMeKae(HOrE?QZ>*V%^Z}8lzl0xNV@OP9Q_Z9fslj* zDydrSpjEzvRa~~2ds?JH%32k0>T_qr8W;2g2i01qj=({mlQEH>zP#}vEraoF#?eQUl8a`u1g603EudG~kU}D?e2a%aLXbC}-l;tZxNP~S_3^nNsW+oXIbxN2kyo=% zoP_48)vMzY)`qo9l(}JbTaI~AExbpXv7^{r)sWVGX!TEk??#yVE|m-{_PS)XQ?gZD zgyfn=Uy^Hm%pl2)YWi8R!VJ~vCt!^kFUr<{a9}FN9HN*s!pPnQ`T&26;EsGJmF(Wq zu`q%h@snFVo%k%9JN?A@b8jZ;^cy%NM^L(qchdz0Wh8fX41@Gi-O9{y`ThF)34>hM z6T-AMG2>wxZ0VAeYY;P`t`l?z9-qmhV*nslseg?KU2vd! z)z#Q;->cWOkwPD+)aA-P99}!-Dc8pY9~L@5Y2-m>+S+Ni3%DUe@LaxY0g4Jm%g`+b z%b<#N>D<4Vty6BgV~bvFM%5(=Zv-AyfVn!RyT5r#tGW#imu=i4W%P0RrgFdA4HQPqdA)jqq31RSvsN~e0mb_jMB8ZU)oNL*M#(o$1OJQikI*z{97CzD#hxpc;(o$!8Jh$25gxk> zpas{Mt>B?%Sc@JNoeun(D_85+l%&Xh-E;B1_8=q)ysH4Sb@z;Yai<2*AJaEa1ez7N zR{^97I#6%#Lo45F2?B<|ywXdB1=HID`)2^DyTHEE2xhfN<$KPmhqJbH_e(%`p>>pA zC*etp~HzJLR!MHeE(4Fm>4gw63r>Mjt_9 zP5st+f=5mpdOXN|4;0Y^7FH@sVC5LlHZW;n?N;t)39*>3U+1$dhg7Cnwa`Nf81xhD zN}yqBrYQr~qo?-23f3(&jM4~Hv1)o^8{do9;v9LEPbX5jgL&!Nut{jy+T58Sg?1-V z!s&HI))hv}HcFcSRqD&8>Km__^1wRmvwbs2E`gt@PLBNnz>ZLCJvJH@L9%*uLA7~46D?o z(?_Fh2Q8`G$ht2&JDH>svI<5f5Uc`7b&V`z?xFMJi%scv#dQ?~DXp0~j(nvnv-D)mWQtt8cOxVK+{`yhXb)w;2x z3#XW;e&kpCQLTeWFpo2u`C1S2uyj_g6aLrX&UTP<3+$@Y1*?%^OUl7=z=s8Tl~yAB z9O=-gD~DV=5PXq#9+$ zEIg2xvCqjRwHCU%e-u)JsngnT-GDsq>(N!e1zD`nS4yJ<`*~^EXn)A_#z7Ez1X5M% zVnrU9T3UN2v|ku9UhZe9OSejEOwsbJSH^s8bweYCaQ79eOIr6O2$Q9@%$@0~TCj@} zcvh*;Hc_&L*dniuRJSZjpjc_-;g1Uzu7B+h)o`N(a+OXj@2|^o=9R3;i;+~*gqfby zQE34K%C7oaHLoavVWpcZkLPN17_c`n6PmNB3)4H(s??7f&AqH5W0b(N(#%=O7?Vm} z-H+yJ8gQ9jSq>&cP13^^V^rsg5@=T1dBQui_Geh*Wn!vZx zN`#+o_HFairvx@c6ycd|l+a-+fLtdZ-#<3KWUW<78TIW?X50W6CQz;dh;@?C0R0S4 zKK1x95^Ld3^l#tH?08X3a{b?5bJCi-RrQ^B=h3R!Rl#pcWl`@z>j&UM(4*2 zaBV;4iWn1A>fiiK2{da#5ds@4z>K*fnp!sjzRux1u5~O`8q`&z1Wr}}*^V{>RR5mt z`us2e3<4)B6|vP&@$b;G-a|q5A@rb1U7{QwX3zZQ7@DEcQJ2k74UGT((_$%-Xymjc zQ31obgLCCTYc}#%CQ;6~z8<}LE}Ef{qmn!&bl+S2N(JEh0>3KNU7^Yp`c5GGCtr=D z7)zo>i`T|j%i^tvjE}2C!5W)~`I=)3X)#aXw7%)4+T1r^`E~0E`irgsg_#PZssIY$ zGqqgPSM1@Ur)}wwT!M)$DT(HEX1(ZEWf~u?RR477sivW)nx{0|f9P=2lr3tX;}*4& zF1n~Cu7bl>fT0KlthdL&yCmgfUIDH1qJ&OVTA{;-yZ53Tu~v@T`8S%Yq2pS#MukV4 zFZ-riHW}naRZj|7|eDk$FOk_?uQ*JT%ihNb zX@g2gD}KJa2?^Euue*NKFzm_bUK3QZbCemGie_5fx(@L14Y*$&xl?N|$crL5JZfBk zA4LIc_@xo!9|BJhx=?APs~6Z?um3V09K_5RRn;uwDJUcrU0QLO`VmQ#8IQ`As#L(s zUK+I<$u#s?_?FV4v*+`n)f>8OfTDV*=oK%j7YtEmB&uruue>9c+DlP$R=7SPxGztU zwC>xtuk5@l_7><)W=uZ;WQB59s-~qTa$(Kum3J{l6lmzUOd!O=V;@Y2M)NcbvJ4d@ z)NUR2VRmpctzN>7@y<7A@b72ow4G1!F|!F$cvQmmJhz!~5Q9l3X2cd-3t zWGNB~FZM5=ed_^_6l$*!IrX&k-onPn@lxtCCn&HDWa* z7jOBD=WqHs3GJAnx2jak%bS;+aIIDFQ?3D>pArDrZpx!V_1XhVkWi@{r)NspQDHyp z)z>z7vK$clc8mJNovNT#GrAPBR{Y)a%!_SuA*qI;mZbU$l6;?bG;DJnNi}p=qV<7< zv-X{+Mo20@(xmDJBo)kcRm-^9Amub8PgTQ@!kjrVtq_{2p~F&{mqE4+{~wo~^ADOS zx7O6xPsL+d=7fV&*P@vkI;&NXcI&Ww|Le>O8Hl7B`e}d$c#k7)c5_cgg0u3e>YP`Y(_dS;X$d}0R078ch$Q4j9dPx~=#))FuQ0sY_o3|RT*36@YhEu7}mSb;)|@%9NowDbXyKtf{e-Jqy*t=>lkpX#An{bOsb`UfO`(c2j0t5SNCy&L2zMSh}F3;nVEe!;F~sQNY4x^og!LKi*h$D zL$iC?*?n#Hmch{lrTXThhTWF|=P)Bgk?}G`RJY%_WLu}2a^vfN0NofB~U6%w~&zwq-aBo76?ntg_ z1h(a>ImpPRhqkDhvrsnGIWW_$?Y~?HyOIik#{;AFbST$WnGO)KwQcx~cYuAFQK86Y zl?<%%!m*&;O0*#h%903S@krLgL&0tta-m$gE{tWc}c1^XXaAxWsjS`r)2h)+2;q(hRJu0!PWJenFn?vZ5ul?laBJ!L2tcwALM6-+^MS8(+_L`vU?Q1Ix!~_ zYwF4YNS3b)jPEfceWP=Gu3maoNWuhJ^b+90vHWF);PIt6lm}V?>dAlBrpPT`N3Nx0JPb^6P-`Lot4Vte}?aC3%j+OF!i(IJO z$whPlBg~jmOsw??v@G3AJv5WU-Y_-FbpkVC1=$Sc}&qi#^$U zUPmO>CRtnP)$iUtCMnms2lbX=#>?1Mw7Cq%i5`_YB(NwW-pz2=qGrs8CS}d zOSjnUVpL6b`~C3z2oQbE7*mdHHfNTVp(+% z(L_1YrW(BhQ1R+@e0Mk~C73mr>ZqsU{d?dFU>!u8ai-Au>EgMpoj_zTqexi-DKfY_ z#<8~W<9+K$y%ZfpJJ5QojkQ*dExmF((4u0CH_)aTMq8>05~oLUgkv{5`>2CL%;g1z zR9%+AtI#fvpLoBmn>`f7Mxm6Qs)5m5c@X1bXFc~X%4p4)Quc-+#Lm2A6nHH@S~&D; zXUn?WONyNv|MYTTTxLzB?76}t`aj={k3gz5^j%Ud0|X`Qn7w`gAYnzDai-XG6@j(h zYW*=|?r6jCO39b%1)+65nhvrJ;Y~m7WLY%C)Sl%>s%J)u zF!fveJAXC%ez0iM$F3m=p3C*1^<3T%j=R{Re{RIPQU&bNlcwyfHV_drQB30(Gm ze=8YHlxJERk+6yLhI69;-#a?S&}H2~$c<_2yhdp8yU1(?yL82DQuKt=4Y zKYs>%mJn@5nc^{p=RsdKS&*Ngn&v8CiCIgji3yB=37Rusd$Zd~fd6J4rL0*J30c~u zXI}mi9S4MW`cgMk7F5&>;MRZ^{{Y}OBTm^fC4*891aDoq2)e69oAr@ma#@&Sn_pH^ z!N>W}#)Gn+@K9f>D(KyLK(hTYf-Lyq`J6kDwQ?6oU2wM~>+W3^JLddUKo*HM>m=3D zszn3WDlo1202iwTcjXwMb62HYI(S&CIsjJ8Xj2{Sn^m<%*_hjpe*-AI3h1Rk7f^t5=r+YtYlD>}GAHN-;iqFnTMsN!c7l)DK^x_0%a_FmG;5v_k6I zq_{`;l9E|Kb;p23WvPab04p*1r)Ky8Fdc-~`vO_BB%LK+6`KwmB6;DQOGRp{4Vt5c zSNt^MNiFOi9tw}kvg9V3yFMH{bEnsUDHS98Q9DUQHH_SY6t8!5LA+&_OuRzl8hP=z zen>iZO^s&kuGLI4)hpKM++WiB?v_nkyCB8=UdVcNes49KkumD4=GnhccQeL-eC23_ zPHXmVs#ER|Hg{|h7Fp@Xqic)-2}>4Uy<$Rg|HPyoW#swy-~U&Fs`D6w&QyLwBnDTk z=!;`KJ!o@&YkD$A!ZC3H{Dv;TjyA9x$+xOYZ(uhIJs!~_WmBep+a!|azWs}=2XANy zQM~q`>@VJ`#<;B+_~hrWI(>sA`#*pkqo-*3q-XfHWp>uzB>Va7^Y_-ad%ke-bE+45 zfiy4cMw^QJiJ#xSRQ5qzv(J~MKVC4p5*>H_F9TxqbS#6l2iE%CQ-@eG{uuSmiazQ{TQ`t|MK{`(Mt-7%;aS`4)g#Up2AFXH~J4+C`CZ zKLGl)@QIHO4M145eu2%Keu6pbNnCE=bLLHuV1Moc(wCl3mjusx#~84=9OcmW zUNG*x(r-}-00jm-E?2SzWh~pUIAhYLuC845Mlq%s`iaWXLV>FsG8U&pEX%}``_@lr z(immAH^Q%+M9a{Eg8x8P6j7sh@rHT2BkB5MxuYav|5-a=y-O@9X;qUo?-1NbkYhmp z@|R8)1i$XQ`e0HnG=1azz?nW}A8NdM=Emg>McMS}C+@LvdcZF7EZr~*61r3>3HO)} z@Ag8gFisTgaRO}dhefLPc8{MzqQE&7I%r_pm&5FZE6q-*d0C7BKg`)!iwHzox8t~E zHy7$Q>JAXufF|aMx31Nh>YbE3QIg+l{f+%-`dlXg;<)Qmu6+DeK|Heo$;fA}gu>l3FT{3D<*!AfLf? z2uty0N7&eGSk_>sC;ABxVL&jmWw&E-w?jy9=cJ)-Uj*wySsrHR{F#-IMd=a38HUwl z*n7Tgq~dgC3yLYFrYF4yP=bduElQ{bnkCn^T?U5<1M-{8f;l=5vkg}z`M|c-8faC^;4wtQ0;bh&Aa`o4rY8qd^en_)s zDO<*cM#^7fZJV{I9$8Frf2+|G($EO|8->(6TDQXZzno!sG5eK$MM6unA?PO=q)VjrB;H<^{7l3(xHZ2-POo%GD^;%K+^km0u>#VLg@F7Ng?A;BvFVjHm6 zRN=t-mlitK5zXBcA{RR_~LjnKx6}go1~E{s-@&V*uNK&t-rTZWGjiDlvHSOvMq$w6htpt*bYeI{Np$7)%Zyo%=T+4FHqkQDMT z2~-&Qrs_N&wjw&8Z30RP49IcnZYqY@H}B$GKqEqrZ&M?;uCZjOO+0y~71&J!x|}q3 zmZ&NrZt$w)x=6TZ_h-TtQwbj1<8!1K&)#om@Umi-WsQ6fiRZRrsCN>t#-Neszb}VW zV|qgHg*YZ&v6;oi$2CTC_ly8cIQW#R*Nta#0o*lsvr)2{YO2W$od0QVB-=9pu(G1O zrDHR_vCzE*6v_r%Yprh#MS2qfC(G0>=b1v`?zmejT68~45)UpY~Y;dzPof3 z3D;K)RN;!MzaH~jIIuti;+-lSDM~(yHDCL9C*4O$hdn(xPZ58pQd1h@wlf4jhOJwg zWh+vU#~graS?Fl=_4D~r4b)~Ee;(kZK~FS4@VPY;Mhtia5KV%1GeFLVT-^__O!W09pbO+BpzY1JM8?Xlb2k70~=`O>nr}82e z?y1uPc&P!2&~FUppfKEx-&m~<2p=l#Q91 zDggXemV}~6Jsz_GQV%lzsKTY{A_MgZ1tcCE3jWDb&G(3fa46uywOF9W)6)a@tp*A) zpc^V1iXu|Nq+REbc#ri!y1hc#*QF9=%m+w3GRJ|fHV+5pXh1$x)C15sL*vDfX!0Ht0-8KC9pzm1?knRTqrLT5 z8DQ7kq#IBhXf=3yML>u%c>2;$J2wA_4FR5n9TK{`3_$!i?y^Qnjc*8asvlb=p|n~m z5Q4c56?h9N9>xDzGw>xfMTj+EBKqkjk*r?X*;Y$4A5;w|)_{qq3TM_MhroJypF|oaOu?D^2B-JpFBFAE&3GZ(UENKXC^kVgN zME^{R-4{SyPIxb4VYCGvp@GCB*u2-i^>HNLBQ%hB1e?E=e{c+m_n0I&;uZ5R`N|7l zs&s-_14g3%9$QI5arT0e5>^WD_;HDPYbd1PI!FL$`QU@96V+G}YrscDvzC1}U#IRT z)Vwm*fQSgBgE-#0;^CHHOAY9Vs(cW~e>l0h3=;1Z6Ks!F_Vb%VN6sPLdrT9E^axJJ z=RfZY-bIQvXglYx8%w%l?L4E;_11^|Nj3fzl~_Fs(LbZ#AIZ4e>C}qK!mt0Ei!|>Q z3TX0RV}pC72bX-YVP2ttiDyWoK*4}dUcQWG?=e3h1|mw2^K8r??6v{n2L|D|tiu79 zp2HJ^W}kFfs3uLZ2HZnGV{v8-?O;gW0bWL+i{G?j7Ce5y#onE6}P&xa2`XVK9Z*8ZP!$*8nn%`J=+}yGkw=3?7ym3m1B(=h=ihnxUBtG6kZ9yF2WQq9NDVo za~3O?ne3H*qUKF;!V!$Loj&oGsQ`iuTIt!^wnbaLcr3GFfkw$XhfPWR6%-b@-RJ-U zO}usP)BhuEknq8nd?-)cM~Y>2o?IV_ ztQS(QY_4M=2j0orvwu3NL2F{|9nXXFi!nFRSr#pVeQ>YtMXjY}tAqX4x8rjlLX=N1 zfyVfJ?WZMxj~TS)6Kx7Jh!b9axeI_egZ6xiY^EbQAQwFF{6Hk#wA^58$C^1f`L^%% zVLZ}{H+-FB z)@4Dxx&3z0AwczwHR$apx{-AS4~irk*4!zDRKpQJ^=h>}dHZuvb?&?8)ozKTb9*tC z4vaC!Ck=0bs;oh?KYz_sK{vzqdNm#o0=YrsKUug^0SIawH87ZkDEbLGf-ynS)_G@k zCG5~F?bC$pRc(L2e3ed%(upz38xjb^Sg~Cm<@>WWzXcfshhZHe&}w9%8~!|1931D2 zS&O!Y*mXQ*uIK`#{@xE}0-rUeF4_aoovmOzJPElrZg~w7FBQP_-2(lRkbpPZC6{Ea z4)D^LzQ||K)Wa%-vieIN{(TK_TZ7kDMcXIspi91Lk5=?Xv-buH&J`knv~iu^jz`AB zP0|E(ET1CtQFHvD*QULQ)Z;BVV6hvPGA=D%0KQF*HRvPd{s#ECQ7 zPx*B3mn`qM2gMg-5~J-?_N^_;LVV$huVCBCoM&hSG>W(a?H#4x3ij7MTrVMhbEa<< zp3CgFx84V4spm2JofoX@Ti{g(lRoMQGGc=cg`!zn(v=Kq^~C`t(agOeLZHjrLG_ET zM$*0EfhC<4EM%;_xA)EWk#uhICTL?zSCM#jqxEHxbZ=(`>)sj6{c7nh>yUIU82DQZ z!+B=$N}6-1-o{4m_rd}e@Tr?%0lAf|@(c45OM(C*&>xIcZcp3isQkX8-{hEOAUP23 zQcdMEzMH$J90%%8?e-~14umV30OI{|ATj{mE!To`Uw};&io5~DE1OEmfvo#|;q&q$ z-FQ1M(5)mq>_qjP@-f<4Z%DxQG{8wPZ}{yI0OgIjj5f+U@`YkJH=g#DO1=)V4?UaF zPyNmasG2t7gR|q%{&K%E*7HNh{_xZ) z1Mx}w*0>v@cEyS{W;BWeQL(iwYAaIu`}B2!Sz<;%AvrT>s;I1{I2*vKD}pTQuhta+ z!7(<@G+PkXLc^$Mlm5A$eFKomj0ujy0Brj9exPyY6e@5Ojl-Qebrhm;Y}0i&-%e6w zD{J}JkwlfwAb7V1Gl1a^S(x>1MYhfK<69kP%ySf`?wAw5Q*o~*lyle7563)B918#2 z#5g_w(GB{ILXJCE6K67Z$yBRd@EG|@F>3MHJ1SDe8FXUgCTwpBHmy!SEN`OLlj02C z$d%=XG1H~$0K;@80QI;v?gN!<5@*bYDRk=@XKhwoM7YWNZ;XMj+Q7$oi zVA%B%Y|H2;O4e2wER%3%Y=hZ=^^e zV-_LV9-UqI`j7A6o#gq~0g&i?fhVKn-w8}=Exmf@w_Xx<)u z9epeF%aN*e0F0QlPn6~j?BvSu_h+DaYeT!DZ>2WWboHLnNVG>sM`ekeea^nDmJWo& zY-)ba2%WHW@Lkfs3xS^XyhVRiu=#?MUX$ZJVu3PDx+RL6$b>5}^45{L@1l8obaf^g z*vG?HzS)L^d-Qb@?v_5ev)B1#e_Ny!gX*EA6vg;HYP&BRnzzTm&gKnb@7^~C4n@K} zIy(~%&Z9|fW()@L#)OL~Dg}J4x$;o)`2e>gJo-BPa(+nDMcL7;Jvw_ewZt6XXV-rq zljk;~@pU!hZZn`sEYO1q0nuN>zG^-<=_jX~E(a#9=NtNi2r7JCUUA!ZnJVPiCImyj zX#)uP{bKtIXx1LRoXuKs#Cjd-P5{1QLMfDH4IFV#)VU36@jK3hQ^zzC>Ym)(k`4+R&*b~*E)wo3e<$G#MU+&h?k}s`BMbNB=_DMWNXwa-UPZD!dAcoI z31w@3di5iazjM&m_&UnpSJcRI64WG?#!~NdbVV+hbBZqNi@@ke5Bs6=53d^=)?jk|1ow+RF8_Ym!B+YS)pIii(W$@mx;QR~= z;a9$2?z=Y(*Pq!5vJ`!bLsd426Vs~1Oh;<*mGI*M4D+zc#^*vfp>>yQ$oZIFr7H zg66G&M|R0fNBZzGF1XyEAmI{P1RCgvaWU0{#EFl-X$~@g7*GChu{@PCN|jcF{{rWF z4qF=USI_myL+7DP$b<;U^=wfumC3dlaBVKoun7lH6b*vI`5aF@3pA{!|A~lYktLK# zFRMMKDgZ+h>Yv}FnaQbXXQS^vpM`{ba(QOT5NQ*Zy)Xp{_vG-7a3$>YYxmxH0E8x_ zKS3>&N2vaib?==JG;to&Ogu3_jxxVryYm1BW4X(i3uiG|K5#z!DC_S?yftLZ?r=h9R2_s&UO0lVqr{A+#%+7{?Qh6+J7lucc-|BHls%J#_ynQ+AhCp=nF z66jjEsWhKC&~@&tO_l)@7cNK)#RI?^x3K1mNH5+TKR}9Asnf2%(ZszuJ`)an^Wy?L zbAvE!!s+9F&k`#_ESse!h2b(+Q_djGcyfMc00qqVmskl}49A%;`TS?kZJlR8HNq!7 zOH?%J=&5f~C}u$W4;^m0-)X}BuKIoa#O5TNF7?|qr_BhrW`=VxMr%h6?{aB zSc)aQ9Hm2&^w%H!t=`cyjd*f>lHL)d_b0w>vq||%feH5%_kI16c%hH`f9V|YS%R7W z`!U7X2s}6kP>$&TWy+Robh`QRR&|?H7?rKtg83>06fPL?nUeBH3GS2{1Xxd6%1OoP zcAM3^Zzj=`|6ATkgookPuM(u0a8K@U3rE{}Ez583k<#fWc#%m%LWbzh_aP1+ zikVIzzI?9Vei*M1^VurQpum3^YcUR;U5QXtd+pkW)MbVWlqtE-h{7A@Q5F8_tQ^7E zI?T|4xvV3esY=@CjAKf+Q@Z~!$!5@CbEJzRi0@c!eF8O~@q1>H2{uCofe+8#aYg(~ z?!X7XYHdATNBNCtOInDq9N2Ag!#?9}mNM$NQrT@^E$TABPD9F`vkoH1!=^J`Q)XrZ zi2;v;si6YghYW*V~g#3?&pAuHy-{e_4Qz#a|Rd-e#J@!IA>>9R;N*GK>~ zwn_r7WS-~oO4PjCZw*q?>!?tZzJv^N1j)YoA~(TxUsaeuRW!*2^~^od1Y5cZWIv@L z;i2O#RH`nUyP5ynbEj)(_<+ZE@1AN0EZn3ip-(ZEa9ArTIALTZQWX6J?=)oa@u{;A zC1Y2_`PW7x(OSnBY=vEJ^Rg&6mfd-?yoHQKn-utq7D}#McI;nIp8=Twk4YMzS3!L4 z)rwyO5I1D+**dmvSZxh+yY4%yO<&4N$vlM3(=+!3yRO@?UQ?k#0vBHL+>ACzxYpH0 z;q0Xg)&W3$>7wegzT-hYZPHZGXVi3eBX|s-`Hzn(?L;%zMtf=I@QsdKZ;Y%0+|i_y zp#RLRYPr0luRI#pA5C2w@8zkZuUUdKomHC`M1>mC_iQ_)s|r?R05!UID|Z`!6ywF+ zNjl>hgPQK@Qm?*)q5PJJC|_?_)1rn*xmBdr?FGaNnvs3-*6dbiT_wRE zba3Z6w5whmKTzQ^=d`))fZOv;)w@05;$$wi_+^D`5*2F5>a!iwnKA4@e*b!6J#d&c zr1tsAM-9iGTlM^05SmSz1p55bnZB9|&B^-F$6z;2S_JwDN5HbE!{Q7`FJAngCeCCd zy}bJVw9nDDa%<5aeH`(y9mkVFU4B=Zs4}zh0s1T2Y~Tik}eUNOD4Q|HPyolJNii^4n%`)HLMx`P5t;%)4etU8{UW5mekkFK*A~ zT^&z6<*NpL0H_#p`|OFQmV!Q&{q5gDecq7YC&`Bv{=tKsy8)t`Gy(M4qE(;-)_CV~ z=gvsBm)LL1R_$>_@0x$R-^>dh&yi5?@hD16yu4@v2ttM|KU?AUl%b(FZa+r7YK;mt zOIycjS$Zzs`vHw;gKT0V0@D#9gLyn){%%Nr~t=)SVSh`8qKY8-D{4(;{ zeB-b4KBN)+xOhzWS|qSDUDg)GAu7jHUzB#BFUq<+UDhDu;bADX6hml;gWIA^J6!!4 zB%a&6q4-4D(5L(0Z%->E2BshFNx(vQVfL2&gT@*AF62UBX2|&C?N;nI5vWs1_LMn6 z;6T7vpa%t(9?6DNXVKCzq!=hO>kwZMmx8R>^v_gzjdZp{tqCi$@|7^98I^Lwe`C0EXTA@KXC`l(1BFLmSG(W z*fOk}sSsL?^;tmmiiEIIR+aZsFSUOk)0z=p)Jy8xZAh7R78{9m!BLag8Hq{XD9zHC zbna}apph$`Ztj?Ldl{f?m@)GmM8Yv?5}4Fg8pK@!_lZSI`}HEYpp%1;L-6z@09+)T zD%1FArTQ)6H@66iQ2P7M9G2q=Fd{SRpfl$%YCOb>WXjcG_4!{W0Z$OR59zhe>SH0n zRx-#&p^FJnFdKQ}QCYMIEnHAAa28?NC@n;Gvodjq)`DZK8Hdmo?vN9TmT~Sm*#{Gb5nQM8PG;$uby zE*)OZ{h8H$oGgp4B+QI<=(p>b0g$dy@oQ?H9VRfPv;g90Dp2FAk8d=5fJX2D9pVU} z-d>^0iwDpM{EpYt8UXwaA6jGx8o@h!SXu(9#(#I4G(aP0Pa}%O+9Rm<2G7*nkQI&K z9Y3rQe2FplfQz4Inyu!oVP@1s$yUpiqo%BCtY}suc83a7VP*_PX$%lg8zwAJpQ?@u z)6)~dHh?>=#E-_j2{3}w{PY+BZYW-B-}+beq!uPXkGcH|H}HI8YlcMa1xh!gCn`!; zm?gRDv}=jxpB99Gt-hum%Bp@A7ZqkkOjPHu`c|f(Thr9oA7<7$P#yq$99wvB{0t;N zE$Dz6f91{k1mrGZX1qjo{>l!I@33Miz#cPtB9N~h)s}s`p%&7RhvSDY%Anh*ohzSe zi{$gefw_-a>7#TwJ6E>LT=m96VCd?R0oHTt)y{DRXx@ySC~2O}8^p#!9kM2%5jd!M z(hP`=;e-EGKUaDoGp^GUy)GH1li0L5$U2!~fX5IxbZ8JKftbFhRV!0#V zy$0|>&uT>05BWBQ*2e5aD@aTJz!a}UuZL|XTtq8K%lU%jyU~lEk3UISS&>Gd>{&SF zMQG0#>iM`Oy)w1Q;WYCRKHU=b4)su{Vv#t479`LJ&Zl>`73TDr7k6C;K4$WAvV_!B z0tET_v;RB!7TO9AHB2YWTLS=d{q>z?o53N*taYKEJ2)eN1M7;sA)laCct;8v1EniT z?~g7I4jSB^^jHB7cn#tP6j7^aVP*_SMK=&cpX$7=EKrRZ4N@Hf&{U8rvxweEPxmFtowm@qx3BcLF&xc)OgfKX}HBT-oc8v%rzYDpEhfQ-V7MyZSeoT17~{~knY@{Sdx zCSDM(~an?DP${`dYa>70^a_#|vi!fT^w5KXb#SKJv>^p+cku4Y0dyGrj*M zP>mU%(tmfEYLJa~YVpDnU_WNuN@WCKKX(QP)kaJ3o=%YNk^Ni?TG0lL;QjdFjG%mK zG2^+iuLd*Fqn~g%FymYLDTyGJKA(ZLsBXu8odg1eSzATFVG?N!C9Yk2aP~d4*WU9A z`XGg6ck&f)@DHCvqXl@!3f!pd=E2GZ&`x_t3QNB4pvl9|xSY39jE?q>6u5g?!4dby zDQ%UbggUPlCDgm=S(zTc1GH|&!IaE~L4uh+dgOwX}|_+2*rv%`|71Zz<14BFRDrc@b+S!9$%ml(tr+Z2`E@zKRtFm$Ro@c znaUd22)>Zd6YM$(hqF>1LDdN%kKl_4fDnvi#k#&&9IF$`S7kSs&wT^zuAY(!4G1`K z%%XQ|0o|KXGW|8fqC9f4?>a6GLnEXCCIX~F8yBp81u4mU9zhj$proN8IsS*1;Qhp5 z4FFtV!R3)t&$&mI=3E?3|0U& z`K5`A*VhFR*$X4nRSx{JZRM5Bm(}lF!n}|&9r+%R^U$N! zD)TnXtjD9@M)>G|@X+*j&&l7@xr~0o*(?prOv@)&Z!=iDD_f;@CAD`~n4Y1@Bd8^p zanh-=e&t~M6Cb8NNpH6f2A2idwijxqExIUN$5$I)E~_3u1iFJ3GSn%*bfr{t^^5y( zFC0u~%7`0Vr_{RZ1l9f<9Ij_z@`|I|Rg0*xDX1@a_l9U9vtE$4Pl&_3-Zv?^b7Il}JlNvGUmh&U2BRN$jBugLhc*`w2Xi0L zh70>8wCx|N(T1Bm-0a?K+GAPNNu_X6yYsbo)XXeA)I-uChzFrM{h|NOMFV&!TnGcO za4mavrdy4dA_eiZ-f%OD!-Glpn;(3R=Fc+$FXDak=ckg}d51SrPbET!wE(c;o=OrD zg4|OH7n*DB$wxG6igkj8>Uo)pXIq#0Vaj#;_+_VJ)I=uS3op~&R_m%-&A*nX+xVXv zM#BYGnxWb)`BoH_4d=}{m)}N1csP^@OJF&qdi0Oqo2ieQZiIUwXYwH+f2sZCeN)jQ zJRD1e5tyD_h6pd*ZQA+oQs4nX{oQaYtQ$w*0h1$2{Y=LaB8iB`s)Y#ISgo&Oo71;Y zYG=LoRxi7Nw!$+^SeIU?&NHG)!mns6JR=3w%5i(2@ZlXAsizWwjTitcoKp!Mrug+K zM~g=(L8nMJG<#tKgw!R#4l5fF5z!R(I_tQw@HwCx0p$XWz;is?Oi4Fv8NiBqW_;=g z0C|FP0t^8ckzs~X>FL=v{u-I6WTsxon$8+%52&Rz&&jyABIF8EY2F`ucDr`pdnk7 zb#KH>3VZ=oc;0~5kg7am2Gxey5K5JyQ;mIR0VsLlZQ7en1HkxDWn#uX>fNbevs%Oe zuD0stLyIXT;f0>JDZASK$mnJ%n?P5`bw^v>2a55++;kK}Sc)#xHvDy`5gNhsxx}tW zg1Z02*SqHh)??P0Qgk%71F&GYI%iBW098G8Q+5Go0I-J8`AK8dieb1}k4mrxA^dPx z?zy~w52Ps1fI;hEZl)Y^Zf1UQI8u~ntZ)VZ_p^DLuSc1l7w)EQu+9)}DS!v**<(s% zphZZ47oklr6sMynEErR_pYpx<$L~%o2`U&o^k~7toi^Xxd0%y32K>wmann&upa(1} zeBN*-H~@O#ZSoP+1zf#9wH>fdvksP`3$W%7ES9MQyw&7?8_@us&mnlN*0e2<`u>MR=rV zSg`ImQzpc>>{NeNj-dDk88Y%gid~7V0csR{mjeKUQ=>@P(!y7x;KxZ3Q^C@gzoQ_(bih*q3&&j`2pHiSvrGwa`yoj|V6bMhde=Vu0>s8(eR1KL5E@ ziY_gUqs0`cH`Z1C#HptHBiX?kCCWAXHSdPh=i!JVEQ-GHCIzA-s{02yrv$Sl(N9#L z7HHr`*@+_-U3<`~U7O1~x z+L{ZRv7mDH`{$f85g#P~tsb`tV(3a!@DqI_PBaMXadxU{d`q@F8@EZoIic}q%fQjh ztRbhpIeu-zV3VgG%I-)2H(h2uIqg9x&In!4*zOR*_^5bXar3vGYDP*U+ZGk41sJY4 zJBMi%Z*}TPX%^IPV7^=K2Z`L~-XFGPJgA9qeAYvZYRIi(&MpGJVn!8h*m*#5nRYC> zU_Gj+p1{HiIAdPza%>mKh0WNa)({T21K(fw8&c|1aMx_sw9`+#m0C#IM8R(hJtF-` ziLjn4YVB^lkcubVo|pFKj&Wab;s*4|#WkY|OUn2gke)264ndDZm8n=Sq@2^|Nqy$+ z?|EBBpv^GKTSRT)d)e0}uUZBUCi>^PDcUOHeOSnypv&@nozVc?3sT9ulmS@PLcU%b zaA^5OWKKqziT?mTu;A0b^rZ0+aQ|q=7nP;^e2v>u#$1`l6HkzYJ-|=x8I$S8DB>Cq3E?9M-IJrzG8%^>c%qG^%u0;7?`^I~DOhi{t}*^!T-l zX#PgW7i9p&cuE$ln~dh420Xxbm#a1uu7d{PE@ccjG=OS8D@Of=!lPM-PDMeE{cuE> z)vl=Z6`DVLT)3)99TE0dY6fZ`$#D(#0Hv7mLDe~{O3B@Jc{X4*W`t1x0nnka;Har< z(EQT?2~0e&`j<9rd>0Ln222po1l+Bz#a+&Z2H-_+W3yxf01imrd7W1SR5K%l`tJZB zz8|=8;wHdkGcKqs9q2#P^xo&u?9%`Xtf(bNl+EXFj6kzb114A{Gg*FQ%P$%u`Pw6e znnf}Bs&}mo`748ZVItgv2EYWTSi#=)R1Xrn%0#`VdTfLlG5U1{pPhU#4_Xs`b z6Q~4w?Af)|GNA#|00}nxS>DvO!LhfHg3_T%T=2tA`yIi~m?5>?ybgvO2j6s^K@w!kn!xP0cThAfKp-a9Yag-3=Yl`l%1|MYj(Vf4iRP@H$_jQ0eoi^uA=-gSCiCR6M@4J z03Dn&#G18DLB_CP^t34T)+9pD?3Df2o-_cpfn^Tn1bR24b}DKC5On+F z;8_V*eB<&XGSC2|C&4y_eq{k-I-eCf|{8`gn5Ps>g1zP zMy~97{Xe7~&zS>m2EgpoLHxK^%$UeJ&#je0mlZO?|*x$T_T#l=j_3s&CCb5 zlRvl>uuHR+oBj#{`Tp-OtlNmRE+Tmb-^cQM(hUg!ZkbUdcXU3N*DBZjitb1l2T7_q9pwHD< zsUJS#c%%Q6o@yICfjnq{5bEJ##GnhcL0l0|ECF;QI~OYt($qoS_sGU?27s(eNP9dC z0g$=zw>3Th4lH1&2l>bc;#Xb*U;IP}s`oa4;srmHjsdm(2s7TM=mjjQ(0Jgaszx1<8XcIi+1T6t=Lifm-Ly)0*P9KP+jtzB3)&p17yZQ(-%BH9# zmq8Akp-1Lw^N^lALxt6L$ak3J(WdqNoE=oUgkVYrFu||uxZIkT&sPOe%#5}vDu?tynm}Z?e`Hco8b9;;S2zB=~~HQA!rTW(ZLP`iXkodd((J;4m?>*4IOL}59@J|#1-qQQLE7eU_EBcO?dzSKtbJx&O!^|2Qb4J&km-rFXEN_;f;Xxm^Il{764CT ztG1SGjn?3~P)Tb*N2NZw^S_SPz|F^llGp$sKIZslqxI1qtwX5PnDy9{)r7qGN~to7 z(HgwN1XB_l0EFP*vhDc=?Sp5aVEUm{#qnZ(pg9{+WCSR+>Ypo@%US!`mmjdynx}r^ zD=H&O=$)>|3H7Xz_0WkKKrd#DOL1>WFWf%4UOq3FwI$Gto@|Nq0tt{GWhnM1NTl^t zOZm7&G;4^YyVI|-z7LQbz>H$)rzAE4O62auml;PYqo3emW&}%d0Cj^89IYRRHrO*h zFwrbaWJdvsaI!6L<{!}jo=+K;V%Ya3iP8YS9_o4wpo1BQQdEv_0ObRg_m1y)3{Dwl z3`%tf%H|Y3<=_0(Hl!!dd4#$52r1&V`{P^`$P|-1a8C@`3%vUb){CD?}bo0ZA zy$1a4(Z&O(3Ide%K&}*|gCAwu1+7?d9p$PX2$r^%XaxA$+vE=p27@~fp2irU zgqo(d$kX5&*jx`BOMBYZMKq}5Oj+_|JurO_6iY$AQVIF$uR{Hhbg$rG-9sxk1;g^T z3FYCcDxDNRj+x4bx{d+b$7*)9g*I>LIS=B z9b38dWZce=c*@Q?1Ud96nh+TET{R`hseAaqs83Jk88A7){q~## z!lNe7ffrID%o=J6tFRJNMCpF=sP4yV{ZhDuFaQLUls4bft+A^9NDmxK+hy$|ef5ep zI`@}OOcfrcFQ?uSM|z-HIwQDUoX{Ywzf6?s1CgO#u^~_=r&7m~N1#QRb0zFW*o~Z+ zouWogPX<*fr#f1sSu;(+h^!kj1%vYS{`oRekyn_o@847g@b2cr?;`nLVZwS~0eo}w zPOp2TkbG_CAVqaLWwH%W^wavIgD)XZ@R~I^b#MTrzr6csC0YTG>SlR~GlCKba<7Y9 zp&l)StHjhW!nRMG((YLDS~s8?4@^s2x>H_fJD_l>V)|!M>o$=dn3jA5`227D`mfKZ z_pFg-T{K1CqT;t2gImu({s+>KS9~B1;o5r5=Zp4H%O8;*h?cg7oYFe%uv_?M!%u*L zdf;06jiHoR&dfYA5NXLPL^x{zed=;&&YFa@wFg*%4Z)SqW8 zU8ek;gS>%8;TcP0m=-9cj3wYL$Chr>wy3up0xLj|6zb{XeEps)fe(8iT>4p$I>5sU zt-lB6>49*`2jI6TJc)Z_UX6ILu^#xAe)0j#UCWpIbu@xkm>|<(D`04011UG1#v}iz zNh44dOE4Wh=MtC>H7jykqwx_kulXw&7^l8#CL95L?eJ8>={q0|5*nYFg-I&^xJJaM z-??C~(`o@CQct{;r+=(vN|xL$vk#pgr}Rgi`R4u(ZXgyn!7DRCiT7H1U>i^!>_Fj#FD?Oy=7C@-%wE_6?y%RVZO=qo5bTd=!j*ggI8Yq6!MIQB zPp%J6?=x?%0j11bWC9d zY$rflzD{iiH6sPlPe|@O5HjT=vR}Z%KhDCVxEtf?@0{ogrtuj9ZNT%m+`bOv6l^^8teQ}!sSwz>Q3yBh;R+G5V>^dCbFT%)J_RSBT6Ii=Ho0DgbPoiT6S#5QD6 z{tu8v>PelhGumxH{W|K!Zypz_G%Wkz&qZy}hVZDRNss*2g6r(nUwW%NGA(Ylp2q;D zwR=p#$!HW~Y*AO@D@1Vwt62Ts0W^v+sHmf`s+W9t9`I|?h5)+Eo>C{omqualSlZV^ zN<2Qb?$-e-@iUSu%?we(Bs7`O@|*v_0?dh@(gN5Q9@H%x)E?idKKNzejOGkbbtHK= z8eM(*5y)B0DWJ*_zXen(l(+WY3Fx z4ga)lwp~(K-Ezc-`H0EK}WQbGy@6z>?(Hk+CFHM zG$V;{v&8lFYNd%4kbR{UO3(qW-HUy#vnZ`bI9r=N%MQXh8w0ptht}o7(Mq@vdP6KW zisC7y%E!+{dtzKlk*tf20b+VY<(-QGnD9Z&z=Wl55}4F4eB}z5zByA=oj%CkF7^Ij zWe}ar`J&P&;N$47|4e@aL?^SS+JQwua>?Vu`Aed8q%|c04AOgDKdXa=NGp;64$J%| z{~bcAN-K=8Aym};vqO<}!1v6%bjn)}0{QK7J2#^-(wdR5B9P+W@5fyD7&%BSjclQ%wDgibV|g@$uqpCwBxZn-Qhwn8Ni0 zZ1(uuKDkt`gRTTM`pcp^BfBnS>X-^c&a*b1tgl>%7L#lijV8O64NZ^#|T4b3Q5> z1r!19exJUF8mgkqX{mnW;Qo_6K8;RMQ->&h4^Vh8ggqit4%R=5mXS6%!Hpt6++AlC z8Y69JfB$fZ!0(sF&(gr0~_eG^#ndS1mgJ{#!1|;;|kut=y zbDEzEm+$$NZv% z2eiFJjn3?AX8U^5=2**B#fFc9?*mWN^H`xLQc<7xli@JmY0bEMAQI}itN}*>xmKRO zYs!OIV$Nsvvou-?t6usJ3w$wC`lkOCjgvN5p>bG-0>%k?SZfMWTH2t6#sT2cx98ME zw3xJki!}&b%=Pj)XQ&kvfdFBKFs!&C;mg>KX9ofUHYdLN?>hS~1Q~F(Sz9iGy)Y-h zDx&}c?mFObI<%Cu)nl1O!PK|z{vqelQqopLp;17M<6yeh6VOu9mZ(^R_>Lsp6TAO? z8pRfKQmo&uBtmt4SNrgJ5PkKuSO{J0qdPUg9|%j@gN8^OpwJLXfZspn6_g5@(_$q} z@hHr9B|HteSASKfC zWnoIRKQfy2asgkeoQV7{0qsoM(1a`tcwx3{-;PBZOWV1Jm1G6;uAJA^X`3(zttO3_LMRUa_=9wB9Z`8^QTn&$AvjW=N=gGa7=2=Mf;Y&c^l#3? zf!F{vPBH3_BP*^`pO)BdaO$y~;(=IBCmOoYnaHgjCpXu_!{{`GAJ%KjB{v2yCZes)Z@zBvf-tMR}xT2!cb{wK5m2udCvTeV2{nAXb zIr{P2@hEfltY7S;k>K~uG0~Ts0i@xPzzk`a(@02jVBej&>NikPUYWBFr&Xn!X4qI7 znQstQRq^DF|--yys~29R>j3=Mzd0Xp zDB2%&N%^NQc^hOH=KWIre9>Yy;~i@M(!C$ig3<;r_CV|_0L9?ul>BFj`o4XXS0=6f zC2;lNM7B9rj|tSu^R0b-`?&{8&dwLG*$iR$#~Mny(Rbq8!$GX^N~`Uj*gLsff2UAs z=?*PtRo3V30$=sYthGA0vO@rU6u{!Aa#jvmd;h4bHNlI#vTNy>!MdO(qLoBMh2BJJ z^H_s%hlq|0Axopxu+&2iXScd$Y6o1%yxFSlLUh(}`_kehJ$r`f-2wc>cua5jKyt4! zo=IiC^U6XH;`AL@{o%*1j2C5iDj{jt7X6N?pIb+n_guAg=E%1!S{fnjo$B|HF?+-t zdjz>vEmu^gzSq8`Hnsk(YNNc8ZJlB0z!co4bMoswyA7~mM^@b0u)EtpQo~ne206@( zC4I$|&;JbYO0TqAdm;FqOHfEl@O;1l4t(gUn3Wd zAdkY`&*M_)223q3{hK3uU$plgE4{YH0yQ~Z@zd$A0g~`BbV$M`4hu1-N<=pVv-irm z6=u(3uZ)A4Hg!LW1_`T}JS4eA^K3yGJnTfE2T9v^ukakWTlY%3byvc^2vPTX!<6sA z(}Pjw{aVFHXt6l_?9N5`y66aoXerIiP)q5WkuA zZBpPQ$MRc_P4%by2V%YOOe7TN zR32sV1oV`9nH49elVRjgqER#U2F!%$=Rv|3E5BQ?6o- z0?A<4!e7pZhDj5|&@jx1eXHS4S*T&8l|%YxEYYE9gP90+AqE};KeDyZr)qGC4oy?W zLI+0{=AC0OU&+q9+0UsNOLS=3;3XoWsc^N&M=3Zg=uj=V1RkgE;Rd5pl<(K)$A3LiCHV`rQ7yQz{a^(*30M|4Iq^gV z$7ru~T*u=(_a4wKxN}lhU*A4{KB+gO) z@4m9yk(`OYay{o8YHk@FrbUOO0_peGeMn6$qT5y3w*ij$s%6lD;J|^R) zA1~($7b0fRLi-_kj+}A{0GL;rE>{^FM!Cw}J~yH;+LtsXEmT((_Jx~o zldDJOA&sR8R%jHK8nFyXcEndBl6xbKr3qAM7^JavrK@aLE9=qvwzF{e*&xo{w{;Mc zSG4tBPVnSHba4juqn ze5|^6jyE{n z8goxs^r+9jU@y$u)QX{=EDPNX^n5+!7vS{fjcUa~*zGM2y@#IP8m;!LjTYW<_i)-) zFHo)oZTtrcxaEqvTVr>GZ!j#1SAmVEp27HV)hHXz40?owLv;d6QU_j~Wou!AlwHy#x!=K}zTe zguqQtlqR4wmCywNLkWbEKoX=^1r!hv1VoyMz>9*?K?OvSj?x80EFc|}A}HA2-F@zJ zce8tPckYk8--kcWoo9B=%a{vC){P5wP4}pNQL&LK+pv$ z+tt2BIa4pm_Vhx{EOu8@GWXK4>TueFRgn1Z!mXK^kM;i zl@o#4+yZwvB@O*pfO9ALY5aq-%X|Ia`{xS!u>j{#=8v)ZVT9q!QJ+;YH?9?BBrOq{ zwR~{y$5X)apR#ck;P^N$Gjq|w6YuQ-L{b*91N|Ys;LJxyr)+4|OdAg$e?yd?-m{LhlGlTVO)b&I6 zVI38gkW@HqXGVxFx~Y3+op>5y5^{%w853n-PNuzr=PM~OV9fLVp!-9FiFbvO?^1>nawiy+hAZroWEUAU@8KVK*Y3i{7ZqihN35h@e zJLQcnJsZeV-+1sYLY8Y=e&e^Z@BD^=oUyytRuCB!VJ){AE-A)zxm@4vVpTs7Itz)( z&Qqjl?Par%a=gY{K>nxV5>`r7Tyf*E23_UAo2L-8jAp+McHDrc;{R5Bu?`wLBA>m` zZ1!!e95o!&Cc|Z*>JK8Ty~wqLJl1kX<(bY;^hD4^dV8VSYLnR&eY@_N9w0_2_sc2{VRsl9 z{`l|K@N4k(bL%EX}^8f^Zw4gVK^t6Ygbimo-RM)(ou7JcWMnl0KX z_Wn0B=9rHS#KaMa?w%{*s*nV@JUw~H*{-JaK8A94Ecc5018xN~_PmZYseK5nw#G^F z_)RC?qa-3?*r^E7cpyK_raYbWu|}zk0MR=S;`ox!;We5 z{9Ob~EanVRoMF*nhlKq!7r_#l?u9i%x!-?1-UQu}U2~e8BAnn@%Tk_h@2?*Z`vCzH zNzM>OS8n>Zz{H2jJ;ag{|5FlEJh7JZF3ho2=DH<=yRG1rmJ?2ewDP&d0iNr`Zhzao z-aAPL>FMtA`>A8l$VsyK%@)F7@XTMr;1Bz`sb5l9X`zV}Hs0xMc`n!YroFKgfhZ3N z$6oW{x~;XIS?}5_og7OMgi2WWTwSg|!;ZPFjEYRG+>XHxvhgJ6ojkAhHk;j8$`!0W ztI<1w?^n3|6~ZObS=fvo;j9ri;;x(6RbLRBb1yD*bF(2==kabJYex`Ek#s7q$i~n0 z`cLR>mh4!&l+(#We9gmKPo3w?^>p;mKkt=AF=C~-fnV7urrYzjTWB`wv3B96fz4MV zb<3xY{qkuyQWT!c(r4p2KYweUz%SK(-9_LKidvJ8rs8mqVe-yfJDC+3_1}>S1(22BH(b-$^I{GWU9@`B_ znUYwDx~4nODCwU6>s~Gd9zYgwz)=EQ z-Z1?(pb_Ol)2x;|YYw_&?s`6Jg=`NX3plp314@S1|9x%w2m~HL3UI(t?rq(%)*J*L zKmzcBgVb9y;pSun9zX_g!10&46} zkIMC5A-8i@_%CD8%73v^!aT0A|I^>cPX~cWkv?V(L`?q2Q>KG8j97}=k;99ZM4f8` z#ARiAocEb{^BXXr6s4mNo(pd6*o@vK-c_!=l11S%muJm zim=gVx!^vxzI#%-aYJ0S)jf`aHiL5OsP6}OurqwN!lRo%Jx~3m2%VS%gm2jYc(;ah z^bcDsc*d=E3Y8*>NkF25n+)wRupm6bt?}c2j2sAf2H3|5eqEl4h`5h|>;2cG>@Mmx_PK#*4>D#kBIkal`|A& zk;#V2zGDo$Pe@#otBrn+p+`bON$~Lm6`T1$nGSr*o4-HExyCJ&%s(V;l@lA z*vKuZJ~VXsfY%Ste-HTu!%&x?=F4eTYz=2Uxm zCD5|=icO_GAbbfjIUjIM_uRb<->JiX{>1fyLJH-Wr!{Le>UAV0O{3>DwcZ{X7BT20-DiVsfJ~ZCjalW&#RJb7>T27HhzX3)gJ| z1`}j!ihBWtcTBtc9VqUEI~!eG=Xw%j`7X}~MGJv7syMkZV9Pn;%qp8jRyD(-_^^zD zVCGBEtVyeD@+jtI!|-+U=m#iK#L)>I8Z24}Z4Ap+omU)8xhgj{^sn zo3iD9fYlO~$ZF%J`AgkYq86HF}T-PoEJp%Mu!EH!J!8&%(KjZlg7^(vk9di?lv;q8!D ziR9&|MyFHMGcFck5_!upjgh+f*oqzK>xrBdm}bj6aN+NF5UQk>-%KD-&5>IF)yHqS zc|cBtm0D@zt5_2?v}gA&4*}xIID+=f8?5XO23B+Q2sjY=#c@+V8b{EcNmygJ;=_OY z-E?f6{Sk0yDa*qO4KVe?-p}&@%p9Bfj z9&Z*EvdTH6jjUoH10UteePhW4;01z?%p0%lrV*X4HG6pR$$}{2$RfKFm)`Qez+6*dNNnV z3o-iW&-?e46og7D~)tPa#XmY*i+>a)&76vj)SsI)Fd! zps-bjX*O*2?hvs%KNAm!gw}Yr-QL=*a}-KR{1X_|8E8nBw6`SP-hS#9R+h-1}K z%x(KPg3`-D6?5FA?inFq)xCf7=Mv28ZsG`1F9myq(0L^APJUGVaB~H(LF0+H&8>(y z!fko(kFef@IYyg^4en6q8{};&m&H{~25Rz~X>WjNCcIYd8p~3IX6fjAf4+h&rLq~n zURCXU&GrbD%4R%Wocm+v%V@BuY-XtFpkBfYQ(izpOeJ)vxNI&!YU)rM@rlKs6v7!U+pZWz=v!eGK@F++fB392n0Cc3ex#kenjG3ViN z1htj|n*#17D_HJWZDg->tl#+!PdR+F^xPg-^x^sLaLL8iID$q?*vnx}VSLKMr8kkS z#3JmbN8Q%JQ5$9>TZzo&u%=>qYwf!^k*!4H3Q#s1)om^O-{|WImdIQI%c_qK`$Fw9 z_uToYI$T8NvT_iT62_+aI_`t`B7MwtDP^6~KWo|58!Wi^{f7FM@6?A*bOwGPD6gFO z;;N<29^=6ON00v72GES4xKdzQi8O$7{Wy3#0+wxwf0_wmqX z`cG{iJLw1XEku5sKc)Y`7w7W*3fM!qhE4we* z8H#X;Y-cT|sv?rDcjWuEKjcBq|BF(iWqQtr?cUb=e=8IDDbO4l`Vr7?a;=I7_ENQ3 zj=i8Ut}y%W&k(Mh+507>g9}!77nlC{HH1qfyBF7-B+PI5$u5vY2sf>XI1{*Vfv@1h zU%UvCNHnp__5vHLygAcT>mgVf5O)89h2G@fPxM4?AoAI3EtrIT`@x3kXxxZ3n*+l| z$=Yu)=gG~yHrFXMq@xi8HkAy$l z;=roIt(rFvYkf44-5RLNEI(W{r5rGtD%Ema0VsEUanI`rHvlTbRm$l}1r~y#qiVId zym1=Q6KzYu+ds8YR+yEF1*F#?(eyRw<4WJmq710$p zUYmh%1K==R3A~f<*W88J$nigADn__-%#8@WJuN+F!Mn&(I)BCc?Zy`V)+Rd;(+E%W z`YeSilqJjOZA13T;I-uizUs#UO6v9Q(%vP!i&3`0JkQkbE_dC=*qbB`ly z1E4UNS#&Gi=Nhs$00J{qlfbhFFRubNqT(gjtck(FE!zempU+3iGeUAuJM))$l3r%45va{_FkKW za04JQoC;-3-d4w)vc%h;c=gp`y;knaJUz;k&&Lz)1aniaBl>5X5Fi>Zmm1jLC7VKF zInyLi81>cTq7DuK{-uh!7%TWhiy5q?oSqxI_d>YRU|Txl;sUozl?M?E9=;QeaH&&c zZZDb#blWil`hm`3EQa`c$=yYOZG?ANWmK4N8|6RIXbbWJox^z6^3~DsRc@5YIY2z& zx-Z3AG;8^9#rN+cU^}9h-EtgeVeZG}>Wm-Jp_AZANe6N??nZouq*+FoS z+l%%5b2GxHve}Ezk|o0jI;6-a4wL|uDS}#?Q&M}n`{LlPy2c%I{DG{eQd>cXyY63Y ztkK?ljyaz2o~h$~hHpH5rq}L4DP2c$@g@IL@}B)NFK;)%exqd)yB)`?9sph%TJM9~ zZpbUNm*vGT?b$*bCq5Y4X|-#t0p6kN!Q7{xT+87I%sUuf#9f$IyhGK8Id>hYH`mEU zr>o&NBKXXNyGDh!W&-b`Q|?*$hA(&TPm{1q&M)c5lPrf;VWqpXNiaUxi6-dej~3qG z$wjx-+K_ueUzxG{X%n^D=n_KtuA^GX??X+lW};sIs#GuJ04wEv4wz?xb}M_JEE+5; z(9jo!U{bT;KVd3TmyW3G!St1JH4 zoRm7u`|z1Lryld>gmhpuRU@VtZAxtRD`@dB*p=EilWGzX0s;jvH&jO3oL4H!5S;achJcZWzmWI?AbG%0i3@I1MHG7Cy(uId${%9sF?9H z3<1ib+qDV;pAuf-6bukwZ>}$uA3Zt&p;}9?94WAgzvlhbb=>KV>I7@$^`U~GO3wM( zNM0eda!%EHF$b{4cQdMD%S`zi!O9TGrb|$41?_x?uY1)+j2d4x(P zD?EGo!Qg@m5Gt9j@Sdare{SrGP|0+K>-l>Np8Kl+ivs?q5LUX?A7PDi$7iCW{s1Y3 zs_JrNyIPtmyXn&x&9^Y)sdsO2Ox};sS>XgwghHm?moLqTm^$h zc#G1TWyG?Yp1D6se7X-pC01E(DabNI-t06Bp^}*k*P8z*SMXhgDkIF258z63waG73 zLa1coLdi|;e=83!$cVuIlsp?lC9XbB<=^bl668Xvs4GRRU7O3bm#^Jj&RcT+r*Kw& zyFbqI$*9J#rsHxH17=c{T#lLMqFmKq-fWCuiL2FKSY!EY&mWsxAy{gO4HbpUSehI) z@O&8%QL)q-D^{uv)bfSD+=Ec5Oyw)eW&l*}Rp$^wr7~5lQyY#g+`n&g2Kads8r%IRL~t4xYzarFp;$jx4iwPKxJgmOTyJ- zwKjtpz5P8%1s7_dcK`j@TL_rSUT!dK=;vN4QWXJH`Rf3KmcC@ah9wZNq=o;)-~~3P zApds0^)-qJDv22|(CLKiSXed>BQXC{NGw6KA#p{cOWyiV<%d9QDbf+^hbsp*4zxyJ>4S=_-2RFy5{gLv)V4SE|YO#>wa#@{W9l9+A>fU%|9ntDt zs3pohJojbf1!~b{*22>d_5K+YhrAE~alypn#VWgE!I~%Gc}HjBA*}WA-B!1p$vBG{ z{{y(MBtAX>;(`+p4WoAcjr<@9W*s*mp-Cxya;DKM$0%~D>{-hd#X1lfpbL1vi3AoU#MSoM$z;FZLE-U0Z7b?BEeVn@-=bO+lR628Y#A5~f{ca>} zhDfir&ZNfZynZP;=LzIkYNyOfEnko{aC;`KTVaG1Gnh_Wah0XkAT|7Izj-2;q0&h! zPz`HetUjw6@&dis;v)o+s}F}DFVHC~<~N!b63*|3V@9Veo;5A}Y4ChE$b6+XM&W`V z(pIY$%%40OITE~d^255@tz2A%4pdzh?_t<{tQOn&&>WHHomcZ9U^;unEXSNYwVr(G zMFboGfyG@a#>BLBrOF?IK%?HcC0xO3gMphTqQM=68wic-0fo=JvHhcwBLbl@SK}B4 z|9;`0UI;i4CPSG|fm$b*B2NTDWj2{K4DQwRY3SiVs4OR`vZ{BjyWuZnZy;o5CCIS% z&&q?AyERB5vy5OrWUgB`*leHoE$R9M$YoSv7MFd1`(6KCI;I8qe5xwTi)v2z`d%tf z8{x|D_unuuYvFvaaI+<6kQb(<^p{YFqOX!FvHgy zk{_;*c^&ze%3lTyw}x)-Y-BC~#MFtP(pTVuMlZ+gaptvr43|n@h6@goHyys?0rCQs zyaJWw8r{3EpV@g4w9hig{FB#cpZDIIwGY@yRaWu%f>X(PH)fc+gP1y0HI;+Qi<(y0 zODF9_S%G@pmKWEI+OPN48HM~H9c#@Ba5DMQ?uJD{R-j(D#q9-?$)tYWOdU7#ZUE#J zvUA=5KcizHuRIi%7sW;*i4YgBD9jcOwg_n0l zfiIIAox*30KR*PVOx033=uFA28NDL(WJA{(N;FVKR6bZ^vUYRDUGrQd^9Gf~-U|-( z=xx~g*_npggTczt^Pd|StSPRWQGLRr$hTAqGf-Y0bX%YNf$PFunVf34T%1|QbU}#a`iF${pAJM5ioHMEP%PyMlie^*6%9>OzfaJ zu&R@mGoG0>Hu+wmQ(ZyiF9+tQu?>TZoh^_EB7&-{8jv&;UZq*I-H7(al5R|$Xc-cI z^MV(a-7g1%IQ04(a{=L^i9F`mX3nYfOxNc?d8a;iC_vG5c)uNb?XW8pR>zGO!Tn4A*B!yi@baG*I4tn&gr053AQup8Fn56&T*U`h8jWnFQkR2* z;QD0Q%2^1O%3BT#Trj7`Pmj1RP^ljgA`=;%k(r*7+8gGzW6P$z0ZKCU?L#lJnc42KWm`H0cE{e3L#>^~>kga@n zW=1YD@bZVt_nQ~l#ng!-^4W`Q#>Ermp3i|SmIcah<#%yGL5*8fuK=hcagrSVk(tPt z9nR(zkR8z0>&UUPKNLpbL`ri7vlpBfZLKH%Df*FLK+TreR#r2MHO%!*|2R^LWqJOm z@E*7717wnqHk{WD~%oyk5#Zy4x#_>W5oFYr3e|5S(Cnd~6*Q<=^^YbknoH9T{) zusfAgq3u+5p!@R^?b5%po9MNt)DhlE=rLyHa*G3pI<(r*ZtsDEiA*Kj^kB0#YjO?J zZ%!|DreQJ~Jv*P7*=!eP0?v-=wF0PK4P+15o%aj zY+9V-<=H?>;UP%39E-CZx+yEuLb=!sYG^5K8-2SkcfIS2emt!=CWYNZbA}$Nj;J>O?FU`ys9)g<7fgg}G(Cd)OdcL?@ z=!0}~a^tCEr8SG+;MBBC?sDLeq04@J$UU~F`k2D!@TZc}H3yVAKWV;6W)I<-t+X@_ z$4iIOWoqcJL_Oy7fo!yuX9%ri7SmA;_1D~IV$3eWqvVKeSjRjoY_1ucIc#9B5IEIM z+q7*h0;iN@0sdsLx4Qz@i*##OYpl7D>+#r|Zm;DmAq&$1_KXkLZmP)g5dTvGgP`m3 zV)K|Akd)b@Pp=GjNYO$=@jf9fjAvV7JcKK_l;6q7OiItp=#Y}xhZmUeHqN|Nr%>(f z>pupu?x9rk@WjDGwYVAcVw!o(ky%cu;2e&}y7}x~#JPT8f6e2e@Z3e^e%6dV|6Ijf z<}AwNA@SU6EUK?VJ~^Lh>I6I<*(UoT565L8X!gm+Yc}vbx~mXf#`yV#4>){}+8R<~mHwdsLFoAa;zM0>w+Pmbv;LCzxxzF4R-7lg2ot?!Fj zJ!l8*-PRH$5W-uFUUZR`ve|0uw_{g1kU$7Ga(Tg(+@u?xYtoS>W>@YZD8RB}o3qu0 z1Lh7vR#SN#;8={ zA~H7KIz1kLtTA9YK@;X$&kLF9@!$7tZ)0}-9>NV=4A;rVT0S~GYkf7holzJrn@7J4 zXK9o5U+zk(+=yM)v}-qWQsp72!hCk}tZXKv)vJ$gLBOOk?l^#FIy2o5d9B-g&@mEp zVbWp-jQW}pVl{p(swyehO4_HvO#B#{Nl!EO5!`zwP zB||KgaGO;J(|GM|K9Pg}dSNn<+ItAkFS-t9_5ugDJn_j-$ib8*+~)_GHDz=ALW9cp zI56+GR8LsR&6?ZIyt_TzG`D9#kttDnZ#$)4&5ywHnH)F*g;O-T9VzqncF@rhgkxUs zhGb;FFPXQ;;fFwJBHYI1g8L@KdSX6te9177_M_#j#6pjd!2<`f6))Vn^)ImC4Y1fn zc#4r54tuPMk3Lfcbl?Q}n1sZsZODPYlR*zlP>^LsM&zqFr}}ah zeU}RA_INxzoJ=Cq^@+bm&gPdgm(7~4?OHP@U5AJ6KiJ~r;kIiMLnhXVeB%uxYj6Lf z(Rz-pL;W`N6|uiOajYg~~X;~~87XrS{ATJMBkj&{O( z7Z>wA2YocG*`P(u{f7oO4|^^;@<_|L32m+YuR2(cYhsIp?)%#kPUWAXhB>W(GD*XK512P9MEez6IEgAxPMy=amrE z3wFOt1=@pxP0+9z@E~leB<2qSVM7qH8R$ybNT-*}cf1K`lL+^SDfoOjhb=l7i%^9Q z&MS$)?HNJ?=PCr<@9D3O`vDEBJvV6J&aR*i|8dTeJrR5$*+AK_(cv$ZPdkmGMn=0m z*$8;vfEd1+Tc<)q1;$kVr?8cvZ_|9kdk}XG#rTzzr=N}o4M?mtCnRgX0^+{h_n}wa znya)4GMf>Sfv&R%y0vyU7*c}XO|w_@ABH;ye_7%cFr)<8n+6Ywn*Ze4!d2OD@;_xr z36DuKbRm0l7K+tf+F*A3guKOACWRfXAG{BE8)skBbAQWQ2l4da`!{Cs5lgwq;!x4oUddVJ|BJY zxi!e=l1_fIjS6or+7Eu|`^m^Hq$H398tD4|+Eb$}$O01Ee-;qB^AxSkJH4huZ(uM% z9jC<~lHlL$fAKBjDUKKq;q6HT?!BBq`+)d-;S)gGC5Yy<-vDVhA#GASki!VFISpIM zVX}$r)@aiV?s^{SN)EH%b;g^>yFvHZ{0CIiB}21GELp%) z2+ir9zcPpBf3gEmcGCTGUp$DUP6(t&W|fI7U>Y4^SJq`UT0S@;p<8^pX_^@$5d>|W z8sXsGm8(O4Erx8iE(>O{d7gB%wE5}(^}3Ist<^p&G;+s_G5yncs^Td{hDSsl>jWSR zbo{(sRn5>_dFh>2$n3!QK5SmR30*H?=`p_g#Z6bu4vgvdPn*bp99tR9jn*9!2-PRG zYO-vl3oZFF>!&?2=6+3t{WVK2ANB-?hx3!R{QQtsZr(fc_fWH5M%cx65;rC)EI6rq z1~^Rh($xK1+;v8UI>^wtF#W2>(;vV5PNyW%JcAv1BfxIZ%NdRVEJYQ26IBXY)0z@*1?A*3Z{E z@>)1Q0Cys>&f&-ti8z2lvXs?a6PMJcr2)nM1Tkn1Cp_XyY)qwruKSik4 z60V{e16bjFW@khZYwga0Y6kMPm(MM8M^NFkjAOr?7JKV-bloVo@*eT{WZE-O4xpr$hG~E~0X3hAU z-s&P<^y=X=V|a{bohU}wwRY-n90;p1G2PwZk?rGiZ!{9^H2*c#{ym~FFz-9p z%DNGwLI=Y76qZkny0|{~<3ru$Ar;tK(3OET(qHYPds`rD10g$mr-D6-rIGzXrLxZf zvfCwhS*(Q*O5dwHr96TTgzVyN4O8rzQv2})7h0ja3=0z7(JJ#Zn||&DCKh&qo$3#^ z>nExV1{-Kkw|mla%x?KbYEr_A-S2)o)&gH<2(;ofypVBef8mvfJ3vqQV& zPT@CuKJaMUH5>CD(NE}AESu+3oqL5l-Q0VKQP4^5q4c3#}|zhLv~I^Ft_uyRjK}y9y(gOMc!Z*;QUWX zCov?_>%YPn6oxO^`a5r<-lmK(B8J3&-_Nk%;n#nrgn?Hu!uvP8RFi!K|5HCi#-^VP z6|HG;%-;&sc!Q2BhJ*FmjbPsI(GP2Iv8!ceoy@oj?M?KMWjXcEsQd3*M_P3 zG=EKd|MDv!ec3OnQ@jdE2b6yp(07jOXoboW*FTko zIFI9N&gi#s=q+HcU7x2q10BF^5}tMd%o*(3ysW@*1ba^DJRPj}*fn_w+Ze(Uk&j(O zE(w6yTz+ASH-EU*@Cb-$yC6@REr3}v(&>Grait~Z5&MXEQUQ0u&PW++KkIo9nHvDL zooCw3$!eiz%d|((0kE4vGpW1@eZF7&<}Oc^#9@DbR602YCAtj*6Rsd!NkD5EVYuc& z^^1*u>*ZEc$!ldF&M&X|(6R0j9mKiR?LrUJ$B}m3T^2_`{yqQn$>SzNBJH|66&fYE zQe8e9f`9|4)hVGU8&xS%q@bCNBJCI3WwjW3V`$pZ@6Bu!X_wt0Y$F?;EHwWSw}q4O z9BIGZPC+-jmpl`KTDwuFq6Wfkh6);jHj9$M6}*x5JMFUC3z*WoQ=b85-HxP5?z}mU z+YARW`G;|1%tii4n(od3H%2k%!AM_CQCKb)&?qbiz4-6}ORfTv(}Z`@Y{bP{FMr(( zK}(zM36HrOu`y@a_kRJ5vEOl*HAb>IA|F0x-Z67UF_NahQ+?tDiZPbkdUq}la*6$R zJH>j|jIj>?Y~3FffRB!2?A{I zKC$9sfbI6n?KGPq+h^~c^#)+O{f0XTZbZoBL(?C)^H_!LvWod-J3j@;R%f+FeO<*D zk^voQYCLaLGfyL?Ur31Fg`fjrx_~yjo7PL#y#<&~)8naD!(m+X&5wTorrWQ&%Q}p1 z9`TMNcZH)6=y-4ctCiWm_~NlrCGFSU@zvbD`@+JHB*2ElxwZA ziz8(TgsJ_4T;u@A=uKtcUj_?Kj^k!}{#1!*z})?v0AfS=2ln@Otr5 z+ugZ>!hbn|B=8>;`yn6B`3N{%nJZYmlHCs9nGxk0A?N^7fPe;LdF;2jPatTS4XsvZ zw|7|eK|(c9BkT%2m;aqv2~J4CLjJKi?$t!#q%A#u>9bcsTbVCa>jC~t$EW`U1;~CS z9=BWvXHFNzLPmJ{sHO8vd1R#hc03W`&xRfLDm+_#%VNA)SopY`=Ei&8UE?FsCy?l` zd;&kU3_R5Pjm>9}`$;K4f%hQrHy4fm$$b7N(*Crn=6>G6G27h%kh!sMo;I!A^%x}s z$k_3l0oY4RYqX)dEzIdkl#s#U)t^^k%?dK z-LG#Vd{X_F_)Z}OG(9ot_i_lIoCTb5I1LvYGJ7ww=J~c4Z$=zXG2jyPM|B^_qV=73+J|+y#!LY5Np-A!i9g zj}-m8;{MC%7f3n5`GxfKq+#wSuZ#c8L^i&Y{_S^WRi@d*(0(Av3Ew0|J&U#?} zr%Y|^Z@T*M9YG9RfM-MO?3@dgln~(PU$eb!@eSs6Dv|a}`h36U9#j)L3HGD>=?iC0 zsQ=d6GZ$_{V?)XqVr<;sVv!pb494cw+xNaSg&&d8q^$t)3qr!jx06G)LM9dgX;o?9?6FnA7YiAD7gW7*`h zOKl&xQ*EW&kPh>kGsG`2e~EC_DA(`yIxN_>WqPZvj%%gn{la zcuO9WLLvRxysmp!qn{wHL}))Dl!0dJap&sazoVZZO+~yvp%hl0r*vA38vOM}G!&%X z!}}Agvax|?ZgT36HrOLC4LKCd@+<#SdIS60wMxh`(y?C<@L|~$>PeBWE(2vWHjo_R z{7hOuQK##Nn*(yU;;`Z%iP+z?Rldbntyu)?qY?h-3tiA?kh%@;Xs}pfzRHdm4}E^Q z1Sk|VZJ_rTy!DRz$#l^xrzWg-m267ZkY7N`8Yx;30HSjsF+bPAmCa2u(SA3X+|6&Yj5a;nC|k~V^` zw<@)O?+x-*0o5PY$%7oh{2u)U&jWoY&UCk76$(pCzZ4cp!ker$Ys=P2yvU=1HaVD=BZP~weB}a-29QZrxbhW_m;)`4=5g?p9-sAXxy{z z4y=k#=QD30G(ulUANLbj3AA6==S(PBlHj21I1%qky^op6CFAbv{@Mas2ZB1#4LUEn z=-=2cu>M;6fKs!EPeVUJ=eYMLoP$21wblaW-JpT-d})UlcGdA#y88y!d8M{P)BJZ< z2S=6E-etSp`auFH=kavPJNNuMCD-)O=2J&Uy6bhS`LY<=Qi>?!n%}P27e zpkB*nITP=ncIt~{{D8}eWqD9!JsA~c*9@w_>=9#LzXl!s;=T4k^OCFSMXc+onPH}* zqwMeE`W)?+T*=GkrT;hD47n(RbWre;4IXdk>+>OGq-4#E790^nUjEG;NY&%klJ2t^ z7v7JTzPyRMKWnQHMGy|Uc5_@5g*ej}i>+QGfx z2;$DB-WBh^Y5{3~7T0whpMsN*b)|UjL2pU4MtlX+O zbJ@|hA>qx!YJ@&=C~RM=rjuT)UbRGMN_tMMH*Wps+M?!CR1`r&D8A14Nh}G_d%G_w$^0VU_$K7ml*c5B?Ivgr0pr0EvMhA9O}f zeF;lX40k3zQ2}%q_Dlbq#LzVVtme&LZvyU_UpnKFW(Zj3%4|F=fz=D_Wvne4S{&RD z7e&wx3UBmJ8@IzP@S*e>E6!Qx5g&WnJeo9+3+Td zN0`}$L;lycCb;W6il7t}A?S68>515%8*BpcK~M;)xSg5FT@0H?%nK@vydg6x#T$J4 zNB8rSZQ5T(R?7h-Aq$0ojy<5wGfyF_t?hr7G2}GYk&~}>NAFJ@gYGid_BPHd*7z-l&>z1Y?V@9{ zHpzNrRDDzk2pT|@EzDxE4C6IhcC8ai4>GU5EuQDv zD3GfO;y=}L-f0`ozK}6(=Q^AOGYjt{*J!o&XPZWbc4r9Z>s3a?EXjF4q~ zP|^pgTVZuOKsN_QaUnp^WBTB#WjDcGjiBaJ-ON{h_!2aHLhI(9q2D9F1V(oD6NblM zn(^N`myl{?2S#5TkC+{uel$)&&TOgA^VgD)FM|9{BXUV&I0|D1s)>>lg8an=?1py)rMoR0yCi8B8JT?`iRr_PQ zPWtmAn;qX9JI_CiJWV9I7gwyk7{Pu2cAr0xH;6R%Vxtb{^60kLTyH2mmko}c=cr+C zSLu8iU@$>pr-lYMjIJ*Y+oHy=3Re{s(mG@Oo##(ly~;J;&kf7h0wFN=_M?jc>m1 zUuX)#CpPlj>n=X@&|lv+E{5=_)t%wD8JwKG{U7ca^c2FEWzB#0px`U^^ALA-j$Ui? z&>=4W2+lg8v`gx|6Uxy22Okc9w#9)}hn*b}_V|o>?!IZs@&CB2RcZ#|@;&b$i)*As zd*$e-90tg*nDA5il02vJ|DvP?*;Hhc7TSdI;{wihW8#{;#y)y_y^{w4v+OcEZ~XHo z;c>@VDdgNc2w92={Ew?ZRz_4Vps&2Kt0E}SgiH7wXLDrKZGQdQyeM}br3@lbWfvlz zX*YY#_2u9A-aHKxMO4>0sQmIh(Glv2@p$~gd;nEfP)RRv z;nL!l$NzT%SxlunM@9>a`vz?M7vajnX%9ElbZ`9na2)7ii3&Pr`1o0Y+UzO@ee`l% zeD{-w1ff+@D=TT)kh-E<>kTPquWj{;nqG*ui|72TCjAk51`>%xV4TQ&V zzR|70TyV@Fnkbla+>2%#H3!aK4@fM_oL>@41)8jH{WdT8(cOfX$v4_Anp4OIW-opB zTsQ}C zTS9)>%P@@+JZsyFh`n|doNFwLDR7$UyYAh=_GYwQ0H?yX5i$wQ1>2`hItntmT>z&b zBT03E(+d;9sM%F-S#Y7rAAH#0MN|A7ZI`yW&?50@erPbE#K)$DKiaNhb3yt4)iB?x zJb5cJluTbF`K|iyTaDeARdRw|tR@U)F>9Xb=oRz(&*m~nv|XvDK(d_R3VeVk=B`i9 zjf|#om>F%Rg@WI;%XDW}3U_63@XK9kt=I_E2JY&ByeS|_+9hkQLzua~qZj5X+}uV9 z;z=^TnWPM%UA3md^TRYAt~}K*>{@(n%?Qvy*x#si(Qyizf2itS&_LLQYbq?{^Um(&%xl!BK276cx9h5IG#87il#Dx zc8!`lf_rlu>DxDGUeL>%g7OVtuAgPAUbOmV^YlTqU8<(Q-wWEc?|ze&LG6Qt@>Tzd z=~GAC<}Bymq<(=+tJySL%1^w`E}bzC;^nORlvq^Kk>xa!H7DI@Zk9hc1r~0j0qHIISBd5*$_YTQf)B1BoQc%6S(afyUR{_Ma(~ ziH@Q*;ryflKN#ewz}PIEpZ0K$2+4$!W6-xVLRpOPKh@{7g6{nZ_qqk=m&E$FI6gdz zU8te4HKO;TFWl;*WC1zEwk*KsYHV@c06v`j<{cMU`4D9pE}O9A0}xV+FU$tl;%AU=hnMSaa~WFT0wT)}}nXt1$X*Irx4Z$yYSB?|y3Q;`c#|WWR+@*vTBp zZqWzsOque*&w$K!ftmtq_%wCa(n-ix5}El<2eTEpAnEtKuOM4V1opzF=zjfgP^tE= ztqM!!e8<94ZmoF(ZT;8Yjd4+xD7A~x6u0t4Of3jL&vPd)f~E1(aV%fM)L@^h(+O-v zMB6oJ(pnf?B~BeF0Jvqp8cxMEqU+qO=wCtaZNCmqMddpunislPNIr{jX`B_#g<)HM z#pu4s3o^v~07C%W%yYySMprE)=?S^43K8 zYfF=dzXPqd^a6>#=2ZRkd;7l!xyG(B^95N=c7#QXuujD$6#+i5%gYo{5V+sHeY_%q zr4?BoU^P*?o$|`b83>kEX&qRQ!wNn6>QV%2ZK@R~fcQE%J}wEt(%I{@MB0!I>oBDk9dTxfw@KxZvi zKWM@A_KLTAB3tRKWuRtom8yB51A>)Quq6WqYr0@~(=A&OEWO@#MZxvx(Q92ny_KjI z-a1$NnDsXK>pyRR5wpv>d_mjQ4BBt6om>TcV1HOu0R{E8eeYKnBUn0byP}{?UDshc zasj>Gf{AGUk(0uat#sZpP%~&J-8^0n!P0rlV9lT{GyRPlp!tj^^VYcx#ke@C;)5|4 z5H6Xz0+$)ArG)q?J8B^}khvSmXS#;DJFmQO3z;ifW=RPQ7U3=`F>kiJEs*kxQ2m-XS!a)LH?x9UE;$sD^F z`vqt!G^;%t?Ea?zZAY+V7KgHKoH0&=T~RCbR|HGuv4AzK9rxL;ItZ4`<50GeXa?~0 zAKJczU<2T>Xhk(AEM9PKmYE@A?025YA!Ci0272k`W8eXrj7xX`Ojv&`KSW%l&ViK*K@)E|pyphyQIly0fLm#rEdgq*uuRLF zSqpu<^sB#afsYgmDSh}KdA)jh1WMzr05w1Ubnog9sE_(*2q#CQ-!4kt;Txr{@9)VzurS1Pn+a&P$O6q z9?3lg*-0gdj^5Z(f3b$25N?B+wvJ;TOo$1n)0wiu%MxQV&fM{ z$fH!2g6*|Gx0U?|eLR(;aC2>_=lO3CD3zmdYwd-yPx&T;N*c_}K^vvkmv%PX`*pj3*A)hr$Kz^?u)5Ga+RaHp>E z$c$wmN{KQl4^uT7y=3p?+?$b|REn}~FS9mZy4vbh1S%uS|H#9=w3fNQ--AA$N>MgB z)dy+Qtv1ofPAWykd{+mpHuIIYL9b_j@>0Yozh!~vCmr?Q97~UZIx0Wj!cjI#td25d zZ6z(Ym#DKHZ&a%9&$`swf{St9~h(y&DcL8xK|~VrgXMUVziI zpI83%C5Qz3eOqGC99V-}Z=avH1ldZfsSYTp{#U+j`!2GTMp*~epu)aC-zki2rBT)k zYG#6FnfoduSQ)qeGJzM?>;X!4dG7pCV zM+5fCJVRoyd1Ug5^hK`&dx_#G*Iv`VIrbd&Nx78OCHpN}KL5hGW#ZWR|AEMjqmviR zF2gSWnjeH1Q5(g50Hu;I{1>$l*-9rbm<*1(a|3Nq$I+<^r-T2D***cefKFaGAxyZP z>lp+~Coh~5-Wq&nAo8qagDoe3)$0;x>j5QKjQ#Q}U&O+h*2-M_9sCTk3ukln4=w@P))=BTiVql^&!wJx4~T|i?9W6h zo&}4TzjnR_B+fDMbl$?5($u)|@1Qu49J8eZI9H0eSXw;g$k{6=wMt)0Vy?NL6+HjO zWYgSOqAZG!8Jse`TXOp+2$r@&?1eQ8`K^bx6+p1`iVNpBgU0^)1cIf_ZXIhuN*F$R zPDuny9X7?Fuzs*X*!tr`@U&p%UR;)64v{9FN z!TZLRHhcW_o0Q(>Y&VuDi4xugTgTfgy}BFt!G5Wg>IV=D^*%az7vU1g%VPnaUc0z< zcV6TLB6}TNBgoP=9&e1S4S>9Gv-i=@K0FTCOVmQ~F$0r^?%z%WQ}bA&6v_bwBbNWG zJe!cM#Ex0mYB+X%!ymvLI+iGda%=_c{k?(bC`h*U7ao04t919AuFmx#U;J29Orf>9 zD`Per@;aBqvKNjcBNNx;dQ*Ro^5f^Obq1a#>Y%t2z@(w$`L16A7Z6oY4k(C%Q)v(1 zLa@>YemfdrD+AZF_zF*BAU};IYM>lzjo^Ac^N|L~Ryu3p&QHNVyJR3(V#6$402+it zsvoC?>32zBr{h}u}{}~au?`fXctt4aJGs^oeZ@?&CaW5BV00R9b7|Nc*m!B(cg|+}7J(?R-%I6o9QbHe!jn(T zL9pa<%VAAx!^iKBF*W|NL?M*$0&Bm8+E$t6$VTb%g8N_aJJz_8O|G%WM#;g;rc2;= zTpeR=(vh}@kG8IJI5KbIJiS}GU3VDR7l@4_(>R;6TkqE@a|A^Ona2Xx^|kaxrB_ex zG4K0|wckIb_@aHCJl%t571ExC-uGXgyeK%xRhS>LVuPuL^6c*}ZwJXYDgZ*WC3g)p zJ^aU~O{(O_R+eQ!5%0=*VHot_4J_3M+5BiI1=`y}A+`i<2x0Dq$c;4eFE zrrBC>XTf;)nFggA%j8JpFTaRRgFdpQYEj?@qLxYw8af@f_3Va52sQxvGFT%!R%u`K ziupugta2JEo6;r;!4BOqu?oz+RhPd%3lt&Z6;zHd&>5qQO?wU?+yH3Ij|v*z*t2cT z0E8O=kKysSww-?gkC(;TpFEUat{2R;HpZgBN28{;ato2tn%JK_RFT=jh_f88h4O;Z zC8xM7QNaUXbiLpKNkc=Jr}h3l>F5V-k*fosH9vl4^zYB7jGgG}nG|Nr+-6}m_X{t~ zJ$q`-C_Uqs*TGV(vQ1@W3O^~Pp>|r)@kQVUWd)stYDDt4`G!9N(gjs~#ivJNDl5#D z-QR*dQ@ZnX!7n&fB0^bw$i`f!`)hG9^tpCxIzDF@3>qs{4aM&ks%_pGpeLfMqC>d*i>QF)D zYn{3mK1h2w4S9h`XJIY!?#>oXk0LJ+sVs2KmuSvaEYA*(IG0;1M3%Y&bIQH=2 z4B!Z=7RxahIC#w2&WjK(u|_+%AbcM=b+Ug&<_i9&@Pa7Da^@PWE;)D1yO-|sc-GiG zv(=5C`9Si-q5h7w=@#tXo8vKd1-1Lwoy-|sbCfuSP_3+XQB#tunW&FGQ)o7rhuZa7 zF6z9XPx+PEF0worz3}K4FN20Njz;Pfys(C^B|$Kc@8p`sLc|n##rskHRVraDQ%W4Fu`Con|A5|LbdW$6bc8`9Idzsv*XeC zTlp$cjW+e|(yui`meLBauoU!=p{F+;2Ej@cWu>qwi!TYv;jg)2#H;4vg;=5_i-Q`Y zKVkUk9mq~9Q{kz~y!R&GL79I{na^L=R_epsWgSVt0j)^%8x*)^;E2k=_Td-fVM@^$5ZPmTNl$IpV_w?C_>_h z(yJ7{CT5Dn_B5G20ew7`rEp7i)b07T%{i_j`M0o?uUfH!YTg66tlGs?U@cK}m4bI_ z-#XK5BN!^8=8A(FBrQ1M_0h;qDoNok?WrQC|3;uxlEUrOj*BKALZDQV!p+q5xGs;G zllwTL&Wd+axbaDTsvNSFNK^r94Al?wBXS~Ji9{8kp!MlmGARPV5=*KBYxX|LU&fp= zXK-;urIqk3bZ!6RQEkl0tTKV4F%}ip4^O{S#%!(Ph;l2h$;PnlPkLc5a0F3rko~w!~wfuM`Xt1MLMtv8@i8;;Us#yoGF~GZ=QTf9HE}9KjL`E^`6w zG)we-zqdJsRZgy12+SXKLWg>TKkW`~oQflguK0+79=6r8*-M^LDsa?`z zP!te*W&vwN!Hi|CS0G!7ycM8eZMR4HG4F#`hA6LMi+b6t!v1{!`gl-q<$%$MYpfaf znB9F2XcUR+DzCkUa}RARya9NDcp;S+6_niPJ&h(ITq1QH?}AZVw7h6ugiCCf9bB*? zTVP!2N+8IH@A+{*zy|b(%p!#VA&B}a2i6#~_ba`OrjSH+l>-Wftjb4K(S(=yrk@wq zZ0#d9>}!ZTOQ$dFYe$c34etMmBdV*owV?lO*yo!qfV(m)(zt6p8oa3F@}H{A|$_=(iqt)!;1iFwg?x?B@98Z^r8zJ&{sz{TYzBc zyoHTo(&NG4PR%&t)m1zWz_MzWtL;{Rb!F)R5^wo7pw=yioUJw$IDx30a;ybW`@h7& zpCed0aam()rrP_>Uk2K#IHGpSu@>~8!**A#i>#&BT-bv?(YhnJZ#^!SMqRGXL&~PL zzipr6ZUjobLY$&-_eU}>YM8ijPVdG4$hGu1=)huW{N>Pm%yiW0d)r<@s4{r{8k~{} z-SAU^!Kug%H1-Z~P{YL5rEc*3qCFaSbGhLf7Lfo9gB` zW!;^Mozy?0m+ocHxY3P~PtyLRrpemEJ2kWoU>{k%a||C)mY_H}9RI@(T`izj3D$`++Ljk63Ab zplR46;m@`>uovL7 zej*MBO6dQ_woB&ukRS6@p{?9hphKSfrgrmoYsMeeb>}Tdj=g3o-s0jVv-}a?6I>N& z6PI~*-*pdW$P%n@%0gDL)tkl7JYrcooj9~Z$+(P*h1mbk|D-eG?OG}^hU|?3;}}Bt zYpcT$B8{>9Hhn!=jUDypr>0Ni?GOBUZ4|2&T3)$*a(6*wC5^Y@CV369;=jl8BP*@M z^;yZ(#3uOlx)ZVj|W?d=<3SP5tVKTZ^d|vp!1%ESOwlC9j56S$={q1oCO0 z3QVMI+r710?~RJgx!&Qc4AF}DX74Y^F!`T~Yvrpj*eog2x>o%TIh96HhQ~rwF9WN) z=lG6$g8wNLl`&7GDBIiBLSRDqs?~wDb{&=b^=w5+C)78eH;Hx=isDhbjLL^uUz`Ad zEkMg2dENoT<*}|aJKzQf>ONlR7jvo*Z-2|r#d9`BG`IF?QY{R*mBv;!`2cxp+T`6E zkfk)Xa!j%Kr&)So`QBz`m5sMwTIKtGcUEHt*PxTvo--#k@g6H>6>L$xSwb)+fXAw? zZ|IUj4KpHfnLp|W^A#Wlu1E04MV{V`TutOKgC053Y-rxN@zxbLC=?dU$o0$Oq|}}! zWRdHCEdklqE~#=noRXfA86rIF%<5!Te6PvhZ<dGUIW*>Bjcwr-fJm^9XM6)bb6 z_SHj5+?xrqw*A3AF+^;MQsBw&PU=`ph?V*Hs5V*&>U=lr+*{=}rZMNH&U?)bPlcbd zXYCmLlzl}$zvL*0GB`#@TmrfYN)VF;3 zOoU1!C`T1L3z`S^O}zoG^o+O5rhFc7CUQ>j%N(_8!lELe0N8a?3a(dRuJfw?uzwQF z)5G!hcl&(t^}m&gd)b{jxd+{e$k?LYA5$iy_m_YT_V@c7!;N8^Iq~~#XxNC1W#x*= z-Hf%7t)(8z;HRgvo}iAm-&^Hc$?7YAhM3h?vG}G%#f$}iy@ZUmQrHKN5>4TU=QS`l zhLq(E8;804k*$##s}WNNJRW484T!hPs2p=sGeeAWxIJi91yEz{5-I^HZYwZ12lL#^ zxewV%qp(=4cS@E_wx6DVFo5SpKKoLVtzAClkm10=oQYMNEL*A9nbRFJx`Jtf{jMtU z`Fxzbb49Vjt3_A+pDz|ezNM8}v7}*MVNvtaPfvi_9c8VyDQw}TmfmCzsWZMALL;!2 zq3OwR#-*f+Ag4qTx?zrHu>YU&HwPg+0zEmNk)sYzt=!*@OQpEV@$gGb)K0g#l6V00 zDRzAn9}N#DxoPFOsrxS@OhQ@ZnBn2zCZ~-buKyn|TKrF;Pc(s%9FtX4Ew*2Jw(K)t zaVc6hD%sY44hZh{DE(6VAoSUUR@X%|0_Z@a=_3%P9C1HZiaAN=lrGwr*RHsspeY86 zw+o^8kSAw9+nJJMk;Ofa2}CCxL3rbQYH09nNW_&G78c^NAs66CJQ$lk>y2S3&D#7dv@P3}#nS znf>DOv#Y*AA1-6b58=&JT={I_7eW58-xno}WIZiU@Y;y?EYhtS!laRr^>BdT2Oj<8 zN90T^C%K*dd!^#_m&zTNHFg(v6kf{SfWXW8fS8|Do=_inz^-rN);evG(Z{ZRu|^k! zNh+Gzv|2keXN_>@;z|OsE1TF248dF=!*U2%eVMmn_p=C=P&yf`vp5e{pzhpE^r=`> zYYFw!dz&k?_QKU|(~z}<66%G8$CwhzE-MLoW4o+L_?A(CFHY-q?!mw{pMY-Geial4 zHG1RPlbTNl-KYI6K7j^u(~6@9kaYx-GVAm-vi1DA67IUTLQa`QNaSpjnVyo`J4AP6 zvD;fFfls$(j}r+kKNY$4WT*L}iecsu#bu1PWn(6P(ZrvVuSW!>-^#*LDCZ2q} zF2W?#(;DLLO=hN^RYFe9YzDFbMVG`dd-miKP9x{veKGQL(E8Y4+vD--o#I7C=##vr zWeUWCK2ll3^W#!C^~*Wa-$PDx5X3C|pw*{*HD9J&1)&vUJo1@ixL#1s)QND^bc`18e(T#$j>!X$NY5oZ(}`zfs)FsUSR+FxAL1trea{E0_(2hYX%nVbY=z`9#YfG z?>2H%fSi)|tlu1tIEk$S(g@jZ&A04DR$8gbQ=j(+Chfx`YKOj!Agx68K^j(;59*g@ z@RW@YiKk}ipE~u640k@F@Ki>*g{OF}Xxi95lZ;#%TZbY+68(wVOUbmi@$Ng*d1z)y z`wUeYn+?l(+T+sB!@1h%S%3DF#pz&#DB2^(Qny8wW?rAzTC8$p$Ulnhi%cr;q}e7j>&1WKc&m@JzaX~Ngn=AxLV5tD)PMSSD?lUASiEsrbw zl=Z^SPq}6!KR&v^*maAo zW51+{MJz*Qd5ULiGs6CRt6^JYErqXMTyUhn(UhXMj71b?t#okqS%9tenN$25kJgzA zDj!8=#6I6xJe)pYWm#k&g{vIS$ol6B#I;0#6ryrKZ*7+OzUI|Ol6jlMTRq>5k$KR{ zQkL(<<6#q8JDrn+oYcJf-<(LikgAYYg1V4-6DR83SivQ$OtBg>lSWQwdC#oOA!nt4Z@ICNV&Y0O0KWDt2?HGpMMuQIg%ZLQ z7|Ic=v+&Yt9#uRLREw?TbVe*sQ9T5Tbr@U+gaAcF#G@+DW9)K$9kYM)2|pV9;jwk> z5+bjWj~Pca%e?p8_sEwtc6#_hHZ!LFe5v8L#*#iWlg3aNPmaymccL2b#HkUK@Uk5z zC|lFYmB@~$>dvfDaO5)n={hQnqa3x3J3>5goC9D(R(*6D_lA{&0=lCR}-{T_G^{ApB|ah?5ImmYmw-7sY+Ru-%Vj;mZ_<9YNh8lF9kzo z7amD_K?9iC?f73{s$zeX&P5&PovO&*qISnT=^)vWlt(O3SuGKw8;zh_ibv)I;ctJA z&Y_cc#ZLphv?hNwP@L=+DrEsRCX}C-+3-AA^|0Tl z5}jv5k#7x=V65^C2!XG%50(^Y)aAGNV6aFMB*zKHO6n(Hm#PQ8pQJ+aLYm({=vs-f z2$a_PX0t}w{Ds4>g8o6dKt0>As%Z+@=1;8~3evuEt+PKgcj_mH=H8W6!w?>!(`DAV z{kX&{F>T#F^tG}J^JkylG*k-Sei~#Birz>FAZ3l07UuZhH|BL|EXWCk)4_Dw2Q44n z+!c2ag*bta4ywDACk_2+$0wED)S*;QiRhP&eBl5t9lbhZ{97)`m5fAD7&(^msf~D- zOLM`=$fEy%LT7(H&ifphSdub|NBf|5O#mk;LLX3>kbE0=KUVONm z;k-0`@lQPSab%gOJ$0-cWpk1CO(P={*K9Op7atWFVZNEfhMmMxXPpQvKjm6mEC@M( z#M5k7pK^_AT#&ni|EUg;70^#F;r|p}@b0JAxicMwq*Bb|m!zzuz|z{k^oU(%t@0?` z_hWE&7ko5`dFCPlmA2YIS%m4Gewj)A8=I;<4@G%oD(x#~y!Hzqy(T|95E{m3tz3>3~`Z*vX+&v6)N8W8A{?N$3$&eeD%c_+`FR`R?6uYft6X7i)1tX z?bhYLgVDEZjzo+a<8^zV7LQhXbm?Vy7v-Wg#)r>;sT-*~u;Aky#<>B(K zr+l~WDCCqo0(Nquwsy%UH=3IZ5FU!eh#6_lmNt#JJq&y_MO?)2^fdR*!3s|y>tssG zw)k>1FU4g~x1{vFNqm@j?oi^~E+%32!&^nOjC61|cuh!$~nE$C?ZtZ5pTh+kEiy?jgMm7>y$W&eo(5&fGhITuGY$TA7 zLz+uC|BUM~4%tXzpoi_Ex#}?)L8o4iPUlwvKhFLX8p`CG4Gr5gZywgVb<=MS)oga~ zV9oZea%Bt{Q2e%Wd#R`QY2URf$}mxcMcf5QPL%h{VDr#mtcM~es+HaGvz1BD=K<+5 zip0yL?ir}A4ZT+ZrC__Dh({>LWC5j@ikmeat^wK(yP$|;n#rxpvWH#=ZATP|mkbU@ z{rHB}{!iJJ2k2OJal4|FB}=x+ZWzoyqhUm3%QChs(bz|}#u8G`V4mghak9h47topZA%2-E*GzIsNf|-{#XJ(much4m46rUIn_7Ql1Nivd1DHBv`2fAX1-=NRF!?%kZ6y@YN9-r3xrCf1vPy87! zsu#(_MV%Qa9eVZbo1D_KPv90>qSI@H%c5?Gvn36+RDQH>n+(Lpkv4rJ7k zHAt%OoYJ#not_;#4G44wd%bE$g7-Gn3gz^wts)4#S8rg)iLA-YHeNEnh$gEWg=2qY zvY&)Q1Yk^tZvNnD`n)Y@RFqCr@UlD`26h#!`T^ypgiF{%C?~^q*;nE~Tel%>IIIqU zGKb}xLIwK_y~?C234h2Hmoy(brVeKAXM{^wM2LyKc7mBSv`GhgCK4`T5g{htmi3rm zw6Jo|RK`&yWFkN&f~IfN>It_?V3a5lCXs@J)`RDmoINdaWM;fn!YXpGb;*XVe?$uXE2+3e@YRi5)>3GO1hIcaQLZ5+(2!3t1d0X-pcJqXa4=jFN`Mqc|}@i zH&JT~SW|uNb4G3r5^7NZlGy-fIp6FU(~gtOHv-TU>#JwKS1dgfp(F#15Dl&k+KF#T z-hY2#8hjFl5h9Z1K6ka^Huv=3C{85oA_os|{BR4tqfd`joS*_9MPRaf3Q2z|nW=d- zTu}c^n~TENylWd|KEXJWgk$6g3x&VE_N{97-R#n#49!aDMFC9EEb|6j<4L)>jhTdC zgt+{9#=Sb3mUF@iQYnCXA84%Wm3Ja@pdq0bAugO~pa$$bRprPF%b3QBgkc1zn5alF z8F8j_VfUKl8XA=wJ(oxqKX_8QMu+}f%7RDIZ%;% zA}BPH$oH2|c(w=k{UYa7pz8j#Ri8YzcVl*1^ct*y|KOVs6}`IW`^v3+H?d9g&`XoC z5&j$_I6-Vt3EtZTR#=lSv!&gA(VNuFVe{`WD)FCid* zKD;@O`)>MQL!^fk& z(`C9fW6lL;<&C)FgG%3g_~2?&IutWD!cajlNMh`5x-4DA#Apf6NDXjh6W_TOpDyJ< z1t&5ND0hTfv;Mu>+zN@ZY2aErEy{8idvgaTs>nCJPInR?f9^a7D)LURThcE+nPU$< zGK!FlHlkLvA*t`rO#F~Ai~!7}Kx&7-R^-?B-0=p6Z|aiF!#5p*!>$+0*V$h?4EPP# z^Kkrzl8p-f#<-G%ZiEuU#RszGuO0o)Iu24m&<#KmcUm@cAu}8=B2rZ6QV9=LTQ`N1 zQ0p{^v*ShtTE?o<(W}&I%vV)0ts|@vmi>;va1o50X5L21^4U4o`xS_5S*PEHeZ%!hf8R8q-PEdeO+QwlF>f=G3&--A{^K`Qu zA>kc4660yH+uqYg6<_vX0?tW6wv=I1{@f$SsNfF8nr3(be`Sl>yURCO=~}JU^v?&6 zeZXj1LPVX(aMB4J6VXV5nl=j0 zlJMsp?PX*p4Nh1rI z=P+6m4Su?y8bw%78|lxVd*o_jWs63NH@x!ggZ8+@s^#+McdG#tTTu2o8cD?33V4m& zY1h{?8xElyp9l#V>0xl(23hWQdg0yiOk+kuN5ZS`lsxkw-Cp|IVQhqikfZ>)PHNkc zom(*_yM%~@n4GmO`TX(?G!6Wj3ns{_2noxDF##3~o-(miTI^QGmzbm_p(G`!!)Q1} zu`|H_yQ6=ltf`0?L2`wunItGyY;>X!r%;gtqoKNSM%RAlqP{y20?Ndnu~XF*#eZ{O zkA`o<*2%}1Xy#8yLLbHk7&9$<-t4@q8Qn_wNTA!m7Dk7eDpfYl;6(J@t~w${Ha(z^E^mLE83~QAPI06y<>9|uec4eGF!c0mCyoI5*hp+*&4L34k=WHfbNX8wx&=fS` z;wNL7wvA-o5q)$jUqa0oCIU*{Rx`I*+7tSm`KKiZDDqX+L$?CTOVeL@o6;yEVnyDX z0&~hc1mO1pbOY!)LXi|H)^$dibT`dk-*yM#4%$<#GhlDV_Qk;~+(; zRt@7L;c(jJb6+wMKtf9bDGA(L-M;D1Yyu>7Bn5|kZ>T)2#acGx%x8=zNf=2ED%Su$ z`XKKEPE=8KjAjM7m1e-3){FM^Ri6%BxX%~)tZE6-JpK2{s=srXBFFV;2|ZXi zaSVqk@>`FVQ1pc^ZJ3NLnSlfsXqcABr0ivWr-{`#SNTsa%O%#^3x>Q)Lu{mknuH?T zU6&k_rZ%M-h?Fps6db97`&7vmj+T#YY+bQN`p-UsDtMK1x%+Si@-pD1Jx4~+#(1P; z{1J$W-5j=;e{%7UUvRLJo|6O1romcg>aE4w$@nvMAn{WNHqmKfdh`V*k6ygkO$;W! z#AU0%CKftd$=$mU))|LDLEZD;jXVPluWm1!`G z^ye?Bn|pZ4-rav{%(F)dE@q5b!dy~omI$>H7@Vz<6VbJp!3vQQ>Jq@R9Q(Po7BMZ< zNC|f-013sCZL(d?cKn8>+(-#~2|+y`W371iqrJ2%9Vy{20V-|4Osz1ZDz`{7*ToJD zI4^ar#uHD>S&K-W{CAz7N^rtc@ z(?<<>80zSg-+kzIOAXi6?H6Cy1xgbh8MaQbAJ6@;`Gw((dL@J=#|lDvrP7^9_1TYq z#MqXE(1fVu41Md8f0#qaNC}(C!DG6*zjQmEov~L5r73{PX2{S2QQ6(KGAzqDMGqFZ z;nT4Z3+%JXAstitTOs`Vdn@`e+1EJe^TUS4f_Q*iT=n3sgLKk*knV>cE z7st*eGbvZ{iW_R$d1b;5irt%4Uc<>MDVozjX{@a zq?304u_w4>9x1D!u|LH%y|xd$_Z|1`GS78TX_qR`_@3LiZiud^8oeTp#QbL8o zMTgkPz2e%gPL`rf#VH{}1yF%LZLNCOT)!?uUJ?EbkJY;;vB#PRx4NS3*Ye9Jm{LJP zhYHB-Q7RnmQtt%gSN?=3$6TS0M55P#1F!FALZXBMg|gxWIvQtp@6OqS3EvV16o7h; z?%US;nIaslUbtXE%5!W)!48iP;v7}RyxterT644%Iwm3;yBGi2ORz6qi#^WF zjc=c{nMAV}w_5Ht^$f?bsuR`j8}@Wm0Kj%GCO&xCR{-i+aY)G4*6XAwwY=dt`Fw%)004O?6|Z{a@Ub-^0d@SP;jEEg?cFvDFPM ztEzdU#rYLXq?Jr)Qka2Vu{spDpo>RkUCd-J2_s5D!-!G~ao^8lA{f7tkfIQgRGurA z7g@^qm4puE;PFSn8y5ULj!6fS5ltG_{`MSGN8M&>BFUtt0BBlG1lDCK_T!NS+H;E4 z$tGA$PXpkQgg$$j$RZiqgu*%ji?I9u>DIb1hbq{_22deh5hIApv3g|@$g%h{@~j5^ zkB-aL%MJQWt>E4lGOBzDJ1QW#o?7glt>GTb8Hd>@*QVpl35bLqm4>bym^rdtHM~{> zM&}ZiQ~(=pe3ArNYucf6jE6{`i$hfCZ~>-WFs+_gVL0Q>5~379H`!+1#>u$>4@DfCVaqDagu3Hpa8aS)TaOY#W~ZGZF-T>r#E_b=cI1c z)(JD2crh(lltzuW%JO`8zmuORfXmZajjNs;|fr%MoCy$ zRULLyn!oCrE_3TP^APmmnl4Jj#A>20fTa_4H(7#r`p&Gy+CR-lB6L!M9wNh5qRMy z(H^u!h>|d^szMJU(K(`qB%tn>TO~s5sLn-DeEgZKC5QwMgVSsfapI-7XWvr}GT0*i!crQo2cN=uh{8!t5D)TjftXAS^RMN}XuVCm9- zQ#nBe3A<|GCK9!$^&v}&)9XS}lGo{A#EIogS?bpLmiuZ!xeZ`yq!B4&U#)mzGKVSh zPxoDTOU|UnzDl93{wN8*3gv|TrUKMaZ|i~jOWav&MlRJB>EV@4>h3wv0tQbt!^^W7 zBIzqTeNV5g!Nh$Ds|qFMC{>f|mj9b^9|@%jAj$eXb?Lk5?u0BOeo7cs3J$_^ID}@V zOT7Bomf=j;m+-1wWGGDlo7=?qThOQ^r&y7Lf)?-rBg?ApSKPdaQ>@58X~C2C(mCd` zaFlWBJ4guexX1BCjTY-@>mo`*paPZR0lb}$Uj5P=_Z4ZAQMz-4(Z`Kci3yL#k>Bdz?Q!wZm-Y<0b4U zK!oulOv}A$(R&9uOdX$sn3A(0Aq!u(W1f7BcS=Z7RRiNk^w!i~t;2a|E@1++gewKJ zC7HwV9_#w%$vwZ-Wrn8uf}*Wi|~GiWKM(_o7^@DpSWAD_jzj;hZ`a3!IZHW^Wwo!Zenn zj6JTO66ixx0$tc#S!2K|deG@LZ)9d>F-KpJ~G%Ddn1r(czhf9#{?6mZ9*{QG4 z9$l1#AeDyfcF}0{JhJA|PnZBGdAAPG)u1RVjds4+V=t!(Ng72&_rfJD%4_^FZ#q*z zOPEq1tH*KXmZk^dI8d4AA}F)V%kq21)=cw6@_-#kN{<77dOB}z&S)hWRpF@v0TK;H z94dIgH7&z$^-78S)`K9`F1*?|Owy7Nq#PZh`>hVpYPC3ScHWO$6{W zZW_(JcHLW3{z#N$d{i2~>ubzFnpfYSl$|jP$wPJsPu8!<_#HEtXfAol&cVY|VzMLH z`0@;9v~84Rs#E}#%Ms`AJyVM_2U*I6Z)eQm<~s#$(9_o_384xkwT-J*NXIEmB=Dam zrHTTzRb^sU{#Pq8@ztM46##YnetNH(t@bAiuy8{^Fq~HF(Zgw-z3M?2n0jR3?ULE1 z56o6ACSSTn^)hDCS*+-RN2@c^O88T#(6pVkM*L&#%EF9NC6pkcV5ZJ_@;y@g@O_ZCvDaY~egDiuJ5;}mdF?ygdmIsa?IDOQ$XX=Qxv_^}M!;!7Gzuuvc+9q=?}@V301 zR%Q7WF}X<&dj>te)inXbQ}u^?c&f8!1+HhWUKOe*r&{&Zg~s)ZF&-u1MB!TTEd0iA zEz9PLY9v+(D+)jr3m>E{X72;Tzeu;7Y0gV%Q2>j(VW@?$RYMz}t0#Bs#;HMf1cKG^ z9-HDUEgPTWK=n?>6SQrJI;w-Aakdf`y*czUr(0cS`GKmZ)@|7FZ=}1;$*L1UFj&+p zBWs@tsrflswaxm2GToc&g`O$L!3um9^yMHY8RFs4(g|Ltj zSlHLnrEKR^Aahy=mgu$k@~VBA=9A=UyS5==%vFz@F~6>5>S_s13IOe9+o!(_-N~Ve zyp&w?n7{VYFH9p?gZVor*J^sMLyiMXl_Ft6!6(!5uY8s{b2vP~Bsat(TfMmH(~h{G zZ6s(3-$|7w$g~Z|=ABhdByPIPT*;1-FrFM-j(K1H-IvZVQBJ~mazN?M|Cic}SUE*W z6v}9DN4kH``^SDY=i$XJ}#jy$(27mD0Lh9_%5;hZn z^30(8PZu3PFBcf?*r3jt5a`7w_w0xb6pSad;W4M#M&?vLT0&^zLf*;aPoATBG+M%C zQgBWlrTHl`+wHRMR6N7)B_pKLaKRGb^aJmP;V}?(u}1wF24%E_=;Ztf=qQl9(x`8q z`;6a8MoKxLE}2HR{GNI5i%lG)$Zv742V*R)lsactkIOVsM@v{vj+9Q9%0m6CQYgcu zi4GTScBv{))L!x;_uZlt4RC3FDc$Ss)@rF5`9zXmTfpNy+;j~Tzd1Yg0Am7RsKYe@2Y|XQ!?5Jg5@;$zB>Mb{68!}5M zPq0=n&pX)AzNh~BXf|UA67my(d(9>K{P?*1ltdRT;Xpy+vaBler@dw}aaKZm0xNiVLK@} zybnh}XV>hvo*qv}O9)R6C>$POpr(ad`$AoMbGGU0tbxJZArPdfPFwvvB$M0UFzR1j zs(E;;(?o^|`D_z;{O+XpX=658!h3SGfbCgeYB9yj{E#{fTR2)mfCA`1g3{6IwGm(b zjdqIlkP%M&=R;u#+!e(>IWVvJv0jZ8#}Kj;gLBQ7QlESfaCAR~l}rw?F=F%C)6(+#2;O zBdUY})i%J=BcDH`+|}ZYLM03+m>$W|CVq<;@P+&FhLuXlPc9<+kj<9||DH(c9?=r& zQyMNDOhQRnnH_VOqv%h}7{zD_`N_mrBxUX$tz$F(EWqi-*LzdooX*iS`}pweqQ#dn zu|`6K!ndScY%7B8IXnC&vxSKgIIoEcTNubWpmAo%MVtB6j!=G0w1gM+(4W8^Bf~g9 z{KDw6E)UVPLxE!l;4!mTs6eK`ozGe&o4b&Pck6Ww?%fdC*(`izYU~p(|H_cpXl{9w z_bDL(d3z-HcFX1Bb{An*t84ukWgEM5KlC?L5drg(->g7qkVX#swSFc@OZYQ|_wP%Q zn(XyiCyp@Xt$-KhbPX87@HZD9{6)`1q6O5b0Hl42apl$YojDn`4R~oY0O%%ny-}W> zIBO^;qyJ%00Mg!iWSzgNKNBwnd?*JH`^4~`2wsnMs$45VWUf`!Ly}PD+uyV{TM&V}aqaTDJn1noKN0nGO~ao#t>6BXZ^&zwUaEmoUD*V~fd-eA5mN7t_Stny8m$R*%T zY1!3SW5_}b4Kplrr}vo-g@8jv;R%l{Wa)%ZcfV$YMFEw{0ry}OH}5;4EeGqLoCC0Y z1GnKT6UTF!_U~CaupN5!145Ci3Cjbg&Q3uMt~^(iDK!NHs2q4VX6g;mpn{JcMS&ll z$7)1454R39uhuqelp*ry(L533#^w1V&tn@b{^PDnr*gV^-dH>Vw<=9uHpHFZIlm=` zD|K)zVYvg$JFV(;VBAo^uhR0m%stwFc_L@@K{te&+K@UqN{y8o@sZ+V4mM=WLhvSE zKx`82r>tDHmFemTCQ+p!dW?NexBKKYcMOZE1f58NM>_k3LbXq@{bWY?xnG!ejQ?z^ zz_Cf^l+-=}H?*NQtQv!xp#IoR8L1vPZOlg5}_*SasI8 zw#ENqdNYCvRRKI~P}v1+#d>`@Foqx)Qe}YBmQVhB#a>{1S-`&vz>?iS!wlOBG4-H; zdXe5Iw;LzL({mi?x!$;ate`$F*e zL#wNMqpFVMG$D0eKxD_SC*Q4i&@HPBr`50$r}bcJoI8AYA|tbao)yrt>e$oM<-b;r zNMOR4U__P1buaF@!&Gz)zO2W)otf%NK-x0VvC#pAEQMcOwZ>}3qXpcp06fmCqOHu7 zg)gpUqK|;R<-p>(0BJg2t<*cO%c(U&Z@hH-tgeN}M3u)qi5-4-uKG~bgs5s0Tk6`_ z(uJX(fLtDX+BSTJ_?$;MeMn1h)iJg~^N!E6$aNM|W~p1_9z9WQZoo9`Sl44gXd|X( z5%9X46?DJ@LT&n;m(DDfA^0$^Y;Uv}O8YGLNZaMBukI4PAXiG3g zK>Z3xT9uFo>hAl#1r6yj0_K;3^x}T~m{R;0jW#g??w5jfcKH|&xJ~{iTw(u4y>T{YOalS8S@gby<9O_((CY-{$JuX&?ayt!%v+6^epw3z~z}VD}j_X7-_RkX?Q4OeKBhmQtzV@g@gH#R8 zR?{_fy;Uvm(I!-kfbpePEl}HmHp*I>=rXI*c(;Br<<+VPs$aIMTiE`=`-~|FxL+V_ zsB_Z|jt3l3wQ7I+`T1v1t*8f6RLw5%5EWH>FzI0Jj7g`mRZE(j-OAs~3pcvLi7P6~ z)5IlLvT}7?^Tn69F3*-N(W?TlMFU{NIwz-fDU8+gXD#9ujJkqf5*Gkb@6 zm3zIy0gIeC4LHquwMqQkY2XG-x(|~$joa!TejMn7Hvtmox^>xb5J1Y<`0bzCB+hEx zXSbqVhZq4rOc^qBr!4HzC(`bP7&a`Rg#{2vP1kDm1?J6#7=LCMnn9>r(QB0!&RnSp z23#wE`Ln_tFH_@WGc>U^*{kxWs~8^>@WPaocqGf!o{hRj{mUdX!9c7uSoZQ#=BE3< zW(s8iEllC67p%!jU7p-6o&y#7Eq~Ky^YBNxqC>z73rGs5#-!}3d+EYerlc3l#|nT_ z?t0h{wX3=-Wn^3(yFEPB+0|CXRyKDIJ$L^v&$_UNKM9y&O47iEj>ri69pKO%kI!|h zc@tNc^B%dz@v4Uo1hI2vhuUrvKN-%Hbpo!Kk{j9vRvxcf{H?1@og^TMxqw`yob^WJ z5l&3KY(dpPw=wyDShtVyfhb|F#hgef$9L)s9nS<80TImkb^wLoLR1>UIA2Y%*>BRdJbWVW8;!YQ1eeg5}mEu<@tYD zL0iBvGL{$EKG>9J)Ozzy*7ckcgzl;)7ZJ@qIp>259H=%1A0>bjkX)EBZ0l(zun1li zbe1b1r7l~hSA2RRN{PN@1Z;y6;UT3{w(QC@>9deY&dxxC4t?X6dMd^S^>tPkbaIwK z3!PF(gO2F5QB5pCA222LbyXL1VykSU?E0$2mc~hL9yAq{l{UsDwwoxUC2B3KCbb(M(;8tvSEQeu@cyGFF$8l8Y**E`~PdM3p+J%2l?gvDF4{;#OZC7bLDP95I(e_4QT9R0Ah#cAZu%{Ah6w)z?`yYTC9HZPOW(IyUct zL+*aq@K&t=fwywi@RqPXkxagl5w}9sq$zS_Ipxj7EtFFfBbbSWks3DdxOY>@)z)oD z|JwOEWKrwMMOM!i*vKzefBhW}S=2Vx$gqYsa?v-RJ-{K$GHgH_?6{>|=WFJ3Be;W@;JxH2b3T!;;2I^qzj7vrz_H+&u0RWS_QIGBaJ{WhpkONOQwBV%KsEr96g7nVi_ zMigJ~mb{vOrS*ZHjDg2v&=#QDg+l(w;$P5=Zq(30gF~mD9i2D5dG7U%cki5{i7i&f zzY1sp9GE1wzrXCAojP!=jE9A|{9|2D|M*orb&XgV87mEzQF8ZT)2eWKkXGo5jt5!Z zUc4S#-+r9(+hS#0ED+evz_XWiRMRXTjyJLXG^~I#?8=lgtp%j>PvJ+mzDtHTFe|BW#Ywq=Jo!X7vs@!`$`qyuKckC8px-uqK;1i%IA*$*9YLSf` zuCy{o)o{0?8r-P+EMsgkQdU4-dXDk=wm*+>s8R<;X({pV^0_6!E}7$9gl z#`?(J7dcs_2_9v2i*xP7)i3sG%7k3OG_HVi0PmcMU_Ey>e4T^UDJ^&%t=eNWtDXIM zQAs9}hf7^qzj9?M_imeAXE}LwF&$i9WDqe4VtD?#_i2f4T&#axBeb%zMv?mFh6jT}IO?$GuOs zuKxLwO!gHF=mJ3j(RSP$T`v90Nhoq$z@v52^b7-*a)_dm91%&_{(a`?7Th-gxGD`&bzV%YmiC3z~QCmCDH~YJ$0-kZ4qN)ob^A zmcj)vbs@A-FA3RL&e~-rYuEeQwxyh~qAs>0EZ0`4IquLDCeO;)SPm>U*Q^9ntjKw0 zoK38Zi{+p~p~0NQmHaU$Lz#(<6nZY!pv;Ce`(rnb(UZ7X86gYoiml-?Kl*%Y4%F9$ zF<&7l5VD9L+&K97QJ3Rnc(68tpdJk4lkl#B9+YAS?>5KUuc2+>SQ#}7Wu_%p(?tV{ zFlrFY>Ac-1!eY18WW3@6WRypT|b6N_VTkv92W}_qHW0ebeh(N|(mOoJaer+s9 z@n=K^!PG9L3z`}~DcvhS2PjOoG&2rL&fADvEn%(&KnUNCRq25E@|ug|nSkg&p36yQ zI1Tn-1`-fIF0z7aM+hczIm$#)xo&Ov`AMf}D>zn0%Tk0_r+;m`103&3cjvl7fc}9la6{=y&|!IoGHR zC)P32!-*YUbdTh|9lCb%IzC?fQb&dy9V=sRscFf4RNGtPK}IGT_|vxniw3FyucaAi z`rSRxGJY!~a5?gV-;y2Ljo8PkF>5BHaRDqT%8Qpf^9MbIiuI>(IXMXKcnzCiN7xPn zD^%pZT}SgEZ4@OWTR4^*-6TD?RNB6LVc823-M-oS6(_E+c6K^y)B-Xu*}d64dojX6 zjMQf#51SJ*tq69ZQD=tC6)T&=1v*F=gFFynpoY9VCMVBlcjAZScrTO?xq| zJL5zu=o)rU_8N+muXV4cjByyv^5DRodX`aP$UcP0zolMv#yE`Toi8rlvbJGE*RB}L znlnx+BX6mpRoD(BYC< zfrZ>)rJBUXm+~>2P;au4lLKW`)A6NM>tsR13_Hhf#n)Zow6T0 z#N?MaQP(N}3w0t{u^*-n*vn*G4I9*Bu|V+QT@D;RWGS;Pl`*)&pmoJgNSHKc-D$?q zWYjH0)r2T4XB{f}t(&{JvrQRuOM!AN@{NCf!rXj_l@YfPRXzJ@`9%HfBbZ?xvHsjG z+%_O6HiwBZl-cykR(hW*RyI-#QG*nWhl~H)pR)s@7dx!DaGMo(ceV1U2(F}SqGb`j_ctJjqMHZ zpUt;6Tw~S zAq>RHC|i!Ska$Tc=s z7jwMI7_5w?h1z6`j;JMP-*Q>UracMk@Dy$)Rr;FqrgDpkDt3nb`k5npN7(n7fBq*A!&8Zq@v|I}DHrn6 z(PkfTij{gT$u%>#m0ix5ZG_ZkAv3xGOKWw_pO@p&Y%%4UTJ=r00jx?r9UQ%?zAc)EgbVxsO(-IC<>bHQ(uwI^=Sn@nmaQKt9oXrx{1T07V{rr#2eg>3^ zKi%vy8Z-aVb3Izt7c%rvYiF&WjJXA-tE8vV?7`_rrZ8bw#@qr}Xy6la<@^~(_AtvQ zo1f)if}nOod2We6vvH`RUUit)qmsSXwaGwxzj3lDT4|_Eqq=Z~u7f#og-#r3t=mfY zxW=sr4%OF-9UJ!ODA!znsRR?jWV9{tU(x_B@XEW*IY5yEBOoca{_M*R&GYWwVNWDk6iod)tL-;El$SGa>Ry( zql*6Ouk0noiq2>mID4aNcEyCt7QFzQG$%51xiS<`j)GjY;VLULB`EOJW@F2yt1)069i5xgcKPY%MlbGgC%~@ark4g9Imh;#x6bLl6?5udyP*p zK|n^y0(qfvK(+;+SI?A-lU0~wv1?GQeR66syUHFGeryVdD=dcPYV{jZT{4ZPD-checaj3%57UN%I_K_zxOciyw>I7xlu zLBI}R#TflItGMA3wc2=pP8OmjgoMH9Rkl%3A+pY8y6cFSjn4vH%E$VA`-HX}qG)pr zh%{>b`u+7R9HJ-^03xWs+Qb~2(e*P>+}i@y7E>G7gplOL+n7NB6oI;Ql;7nMn8?~mSL%z<-!xX!p9HN6wP-H@n@&h)oOlqdrQ zXIc2^J+pBKz{7cuIG6u-?Wx$f_P%;$a~vqYyHUFADWN5PTTrIsjOk@gl#c1*b^-sJQkOw9<( z+S;P#1ut^8=DV#9xFFyrDod`cIxChX_k8}5VQ%?rTC&u^6?&J{PM!Kf1Xa^ttUu6w z*oc29jmy{&dN{nZ2U1sF(iqdu6<$hNco!Rhh-!?*%Q!;{}L=lPXs z7{<#;T_CT6O81J7eON}#aYhvzMkt%cmEbfCA$!}Kq*>ic^q>vHc-c5E`YvFlug{I) zj6mq%>NPMX91V)>vyv&{WK+06N|rqN*6j**4(jZH0_%i7vlWg*croB zmUZ7B8x@|;=vGGRQu1OFAyFaA_H3s)Skc8L2Ug!?)Cv0R^Yhib7Rz4!xn0;fTiF~k*MznX<9Hf2;Vz(htCJF24c)8#91DiH3a zRU4Ep=!+>?n5WR=Wn?c$T+;r#JZ|u6PEu_pLAQDybgX%$pGo9Ug+A@DvB+|b+t4|R z=}^dKalsV^ru&z#;a9^rNSQwaB;665uJC;#6L)13xKPRz%b(`-D*2n6A`Cy)y7cm6 z@FF+>LSIrhok{!exprqxG9ND^b16v)WT67Z`Z69RBXR*Gip=f{U#~nOJG0M{jo#A0 zfm%T)_2`y$|HbTs*hUfR&*oA|eU;ZJkP!ptwqhK>e*%}vK8_wJnI-(uD(`SgkU6V^ z3XC?A*>`-pGR3tpQwiF{f(3yps!@lJwYbip)mtXCZwVZJ@bK-kcz-gNtKOz7Ta+mq z`eL({?vw2ryX(&F%C+?Db@kr9?=n@1Y!nyRnFYTN$HuQ^n0x4{Dh7K`*qXGxpb#~B}!alKGh zzF(35-#d-D#gbLiRXiID^PfI`)s2#d@9Jcd19@jbxlJm1+Fa;U(U%mNxce;<)O z?oC~NeNQ7MOBhYa;J6+SXZMeME(_Cum2tp84{GOYS4uJegmKN{c&R6QY<#PZew!h& z$IAwCfvg_4n{sd1`wz4KlTpCnIEL9z7Yn^SirM_ihH@dK-NjtIpii{h_DQ3D8JQ8i z7uVm5`bE1arS_Dm;5tBBKrn}8i2?%6X6Hgj6eijP+)5St4(Qvg>7(f~2C-B8bXv^4 zb#LqqqD_DlHL?-Xt_)UJzEG2sQRMszkdy^C-fl_xi6En>KmQnsf`BTD02-C3`Ppgj{zSqR z;EF16z-4(vT^e3m#(|1*xeID*pvoB#eSsp}9jHvHE^%?Uu%l6q)CH7C|K ztDQ0F)+>kWK2tGrv^{nw?(33iqZZOKI6zCC7Gsd-3#1Xq~;%xy0r5L zRMNqwP;&P^ovgo5tMEMf$}D_>)Vc95^h%{Cf79Pu{wKGNQlF*8`ZMBk54xOK(PD?2-As98EZ1oISN*KL;#z>i{s_tJE$~ zeY*>6xU{xrAD4yk$laoFm)h~R7R*y#86d9IvF*UzC1GVDCP~ZaU?3;o%1Ep@caTeKFxO7%)G1&X zE-_WHpe)-6@6#un%T+eCkwXGTZpq%I;%_%O zgOmDsiaI4G+xzvi>U`~PXbmsdDJ8gr#BM-CJOyD}x+$~Lxa*=)^S5{brcTd~*-auNdATDu-W z!o*Ig2Ia;+_ky1e{9`)wYr`p6?9vd3Xz%wx&wcAT1xqtE%_Da%{=St7X)@jyE}2II zsYJ`KPBVE#HqI-63v>y1im);_)aTA4@6)?;uy#@}_8K>{EKkx!#*bxOFc2HtCU|sg zg@-3c<{sp384N$x#t_Vp;n76!VzOtdmiZWcS}3lPj0T3H^0&q&P8zk0(SU5eR{$2{ zj-`QT8jcMmjX#jq*O3Dm8Jc|%-m!uO`b@`;7JAP^`6AqE$VeSBJ{Sm%=t$Ec2i;W~ zOxqF)wMvDD>lJ@GSRh6$ZeDlKfflQiYDdN#Zaj2#pNMzsb-Qx&?RxJ-Tt9r}W`=s@ zzOX3gS&JPT%y_tL`d3x1x%7O~^W&J}B1)9D0nzR)%{uzTZcai`ng%>tb6#6Ddpd_G za%My%={W!J(GR$97NuiAvw^c!7>!#I*FI*{2~C> zvDPE2I~u^o8uz}zp2QZDTnjKFjO^t_M_xR|A`7y)rJgM0!utL7kCt?^n29R%Q&cVFGAnc!yVzdcsz+cGROqS*N(V|7 z>$flMQA@*Lb;$GeSGcck3A%Jk%{LiGknz5pl~R}XE!ewlS}kV`OUC_jV4VbJ;eOU3 zeF9T}$*5lrZemEAL>Z?zNn*|AP~A&5f+ZDja8= zEk?)jps_)9gK4r!{%y^D=6E1RTbmCmjA^tMZ{6(^r8r1m|8=yB5B1o7)_%bE9hnkI zHqNVR8d;6jUa!5laVQfNWSlPq=5~_3eow0BN^3Z<{{G+&3~8(^o{tc-ec|ugf4c`` zMzoPpzN#vI8X?%OUzLwOo&k@22y-rS-oU8JS|*Tx*v01i_dCtVWaOiwN=FCkt*{dqEP^ySD6%{QEs!uMt0`MhsEZvBK= zmN|}!0N&a_NP_DlyQz)Ulyd7YTzLpQI{Ij;c*PmD|fBOm{2C8 zfH|t7@n~bred%2nXgJ!EaED`urp&4Lr~RvMX|h}gzY4EZb4e1 z6Wc}Oim@wOF@Z)#`Kk(sJ{%En!=7iha-hPJ8Q*TARoJ_k6Iybh!ipJ>U})@GwRKbt zCWXo9Uhw%O7;c<(We&IMLO;cdiMzR({CM0vH#3^Xq+KegF(Ir@!I5!(}uu7v4F5u=i4D=I6^zO)XsZ7$ZQFco_ZY!qu*ZO!-JYI=s2)eZHei9SL3b+=}CqIKO7X$iLIb;L^T58tb1~WXbaM{o=_;T#twq**0KhC$_!o)+_+^+yG*H(I@e?EF|8=mx(rF7(j z!tS4JLk@(_i)F&0Z15LIYdl}1m+Z6X+ymStGkjL>8aB zAmewrveKw^I!hrg(a3mR2%;$ui1i)EJ&1qi{Kh z*jQrrjJHNLY0ucKjKmc{=IX`ix6l8{;mRs-r33IWS|4TVSnEelx4!unD^Qe|lm(Z2 zJozYXQiaPNVssGEzwj^~x(Kes+9h_kJewVD7qwxoov-%>qL_NKn!X>|xll7Md&%Bp z42VrTG<~-=9N_jQ4FA;?ornKoCWL(hXqWF`pSdu15>qwHm|Fp9T_OeZTGpJ?$EGn! zS4QCqz*F8*!sdCynW*DW<8p0HZTLy&y-A&g;f!neGq?hS z_#d59z8R$@gv(}kfpYB~f9F<7Be}(rx-if4oL>L&r?|zEwXl&r3VRXIu(cm+(){xe znZi~^*}{*qCX1HTx8x`eQI{dXYH&a#Nutg-uij*Q zRz}rA8DX!huLkJka6fy(Gl*-IxI(7Znr66vJeXGEYTN>AYN%ncR?_h&WCfCr!p%y! z6x&Ah$wm*N!iB6XM-6F17&$ielaDMN!s%J;#ZH@ar-=wihng!leM`K7hTAtY5wVG8fr!V_iP^xUqZriCA*p>-#3V8Q$<@A$u#x zo#5nZ`A@ll#{`ybd;^zkX>uu@<4*ig?cuptWvt1F%0A;ROD?WLU~I&j+6 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 Ds+h#fUI);RNv~g(sLEdsdF{A+> zDR}Tv*C0in)C*CoZWJ8y@!G=rJLR|h>}N>G$NkMK?UY|slBGLUX<)`l@oK|8n#z|^ z-5Jt=kA$qAerN&tB}|7I67tciZSj;(mjCN?eP8D2LBSy(e=f7JmKUO~3<>!-Wo4)F zYL)u^F`AIjP};uTR$FOOtuSbs82pD*JenAr1IQ zJ+!M_<8|`&qh&7&4*8g2-jT0zTLv&BUT_om=b6D@06 z{-b=mZ4^U7K6=bqb3>k<>kJ9`_^@}kHu6E;p$`Rzd>m{Mo${EJv_A$B63Tt^Y-nbA zO@GCR(0TRC?>-OZHQlwZmK%G2j>lCWcX>?@W=P1#*mrix^2-@NFeKz-$NkfMWgk8I zQEoE$W^XpNXW+lBQCv@w~6lz3Hj(cEOW~LRocwj_NU-bUzVz1=PR$kp$uuj zN7^U8R2}4@1Xr;7ttayUsuJ?iqxfd+2&~^9dlS+?k+e;OykA*a&K=H(kdH_G($|!q z@hUV>%Z=pFL4xYJ+?4*8flPmzK0{hSpH3AK99 z`!nt2gTXI`gnYEwGABTOUq`bcT5yP%RI^cYdFNThh>(xb4~Bn`C;T%*Lg&@=dmC<( ztMnX7xefS83(@6O)1S!)gAEJ``M7dj11IGlQ2z9a|6oYS$DRu(<&$q~cnqW9kdIya zHs~a;ZA%#v^3iMGXLC9DONNAeyw|?wIJt>x4yWLdkFLL#M9auU3<=ru?CANF-(8j7 z5AaGuVmCwE9!+m07wJ4g&FyFp`S>h*4G$T)m?0q_hi$E}Prg8T&5)3fhjPw;EblxX zBPlrKW9Rg*_RGPyFeK#T3#;ih{#4yzM9o4*A&2VZ{mA$8Cg!I=xHQ&8Ot6iJy!J`51ZL z%v_$GcB8f2*!y#eT=X~bw(8vs3Hdm)aKv17DD@MbVGLCX`Dk#YS#)x7c_GT1a##GncfC70Kt9GeKk<=~eHjw+@m}Uz39^sT3<>$T zZ$Oi&GBWoB3J&?$CwqlUa`5g93HfMgJ}r~H^+Yfv;oBDU?Sy)e4Np2e2A=ge};s{azoQ`yX5Bq zPB0|oV~OEImdI6FPNLwDkHze=n?U+AB;@0@Y9&j`(-Y5-kdKY_oOGA_(kA5_hyPpK zsz5$YPx~QWMg}k>UW;W3<>!- zJ*d}t8JWP4kdLo_e+!n8Hd84$$@H+VrQ85z%zkdIA^bhDF@w$mv%@T^WJqYnix-Yc`A&>f<#UFFd_3OZddh7z30ZR% z1&4fGdh&QRdCQ&0kdTjGH#~SHBOfs&ldw@^RP@zvG!w#8LkA@~mV?13r@C)0$Wg zkf-N0Lqa~fzf3amL+!2$C^+QfabK5B@2Ob~|j4<$2GD(EfNQx`V$wlnoYXxv}SS zs+!e1Aj`9yAr1IQv$K3kpG?ZkC|LdMyk|(rNAuE_(ehZr*t5$)`H;1dA)!`(_pen+OYuvFRkmGD!66^BEHrB^BX=<*bvp=IU5a_%DxX~0KXfCs&-{O@^y)Dxb61?4v2BO!Y&TYX0Ep#cmD`IsxRb0>9n z^xMQqhJ<`9k?GSB`K(bOgn~mpKCe{ph+JiFhBV+Kt!-}i7oL}^Jj{@gk9XQX-6vO> zbtMIddgv>&Gxc8t8Ny%I;<>F3F#Fq+g}w#@?Uv=(fXH zS@BK`2~~MC}*LkdGJa(p6KCsn1y1R#R}u#|}lBjhCzJ#*mPYk@b!xs1vSN zJe(mRAI+K#-6GF;_B9k7^07t0zy7G9_2 z#-7iqRnhFBj2z66Q1DtsejSs0=rlt@KK5zR(@S263a+Q%27II*vN}0eqCChJ<|FH@~Khya2~BB;@10H9vC6J!Bh7!43FG zV`-Lt#VmO&Co&{7Jrif0KP)2?84~ibMTy|*GP2?}3J&?Wwdc88vf|Si(twXNmc6I= zCd->yB10PRk&q6Ha}SoQEVG@0Lq3M2eQcp#lIqW^V+aY&j&p05nR4!nj0o+InV&uG zE$1$}L(7dlpR=)Xk-f6w0~r$X(R;+G&vILyU`WWvh{I2va7a&{Sck|7}<&yK7x zS4HZ5EVNq-4h?0XQ(6=EAOlyKLt17 zBOQq9e|9S)2cOQ6kdFlmUKk@k@^hCVAs;i14-S;SmRtS+1&4e*eQBMKdTi4#L=zbj z>dRO2@19XRU5~uVkOq9D>B*OQ*+Y3DvOP$_As@HbU-L_?QolcrAtY4fwdN5)au3BY zqJjO9)}bL&p0<*=39Ca|ZtVG-!Ue~lmM`|kFeK#Tm;o8X2L}T`563nq??Q!#gLGXb#ASSlxO@BLqa~fj_P(yR@^dzfWu4s zyssgRyeyUES=78xgnaYG;i#IsD)#=Ivwp=!%D0H7G9=_<&y&r4D*YG|^6}RG+fC%n>>NWvKK?2_WT}iSd5nTXJ}zwd@U)EdV@Sxy zJ=I$ml=q1khJ<{4W?Rj~$HUggDLCX~q2c+ysxz+laXcZRPLHdx)x_tnv5W}qk6UdW zbIG$~b3)6Fy+3Dh$1{awseq z4COWuoRF7B+xsaKo*FrdAt4_(1m3MGkL4wXgnaBXu-*st0!1IZ^jQiH`8fQ`_@Q!@ z;~5h2(P2&PI`WKPWk|@!i=%09*u66ztZ zvq>Z5oyRI=t^e=JtSa{VRwMSBjgygM84~ibrPX#5U+B5QkOq9DgL*{|yC?F5+g_mH z&{#fQbLq1@;o}(+^3iP3@%M6-*BBD=F=;^Tce%>47b!U8<65g8k7dOtGbH3=pwGvC za+Nn267q3Vi-2=-U)o=y;E<2GvK?6>pI2uP5}NRfjn?_fH`H%1BD6n#tXas!fv8N3 zmfO*Qk0ejQgoh?pOMixhe4HAXak6~IiepH~$N1O}_vG6ewy_i(njWV-wKvEz$#O@@SgygT-8Te-@zaTFZ#v8LOt7qX853~9heIuQ+M8L>xMH59D=tdYo& zkdK9SKH4Ymj}#74767n&qRM$3#LxLwRD{N=tbY zFPos{#%|e0_IEV#e9k0>gnV>c+HHuMTi@x43<>!-zRlcOau1ceM!_K;YfqfeOGZv& zNXSR`y6aBKyLci)LO#BXf1FPC(f&FGhnlFxwae+{DyK0dx>BPk3W-+j+Z}4u)U$> z#(v*w)Rx*O5Lwz|g;-`tni$^mgwUDotp$gQ>=tZo;^oDo7!mUE*BUPqrkK7uej}93J&?`I$}zH`K&RPAt4{v zJ>7p-9?Lj}gnVq>p@)fA)>+@9;09WqR^S}oYXg-YZZ~l+6^N!2uedBm` zR%TftB-u?3du1h2LX^FUWMpKON)%ZkR95!pYiDPd6{09)ugVPlp5yy{&UKyNbDh`g zzW(SB-#^~p>vP}N`@ZjUp7WgN()rig8CUvv8IS@*D6)CI%n}k&w@BkBa&8Bfj}EQA zsJ!;j7a>_b+FR#OrMHQ52+8uX!{9#-^p#narx2XwW6}7J`{-4}7a>_bIwo~6rGsBb zNS=>#w|%AW;MK{1;4B|!FMBhR_HhzIvV1Jqt(eM7(JmvTfRC^OTLf0FNLN`U6M_ra z1ITe*m!{G_PLPqjhrf%Z6;-+Uavl){d<4ZmjCO27D_-T9Hn*Jx%g3RC+rH96>4T6g zA15?frSd|-3kWITBLqLcdE5@EO5L^1@Hqr$`B-P(@gcO2V-b?&W29?ED{T)cx7>3G z$@1|=$kaA8veF9(&hpWJ+^}4F#>XKf%g66e?GkC^IfP{Sm|kILjQ04V+#f4v$-!Bj z-l1QueERe<1`!2(ghgX}p3PJ`_i2P=Rr&Q?$Xxn{LB*Glo8_Zk*2s9e%JB#(;3EWI zBa$9fuB z?llBw`Dj|JqrhUomZ4DyJt9Az3~iNO9>%BOf3n%g2(lX2;OW zW#jh{oaN)Gv@?CRRVsa)2S`>A_1S6so-XnpBC>oOKf9pjgJtU19O{3Nb6X4e2s=;o ze$QBKZsml}LP(a62W%s{(HDES5Rx^PjXU03OD{x?K0ZEtw-tOOF*(_=hnJqz3De$IDCDm0q0Sl~5t23IO>4Xjrq3GfzCmySAL00Ne`m8~`sd`M5R&DiUGt9l^g{F%Az41= zUt4BFH&LhW5S-;>c2`Fu?N};(i~%HTCC`UFCO# zWHpghyE-bLwD-t^;4B|o*J*H>KCf;;NS2SSo^KyZ9|eCPB+JK{XTG^>mrJFOJ$}i- zS-G1<7cEW~8Hb20AAgx;J86qlo?gBoB+JJV8&963ee9}vKH}eRq1f56d>oP7P;-`| zcAjX2WcgU~@bOJF@&iJ$eDs)-ev=N~_74PS`RKLfp{D();L8w_<>Pt%lXvK~?FB*# z^d%gDpN_fgD6JY2R@p=?^C39P$8GlAo#^xG3WQ|&xT&W@JiR}@2PCV=U%l6ls=r0KJ!qn z={<`;aF&m~FIJsMFGRZ$lI7!uZk9vn=_yhas$}`NY(~>#)ij}{KV@)lgkeWj?aF&n1UTs@R%QFEX1$>0%a`nk2Ins}+BAz3~aemZIx zjclX2RQ>ld%HE3QW8nt}Dr&b0WfMgqB+JJkW_`oxyH0NrlI7!G->1{0#+Uw-RkkV* z!C5{Iil4nw8(it*5;822{iS{jbxlSw60uT{bEcQe zEQDnFIAUcFEBgAewIKv&`FJL~(s6C4E2k$8Az40JdG38hZ#`cSlI7#XfipkQ`(sxl zIXG*=t6Wb!K~H!zBC>q!{Cl!D{poNvLbCQptB;9|w7HeD)3XxfX8Ab#ShX!uaNVnk zO$f>Iu~zFimG@cwL`c^33|Qw?fWDE{t1<*<`B?sK(>(fcxep;(J`N1?m_<)dxhha4 z%ST_|W{v1m^-zQq@DWzv+eLRylxAG_((D*QvV62W8DOeiHI(~f*{X7I*6ie88Er^E z13eTGSw05%8#bnU=nO)#d~`6`nm{kWHL5{w0UzO@9^a{PJVJON0{-Sm4B*yg=-x`vV7cc(L}S-N)04^o-1uadU^#kf1BrJ1ClkAEeD3W)44m= zkaP3ipOgI6>;vs%G(xg`3~e>TnEtTv2ST!Z9G1U%GQFm|)r8FSemZ^j&qGL-kFE4K%0Diy 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 Up&W-ChrIlEp7`hghlL9LA9!SSMgRZ+ diff --git a/testdata/examples.txt b/testdata/examples.txt index 9c18442e4..e4f6d36c8 100644 --- a/testdata/examples.txt +++ b/testdata/examples.txt @@ -2041,7 +2041,6 @@ 0.5 < 1 || ok 0.5 < f32 && ok 0.5 < f32 || ok -0.5 <= 0.5 ? half : trimPrefix(nil) 0.5 <= f64 ? i : i64 0.5 <= f64 || ok 0.5 == 1 and ok @@ -3144,7 +3143,6 @@ all(reduce(array, array), # > #) all(reduce(array, list), ok) all(true ? list : false, not true) any(["bar"], # not endsWith #) -any([foo], # != i64) any([greet], ok) any(array, !(i32 <= #)) any(array, "foo" >= "foo") @@ -6261,7 +6259,6 @@ findLast(map(list, #), greet == nil) findLast(map(list, #), ok) findLast(map(list, ok), # ? # : #) findLastIndex(1 .. 1, i64 < #) -findLastIndex([false], 0.5 == #) findLastIndex([i64, half], ok) findLastIndex(array, "bar" not matches "foo") findLastIndex(array, "bar" startsWith "foo") @@ -7231,7 +7228,6 @@ get(false ? f64 : 1, ok) get(false ? f64 : score, add) get(false ? false : f32, i) get(false ? i32 : list, i64) -get(false ? i64 : foo, Bar) get(false ? i64 : true, f64) get(false ? score : ok, trimSuffix("bar", "bar")) get(filter(list, true), i) @@ -7370,27 +7366,19 @@ get(map(list, i32), i64) get(map(list, i64), i64) get(ok ? "bar" : false, array) get(ok ? 1 : "bar", f32) -get(ok ? 1 : add, String) get(ok ? add : f32, array) -get(ok ? array : i, Bar) -get(ok ? f32 : list, get(half, nil)) get(ok ? f64 : div, i64) -get(ok ? f64 : list, half in Bar)?.array() get(ok ? false : list, f32 > i) get(ok ? foo : 0.5, div) -get(ok ? greet : "bar", get(add, String)) get(ok ? half : i32, i) get(ok ? half : ok, f64) get(ok ? i : 0.5, half) -get(ok ? i : half, String) get(ok ? i32 : half, f64) get(ok ? i64 : foo, f32) get(ok ? list : "foo", add) get(ok ? list : i32, f32) get(ok ? ok : div, greet) -get(ok ? score : 1, Qux?.i) get(ok ? score : f64, i) -get(ok ? score : foo, String?.foo()) get(ok ? score : i64, foo) get(reduce(list, array), i32) get(sort(array), i32) @@ -7398,19 +7386,14 @@ get(take(list, i), i64) get(true ? "bar" : ok, score(i)) get(true ? "foo" : half, list) get(true ? 0.5 : i32, array) -get(true ? 1 : array, Bar)?.f64 get(true ? f32 : 0.5, ok) get(true ? false : foo, i64 > 0.5) -get(true ? greet : false, Bar) get(true ? greet : i32, score) -get(true ? half : 0.5, Qux) get(true ? half : f32, greet) get(true ? half : list, add) get(true ? i64 : greet, i32) get(true ? score : true, half)?.half -get(true ? true : add, Qux) get(true ? true : i, f64) -get({"bar": true, "foo": greet}.i, String) get({"foo": foo, "bar": false}, type(i)) greet greet != add @@ -12465,7 +12448,6 @@ map(1 .. i64, # ^ #) map(1 .. i64, #) map(1 .. i64, half) map(1 .. i64, i32) -map([1], get(#, 1)) map([f64], half) map([false], ok) map([half], #) @@ -12475,7 +12457,6 @@ map([i32], foo) map([i32], greet) map([i32], half) map([list, 1, foo], i32) -map([nil], #?.f32(ok, #, false)) map([nil], foo) map([score, "bar"], f32) map([true, i32, 1], #) @@ -14870,7 +14851,6 @@ ok ? array : foo ok ? array : foo.String ok ? array : foo?.String ok ? array : greet -ok ? array : greet(nil) ok ? array : i ok ? array : i32 ok ? array : list @@ -14890,7 +14870,6 @@ ok ? div : ok ok ? div : score ok ? f32 != i32 : f32 ok ? f32 ** i64 : score -ok ? f32 : "foo" endsWith lower(nil) ok ? f32 : -0.5 ok ? f32 : add ok ? f32 : array @@ -15104,7 +15083,6 @@ ok or f64 <= 1 ok or false ? ok : 1 ok or false and false ok or foo != foo -ok or fromJSON(nil)?.ok ok or half != add ok or half == div ok or i < 1 @@ -15340,29 +15318,15 @@ reduce(1 .. i64, greet) reduce(1 .. i64, half) reduce(["foo"], f32) reduce([0.5], f64) -reduce([1], .Qux) reduce([div, "foo"], i32) -reduce([div], # >= 0.5) -reduce([div], list == #) reduce([f32, f64], f32) -reduce([f32], .f64) -reduce([f64], # or #) -reduce([f64], .greet) -reduce([false], # ** #) reduce([foo], ok) -reduce([greet], # % 1) reduce([i32], list) reduce([i64, half], "bar" not startsWith "foo") reduce([i], # < #) -reduce([i], #[array]) reduce([i], ok) -reduce([list], # - #) -reduce([list], # or #) reduce([list], f64) reduce([nil], # in array) -reduce([ok], #?.half) -reduce([true], #?.score()) -reduce([true], 0.5 > #) reduce(array, !false) reduce(array, "foo" endsWith "foo") reduce(array, "foo") not in foo From efa006a99a374f5240196daf74cecf5973f80528 Mon Sep 17 00:00:00 2001 From: Anton Medvedev Date: Sat, 1 Jun 2024 14:57:15 +0200 Subject: [PATCH 008/113] Remove Node.Kind() method --- ast/node.go | 10 ---------- compiler/compiler.go | 4 ++-- 2 files changed, 2 insertions(+), 12 deletions(-) diff --git a/ast/node.go b/ast/node.go index 191ab1886..dfdf715fc 100644 --- a/ast/node.go +++ b/ast/node.go @@ -17,7 +17,6 @@ type Node interface { SetLocation(file.Location) Nature() nature.Nature SetNature(nature.Nature) - Kind() reflect.Kind Type() reflect.Type SetType(reflect.Type) String() string @@ -57,15 +56,6 @@ func (n *base) SetNature(nature nature.Nature) { n.nature = nature } -// Kind returns the kind of the node. -// If the type is nil (meaning unknown) then it returns reflect.Interface. -func (n *base) Kind() reflect.Kind { - if n.nature.Type == nil { - return reflect.Interface - } - return n.nature.Type.Kind() -} - // Type returns the type of the node. func (n *base) Type() reflect.Type { if n.nature.Type == nil { diff --git a/compiler/compiler.go b/compiler/compiler.go index b4ec6dbd4..5e993540d 100644 --- a/compiler/compiler.go +++ b/compiler/compiler.go @@ -377,7 +377,7 @@ func (c *compiler) IntegerNode(node *ast.IntegerNode) { } func (c *compiler) FloatNode(node *ast.FloatNode) { - switch node.Kind() { + switch node.Type().Kind() { case reflect.Float32: c.emitPush(float32(node.Value)) case reflect.Float64: @@ -1199,7 +1199,7 @@ func (c *compiler) PairNode(node *ast.PairNode) { } func (c *compiler) derefInNeeded(node ast.Node) { - switch node.Kind() { + switch node.Type().Kind() { case reflect.Ptr, reflect.Interface: c.emit(OpDeref) } From a31b1fefd615fdad63555dbe0f7a63445bdb178e Mon Sep 17 00:00:00 2001 From: Anton Medvedev Date: Tue, 4 Jun 2024 00:08:01 +0200 Subject: [PATCH 009/113] Refactor types table (#667) --- ast/node.go | 4 +- ast/print.go | 2 +- ast/visitor.go | 2 +- checker/checker.go | 186 +++++++++++++---------------- checker/checker_test.go | 61 ++++++---- checker/info.go | 22 ++-- checker/nature/nature.go | 133 +++++++++++++++++---- checker/nature/of.go | 47 ++++++++ checker/nature/types.go | 13 -- checker/nature/utils.go | 76 ++++++++++++ checker/types.go | 46 ++----- compiler/compiler.go | 40 ++++--- conf/config.go | 58 ++++----- conf/types_table.go | 121 ------------------- docgen/docgen.go | 13 +- docgen/docgen_test.go | 16 ++- expr.go | 2 +- expr_test.go | 40 ++++++- optimizer/filter_map.go | 4 +- optimizer/fold.go | 4 +- optimizer/optimizer_test.go | 20 ++-- optimizer/predicate_combination.go | 10 +- optimizer/sum_map_test.go | 2 +- parser/parser.go | 48 ++++---- parser/parser_test.go | 14 +-- patcher/operator_override.go | 9 +- types/types.go | 5 + 27 files changed, 544 insertions(+), 454 deletions(-) create mode 100644 checker/nature/of.go delete mode 100644 checker/nature/types.go create mode 100644 checker/nature/utils.go delete mode 100644 conf/types_table.go create mode 100644 types/types.go diff --git a/ast/node.go b/ast/node.go index dfdf715fc..6d98090b8 100644 --- a/ast/node.go +++ b/ast/node.go @@ -183,13 +183,13 @@ type BuiltinNode struct { Map Node // Used by optimizer to fold filter() and map() builtins. } -// ClosureNode represents a predicate. +// PredicateNode represents a predicate. // Example: // // filter(foo, .bar == 1) // // The predicate is ".bar == 1". -type ClosureNode struct { +type PredicateNode struct { base Node Node // Node of the predicate body. } diff --git a/ast/print.go b/ast/print.go index 6a7d698a9..f59377153 100644 --- a/ast/print.go +++ b/ast/print.go @@ -162,7 +162,7 @@ func (n *BuiltinNode) String() string { return fmt.Sprintf("%s(%s)", n.Name, strings.Join(arguments, ", ")) } -func (n *ClosureNode) String() string { +func (n *PredicateNode) String() string { return n.Node.String() } diff --git a/ast/visitor.go b/ast/visitor.go index 90bc9f1d0..03d72d11d 100644 --- a/ast/visitor.go +++ b/ast/visitor.go @@ -45,7 +45,7 @@ func Walk(node *Node, v Visitor) { for i := range n.Arguments { Walk(&n.Arguments[i], v) } - case *ClosureNode: + case *PredicateNode: Walk(&n.Node, v) case *PointerNode: case *VariableDeclaratorNode: diff --git a/checker/checker.go b/checker/checker.go index fae8f5a16..0ad22f4e1 100644 --- a/checker/checker.go +++ b/checker/checker.go @@ -152,8 +152,8 @@ func (v *checker) visit(node ast.Node) Nature { nt = v.CallNode(n) case *ast.BuiltinNode: nt = v.BuiltinNode(n) - case *ast.ClosureNode: - nt = v.ClosureNode(n) + case *ast.PredicateNode: + nt = v.PredicateNode(n) case *ast.PointerNode: nt = v.PointerNode(n) case *ast.VariableDeclaratorNode: @@ -194,19 +194,14 @@ func (v *checker) IdentifierNode(node *ast.IdentifierNode) Nature { if node.Value == "$env" { return unknown } - return v.ident(node, node.Value, true, true) + + return v.ident(node, node.Value, v.config.Env.Strict, true) } // ident method returns type of environment variable, builtin or function. func (v *checker) ident(node ast.Node, name string, strict, builtins bool) Nature { - if t, ok := v.config.Types[name]; ok { - if t.Ambiguous { - return v.error(node, "ambiguous identifier %v", name) - } - if t.Type == nil { - return nilNature - } - return Nature{Type: t.Type, Method: t.Method} + if nt, ok := v.config.Env.Get(name); ok { + return nt } if builtins { if fn, ok := v.config.Functions[name]; ok { @@ -219,9 +214,6 @@ func (v *checker) ident(node ast.Node, name string, strict, builtins bool) Natur if v.config.Strict && strict { return v.error(node, "unknown name %v", name) } - if v.config.DefaultType != nil { - return Nature{Type: v.config.DefaultType} - } return unknown } @@ -419,16 +411,10 @@ func (v *checker) BinaryNode(node *ast.BinaryNode) Nature { case "..": if isInteger(l) && isInteger(r) { - return Nature{ - Type: arrayType, - SubType: Array{Of: integerNature}, - } + return arrayOf(integerNature) } if or(l, r, isInteger) { - return Nature{ - Type: arrayType, - SubType: Array{Of: integerNature}, - } + return arrayOf(integerNature) } case "??": @@ -501,6 +487,13 @@ func (v *checker) MemberNode(node *ast.MemberNode) Nature { if !prop.AssignableTo(base.Key()) && !isUnknown(prop) { return v.error(node.Property, "cannot use %v to get an element from %v", prop, base) } + if prop, ok := node.Property.(*ast.StringNode); ok { + if field, ok := base.Fields[prop.Value]; ok { + return field + } else if base.Strict { + return v.error(node.Property, "unknown field %v", prop.Value) + } + } return base.Elem() case reflect.Array, reflect.Slice: @@ -512,7 +505,7 @@ func (v *checker) MemberNode(node *ast.MemberNode) Nature { case reflect.Struct: if name, ok := node.Property.(*ast.StringNode); ok { propertyName := name.Value - if field, ok := fetchField(base, propertyName); ok { + if field, ok := base.FieldByName(propertyName); ok { return Nature{Type: field.Type} } if node.Method { @@ -625,15 +618,15 @@ func (v *checker) BuiltinNode(node *ast.BuiltinNode) Nature { } v.begin(collection) - closure := v.visit(node.Arguments[1]) + predicate := v.visit(node.Arguments[1]) v.end() - if isFunc(closure) && - closure.NumOut() == 1 && - closure.NumIn() == 1 && isUnknown(closure.In(0)) { + if isFunc(predicate) && + predicate.NumOut() == 1 && + predicate.NumIn() == 1 && isUnknown(predicate.In(0)) { - if !isBool(closure.Out(0)) && !isUnknown(closure.Out(0)) { - return v.error(node.Arguments[1], "predicate should return boolean (got %v)", closure.Out(0).String()) + if !isBool(predicate.Out(0)) && !isUnknown(predicate.Out(0)) { + return v.error(node.Arguments[1], "predicate should return boolean (got %v)", predicate.Out(0).String()) } return boolNature } @@ -646,23 +639,20 @@ func (v *checker) BuiltinNode(node *ast.BuiltinNode) Nature { } v.begin(collection) - closure := v.visit(node.Arguments[1]) + predicate := v.visit(node.Arguments[1]) v.end() - if isFunc(closure) && - closure.NumOut() == 1 && - closure.NumIn() == 1 && isUnknown(closure.In(0)) { + if isFunc(predicate) && + predicate.NumOut() == 1 && + predicate.NumIn() == 1 && isUnknown(predicate.In(0)) { - if !isBool(closure.Out(0)) && !isUnknown(closure.Out(0)) { - return v.error(node.Arguments[1], "predicate should return boolean (got %v)", closure.Out(0).String()) + if !isBool(predicate.Out(0)) && !isUnknown(predicate.Out(0)) { + return v.error(node.Arguments[1], "predicate should return boolean (got %v)", predicate.Out(0).String()) } if isUnknown(collection) { return arrayNature } - return Nature{ - Type: arrayType, - SubType: Array{Of: collection.Elem()}, - } + return arrayOf(collection.Elem()) } return v.error(node.Arguments[1], "predicate should has one input and one output param") @@ -673,17 +663,14 @@ func (v *checker) BuiltinNode(node *ast.BuiltinNode) Nature { } v.begin(collection, scopeVar{"index", integerNature}) - closure := v.visit(node.Arguments[1]) + predicate := v.visit(node.Arguments[1]) v.end() - if isFunc(closure) && - closure.NumOut() == 1 && - closure.NumIn() == 1 && isUnknown(closure.In(0)) { + if isFunc(predicate) && + predicate.NumOut() == 1 && + predicate.NumIn() == 1 && isUnknown(predicate.In(0)) { - return Nature{ - Type: arrayType, - SubType: Array{Of: closure.Out(0)}, - } + return arrayOf(*predicate.PredicateOut) } return v.error(node.Arguments[1], "predicate should has one input and one output param") @@ -698,14 +685,14 @@ func (v *checker) BuiltinNode(node *ast.BuiltinNode) Nature { } v.begin(collection) - closure := v.visit(node.Arguments[1]) + predicate := v.visit(node.Arguments[1]) v.end() - if isFunc(closure) && - closure.NumOut() == 1 && - closure.NumIn() == 1 && isUnknown(closure.In(0)) { - if !isBool(closure.Out(0)) && !isUnknown(closure.Out(0)) { - return v.error(node.Arguments[1], "predicate should return boolean (got %v)", closure.Out(0).String()) + if isFunc(predicate) && + predicate.NumOut() == 1 && + predicate.NumIn() == 1 && isUnknown(predicate.In(0)) { + if !isBool(predicate.Out(0)) && !isUnknown(predicate.Out(0)) { + return v.error(node.Arguments[1], "predicate should return boolean (got %v)", predicate.Out(0).String()) } return integerNature @@ -720,13 +707,13 @@ func (v *checker) BuiltinNode(node *ast.BuiltinNode) Nature { if len(node.Arguments) == 2 { v.begin(collection) - closure := v.visit(node.Arguments[1]) + predicate := v.visit(node.Arguments[1]) v.end() - if isFunc(closure) && - closure.NumOut() == 1 && - closure.NumIn() == 1 && isUnknown(closure.In(0)) { - return closure.Out(0) + if isFunc(predicate) && + predicate.NumOut() == 1 && + predicate.NumIn() == 1 && isUnknown(predicate.In(0)) { + return predicate.Out(0) } } else { if isUnknown(collection) { @@ -742,15 +729,15 @@ func (v *checker) BuiltinNode(node *ast.BuiltinNode) Nature { } v.begin(collection) - closure := v.visit(node.Arguments[1]) + predicate := v.visit(node.Arguments[1]) v.end() - if isFunc(closure) && - closure.NumOut() == 1 && - closure.NumIn() == 1 && isUnknown(closure.In(0)) { + if isFunc(predicate) && + predicate.NumOut() == 1 && + predicate.NumIn() == 1 && isUnknown(predicate.In(0)) { - if !isBool(closure.Out(0)) && !isUnknown(closure.Out(0)) { - return v.error(node.Arguments[1], "predicate should return boolean (got %v)", closure.Out(0).String()) + if !isBool(predicate.Out(0)) && !isUnknown(predicate.Out(0)) { + return v.error(node.Arguments[1], "predicate should return boolean (got %v)", predicate.Out(0).String()) } if isUnknown(collection) { return unknown @@ -766,15 +753,15 @@ func (v *checker) BuiltinNode(node *ast.BuiltinNode) Nature { } v.begin(collection) - closure := v.visit(node.Arguments[1]) + predicate := v.visit(node.Arguments[1]) v.end() - if isFunc(closure) && - closure.NumOut() == 1 && - closure.NumIn() == 1 && isUnknown(closure.In(0)) { + if isFunc(predicate) && + predicate.NumOut() == 1 && + predicate.NumIn() == 1 && isUnknown(predicate.In(0)) { - if !isBool(closure.Out(0)) && !isUnknown(closure.Out(0)) { - return v.error(node.Arguments[1], "predicate should return boolean (got %v)", closure.Out(0).String()) + if !isBool(predicate.Out(0)) && !isUnknown(predicate.Out(0)) { + return v.error(node.Arguments[1], "predicate should return boolean (got %v)", predicate.Out(0).String()) } return integerNature } @@ -787,14 +774,15 @@ func (v *checker) BuiltinNode(node *ast.BuiltinNode) Nature { } v.begin(collection) - closure := v.visit(node.Arguments[1]) + predicate := v.visit(node.Arguments[1]) v.end() - if isFunc(closure) && - closure.NumOut() == 1 && - closure.NumIn() == 1 && isUnknown(closure.In(0)) { + if isFunc(predicate) && + predicate.NumOut() == 1 && + predicate.NumIn() == 1 && isUnknown(predicate.In(0)) { - return Nature{Type: reflect.TypeOf(map[any][]any{})} + groups := arrayOf(collection.Elem()) + return Nature{Type: reflect.TypeOf(map[any][]any{}), ArrayOf: &groups} } return v.error(node.Arguments[1], "predicate should has one input and one output param") @@ -805,18 +793,18 @@ func (v *checker) BuiltinNode(node *ast.BuiltinNode) Nature { } v.begin(collection) - closure := v.visit(node.Arguments[1]) + predicate := v.visit(node.Arguments[1]) v.end() if len(node.Arguments) == 3 { _ = v.visit(node.Arguments[2]) } - if isFunc(closure) && - closure.NumOut() == 1 && - closure.NumIn() == 1 && isUnknown(closure.In(0)) { + if isFunc(predicate) && + predicate.NumOut() == 1 && + predicate.NumIn() == 1 && isUnknown(predicate.In(0)) { - return Nature{Type: reflect.TypeOf([]any{})} + return collection } return v.error(node.Arguments[1], "predicate should has one input and one output param") @@ -827,15 +815,15 @@ func (v *checker) BuiltinNode(node *ast.BuiltinNode) Nature { } v.begin(collection, scopeVar{"index", integerNature}, scopeVar{"acc", unknown}) - closure := v.visit(node.Arguments[1]) + predicate := v.visit(node.Arguments[1]) v.end() if len(node.Arguments) == 3 { _ = v.visit(node.Arguments[2]) } - if isFunc(closure) && closure.NumOut() == 1 { - return closure.Out(0) + if isFunc(predicate) && predicate.NumOut() == 1 { + return *predicate.PredicateOut } return v.error(node.Arguments[1], "predicate should has two input and one output param") @@ -879,7 +867,9 @@ func (v *checker) checkBuiltinGet(node *ast.BuiltinNode) Nature { if id, ok := node.Arguments[0].(*ast.IdentifierNode); ok && id.Value == "$env" { if s, ok := node.Arguments[1].(*ast.StringNode); ok { - return Nature{Type: v.config.Types[s.Value].Type} + if nt, ok := v.config.Env.Get(s.Value); ok { + return nt + } } return unknown } @@ -1106,24 +1096,23 @@ func traverseAndReplaceIntegerNodesWithIntegerNodes(node *ast.Node, newNature Na } } -func (v *checker) ClosureNode(node *ast.ClosureNode) Nature { +func (v *checker) PredicateNode(node *ast.PredicateNode) Nature { nt := v.visit(node.Node) - var out reflect.Type + var out []reflect.Type if isUnknown(nt) { - out = anyType - } else { - out = nt.Type + out = append(out, anyType) + } else if !isNil(nt) { + out = append(out, nt.Type) + } + return Nature{ + Type: reflect.FuncOf([]reflect.Type{anyType}, out, false), + PredicateOut: &nt, } - return Nature{Type: reflect.FuncOf( - []reflect.Type{anyType}, - []reflect.Type{out}, - false, - )} } func (v *checker) PointerNode(node *ast.PointerNode) Nature { if len(v.predicateScopes) == 0 { - return v.error(node, "cannot use pointer accessor outside closure") + return v.error(node, "cannot use pointer accessor outside predicate") } scope := v.predicateScopes[len(v.predicateScopes)-1] if node.Name == "" { @@ -1145,7 +1134,7 @@ func (v *checker) PointerNode(node *ast.PointerNode) Nature { } func (v *checker) VariableDeclaratorNode(node *ast.VariableDeclaratorNode) Nature { - if _, ok := v.config.Types[node.Name]; ok { + if _, ok := v.config.Env.Get(node.Name); ok { return v.error(node, "cannot redeclare %v", node.Name) } if _, ok := v.config.Functions[node.Name]; ok { @@ -1210,10 +1199,7 @@ func (v *checker) ArrayNode(node *ast.ArrayNode) Nature { prev = curr } if allElementsAreSameType { - return Nature{ - Type: arrayNature.Type, - SubType: Array{Of: prev}, - } + return arrayOf(prev) } return arrayNature } diff --git a/checker/checker_test.go b/checker/checker_test.go index ae42392c0..0639f1f43 100644 --- a/checker/checker_test.go +++ b/checker/checker_test.go @@ -9,6 +9,7 @@ import ( "github.com/expr-lang/expr/internal/testify/assert" "github.com/expr-lang/expr/internal/testify/require" + "github.com/expr-lang/expr/types" "github.com/expr-lang/expr" "github.com/expr-lang/expr/ast" @@ -758,26 +759,6 @@ func TestCheck_TaggedFieldName(t *testing.T) { assert.NoError(t, err) } -func TestCheck_Ambiguous(t *testing.T) { - type A struct { - Ambiguous bool - } - type B struct { - Ambiguous int - } - type Env struct { - A - B - } - - tree, err := parser.Parse(`Ambiguous == 1`) - require.NoError(t, err) - - _, err = checker.Check(tree, conf.New(Env{})) - assert.Error(t, err) - assert.Contains(t, err.Error(), "ambiguous identifier Ambiguous") -} - func TestCheck_NoConfig(t *testing.T) { tree, err := parser.Parse(`any`) require.NoError(t, err) @@ -831,7 +812,7 @@ func TestCheck_AllowUndefinedVariables_OptionalChaining(t *testing.T) { func TestCheck_PointerNode(t *testing.T) { _, err := checker.Check(&parser.Tree{Node: &ast.PointerNode{}}, nil) assert.Error(t, err) - assert.Contains(t, err.Error(), "cannot use pointer accessor outside closure") + assert.Contains(t, err.Error(), "cannot use pointer accessor outside predicate") } func TestCheck_TypeWeights(t *testing.T) { @@ -1088,3 +1069,41 @@ func TestCheck_builtin_without_call(t *testing.T) { }) } } + +func TestCheck_types(t *testing.T) { + env := types.Map{ + "foo": types.StrictMap{ + "bar": types.Map{ + "baz": "", + }, + }, + } + + noerr := "no error" + tests := []struct { + code string + err string + }{ + {`unknown`, noerr}, + {`foo.bar.baz > 0`, `invalid operation: > (mismatched types string and int)`}, + {`foo.unknown.baz`, `unknown field unknown (1:5)`}, + {`foo.bar.unknown`, noerr}, + {`[foo] | map(.unknown)`, `unknown field unknown`}, + {`[foo] | map(.bar) | filter(.baz)`, `predicate should return boolean (got string)`}, + } + + for _, test := range tests { + t.Run(test.code, func(t *testing.T) { + tree, err := parser.Parse(test.code) + require.NoError(t, err) + + _, err = checker.Check(tree, conf.New(env)) + if test.err == noerr { + require.NoError(t, err) + } else { + require.Error(t, err) + require.Contains(t, err.Error(), test.err) + } + }) + } +} diff --git a/checker/info.go b/checker/info.go index 3c9396fd5..f1cc92ebe 100644 --- a/checker/info.go +++ b/checker/info.go @@ -4,15 +4,17 @@ import ( "reflect" "github.com/expr-lang/expr/ast" - "github.com/expr-lang/expr/conf" + . "github.com/expr-lang/expr/checker/nature" "github.com/expr-lang/expr/vm" ) -func FieldIndex(types conf.TypesTable, node ast.Node) (bool, []int, string) { +func FieldIndex(env Nature, node ast.Node) (bool, []int, string) { switch n := node.(type) { case *ast.IdentifierNode: - if t, ok := types[n.Value]; ok && len(t.FieldIndex) > 0 { - return true, t.FieldIndex, n.Value + if env.Kind() == reflect.Struct { + if field, ok := env.Get(n.Value); ok && len(field.FieldIndex) > 0 { + return true, field.FieldIndex, n.Value + } } case *ast.MemberNode: base := n.Node.Nature() @@ -20,8 +22,8 @@ func FieldIndex(types conf.TypesTable, node ast.Node) (bool, []int, string) { if base.Kind() == reflect.Struct { if prop, ok := n.Property.(*ast.StringNode); ok { name := prop.Value - if field, ok := fetchField(base, name); ok { - return true, field.Index, name + if field, ok := base.FieldByName(name); ok { + return true, field.FieldIndex, name } } } @@ -29,11 +31,13 @@ func FieldIndex(types conf.TypesTable, node ast.Node) (bool, []int, string) { return false, nil, "" } -func MethodIndex(types conf.TypesTable, node ast.Node) (bool, int, string) { +func MethodIndex(env Nature, node ast.Node) (bool, int, string) { switch n := node.(type) { case *ast.IdentifierNode: - if t, ok := types[n.Value]; ok { - return t.Method, t.MethodIndex, n.Value + if env.Kind() == reflect.Struct { + if m, ok := env.Get(n.Value); ok { + return m.Method, m.MethodIndex, n.Value + } } case *ast.MemberNode: if name, ok := n.Property.(*ast.StringNode); ok { diff --git a/checker/nature/nature.go b/checker/nature/nature.go index a7365998c..a385521c5 100644 --- a/checker/nature/nature.go +++ b/checker/nature/nature.go @@ -12,16 +12,19 @@ var ( ) type Nature struct { - Type reflect.Type - SubType SubType - Func *builtin.Function - Method bool + Type reflect.Type // Type of the value. If nil, then value is unknown. + Func *builtin.Function // Used to pass function type from callee to CallNode. + ArrayOf *Nature // Elem nature of array type (usually Type is []any, but ArrayOf can be any nature). + PredicateOut *Nature // Out nature of predicate. + Fields map[string]Nature // Fields of map type. + Strict bool // If map is types.StrictMap. + Nil bool // If value is nil. + Method bool // If value retrieved from method. Usually used to determine amount of in arguments. + MethodIndex int // Index of method in type. + FieldIndex []int // Index of field in type. } func (n Nature) String() string { - if n.SubType != nil { - return n.SubType.String() - } if n.Type != nil { return n.Type.String() } @@ -54,8 +57,8 @@ func (n Nature) Elem() Nature { case reflect.Map, reflect.Ptr: return Nature{Type: n.Type.Elem()} case reflect.Array, reflect.Slice: - if array, ok := n.SubType.(Array); ok { - return array.Of + if n.ArrayOf != nil { + return *n.ArrayOf } return Nature{Type: n.Type.Elem()} } @@ -63,6 +66,12 @@ func (n Nature) Elem() Nature { } func (n Nature) AssignableTo(nt Nature) bool { + if n.Nil { + // Untyped nil is assignable to any interface, but implements only the empty interface. + if nt.Type != nil && nt.Type.Kind() == reflect.Interface { + return true + } + } if n.Type == nil || nt.Type == nil { return false } @@ -88,24 +97,14 @@ func (n Nature) MethodByName(name string) (Nature, bool) { // the same interface. return Nature{Type: method.Type}, true } else { - return Nature{Type: method.Type, Method: true}, true + return Nature{ + Type: method.Type, + Method: true, + MethodIndex: method.Index, + }, true } } -func (n Nature) NumField() int { - if n.Type == nil { - return 0 - } - return n.Type.NumField() -} - -func (n Nature) Field(i int) reflect.StructField { - if n.Type == nil { - return reflect.StructField{} - } - return n.Type.Field(i) -} - func (n Nature) NumIn() int { if n.Type == nil { return 0 @@ -140,3 +139,89 @@ func (n Nature) IsVariadic() bool { } return n.Type.IsVariadic() } + +func (n Nature) FieldByName(name string) (Nature, bool) { + if n.Type == nil { + return unknown, false + } + field, ok := fetchField(n.Type, name) + return Nature{Type: field.Type, FieldIndex: field.Index}, ok +} + +func (n Nature) IsFastMap() bool { + if n.Type == nil { + return false + } + if n.Type.Kind() == reflect.Map && + n.Type.Key().Kind() == reflect.String && + n.Type.Elem().Kind() == reflect.Interface { + return true + } + return false +} + +func (n Nature) Get(name string) (Nature, bool) { + if n.Type == nil { + return unknown, false + } + + if m, ok := n.MethodByName(name); ok { + return m, true + } + + t := deref.Type(n.Type) + + switch t.Kind() { + case reflect.Struct: + if f, ok := fetchField(t, name); ok { + return Nature{ + Type: f.Type, + FieldIndex: f.Index, + }, true + } + case reflect.Map: + if f, ok := n.Fields[name]; ok { + return f, true + } + } + return unknown, false +} + +func (n Nature) All() map[string]Nature { + table := make(map[string]Nature) + + if n.Type == nil { + return table + } + + for i := 0; i < n.Type.NumMethod(); i++ { + method := n.Type.Method(i) + table[method.Name] = Nature{ + Type: method.Type, + Method: true, + MethodIndex: method.Index, + } + } + + t := deref.Type(n.Type) + + switch t.Kind() { + case reflect.Struct: + for name, nt := range StructFields(t) { + if _, ok := table[name]; ok { + continue + } + table[name] = nt + } + + case reflect.Map: + for key, nt := range n.Fields { + if _, ok := table[key]; ok { + continue + } + table[key] = nt + } + } + + return table +} diff --git a/checker/nature/of.go b/checker/nature/of.go new file mode 100644 index 000000000..93235f9cd --- /dev/null +++ b/checker/nature/of.go @@ -0,0 +1,47 @@ +package nature + +import ( + "fmt" + "reflect" + + "github.com/expr-lang/expr/types" +) + +func Of(value any) Nature { + if value == nil { + return Nature{Nil: true} + } + + v := reflect.ValueOf(value) + + switch v.Kind() { + case reflect.Map: + _, strict := value.(types.StrictMap) + fields := make(map[string]Nature, v.Len()) + for _, key := range v.MapKeys() { + elem := v.MapIndex(key) + if !elem.IsValid() || !elem.CanInterface() { + panic(fmt.Sprintf("invalid map value: %s", key)) + } + face := elem.Interface() + switch face.(type) { + case types.Map, types.StrictMap: + fields[key.String()] = Of(face) + default: + if face == nil { + fields[key.String()] = Nature{Nil: true} + continue + } + fields[key.String()] = Nature{Type: reflect.TypeOf(face)} + + } + } + return Nature{ + Type: v.Type(), + Fields: fields, + Strict: strict, + } + } + + return Nature{Type: v.Type()} +} diff --git a/checker/nature/types.go b/checker/nature/types.go deleted file mode 100644 index 1f9955e92..000000000 --- a/checker/nature/types.go +++ /dev/null @@ -1,13 +0,0 @@ -package nature - -type SubType interface { - String() string -} - -type Array struct { - Of Nature -} - -func (a Array) String() string { - return "[]" + a.Of.String() -} diff --git a/checker/nature/utils.go b/checker/nature/utils.go new file mode 100644 index 000000000..c242f91a6 --- /dev/null +++ b/checker/nature/utils.go @@ -0,0 +1,76 @@ +package nature + +import ( + "reflect" + + "github.com/expr-lang/expr/internal/deref" +) + +func fieldName(field reflect.StructField) string { + if taggedName := field.Tag.Get("expr"); taggedName != "" { + return taggedName + } + return field.Name +} + +func fetchField(t reflect.Type, name string) (reflect.StructField, bool) { + // First check all structs fields. + for i := 0; i < t.NumField(); i++ { + field := t.Field(i) + // Search all fields, even embedded structs. + if fieldName(field) == name { + return field, true + } + } + + // Second check fields of embedded structs. + for i := 0; i < t.NumField(); i++ { + anon := t.Field(i) + if anon.Anonymous { + anonType := anon.Type + if anonType.Kind() == reflect.Pointer { + anonType = anonType.Elem() + } + if field, ok := fetchField(anonType, name); ok { + field.Index = append(anon.Index, field.Index...) + return field, true + } + } + } + + return reflect.StructField{}, false +} + +func StructFields(t reflect.Type) map[string]Nature { + table := make(map[string]Nature) + + t = deref.Type(t) + if t == nil { + return table + } + + switch t.Kind() { + case reflect.Struct: + for i := 0; i < t.NumField(); i++ { + f := t.Field(i) + + if f.Anonymous { + for name, typ := range StructFields(f.Type) { + if _, ok := table[name]; ok { + continue + } + typ.FieldIndex = append(f.Index, typ.FieldIndex...) + table[name] = typ + } + } + + table[fieldName(f)] = Nature{ + Type: f.Type, + FieldIndex: f.Index, + } + + } + } + + return table +} diff --git a/checker/types.go b/checker/types.go index 2eb5392e0..ef93cf03d 100644 --- a/checker/types.go +++ b/checker/types.go @@ -5,12 +5,11 @@ import ( "time" . "github.com/expr-lang/expr/checker/nature" - "github.com/expr-lang/expr/conf" ) var ( unknown = Nature{} - nilNature = Nature{Type: reflect.TypeOf(Nil{})} + nilNature = Nature{Nil: true} boolNature = Nature{Type: reflect.TypeOf(true)} integerNature = Nature{Type: reflect.TypeOf(0)} floatNature = Nature{Type: reflect.TypeOf(float64(0))} @@ -28,14 +27,15 @@ var ( arrayType = reflect.TypeOf([]any{}) ) -// Nil is a special type to represent nil. -type Nil struct{} +func arrayOf(nt Nature) Nature { + return Nature{ + Type: arrayType, + ArrayOf: &nt, + } +} func isNil(nt Nature) bool { - if nt.Type == nil { - return false - } - return nt.Type == nilNature.Type + return nt.Nil } func combined(l, r Nature) Nature { @@ -72,7 +72,7 @@ func or(l, r Nature, fns ...func(Nature) bool) bool { func isUnknown(nt Nature) bool { switch { - case nt.Type == nil: + case nt.Type == nil && !nt.Nil: return true case nt.Kind() == reflect.Interface: return true @@ -166,34 +166,6 @@ func isFunc(nt Nature) bool { return false } -func fetchField(nt Nature, name string) (reflect.StructField, bool) { - // First check all structs fields. - for i := 0; i < nt.NumField(); i++ { - field := nt.Field(i) - // Search all fields, even embedded structs. - if conf.FieldName(field) == name { - return field, true - } - } - - // Second check fields of embedded structs. - for i := 0; i < nt.NumField(); i++ { - anon := nt.Field(i) - if anon.Anonymous { - anonType := anon.Type - if anonType.Kind() == reflect.Pointer { - anonType = anonType.Elem() - } - if field, ok := fetchField(Nature{Type: anonType}, name); ok { - field.Index = append(anon.Index, field.Index...) - return field, true - } - } - } - - return reflect.StructField{}, false -} - func kind(t reflect.Type) reflect.Kind { if t == nil { return reflect.Invalid diff --git a/compiler/compiler.go b/compiler/compiler.go index 5e993540d..68eae5ea1 100644 --- a/compiler/compiler.go +++ b/compiler/compiler.go @@ -9,6 +9,7 @@ import ( "github.com/expr-lang/expr/ast" "github.com/expr-lang/expr/builtin" "github.com/expr-lang/expr/checker" + . "github.com/expr-lang/expr/checker/nature" "github.com/expr-lang/expr/conf" "github.com/expr-lang/expr/file" "github.com/expr-lang/expr/parser" @@ -259,8 +260,8 @@ func (c *compiler) compile(node ast.Node) { c.CallNode(n) case *ast.BuiltinNode: c.BuiltinNode(n) - case *ast.ClosureNode: - c.ClosureNode(n) + case *ast.PredicateNode: + c.PredicateNode(n) case *ast.PointerNode: c.PointerNode(n) case *ast.VariableDeclaratorNode: @@ -292,21 +293,19 @@ func (c *compiler) IdentifierNode(node *ast.IdentifierNode) { return } - var mapEnv bool - var types conf.TypesTable + var env Nature if c.config != nil { - mapEnv = c.config.MapEnv - types = c.config.Types + env = c.config.Env } - if mapEnv { + if env.IsFastMap() { c.emit(OpLoadFast, c.addConstant(node.Value)) - } else if ok, index, name := checker.FieldIndex(types, node); ok { + } else if ok, index, name := checker.FieldIndex(env, node); ok { c.emit(OpLoadField, c.addConstant(&runtime.Field{ Index: index, Path: []string{name}, })) - } else if ok, index, name := checker.MethodIndex(types, node); ok { + } else if ok, index, name := checker.MethodIndex(env, node); ok { c.emit(OpLoadMethod, c.addConstant(&runtime.Method{ Name: name, Index: index, @@ -647,12 +646,12 @@ func (c *compiler) ChainNode(node *ast.ChainNode) { } func (c *compiler) MemberNode(node *ast.MemberNode) { - var types conf.TypesTable + var env Nature if c.config != nil { - types = c.config.Types + env = c.config.Env } - if ok, index, name := checker.MethodIndex(types, node); ok { + if ok, index, name := checker.MethodIndex(env, node); ok { c.compile(node.Node) c.emit(OpMethod, c.addConstant(&runtime.Method{ Name: name, @@ -663,14 +662,14 @@ func (c *compiler) MemberNode(node *ast.MemberNode) { op := OpFetch base := node.Node - ok, index, nodeName := checker.FieldIndex(types, node) + ok, index, nodeName := checker.FieldIndex(env, node) path := []string{nodeName} if ok { op = OpFetchField for !node.Optional { if ident, isIdent := base.(*ast.IdentifierNode); isIdent { - if ok, identIndex, name := checker.FieldIndex(types, ident); ok { + if ok, identIndex, name := checker.FieldIndex(env, ident); ok { index = append(identIndex, index...) path = append([]string{name}, path...) c.emitLocation(ident.Location(), OpLoadField, c.addConstant( @@ -681,7 +680,7 @@ func (c *compiler) MemberNode(node *ast.MemberNode) { } if member, isMember := base.(*ast.MemberNode); isMember { - if ok, memberIndex, name := checker.FieldIndex(types, member); ok { + if ok, memberIndex, name := checker.FieldIndex(env, member); ok { index = append(memberIndex, index...) path = append([]string{name}, path...) node = member @@ -730,7 +729,7 @@ func (c *compiler) SliceNode(node *ast.SliceNode) { func (c *compiler) CallNode(node *ast.CallNode) { fn := node.Callee.Type() - if kind(fn) == reflect.Func { + if fn.Kind() == reflect.Func { fnInOffset := 0 fnNumIn := fn.NumIn() switch callee := node.Callee.(type) { @@ -742,7 +741,7 @@ func (c *compiler) CallNode(node *ast.CallNode) { } } case *ast.IdentifierNode: - if t, ok := c.config.Types[callee.Value]; ok && t.Method { + if t, ok := c.config.Env.MethodByName(callee.Value); ok && t.Method { fnInOffset = 1 fnNumIn-- } @@ -777,7 +776,7 @@ func (c *compiler) CallNode(node *ast.CallNode) { } c.compile(node.Callee) - isMethod, _, _ := checker.MethodIndex(c.config.Types, node.Callee) + isMethod, _, _ := checker.MethodIndex(c.config.Env, node.Callee) if index, ok := checker.TypedFuncIndex(node.Callee.Type(), isMethod); ok { c.emit(OpCallTyped, index) return @@ -1117,7 +1116,7 @@ func (c *compiler) emitLoopBackwards(body func()) { c.patchJump(end) } -func (c *compiler) ClosureNode(node *ast.ClosureNode) { +func (c *compiler) PredicateNode(node *ast.PredicateNode) { c.compile(node.Node) } @@ -1199,6 +1198,9 @@ func (c *compiler) PairNode(node *ast.PairNode) { } func (c *compiler) derefInNeeded(node ast.Node) { + if node.Nature().Nil { + return + } switch node.Type().Kind() { case reflect.Ptr, reflect.Interface: c.emit(OpDeref) diff --git a/conf/config.go b/conf/config.go index 01a407a10..77bb2a67b 100644 --- a/conf/config.go +++ b/conf/config.go @@ -6,33 +6,32 @@ import ( "github.com/expr-lang/expr/ast" "github.com/expr-lang/expr/builtin" + "github.com/expr-lang/expr/checker/nature" + "github.com/expr-lang/expr/types" "github.com/expr-lang/expr/vm/runtime" ) type FunctionsTable map[string]*builtin.Function type Config struct { - Env any - Types TypesTable - MapEnv bool - DefaultType reflect.Type - Expect reflect.Kind - ExpectAny bool - Optimize bool - Strict bool - Profile bool - ConstFns map[string]reflect.Value - Visitors []ast.Visitor - Functions FunctionsTable - Builtins FunctionsTable - Disabled map[string]bool // disabled builtins + EnvObject any + Env nature.Nature + Expect reflect.Kind + ExpectAny bool + Optimize bool + Strict bool + Profile bool + ConstFns map[string]reflect.Value + Visitors []ast.Visitor + Functions FunctionsTable + Builtins FunctionsTable + Disabled map[string]bool // disabled builtins } // CreateNew creates new config with default values. func CreateNew() *Config { c := &Config{ Optimize: true, - Types: make(TypesTable), ConstFns: make(map[string]reflect.Value), Functions: make(map[string]*builtin.Function), Builtins: make(map[string]*builtin.Function), @@ -52,31 +51,20 @@ func New(env any) *Config { } func (c *Config) WithEnv(env any) { - var mapEnv bool - var mapValueType reflect.Type - if _, ok := env.(map[string]any); ok { - mapEnv = true - } else { - if reflect.ValueOf(env).Kind() == reflect.Map { - mapValueType = reflect.TypeOf(env).Elem() - } - } - - c.Env = env - types := CreateTypesTable(env) - for name, t := range types { - c.Types[name] = t - } - c.MapEnv = mapEnv - c.DefaultType = mapValueType c.Strict = true + c.EnvObject = env + c.Env = nature.Of(env) + c.Env.Strict = true // To keep backward compatibility with expr.AllowUndefinedVariables() + if _, ok := env.(types.Map); ok { + c.Env.Strict = false + } } func (c *Config) ConstExpr(name string) { - if c.Env == nil { + if c.EnvObject == nil { panic("no environment is specified for ConstExpr()") } - fn := reflect.ValueOf(runtime.Fetch(c.Env, name)) + fn := reflect.ValueOf(runtime.Fetch(c.EnvObject, name)) if fn.Kind() != reflect.Func { panic(fmt.Errorf("const expression %q must be a function", name)) } @@ -99,7 +87,7 @@ func (c *Config) IsOverridden(name string) bool { if _, ok := c.Functions[name]; ok { return true } - if _, ok := c.Types[name]; ok { + if _, ok := c.Env.Get(name); ok { return true } return false diff --git a/conf/types_table.go b/conf/types_table.go deleted file mode 100644 index a42a42874..000000000 --- a/conf/types_table.go +++ /dev/null @@ -1,121 +0,0 @@ -package conf - -import ( - "reflect" - - "github.com/expr-lang/expr/internal/deref" -) - -type TypesTable map[string]Tag - -type Tag struct { - Type reflect.Type - Ambiguous bool - FieldIndex []int - Method bool - MethodIndex int -} - -// CreateTypesTable creates types table for type checks during parsing. -// If struct is passed, all fields will be treated as variables, -// as well as all fields of embedded structs and struct itself. -// -// If map is passed, all items will be treated as variables -// (key as name, value as type). -func CreateTypesTable(i any) TypesTable { - if i == nil { - return nil - } - - types := make(TypesTable) - v := reflect.ValueOf(i) - t := reflect.TypeOf(i) - - d := t - if t.Kind() == reflect.Ptr { - d = t.Elem() - } - - switch d.Kind() { - case reflect.Struct: - types = FieldsFromStruct(d) - - // Methods of struct should be gathered from original struct with pointer, - // as methods maybe declared on pointer receiver. Also this method retrieves - // all embedded structs methods as well, no need to recursion. - for i := 0; i < t.NumMethod(); i++ { - m := t.Method(i) - types[m.Name] = Tag{ - Type: m.Type, - Method: true, - MethodIndex: i, - } - } - - case reflect.Map: - for _, key := range v.MapKeys() { - value := v.MapIndex(key) - if key.Kind() == reflect.String && value.IsValid() && value.CanInterface() { - if key.String() == "$env" { // Could check for all keywords here - panic("attempt to misuse env keyword as env map key") - } - types[key.String()] = Tag{Type: reflect.TypeOf(value.Interface())} - } - } - - // A map may have method too. - for i := 0; i < t.NumMethod(); i++ { - m := t.Method(i) - types[m.Name] = Tag{ - Type: m.Type, - Method: true, - MethodIndex: i, - } - } - } - - return types -} - -func FieldsFromStruct(t reflect.Type) TypesTable { - types := make(TypesTable) - t = deref.Type(t) - if t == nil { - return types - } - - switch t.Kind() { - case reflect.Struct: - for i := 0; i < t.NumField(); i++ { - f := t.Field(i) - - if f.Anonymous { - for name, typ := range FieldsFromStruct(f.Type) { - if _, ok := types[name]; ok { - types[name] = Tag{Ambiguous: true} - } else { - typ.FieldIndex = append(f.Index, typ.FieldIndex...) - types[name] = typ - } - } - } - if fn := FieldName(f); fn == "$env" { // Could check for all keywords here - panic("attempt to misuse env keyword as env struct field tag") - } else { - types[FieldName(f)] = Tag{ - Type: f.Type, - FieldIndex: f.Index, - } - } - } - } - - return types -} - -func FieldName(field reflect.StructField) string { - if taggedName := field.Tag.Get("expr"); taggedName != "" { - return taggedName - } - return field.Name -} diff --git a/docgen/docgen.go b/docgen/docgen.go index aed0f48f0..d9abcf0e4 100644 --- a/docgen/docgen.go +++ b/docgen/docgen.go @@ -5,7 +5,7 @@ import ( "regexp" "strings" - "github.com/expr-lang/expr/conf" + "github.com/expr-lang/expr/checker/nature" "github.com/expr-lang/expr/internal/deref" ) @@ -84,8 +84,8 @@ func CreateDoc(i any) *Context { PkgPath: deref.Type(reflect.TypeOf(i)).PkgPath(), } - for name, t := range conf.CreateTypesTable(i) { - if t.Ambiguous { + for name, t := range nature.Of(i).All() { + if _, ok := c.Variables[Identifier(name)]; ok { continue } c.Variables[Identifier(name)] = c.use(t.Type, fromMethod(t.Method)) @@ -220,8 +220,11 @@ appendix: c.Types[name] = a } - for name, field := range conf.FieldsFromStruct(t) { - if isPrivate(name) || isProtobuf(name) || field.Ambiguous { + for name, field := range nature.StructFields(t) { + if isPrivate(name) || isProtobuf(name) { + continue + } + if _, ok := a.Fields[Identifier(name)]; ok { continue } a.Fields[Identifier(name)] = c.use(field.Type) diff --git a/docgen/docgen_test.go b/docgen/docgen_test.go index 26cf4f7a9..2532a0c76 100644 --- a/docgen/docgen_test.go +++ b/docgen/docgen_test.go @@ -131,7 +131,7 @@ func TestCreateDoc(t *testing.T) { PkgPath: "github.com/expr-lang/expr/docgen_test", } - assert.EqualValues(t, expected, doc) + assert.Equal(t, expected.Markdown(), doc.Markdown()) } type A struct { @@ -160,6 +160,9 @@ func TestCreateDoc_Ambiguous(t *testing.T) { Kind: "struct", Name: "A", }, + "AmbiguousField": { + Kind: "int", + }, "B": { Kind: "struct", Name: "B", @@ -189,16 +192,17 @@ func TestCreateDoc_Ambiguous(t *testing.T) { "C": { Kind: "struct", Fields: map[Identifier]*Type{ - "A": {Kind: "struct", Name: "A"}, - "B": {Kind: "struct", Name: "B"}, - "OkField": {Kind: "int"}, + "A": {Kind: "struct", Name: "A"}, + "AmbiguousField": {Kind: "int"}, + "B": {Kind: "struct", Name: "B"}, + "OkField": {Kind: "int"}, }, }, }, PkgPath: "github.com/expr-lang/expr/docgen_test", } - assert.EqualValues(t, expected, doc) + assert.Equal(t, expected.Markdown(), doc.Markdown()) } func TestCreateDoc_FromMap(t *testing.T) { @@ -247,7 +251,7 @@ func TestCreateDoc_FromMap(t *testing.T) { }, } - require.EqualValues(t, expected, doc) + require.EqualValues(t, expected.Markdown(), doc.Markdown()) } func TestContext_Markdown(t *testing.T) { diff --git a/expr.go b/expr.go index 8c619e1c4..5e60791e1 100644 --- a/expr.go +++ b/expr.go @@ -45,7 +45,7 @@ func Operator(operator string, fn ...string) Option { p := &patcher.OperatorOverloading{ Operator: operator, Overloads: fn, - Types: c.Types, + Env: &c.Env, Functions: c.Functions, } c.Visitors = append(c.Visitors, p) diff --git a/expr_test.go b/expr_test.go index 3724467fc..e71393f39 100644 --- a/expr_test.go +++ b/expr_test.go @@ -12,6 +12,7 @@ import ( "github.com/expr-lang/expr/internal/testify/assert" "github.com/expr-lang/expr/internal/testify/require" + "github.com/expr-lang/expr/types" "github.com/expr-lang/expr" "github.com/expr-lang/expr/ast" @@ -1673,10 +1674,6 @@ func TestIssue105(t *testing.T) { _, err := expr.Compile(code, expr.Env(Env{})) require.NoError(t, err) - - _, err = expr.Compile(`Field == ''`, expr.Env(Env{})) - require.Error(t, err) - require.Contains(t, err.Error(), "ambiguous identifier Field") } func TestIssue_nested_closures(t *testing.T) { @@ -2704,3 +2701,38 @@ func TestExpr_nil_op_str(t *testing.T) { }) } } + +func TestExpr_env_types_map(t *testing.T) { + envTypes := types.Map{ + "foo": types.StrictMap{ + "bar": "value", + }, + } + + program, err := expr.Compile(`foo.bar`, expr.Env(envTypes)) + require.NoError(t, err) + + env := map[string]any{ + "foo": map[string]any{ + "bar": "value", + }, + } + + output, err := expr.Run(program, env) + require.NoError(t, err) + require.Equal(t, "value", output) +} + +func TestExpr_env_types_map_error(t *testing.T) { + envTypes := types.Map{ + "foo": types.StrictMap{ + "bar": "value", + }, + } + + program, err := expr.Compile(`foo.bar`, expr.Env(envTypes)) + require.NoError(t, err) + + _, err = expr.Run(program, envTypes) + require.Error(t, err) +} diff --git a/optimizer/filter_map.go b/optimizer/filter_map.go index e916dd75b..c6de6c73e 100644 --- a/optimizer/filter_map.go +++ b/optimizer/filter_map.go @@ -10,14 +10,14 @@ func (*filterMap) Visit(node *Node) { if mapBuiltin, ok := (*node).(*BuiltinNode); ok && mapBuiltin.Name == "map" && len(mapBuiltin.Arguments) == 2 { - if closure, ok := mapBuiltin.Arguments[1].(*ClosureNode); ok { + if predicate, ok := mapBuiltin.Arguments[1].(*PredicateNode); ok { if filter, ok := mapBuiltin.Arguments[0].(*BuiltinNode); ok && filter.Name == "filter" && filter.Map == nil /* not already optimized */ { patchCopyType(node, &BuiltinNode{ Name: "filter", Arguments: filter.Arguments, - Map: closure.Node, + Map: predicate.Node, }) } } diff --git a/optimizer/fold.go b/optimizer/fold.go index 2f4562c22..bb40eab93 100644 --- a/optimizer/fold.go +++ b/optimizer/fold.go @@ -298,8 +298,8 @@ func (fold *fold) Visit(node *Node) { base.Arguments[0], &BinaryNode{ Operator: "&&", - Left: base.Arguments[1].(*ClosureNode).Node, - Right: n.Arguments[1].(*ClosureNode).Node, + Left: base.Arguments[1].(*PredicateNode).Node, + Right: n.Arguments[1].(*PredicateNode).Node, }, }, }) diff --git a/optimizer/optimizer_test.go b/optimizer/optimizer_test.go index 56a890492..7830c0e78 100644 --- a/optimizer/optimizer_test.go +++ b/optimizer/optimizer_test.go @@ -184,7 +184,7 @@ func TestOptimize_filter_len(t *testing.T) { Name: "count", Arguments: []ast.Node{ &ast.IdentifierNode{Value: "users"}, - &ast.ClosureNode{ + &ast.PredicateNode{ Node: &ast.BinaryNode{ Operator: "==", Left: &ast.MemberNode{ @@ -211,7 +211,7 @@ func TestOptimize_filter_0(t *testing.T) { Name: "find", Arguments: []ast.Node{ &ast.IdentifierNode{Value: "users"}, - &ast.ClosureNode{ + &ast.PredicateNode{ Node: &ast.BinaryNode{ Operator: "==", Left: &ast.MemberNode{ @@ -239,7 +239,7 @@ func TestOptimize_filter_first(t *testing.T) { Name: "find", Arguments: []ast.Node{ &ast.IdentifierNode{Value: "users"}, - &ast.ClosureNode{ + &ast.PredicateNode{ Node: &ast.BinaryNode{ Operator: "==", Left: &ast.MemberNode{ @@ -267,7 +267,7 @@ func TestOptimize_filter_minus_1(t *testing.T) { Name: "findLast", Arguments: []ast.Node{ &ast.IdentifierNode{Value: "users"}, - &ast.ClosureNode{ + &ast.PredicateNode{ Node: &ast.BinaryNode{ Operator: "==", Left: &ast.MemberNode{ @@ -295,7 +295,7 @@ func TestOptimize_filter_last(t *testing.T) { Name: "findLast", Arguments: []ast.Node{ &ast.IdentifierNode{Value: "users"}, - &ast.ClosureNode{ + &ast.PredicateNode{ Node: &ast.BinaryNode{ Operator: "==", Left: &ast.MemberNode{ @@ -323,7 +323,7 @@ func TestOptimize_filter_map(t *testing.T) { Name: "filter", Arguments: []ast.Node{ &ast.IdentifierNode{Value: "users"}, - &ast.ClosureNode{ + &ast.PredicateNode{ Node: &ast.BinaryNode{ Operator: "==", Left: &ast.MemberNode{ @@ -354,7 +354,7 @@ func TestOptimize_filter_map_first(t *testing.T) { Name: "find", Arguments: []ast.Node{ &ast.IdentifierNode{Value: "users"}, - &ast.ClosureNode{ + &ast.PredicateNode{ Node: &ast.BinaryNode{ Operator: "==", Left: &ast.MemberNode{ @@ -402,7 +402,7 @@ func TestOptimize_predicate_combination(t *testing.T) { Name: tt.fn, Arguments: []ast.Node{ &ast.IdentifierNode{Value: "users"}, - &ast.ClosureNode{ + &ast.PredicateNode{ Node: &ast.BinaryNode{ Operator: tt.wantOp, Left: &ast.BinaryNode{ @@ -452,7 +452,7 @@ func TestOptimize_predicate_combination_nested(t *testing.T) { Name: "all", Arguments: []ast.Node{ &ast.IdentifierNode{Value: "users"}, - &ast.ClosureNode{ + &ast.PredicateNode{ Node: &ast.BuiltinNode{ Name: "all", Arguments: []ast.Node{ @@ -460,7 +460,7 @@ func TestOptimize_predicate_combination_nested(t *testing.T) { Node: &ast.PointerNode{}, Property: &ast.StringNode{Value: "Friends"}, }, - &ast.ClosureNode{ + &ast.PredicateNode{ Node: &ast.BinaryNode{ Operator: "&&", Left: &ast.BinaryNode{ diff --git a/optimizer/predicate_combination.go b/optimizer/predicate_combination.go index 62e296d1f..65f88e348 100644 --- a/optimizer/predicate_combination.go +++ b/optimizer/predicate_combination.go @@ -21,19 +21,19 @@ func (v *predicateCombination) Visit(node *Node) { if combinedOp, ok := combinedOperator(left.Name, op.Operator); ok { if right, ok := op.Right.(*BuiltinNode); ok && right.Name == left.Name { if left.Arguments[0].Type() == right.Arguments[0].Type() && left.Arguments[0].String() == right.Arguments[0].String() { - closure := &ClosureNode{ + predicate := &PredicateNode{ Node: &BinaryNode{ Operator: combinedOp, - Left: left.Arguments[1].(*ClosureNode).Node, - Right: right.Arguments[1].(*ClosureNode).Node, + Left: left.Arguments[1].(*PredicateNode).Node, + Right: right.Arguments[1].(*PredicateNode).Node, }, } - v.Visit(&closure.Node) + v.Visit(&predicate.Node) patchCopyType(node, &BuiltinNode{ Name: left.Name, Arguments: []Node{ left.Arguments[0], - closure, + predicate, }, }) } diff --git a/optimizer/sum_map_test.go b/optimizer/sum_map_test.go index 96bdcfd35..2d0ffeb77 100644 --- a/optimizer/sum_map_test.go +++ b/optimizer/sum_map_test.go @@ -22,7 +22,7 @@ func TestOptimize_sum_map(t *testing.T) { Name: "sum", Arguments: []ast.Node{ &ast.IdentifierNode{Value: "users"}, - &ast.ClosureNode{ + &ast.PredicateNode{ Node: &ast.MemberNode{ Node: &ast.PointerNode{}, Property: &ast.StringNode{Value: "Age"}, diff --git a/parser/parser.go b/parser/parser.go index 77b2a700a..0817f6e4b 100644 --- a/parser/parser.go +++ b/parser/parser.go @@ -19,7 +19,7 @@ type arg byte const ( expr arg = 1 << iota - closure + predicate ) const optional arg = 1 << 7 @@ -27,21 +27,21 @@ const optional arg = 1 << 7 var predicates = map[string]struct { args []arg }{ - "all": {[]arg{expr, closure}}, - "none": {[]arg{expr, closure}}, - "any": {[]arg{expr, closure}}, - "one": {[]arg{expr, closure}}, - "filter": {[]arg{expr, closure}}, - "map": {[]arg{expr, closure}}, - "count": {[]arg{expr, closure | optional}}, - "sum": {[]arg{expr, closure | optional}}, - "find": {[]arg{expr, closure}}, - "findIndex": {[]arg{expr, closure}}, - "findLast": {[]arg{expr, closure}}, - "findLastIndex": {[]arg{expr, closure}}, - "groupBy": {[]arg{expr, closure}}, - "sortBy": {[]arg{expr, closure, expr | optional}}, - "reduce": {[]arg{expr, closure, expr | optional}}, + "all": {[]arg{expr, predicate}}, + "none": {[]arg{expr, predicate}}, + "any": {[]arg{expr, predicate}}, + "one": {[]arg{expr, predicate}}, + "filter": {[]arg{expr, predicate}}, + "map": {[]arg{expr, predicate}}, + "count": {[]arg{expr, predicate | optional}}, + "sum": {[]arg{expr, predicate | optional}}, + "find": {[]arg{expr, predicate}}, + "findIndex": {[]arg{expr, predicate}}, + "findLast": {[]arg{expr, predicate}}, + "findLastIndex": {[]arg{expr, predicate}}, + "groupBy": {[]arg{expr, predicate}}, + "sortBy": {[]arg{expr, predicate, expr | optional}}, + "reduce": {[]arg{expr, predicate, expr | optional}}, } type parser struct { @@ -49,7 +49,7 @@ type parser struct { current Token pos int err *file.Error - depth int // closure call depth + depth int // predicate call depth config *conf.Config } @@ -298,7 +298,7 @@ func (p *parser) parsePrimary() Node { } } else { if token.Is(Operator, "#") || token.Is(Operator, ".") { - p.error("cannot use pointer accessor outside closure") + p.error("cannot use pointer accessor outside predicate") } } @@ -448,8 +448,8 @@ func (p *parser) parseCall(token Token, arguments []Node, checkOverrides bool) N switch { case arg&expr == expr: node = p.parseExpression(0) - case arg&closure == closure: - node = p.parseClosure() + case arg&predicate == predicate: + node = p.parsePredicate() } arguments = append(arguments, node) } @@ -497,7 +497,7 @@ func (p *parser) parseArguments(arguments []Node) []Node { return arguments } -func (p *parser) parseClosure() Node { +func (p *parser) parsePredicate() Node { startToken := p.current expectClosingBracket := false if p.current.Is(Bracket, "{") { @@ -512,11 +512,11 @@ func (p *parser) parseClosure() Node { if expectClosingBracket { p.expect(Bracket, "}") } - closure := &ClosureNode{ + predicateNode := &PredicateNode{ Node: node, } - closure.SetLocation(startToken.Location) - return closure + predicateNode.SetLocation(startToken.Location) + return predicateNode } func (p *parser) parseArrayExpression(token Token) Node { diff --git a/parser/parser_test.go b/parser/parser_test.go index 3c6ee5b2b..a280bf39a 100644 --- a/parser/parser_test.go +++ b/parser/parser_test.go @@ -427,7 +427,7 @@ world`}, Name: "all", Arguments: []Node{ &IdentifierNode{Value: "Tickets"}, - &ClosureNode{ + &PredicateNode{ Node: &PointerNode{}, }}}, }, @@ -437,7 +437,7 @@ world`}, Name: "all", Arguments: []Node{ &IdentifierNode{Value: "Tickets"}, - &ClosureNode{ + &PredicateNode{ Node: &BinaryNode{ Operator: ">", Left: &MemberNode{Node: &PointerNode{}, @@ -450,7 +450,7 @@ world`}, Name: "one", Arguments: []Node{ &IdentifierNode{Value: "Tickets"}, - &ClosureNode{ + &PredicateNode{ Node: &BinaryNode{ Operator: ">", Left: &MemberNode{ @@ -463,7 +463,7 @@ world`}, "filter(Prices, {# > 100})", &BuiltinNode{Name: "filter", Arguments: []Node{&IdentifierNode{Value: "Prices"}, - &ClosureNode{Node: &BinaryNode{Operator: ">", + &PredicateNode{Node: &BinaryNode{Operator: ">", Left: &PointerNode{}, Right: &IntegerNode{Value: 100}}}}}, }, @@ -550,7 +550,7 @@ world`}, Name: "map", Arguments: []Node{ &ArrayNode{}, - &ClosureNode{ + &PredicateNode{ Node: &PointerNode{Name: "index"}, }, }, @@ -694,7 +694,7 @@ a map key must be a quoted string, a number, a identifier, or an expression encl | .....^ .foo -cannot use pointer accessor outside closure (1:1) +cannot use pointer accessor outside predicate (1:1) | .foo | ^ @@ -904,7 +904,7 @@ func TestParse_pipe_operator(t *testing.T) { Name: "map", Arguments: []Node{ &IdentifierNode{Value: "arr"}, - &ClosureNode{ + &PredicateNode{ Node: &MemberNode{ Node: &PointerNode{}, Property: &StringNode{Value: "foo"}, diff --git a/patcher/operator_override.go b/patcher/operator_override.go index 551fe09bb..b2d20ec4b 100644 --- a/patcher/operator_override.go +++ b/patcher/operator_override.go @@ -6,13 +6,14 @@ import ( "github.com/expr-lang/expr/ast" "github.com/expr-lang/expr/builtin" + "github.com/expr-lang/expr/checker/nature" "github.com/expr-lang/expr/conf" ) type OperatorOverloading struct { Operator string // Operator token to overload. Overloads []string // List of function names to replace operator with. - Types conf.TypesTable // Env types. + Env *nature.Nature // Env type. Functions conf.FunctionsTable // Env functions. applied bool // Flag to indicate if any changes were made to the tree. } @@ -56,7 +57,7 @@ func (p *OperatorOverloading) FindSuitableOperatorOverload(l, r reflect.Type) (r func (p *OperatorOverloading) findSuitableOperatorOverloadInTypes(l, r reflect.Type) (reflect.Type, string, bool) { for _, fn := range p.Overloads { - fnType, ok := p.Types[fn] + fnType, ok := p.Env.Get(fn) if !ok { continue } @@ -103,7 +104,7 @@ func checkTypeSuits(t reflect.Type, l reflect.Type, r reflect.Type, firstInIndex func (p *OperatorOverloading) Check() { for _, fn := range p.Overloads { - fnType, foundType := p.Types[fn] + fnType, foundType := p.Env.Get(fn) fnFunc, foundFunc := p.Functions[fn] if !foundFunc && (!foundType || fnType.Type.Kind() != reflect.Func) { panic(fmt.Errorf("function %s for %s operator does not exist in the environment", fn, p.Operator)) @@ -119,7 +120,7 @@ func (p *OperatorOverloading) Check() { } } -func checkType(fnType conf.Tag, fn string, operator string) { +func checkType(fnType nature.Nature, fn string, operator string) { requiredNumIn := 2 if fnType.Method { requiredNumIn = 3 // As first argument of method is receiver. diff --git a/types/types.go b/types/types.go new file mode 100644 index 000000000..9057d14aa --- /dev/null +++ b/types/types.go @@ -0,0 +1,5 @@ +package types + +type Map map[string]any + +type StrictMap map[string]any From ac6e5a388a6973c85e98c0f344f308765fcd00b8 Mon Sep 17 00:00:00 2001 From: Anton Medvedev Date: Wed, 5 Jun 2024 01:14:25 +0200 Subject: [PATCH 010/113] Improve types pkg (#668) --- checker/checker_test.go | 2 +- checker/nature/of.go | 47 -------------------------- conf/config.go | 7 +--- conf/env.go | 73 +++++++++++++++++++++++++++++++++++++++++ docgen/docgen.go | 3 +- expr_test.go | 4 +-- types/types.go | 73 +++++++++++++++++++++++++++++++++++++++-- 7 files changed, 150 insertions(+), 59 deletions(-) delete mode 100644 checker/nature/of.go create mode 100644 conf/env.go diff --git a/checker/checker_test.go b/checker/checker_test.go index 0639f1f43..e5691b76d 100644 --- a/checker/checker_test.go +++ b/checker/checker_test.go @@ -1074,7 +1074,7 @@ func TestCheck_types(t *testing.T) { env := types.Map{ "foo": types.StrictMap{ "bar": types.Map{ - "baz": "", + "baz": types.String, }, }, } diff --git a/checker/nature/of.go b/checker/nature/of.go deleted file mode 100644 index 93235f9cd..000000000 --- a/checker/nature/of.go +++ /dev/null @@ -1,47 +0,0 @@ -package nature - -import ( - "fmt" - "reflect" - - "github.com/expr-lang/expr/types" -) - -func Of(value any) Nature { - if value == nil { - return Nature{Nil: true} - } - - v := reflect.ValueOf(value) - - switch v.Kind() { - case reflect.Map: - _, strict := value.(types.StrictMap) - fields := make(map[string]Nature, v.Len()) - for _, key := range v.MapKeys() { - elem := v.MapIndex(key) - if !elem.IsValid() || !elem.CanInterface() { - panic(fmt.Sprintf("invalid map value: %s", key)) - } - face := elem.Interface() - switch face.(type) { - case types.Map, types.StrictMap: - fields[key.String()] = Of(face) - default: - if face == nil { - fields[key.String()] = Nature{Nil: true} - continue - } - fields[key.String()] = Nature{Type: reflect.TypeOf(face)} - - } - } - return Nature{ - Type: v.Type(), - Fields: fields, - Strict: strict, - } - } - - return Nature{Type: v.Type()} -} diff --git a/conf/config.go b/conf/config.go index 77bb2a67b..8a6ee70e2 100644 --- a/conf/config.go +++ b/conf/config.go @@ -7,7 +7,6 @@ import ( "github.com/expr-lang/expr/ast" "github.com/expr-lang/expr/builtin" "github.com/expr-lang/expr/checker/nature" - "github.com/expr-lang/expr/types" "github.com/expr-lang/expr/vm/runtime" ) @@ -53,11 +52,7 @@ func New(env any) *Config { func (c *Config) WithEnv(env any) { c.Strict = true c.EnvObject = env - c.Env = nature.Of(env) - c.Env.Strict = true // To keep backward compatibility with expr.AllowUndefinedVariables() - if _, ok := env.(types.Map); ok { - c.Env.Strict = false - } + c.Env = Env(env) } func (c *Config) ConstExpr(name string) { diff --git a/conf/env.go b/conf/env.go new file mode 100644 index 000000000..82e6a93d9 --- /dev/null +++ b/conf/env.go @@ -0,0 +1,73 @@ +package conf + +import ( + "fmt" + "reflect" + + . "github.com/expr-lang/expr/checker/nature" + "github.com/expr-lang/expr/internal/deref" + "github.com/expr-lang/expr/types" +) + +func Env(env any) Nature { + if env == nil { + return Nature{ + Type: reflect.TypeOf(map[string]any{}), + Strict: true, + } + } + + switch env := env.(type) { + case types.Map: + return env.Nature() + + case types.StrictMap: + return env.Nature() + } + + v := reflect.ValueOf(env) + d := deref.Value(v) + + switch d.Kind() { + case reflect.Struct: + return Nature{ + Type: v.Type(), + Strict: true, + } + + case reflect.Map: + n := Nature{ + Type: v.Type(), + Fields: make(map[string]Nature, v.Len()), + } + + for _, key := range v.MapKeys() { + elem := v.MapIndex(key) + if !elem.IsValid() || !elem.CanInterface() { + panic(fmt.Sprintf("invalid map value: %s", key)) + } + + face := elem.Interface() + + switch face.(type) { + case types.Map: + n.Fields[key.String()] = face.(types.Map).Nature() + + case types.StrictMap: + n.Fields[key.String()] = face.(types.StrictMap).Nature() + + default: + if face == nil { + n.Fields[key.String()] = Nature{Nil: true} + continue + } + n.Fields[key.String()] = Nature{Type: reflect.TypeOf(face)} + } + + } + + return n + } + + panic(fmt.Sprintf("unknown type %T", env)) +} diff --git a/docgen/docgen.go b/docgen/docgen.go index d9abcf0e4..1844f23b5 100644 --- a/docgen/docgen.go +++ b/docgen/docgen.go @@ -6,6 +6,7 @@ import ( "strings" "github.com/expr-lang/expr/checker/nature" + "github.com/expr-lang/expr/conf" "github.com/expr-lang/expr/internal/deref" ) @@ -84,7 +85,7 @@ func CreateDoc(i any) *Context { PkgPath: deref.Type(reflect.TypeOf(i)).PkgPath(), } - for name, t := range nature.Of(i).All() { + for name, t := range conf.Env(i).All() { if _, ok := c.Variables[Identifier(name)]; ok { continue } diff --git a/expr_test.go b/expr_test.go index e71393f39..4f2f829df 100644 --- a/expr_test.go +++ b/expr_test.go @@ -2705,7 +2705,7 @@ func TestExpr_nil_op_str(t *testing.T) { func TestExpr_env_types_map(t *testing.T) { envTypes := types.Map{ "foo": types.StrictMap{ - "bar": "value", + "bar": types.String, }, } @@ -2726,7 +2726,7 @@ func TestExpr_env_types_map(t *testing.T) { func TestExpr_env_types_map_error(t *testing.T) { envTypes := types.Map{ "foo": types.StrictMap{ - "bar": "value", + "bar": types.String, }, } diff --git a/types/types.go b/types/types.go index 9057d14aa..e707e18c0 100644 --- a/types/types.go +++ b/types/types.go @@ -1,5 +1,74 @@ package types -type Map map[string]any +import ( + "reflect" -type StrictMap map[string]any + . "github.com/expr-lang/expr/checker/nature" +) + +func TypeOf(v any) Type { + return rtype{t: reflect.TypeOf(v)} +} + +var ( + Int = TypeOf(0) + Int8 = TypeOf(int8(0)) + Int16 = TypeOf(int16(0)) + Int32 = TypeOf(int32(0)) + Int64 = TypeOf(int64(0)) + Uint = TypeOf(uint(0)) + Uint8 = TypeOf(uint8(0)) + Uint16 = TypeOf(uint16(0)) + Uint32 = TypeOf(uint32(0)) + Uint64 = TypeOf(uint64(0)) + Float = TypeOf(float32(0)) + Float64 = TypeOf(float64(0)) + String = TypeOf("") + Bool = TypeOf(true) + Nil = nilType{} +) + +type Type interface { + Nature() Nature +} + +type nilType struct{} + +func (nilType) Nature() Nature { + return Nature{Nil: true} +} + +type rtype struct { + t reflect.Type +} + +func (r rtype) Nature() Nature { + return Nature{Type: r.t} +} + +type Map map[string]Type + +func (m Map) Nature() Nature { + nt := Nature{ + Type: reflect.TypeOf(map[string]any{}), + Fields: make(map[string]Nature, len(m)), + } + for k, v := range m { + nt.Fields[k] = v.Nature() + } + return nt +} + +type StrictMap map[string]Type + +func (m StrictMap) Nature() Nature { + nt := Nature{ + Type: reflect.TypeOf(map[string]any{}), + Fields: make(map[string]Nature, len(m)), + Strict: true, + } + for k, v := range m { + nt.Fields[k] = v.Nature() + } + return nt +} From 55f453b5769b8448261464c683e2ee8e42397e8f Mon Sep 17 00:00:00 2001 From: Anton Medvedev Date: Wed, 5 Jun 2024 15:48:40 +0200 Subject: [PATCH 011/113] Add types.Array() --- checker/checker_test.go | 5 +++++ types/types.go | 23 +++++++++++++++++++++++ 2 files changed, 28 insertions(+) diff --git a/checker/checker_test.go b/checker/checker_test.go index e5691b76d..fad56eb28 100644 --- a/checker/checker_test.go +++ b/checker/checker_test.go @@ -1077,6 +1077,9 @@ func TestCheck_types(t *testing.T) { "baz": types.String, }, }, + "arr": types.Array(types.StrictMap{ + "value": types.String, + }), } noerr := "no error" @@ -1090,6 +1093,8 @@ func TestCheck_types(t *testing.T) { {`foo.bar.unknown`, noerr}, {`[foo] | map(.unknown)`, `unknown field unknown`}, {`[foo] | map(.bar) | filter(.baz)`, `predicate should return boolean (got string)`}, + {`arr | filter(.value > 0)`, `invalid operation: > (mismatched types string and int)`}, + {`arr | filter(.value contains "a") | filter(.value == 0)`, `invalid operation: == (mismatched types string and int)`}, } for _, test := range tests { diff --git a/types/types.go b/types/types.go index e707e18c0..71dc8b5a9 100644 --- a/types/types.go +++ b/types/types.go @@ -28,6 +28,7 @@ var ( Nil = nilType{} ) +// Type is a type that can be used to represent a value. type Type interface { Nature() Nature } @@ -46,6 +47,8 @@ func (r rtype) Nature() Nature { return Nature{Type: r.t} } +// Map returns a type that represents a map of the given type. +// The map is not strict, meaning that it can contain keys not defined in the map. type Map map[string]Type func (m Map) Nature() Nature { @@ -59,6 +62,8 @@ func (m Map) Nature() Nature { return nt } +// StrictMap returns a type that represents a map of the given type. +// The map is strict, meaning that it can only contain keys defined in the map. type StrictMap map[string]Type func (m StrictMap) Nature() Nature { @@ -72,3 +77,21 @@ func (m StrictMap) Nature() Nature { } return nt } + +// Array returns a type that represents an array of the given type. +func Array(of Type) Type { + return array{of} +} + +type array struct { + of Type +} + +func (a array) Nature() Nature { + of := a.of.Nature() + return Nature{ + Type: reflect.TypeOf([]any{}), + Fields: make(map[string]Nature, 1), + ArrayOf: &of, + } +} From 0c7f72008524679a9dbd9b6022d7fa73b1197f20 Mon Sep 17 00:00:00 2001 From: Anton Medvedev Date: Fri, 14 Jun 2024 09:23:26 +0200 Subject: [PATCH 012/113] Add types.Equal --- types/types.go | 99 ++++++++++++++++++++++++++++++++++++++++++--- types/types_test.go | 47 +++++++++++++++++++++ 2 files changed, 141 insertions(+), 5 deletions(-) create mode 100644 types/types_test.go diff --git a/types/types.go b/types/types.go index 71dc8b5a9..52b8d9b5c 100644 --- a/types/types.go +++ b/types/types.go @@ -1,13 +1,18 @@ package types import ( + "fmt" "reflect" + "strings" . "github.com/expr-lang/expr/checker/nature" ) -func TypeOf(v any) Type { - return rtype{t: reflect.TypeOf(v)} +// Type is a type that can be used to represent a value. +type Type interface { + Nature() Nature + Equal(Type) bool + String() string } var ( @@ -28,9 +33,11 @@ var ( Nil = nilType{} ) -// Type is a type that can be used to represent a value. -type Type interface { - Nature() Nature +func TypeOf(v any) Type { + if v == nil { + return Nil + } + return rtype{t: reflect.TypeOf(v)} } type nilType struct{} @@ -39,6 +46,14 @@ func (nilType) Nature() Nature { return Nature{Nil: true} } +func (nilType) Equal(t Type) bool { + return t == Nil +} + +func (nilType) String() string { + return "nil" +} + type rtype struct { t reflect.Type } @@ -47,6 +62,17 @@ func (r rtype) Nature() Nature { return Nature{Type: r.t} } +func (r rtype) Equal(t Type) bool { + if rt, ok := t.(rtype); ok { + return r.t.String() == rt.t.String() + } + return false +} + +func (r rtype) String() string { + return r.t.String() +} + // Map returns a type that represents a map of the given type. // The map is not strict, meaning that it can contain keys not defined in the map. type Map map[string]Type @@ -62,6 +88,30 @@ func (m Map) Nature() Nature { return nt } +func (m Map) Equal(t Type) bool { + mt, ok := t.(Map) + if !ok { + return false + } + if len(m) != len(mt) { + return false + } + for k, v := range m { + if !v.Equal(mt[k]) { + return false + } + } + return true +} + +func (m Map) String() string { + pairs := make([]string, 0, len(m)) + for k, v := range m { + pairs = append(pairs, fmt.Sprintf("%s: %s", k, v.String())) + } + return fmt.Sprintf("Map{%s}", strings.Join(pairs, ", ")) +} + // StrictMap returns a type that represents a map of the given type. // The map is strict, meaning that it can only contain keys defined in the map. type StrictMap map[string]Type @@ -78,6 +128,30 @@ func (m StrictMap) Nature() Nature { return nt } +func (m StrictMap) Equal(t Type) bool { + mt, ok := t.(StrictMap) + if !ok { + return false + } + if len(m) != len(mt) { + return false + } + for k, v := range m { + if !v.Equal(mt[k]) { + return false + } + } + return true +} + +func (m StrictMap) String() string { + pairs := make([]string, 0, len(m)) + for k, v := range m { + pairs = append(pairs, fmt.Sprintf("%s: %s", k, v.String())) + } + return fmt.Sprintf("StrictMap{%s}", strings.Join(pairs, ", ")) +} + // Array returns a type that represents an array of the given type. func Array(of Type) Type { return array{of} @@ -95,3 +169,18 @@ func (a array) Nature() Nature { ArrayOf: &of, } } + +func (a array) Equal(t Type) bool { + at, ok := t.(array) + if !ok { + return false + } + if a.of.Equal(at.of) { + return true + } + return false +} + +func (a array) String() string { + return fmt.Sprintf("Array{%s}", a.of.String()) +} diff --git a/types/types_test.go b/types/types_test.go new file mode 100644 index 000000000..52b6c86a1 --- /dev/null +++ b/types/types_test.go @@ -0,0 +1,47 @@ +package types_test + +import ( + "testing" + + "github.com/expr-lang/expr/internal/testify/require" + . "github.com/expr-lang/expr/types" +) + +func TestType_Equal(t *testing.T) { + tests := []struct { + index string + a, b Type + want bool + }{ + {"1", Int, Int, true}, + {"2", Int, Int8, false}, + {"3", Int, Uint, false}, + {"4", Int, Float, false}, + {"5", Int, String, false}, + {"6", Int, Bool, false}, + {"7", Int, Nil, false}, + {"8", Int, Array(Int), false}, + {"9", Int, Map{"foo": Int}, false}, + {"10", Int, StrictMap{"foo": Int}, false}, + {"11", Int, Array(Int), false}, + {"12", Array(Int), Array(Int), true}, + {"13", Array(Int), Array(Float), false}, + {"14", Map{"foo": Int}, Map{"foo": Int}, true}, + {"15", Map{"foo": Int}, Map{"foo": Float}, false}, + {"16", Map{"foo": Int}, StrictMap{"foo": Int}, false}, + {"17", StrictMap{"foo": Int}, StrictMap{"foo": Int}, true}, + {"18", StrictMap{"foo": Int}, StrictMap{"foo": Float}, false}, + {"19", Map{"foo": Map{"bar": Int}}, Map{"foo": Map{"bar": Int}}, true}, + {"20", Map{"foo": Map{"bar": Int}}, Map{"foo": Map{"bar": Float}}, false}, + } + + for _, tt := range tests { + t.Run(tt.index, func(t *testing.T) { + if tt.want { + require.True(t, tt.a.Equal(tt.b), tt.a.String()+" == "+tt.b.String()) + } else { + require.False(t, tt.a.Equal(tt.b), tt.a.String()+" == "+tt.b.String()) + } + }) + } +} From b24c7f3a1066a712181f1ddd27a0d6911d193542 Mon Sep 17 00:00:00 2001 From: Anton Medvedev Date: Fri, 14 Jun 2024 09:32:52 +0200 Subject: [PATCH 013/113] Add any type --- types/types.go | 30 ++++++++++++++++++++++++++++++ types/types_test.go | 9 +++++++++ 2 files changed, 39 insertions(+) diff --git a/types/types.go b/types/types.go index 52b8d9b5c..92923f9a3 100644 --- a/types/types.go +++ b/types/types.go @@ -31,6 +31,7 @@ var ( String = TypeOf("") Bool = TypeOf(true) Nil = nilType{} + Any = anyType{} ) func TypeOf(v any) Type { @@ -40,6 +41,20 @@ func TypeOf(v any) Type { return rtype{t: reflect.TypeOf(v)} } +type anyType struct{} + +func (anyType) Nature() Nature { + return Nature{Type: nil} +} + +func (anyType) Equal(t Type) bool { + return true +} + +func (anyType) String() string { + return "any" +} + type nilType struct{} func (nilType) Nature() Nature { @@ -47,6 +62,9 @@ func (nilType) Nature() Nature { } func (nilType) Equal(t Type) bool { + if t == Any { + return true + } return t == Nil } @@ -63,6 +81,9 @@ func (r rtype) Nature() Nature { } func (r rtype) Equal(t Type) bool { + if t == Any { + return true + } if rt, ok := t.(rtype); ok { return r.t.String() == rt.t.String() } @@ -89,6 +110,9 @@ func (m Map) Nature() Nature { } func (m Map) Equal(t Type) bool { + if t == Any { + return true + } mt, ok := t.(Map) if !ok { return false @@ -129,6 +153,9 @@ func (m StrictMap) Nature() Nature { } func (m StrictMap) Equal(t Type) bool { + if t == Any { + return true + } mt, ok := t.(StrictMap) if !ok { return false @@ -171,6 +198,9 @@ func (a array) Nature() Nature { } func (a array) Equal(t Type) bool { + if t == Any { + return true + } at, ok := t.(array) if !ok { return false diff --git a/types/types_test.go b/types/types_test.go index 52b6c86a1..eacfef221 100644 --- a/types/types_test.go +++ b/types/types_test.go @@ -33,6 +33,15 @@ func TestType_Equal(t *testing.T) { {"18", StrictMap{"foo": Int}, StrictMap{"foo": Float}, false}, {"19", Map{"foo": Map{"bar": Int}}, Map{"foo": Map{"bar": Int}}, true}, {"20", Map{"foo": Map{"bar": Int}}, Map{"foo": Map{"bar": Float}}, false}, + {"21", Any, Any, true}, + {"22", Any, Int, true}, + {"23", Int, Any, true}, + {"24", Any, Map{"foo": Int}, true}, + {"25", Map{"foo": Int}, Any, true}, + {"26", Any, StrictMap{"foo": Int}, true}, + {"27", StrictMap{"foo": Int}, Any, true}, + {"28", Any, Array(Int), true}, + {"29", Array(Int), Any, true}, } for _, tt := range tests { From 971388017260b2241784c4ed216f8e6eb91ef7f5 Mon Sep 17 00:00:00 2001 From: zhuliquan Date: Mon, 24 Jun 2024 03:20:41 +0800 Subject: [PATCH 014/113] Fix unary node print for conditional expr (#676) * feat: extract code for compiling equal operator * fix: fix unary node inside condition node print --- ast/print.go | 11 +++++++---- ast/print_test.go | 1 + 2 files changed, 8 insertions(+), 4 deletions(-) diff --git a/ast/print.go b/ast/print.go index f59377153..b79048b2c 100644 --- a/ast/print.go +++ b/ast/print.go @@ -45,13 +45,16 @@ func (n *ConstantNode) String() string { } func (n *UnaryNode) String() string { - op := "" + op := n.Operator if n.Operator == "not" { op = fmt.Sprintf("%s ", n.Operator) - } else { - op = fmt.Sprintf("%s", n.Operator) } - if _, ok := n.Node.(*BinaryNode); ok { + wrap := false + switch n.Node.(type) { + case *BinaryNode, *ConditionalNode: + wrap = true + } + if wrap { return fmt.Sprintf("%s(%s)", op, n.Node.String()) } return fmt.Sprintf("%s%s", op, n.Node.String()) diff --git a/ast/print_test.go b/ast/print_test.go index 51edd63f5..a4b20b0a1 100644 --- a/ast/print_test.go +++ b/ast/print_test.go @@ -77,6 +77,7 @@ func TestPrint(t *testing.T) { {`(nil ?? 1) > 0`, `(nil ?? 1) > 0`}, {`{("a" + "b"): 42}`, `{("a" + "b"): 42}`}, {`(One == 1 ? true : false) && Two == 2`, `(One == 1 ? true : false) && Two == 2`}, + {`not (a == 1 ? b > 1 : b < 2)`, `not (a == 1 ? b > 1 : b < 2)`}, } for _, tt := range tests { From c42572b9c7d8471776ed9a8b5bade850cff73d26 Mon Sep 17 00:00:00 2001 From: Arik Cohen Date: Thu, 4 Jul 2024 17:49:14 -0400 Subject: [PATCH 015/113] Add Tork to its list of users (#682) Signed-off-by: Arik Cohen --- README.md | 1 + 1 file changed, 1 insertion(+) diff --git a/README.md b/README.md index 6c56c67b6..71ec78764 100644 --- a/README.md +++ b/README.md @@ -165,6 +165,7 @@ func main() { * [Span Digital](https://spandigital.com/) uses Expr in it's Knowledge Management products. * [Xiaohongshu](https://www.xiaohongshu.com/) combining yaml with Expr for dynamically policies delivery. * [Melrōse](https://melrōse.org) uses Expr to implement its music programming language. +* [Tork](https://www.tork.run/) integrates Expr into its workflow execution. [Add your company too](https://github.com/expr-lang/expr/edit/master/README.md) From 5e3d5a2e7d97cc6be84d181cbbee4d319853a940 Mon Sep 17 00:00:00 2001 From: Simon Waldherr Date: Sun, 14 Jul 2024 09:07:58 +0200 Subject: [PATCH 016/113] Fix typos (#686) --- internal/spew/internalunsafe_test.go | 2 +- test/operator/operator_test.go | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/internal/spew/internalunsafe_test.go b/internal/spew/internalunsafe_test.go index 2b547c41c..aa8fa00b1 100644 --- a/internal/spew/internalunsafe_test.go +++ b/internal/spew/internalunsafe_test.go @@ -47,7 +47,7 @@ func changeKind(v *reflect.Value, readOnly bool) { *flags |= flagKindMask } -// TestAddedReflectValue tests functionaly of the dump and formatter code which +// TestAddedReflectValue tests functionality of the dump and formatter code which // falls back to the standard fmt library for new types that might get added to // the language. func TestAddedReflectValue(t *testing.T) { diff --git a/test/operator/operator_test.go b/test/operator/operator_test.go index 2ebb176f8..ec7da8724 100644 --- a/test/operator/operator_test.go +++ b/test/operator/operator_test.go @@ -148,7 +148,7 @@ func TestOperator_FunctionOverTypesPrecedence(t *testing.T) { expr.Env(env), expr.Operator("+", "Add"), expr.Function("Add", func(args ...interface{}) (interface{}, error) { - // Wierd function that returns 100 + a + b in testing purposes. + // Weird function that returns 100 + a + b for testing purposes. return args[0].(int) + args[1].(int) + 100, nil }, new(func(_ int, __ int) int), From 5e660e753e47a4f3a3a9e234f625dc210b5a331e Mon Sep 17 00:00:00 2001 From: OlgaNovg <75758884+OlgaNovg@users.noreply.github.com> Date: Mon, 15 Jul 2024 11:19:33 +0200 Subject: [PATCH 017/113] Add flatten builtin (#684) --- builtin/builtin.go | 31 +++++++++++++++++++++++++++++++ builtin/builtin_test.go | 5 +++++ builtin/lib.go | 14 ++++++++++++++ docs/language-definition.md | 8 ++++++++ 4 files changed, 58 insertions(+) diff --git a/builtin/builtin.go b/builtin/builtin.go index cc6f197cd..0107d276c 100644 --- a/builtin/builtin.go +++ b/builtin/builtin.go @@ -873,6 +873,37 @@ var Builtins = []*Function{ return arrayType, nil }, }, + { + Name: "flatten", + Safe: func(args ...any) (any, uint, error) { + var size uint + if len(args) != 1 { + return nil, 0, fmt.Errorf("invalid number of arguments (expected 1, got %d)", len(args)) + } + v := reflect.ValueOf(deref.Deref(args[0])) + if v.Kind() != reflect.Array && v.Kind() != reflect.Slice { + return nil, size, fmt.Errorf("cannot flatten %s", v.Kind()) + } + ret := flatten(v) + size = uint(len(ret)) + return ret, size, nil + }, + Validate: func(args []reflect.Type) (reflect.Type, error) { + if len(args) != 1 { + return anyType, fmt.Errorf("invalid number of arguments (expected 1, got %d)", len(args)) + } + + for _, arg := range args { + switch kind(deref.Type(arg)) { + case reflect.Interface, reflect.Slice, reflect.Array: + default: + return anyType, fmt.Errorf("cannot flatten %s", arg) + } + } + + return arrayType, nil + }, + }, { Name: "sort", Safe: func(args ...any) (any, uint, error) { diff --git a/builtin/builtin_test.go b/builtin/builtin_test.go index 97f249896..ddfb4a494 100644 --- a/builtin/builtin_test.go +++ b/builtin/builtin_test.go @@ -152,6 +152,9 @@ func TestBuiltin(t *testing.T) { {`reduce([], 5, 0)`, 0}, {`concat(ArrayOfString, ArrayOfInt)`, []any{"foo", "bar", "baz", 1, 2, 3}}, {`concat(PtrArrayWithNil, [nil])`, []any{42, nil}}, + {`flatten([["a", "b"], [1, 2]])`, []any{"a", "b", 1, 2}}, + {`flatten([["a", "b"], [1, 2, [3, 4]]])`, []any{"a", "b", 1, 2, 3, 4}}, + {`flatten([["a", "b"], [1, 2, [3, [[[["c", "d"], "e"]]], 4]]])`, []any{"a", "b", 1, 2, 3, "c", "d", "e", 4}}, } for _, test := range tests { @@ -236,6 +239,8 @@ func TestBuiltin_errors(t *testing.T) { {`now(nil)`, "invalid number of arguments (expected 0, got 1)"}, {`date(nil)`, "interface {} is nil, not string (1:1)"}, {`timezone(nil)`, "cannot use nil as argument (type string) to call timezone (1:10)"}, + {`flatten([1, 2], [3, 4])`, "invalid number of arguments (expected 1, got 2)"}, + {`flatten(1)`, "cannot flatten int"}, } for _, test := range errorTests { t.Run(test.input, func(t *testing.T) { diff --git a/builtin/lib.go b/builtin/lib.go index e3cd61b96..13c7d207e 100644 --- a/builtin/lib.go +++ b/builtin/lib.go @@ -359,3 +359,17 @@ func median(args ...any) ([]float64, error) { } return values, nil } + +func flatten(arg reflect.Value) []any { + ret := []any{} + for i := 0; i < arg.Len(); i++ { + v := deref.Value(arg.Index(i)) + if v.Kind() == reflect.Array || v.Kind() == reflect.Slice { + x := flatten(v) + ret = append(ret, x...) + } else { + ret = append(ret, v.Interface()) + } + } + return ret +} diff --git a/docs/language-definition.md b/docs/language-definition.md index c8709aa04..9c277e9a2 100644 --- a/docs/language-definition.md +++ b/docs/language-definition.md @@ -689,6 +689,14 @@ Concatenates two or more arrays. concat([1, 2], [3, 4]) == [1, 2, 3, 4] ``` +### flatten(array) {#flatten} + +Flattens given array into one-dimentional array. + +```expr +flatten([1, 2, [3, 4]]) == [1, 2, 3, 4] +``` + ### join(array[, delimiter]) {#join} Joins an array of strings into a single string with the given delimiter. From c72da7bf4db186bd6ca94ca58dc8da83d3bf3495 Mon Sep 17 00:00:00 2001 From: Anton Medvedev Date: Wed, 28 Aug 2024 22:47:47 +0200 Subject: [PATCH 018/113] Drop types.StrictMap and add types.Extra to define additional keys --- checker/checker_test.go | 11 +++++---- conf/env.go | 6 ----- expr_test.go | 4 ++-- types/types.go | 53 +++++++---------------------------------- types/types_test.go | 8 +------ 5 files changed, 18 insertions(+), 64 deletions(-) diff --git a/checker/checker_test.go b/checker/checker_test.go index fad56eb28..602fe4b7a 100644 --- a/checker/checker_test.go +++ b/checker/checker_test.go @@ -1072,14 +1072,16 @@ func TestCheck_builtin_without_call(t *testing.T) { func TestCheck_types(t *testing.T) { env := types.Map{ - "foo": types.StrictMap{ + "foo": types.Map{ "bar": types.Map{ - "baz": types.String, + "baz": types.String, + types.Extra: types.String, }, }, - "arr": types.Array(types.StrictMap{ + "arr": types.Array(types.Map{ "value": types.String, }), + types.Extra: types.Any, } noerr := "no error" @@ -1102,7 +1104,8 @@ func TestCheck_types(t *testing.T) { tree, err := parser.Parse(test.code) require.NoError(t, err) - _, err = checker.Check(tree, conf.New(env)) + config := conf.New(env) + _, err = checker.Check(tree, config) if test.err == noerr { require.NoError(t, err) } else { diff --git a/conf/env.go b/conf/env.go index 82e6a93d9..494bb5b74 100644 --- a/conf/env.go +++ b/conf/env.go @@ -20,9 +20,6 @@ func Env(env any) Nature { switch env := env.(type) { case types.Map: return env.Nature() - - case types.StrictMap: - return env.Nature() } v := reflect.ValueOf(env) @@ -53,9 +50,6 @@ func Env(env any) Nature { case types.Map: n.Fields[key.String()] = face.(types.Map).Nature() - case types.StrictMap: - n.Fields[key.String()] = face.(types.StrictMap).Nature() - default: if face == nil { n.Fields[key.String()] = Nature{Nil: true} diff --git a/expr_test.go b/expr_test.go index 4f2f829df..ced182a9f 100644 --- a/expr_test.go +++ b/expr_test.go @@ -2704,7 +2704,7 @@ func TestExpr_nil_op_str(t *testing.T) { func TestExpr_env_types_map(t *testing.T) { envTypes := types.Map{ - "foo": types.StrictMap{ + "foo": types.Map{ "bar": types.String, }, } @@ -2725,7 +2725,7 @@ func TestExpr_env_types_map(t *testing.T) { func TestExpr_env_types_map_error(t *testing.T) { envTypes := types.Map{ - "foo": types.StrictMap{ + "foo": types.Map{ "bar": types.String, }, } diff --git a/types/types.go b/types/types.go index 92923f9a3..d10d2fbc1 100644 --- a/types/types.go +++ b/types/types.go @@ -94,16 +94,22 @@ func (r rtype) String() string { return r.t.String() } -// Map returns a type that represents a map of the given type. -// The map is not strict, meaning that it can contain keys not defined in the map. +// Map represents a map[string]any type with defined keys. type Map map[string]Type +const Extra = "[[__extra_keys__]]" + func (m Map) Nature() Nature { nt := Nature{ Type: reflect.TypeOf(map[string]any{}), Fields: make(map[string]Nature, len(m)), + Strict: true, } for k, v := range m { + if k == Extra { + nt.Strict = false + continue + } nt.Fields[k] = v.Nature() } return nt @@ -136,49 +142,6 @@ func (m Map) String() string { return fmt.Sprintf("Map{%s}", strings.Join(pairs, ", ")) } -// StrictMap returns a type that represents a map of the given type. -// The map is strict, meaning that it can only contain keys defined in the map. -type StrictMap map[string]Type - -func (m StrictMap) Nature() Nature { - nt := Nature{ - Type: reflect.TypeOf(map[string]any{}), - Fields: make(map[string]Nature, len(m)), - Strict: true, - } - for k, v := range m { - nt.Fields[k] = v.Nature() - } - return nt -} - -func (m StrictMap) Equal(t Type) bool { - if t == Any { - return true - } - mt, ok := t.(StrictMap) - if !ok { - return false - } - if len(m) != len(mt) { - return false - } - for k, v := range m { - if !v.Equal(mt[k]) { - return false - } - } - return true -} - -func (m StrictMap) String() string { - pairs := make([]string, 0, len(m)) - for k, v := range m { - pairs = append(pairs, fmt.Sprintf("%s: %s", k, v.String())) - } - return fmt.Sprintf("StrictMap{%s}", strings.Join(pairs, ", ")) -} - // Array returns a type that represents an array of the given type. func Array(of Type) Type { return array{of} diff --git a/types/types_test.go b/types/types_test.go index eacfef221..15a6ca77a 100644 --- a/types/types_test.go +++ b/types/types_test.go @@ -9,7 +9,7 @@ import ( func TestType_Equal(t *testing.T) { tests := []struct { - index string + index string // Index added for IDEA to show green test marker per test. a, b Type want bool }{ @@ -22,15 +22,11 @@ func TestType_Equal(t *testing.T) { {"7", Int, Nil, false}, {"8", Int, Array(Int), false}, {"9", Int, Map{"foo": Int}, false}, - {"10", Int, StrictMap{"foo": Int}, false}, {"11", Int, Array(Int), false}, {"12", Array(Int), Array(Int), true}, {"13", Array(Int), Array(Float), false}, {"14", Map{"foo": Int}, Map{"foo": Int}, true}, {"15", Map{"foo": Int}, Map{"foo": Float}, false}, - {"16", Map{"foo": Int}, StrictMap{"foo": Int}, false}, - {"17", StrictMap{"foo": Int}, StrictMap{"foo": Int}, true}, - {"18", StrictMap{"foo": Int}, StrictMap{"foo": Float}, false}, {"19", Map{"foo": Map{"bar": Int}}, Map{"foo": Map{"bar": Int}}, true}, {"20", Map{"foo": Map{"bar": Int}}, Map{"foo": Map{"bar": Float}}, false}, {"21", Any, Any, true}, @@ -38,8 +34,6 @@ func TestType_Equal(t *testing.T) { {"23", Int, Any, true}, {"24", Any, Map{"foo": Int}, true}, {"25", Map{"foo": Int}, Any, true}, - {"26", Any, StrictMap{"foo": Int}, true}, - {"27", StrictMap{"foo": Int}, Any, true}, {"28", Any, Array(Int), true}, {"29", Array(Int), Any, true}, } From da04c55bcbb2709417c056c62531de2f434595f2 Mon Sep 17 00:00:00 2001 From: Anton Medvedev Date: Wed, 28 Aug 2024 23:00:18 +0200 Subject: [PATCH 019/113] Add default map value type --- checker/checker_test.go | 2 ++ checker/nature/nature.go | 28 +++++++++++++++++----------- types/types.go | 2 ++ 3 files changed, 21 insertions(+), 11 deletions(-) diff --git a/checker/checker_test.go b/checker/checker_test.go index 602fe4b7a..17ec886e4 100644 --- a/checker/checker_test.go +++ b/checker/checker_test.go @@ -1090,9 +1090,11 @@ func TestCheck_types(t *testing.T) { err string }{ {`unknown`, noerr}, + {`[unknown + 42, another_unknown + "foo"]`, noerr}, {`foo.bar.baz > 0`, `invalid operation: > (mismatched types string and int)`}, {`foo.unknown.baz`, `unknown field unknown (1:5)`}, {`foo.bar.unknown`, noerr}, + {`foo.bar.unknown + 42`, `invalid operation: + (mismatched types string and int)`}, {`[foo] | map(.unknown)`, `unknown field unknown`}, {`[foo] | map(.bar) | filter(.baz)`, `predicate should return boolean (got string)`}, {`arr | filter(.value > 0)`, `invalid operation: > (mismatched types string and int)`}, diff --git a/checker/nature/nature.go b/checker/nature/nature.go index a385521c5..2b09353b5 100644 --- a/checker/nature/nature.go +++ b/checker/nature/nature.go @@ -12,16 +12,17 @@ var ( ) type Nature struct { - Type reflect.Type // Type of the value. If nil, then value is unknown. - Func *builtin.Function // Used to pass function type from callee to CallNode. - ArrayOf *Nature // Elem nature of array type (usually Type is []any, but ArrayOf can be any nature). - PredicateOut *Nature // Out nature of predicate. - Fields map[string]Nature // Fields of map type. - Strict bool // If map is types.StrictMap. - Nil bool // If value is nil. - Method bool // If value retrieved from method. Usually used to determine amount of in arguments. - MethodIndex int // Index of method in type. - FieldIndex []int // Index of field in type. + Type reflect.Type // Type of the value. If nil, then value is unknown. + Func *builtin.Function // Used to pass function type from callee to CallNode. + ArrayOf *Nature // Elem nature of array type (usually Type is []any, but ArrayOf can be any nature). + PredicateOut *Nature // Out nature of predicate. + Fields map[string]Nature // Fields of map type. + DefaultMapValue *Nature // Default value of map type. + Strict bool // If map is types.StrictMap. + Nil bool // If value is nil. + Method bool // If value retrieved from method. Usually used to determine amount of in arguments. + MethodIndex int // Index of method in type. + FieldIndex []int // Index of field in type. } func (n Nature) String() string { @@ -54,7 +55,12 @@ func (n Nature) Key() Nature { func (n Nature) Elem() Nature { switch n.Kind() { - case reflect.Map, reflect.Ptr: + case reflect.Ptr: + return Nature{Type: n.Type.Elem()} + case reflect.Map: + if n.DefaultMapValue != nil { + return *n.DefaultMapValue + } return Nature{Type: n.Type.Elem()} case reflect.Array, reflect.Slice: if n.ArrayOf != nil { diff --git a/types/types.go b/types/types.go index d10d2fbc1..bb1cbe5fa 100644 --- a/types/types.go +++ b/types/types.go @@ -108,6 +108,8 @@ func (m Map) Nature() Nature { for k, v := range m { if k == Extra { nt.Strict = false + natureOfDefaultValue := v.Nature() + nt.DefaultMapValue = &natureOfDefaultValue continue } nt.Fields[k] = v.Nature() From 3a58a8b0016a4d00d46c7a99c94d8b4dd3641e69 Mon Sep 17 00:00:00 2001 From: OlgaNovg <75758884+OlgaNovg@users.noreply.github.com> Date: Wed, 4 Sep 2024 16:59:48 +0200 Subject: [PATCH 020/113] Add uniq() function (#705) --- builtin/builtin.go | 51 +++++++++++++++++++++++++++++++++++++++++ builtin/builtin_test.go | 2 ++ 2 files changed, 53 insertions(+) diff --git a/builtin/builtin.go b/builtin/builtin.go index 0107d276c..35a9f687e 100644 --- a/builtin/builtin.go +++ b/builtin/builtin.go @@ -830,6 +830,57 @@ var Builtins = []*Function{ } }, }, + + { + Name: "uniq", + Func: func(args ...any) (any, error) { + if len(args) != 1 { + return nil, fmt.Errorf("invalid number of arguments (expected 1, got %d)", len(args)) + } + + v := reflect.ValueOf(deref.Deref(args[0])) + if v.Kind() != reflect.Array && v.Kind() != reflect.Slice { + return nil, fmt.Errorf("cannot uniq %s", v.Kind()) + } + + size := v.Len() + ret := []any{} + + eq := func(i int) bool { + for _, r := range ret { + if runtime.Equal(v.Index(i).Interface(), r) { + return true + } + } + + return false + } + + for i := 0; i < size; i += 1 { + if eq(i) { + continue + } + + ret = append(ret, v.Index(i).Interface()) + } + + return ret, nil + }, + + Validate: func(args []reflect.Type) (reflect.Type, error) { + if len(args) != 1 { + return anyType, fmt.Errorf("invalid number of arguments (expected 1, got %d)", len(args)) + } + + switch kind(args[0]) { + case reflect.Interface, reflect.Slice, reflect.Array: + return arrayType, nil + default: + return anyType, fmt.Errorf("cannot uniq %s", args[0]) + } + }, + }, + { Name: "concat", Safe: func(args ...any) (any, uint, error) { diff --git a/builtin/builtin_test.go b/builtin/builtin_test.go index ddfb4a494..499a838b7 100644 --- a/builtin/builtin_test.go +++ b/builtin/builtin_test.go @@ -155,6 +155,8 @@ func TestBuiltin(t *testing.T) { {`flatten([["a", "b"], [1, 2]])`, []any{"a", "b", 1, 2}}, {`flatten([["a", "b"], [1, 2, [3, 4]]])`, []any{"a", "b", 1, 2, 3, 4}}, {`flatten([["a", "b"], [1, 2, [3, [[[["c", "d"], "e"]]], 4]]])`, []any{"a", "b", 1, 2, 3, "c", "d", "e", 4}}, + {`uniq([1, 15, "a", 2, 3, 5, 2, "a", 2, "b"])`, []any{1, 15, "a", 2, 3, 5, "b"}}, + {`uniq([[1, 2], "a", 2, 3, [1, 2], [1, 3]])`, []any{[]any{1, 2}, "a", 2, 3, []any{1, 3}}}, } for _, test := range tests { From 24a21b287f64d30a3893934a998a503bf23556d2 Mon Sep 17 00:00:00 2001 From: Steve Cosman Date: Wed, 18 Sep 2024 06:22:56 -0400 Subject: [PATCH 021/113] Add CM to Readme (#712) Signed-off-by: Steve Cosman --- README.md | 1 + 1 file changed, 1 insertion(+) diff --git a/README.md b/README.md index 71ec78764..9cc398f21 100644 --- a/README.md +++ b/README.md @@ -166,6 +166,7 @@ func main() { * [Xiaohongshu](https://www.xiaohongshu.com/) combining yaml with Expr for dynamically policies delivery. * [Melrōse](https://melrōse.org) uses Expr to implement its music programming language. * [Tork](https://www.tork.run/) integrates Expr into its workflow execution. +* [Critical Moments](https://criticalmoments.io) uses Expr for it's mobile realtime conditional targeting system. [Add your company too](https://github.com/expr-lang/expr/edit/master/README.md) From fe88af516dfc698aa65c074e1ba11914676d5e88 Mon Sep 17 00:00:00 2001 From: 6543 <6543@obermui.de> Date: Wed, 13 Nov 2024 07:02:42 +0100 Subject: [PATCH 022/113] Mention WoodpeckerCI in README (#728) [WoodpeckerCI](https://woodpecker-ci.org) uses this lib, so mention it :) Signed-off-by: 6543 <6543@obermui.de> --- README.md | 1 + 1 file changed, 1 insertion(+) diff --git a/README.md b/README.md index 9cc398f21..98989a6f9 100644 --- a/README.md +++ b/README.md @@ -167,6 +167,7 @@ func main() { * [Melrōse](https://melrōse.org) uses Expr to implement its music programming language. * [Tork](https://www.tork.run/) integrates Expr into its workflow execution. * [Critical Moments](https://criticalmoments.io) uses Expr for it's mobile realtime conditional targeting system. +* [WoodpeckerCI](https://woodpecker-ci.org) uses Expr for [filtering workflows/steps](https://woodpecker-ci.org/docs/usage/workflow-syntax#evaluate). [Add your company too](https://github.com/expr-lang/expr/edit/master/README.md) From fb6792b2486778dd8a3eb5ab2e7550f5b1dad150 Mon Sep 17 00:00:00 2001 From: Nguyen Ngoc Phuong Date: Tue, 24 Dec 2024 05:08:32 +0700 Subject: [PATCH 023/113] Add FastSchema to Readme (#737) --- README.md | 1 + 1 file changed, 1 insertion(+) diff --git a/README.md b/README.md index 98989a6f9..14b8bf19f 100644 --- a/README.md +++ b/README.md @@ -168,6 +168,7 @@ func main() { * [Tork](https://www.tork.run/) integrates Expr into its workflow execution. * [Critical Moments](https://criticalmoments.io) uses Expr for it's mobile realtime conditional targeting system. * [WoodpeckerCI](https://woodpecker-ci.org) uses Expr for [filtering workflows/steps](https://woodpecker-ci.org/docs/usage/workflow-syntax#evaluate). +* [FastSchema](https://github.com/fastschema/fastschema) - A BaaS leveraging Expr for its customizable and dynamic Access Control system. [Add your company too](https://github.com/expr-lang/expr/edit/master/README.md) From 33f614f92a503a2a1faaabebae782656fde9b889 Mon Sep 17 00:00:00 2001 From: Nathan Baulch Date: Thu, 9 Jan 2025 23:33:28 +1100 Subject: [PATCH 024/113] Fix typos (#745) --- README.md | 4 ++-- docs/language-definition.md | 2 +- internal/spew/common.go | 4 ++-- internal/spew/common_test.go | 6 +++--- internal/spew/config.go | 4 ++-- internal/spew/doc.go | 2 +- internal/spew/dumpcgo_test.go | 4 ++-- internal/spew/format.go | 4 ++-- internal/spew/internal_test.go | 2 +- internal/spew/internalunsafe_test.go | 2 +- internal/spew/testdata/dumpcgo.go | 4 ++-- test/deref/deref_test.go | 2 +- 12 files changed, 20 insertions(+), 20 deletions(-) diff --git a/README.md b/README.md index 14b8bf19f..afc8d43f7 100644 --- a/README.md +++ b/README.md @@ -162,11 +162,11 @@ func main() { * [Visually.io](https://visually.io) employs Expr as a business rule engine for its personalization targeting algorithm. * [Akvorado](https://github.com/akvorado/akvorado) utilizes Expr to classify exporters and interfaces in network flows. * [keda.sh](https://keda.sh) uses Expr to allow customization of its Kubernetes-based event-driven autoscaling. -* [Span Digital](https://spandigital.com/) uses Expr in it's Knowledge Management products. +* [Span Digital](https://spandigital.com/) uses Expr in its Knowledge Management products. * [Xiaohongshu](https://www.xiaohongshu.com/) combining yaml with Expr for dynamically policies delivery. * [Melrōse](https://melrōse.org) uses Expr to implement its music programming language. * [Tork](https://www.tork.run/) integrates Expr into its workflow execution. -* [Critical Moments](https://criticalmoments.io) uses Expr for it's mobile realtime conditional targeting system. +* [Critical Moments](https://criticalmoments.io) uses Expr for its mobile realtime conditional targeting system. * [WoodpeckerCI](https://woodpecker-ci.org) uses Expr for [filtering workflows/steps](https://woodpecker-ci.org/docs/usage/workflow-syntax#evaluate). * [FastSchema](https://github.com/fastschema/fastschema) - A BaaS leveraging Expr for its customizable and dynamic Access Control system. diff --git a/docs/language-definition.md b/docs/language-definition.md index 9c277e9a2..2ceeab72c 100644 --- a/docs/language-definition.md +++ b/docs/language-definition.md @@ -691,7 +691,7 @@ concat([1, 2], [3, 4]) == [1, 2, 3, 4] ### flatten(array) {#flatten} -Flattens given array into one-dimentional array. +Flattens given array into one-dimensional array. ```expr flatten([1, 2, [3, 4]]) == [1, 2, 3, 4] diff --git a/internal/spew/common.go b/internal/spew/common.go index 1be8ce945..047e581fb 100644 --- a/internal/spew/common.go +++ b/internal/spew/common.go @@ -78,7 +78,7 @@ func catchPanic(w io.Writer, v reflect.Value) { } // handleMethods attempts to call the Error and String methods on the underlying -// type the passed reflect.Value represents and outputes the result to Writer w. +// type the passed reflect.Value represents and outputs the result to Writer w. // // It handles panics in any called methods by catching and displaying the error // as the formatted value. @@ -100,7 +100,7 @@ func handleMethods(cs *ConfigState, w io.Writer, v reflect.Value) (handled bool) // Choose whether or not to do error and Stringer interface lookups against // the base type or a pointer to the base type depending on settings. // Technically calling one of these methods with a pointer receiver can - // mutate the value, however, types which choose to satisify an error or + // mutate the value, however, types which choose to satisfy an error or // Stringer interface with a pointer receiver should not be mutating their // state inside these interface methods. if !cs.DisablePointerMethods && !UnsafeDisabled && !v.CanAddr() { diff --git a/internal/spew/common_test.go b/internal/spew/common_test.go index a312057e1..958d45e9f 100644 --- a/internal/spew/common_test.go +++ b/internal/spew/common_test.go @@ -154,7 +154,7 @@ func helpTestSortValues(tests []sortTestCase, cs *spew.ConfigState, t *testing.T } } -// TestSortValues ensures the sort functionality for relect.Value based sorting +// TestSortValues ensures the sort functionality for reflect.Value based sorting // works as intended. func TestSortValues(t *testing.T) { v := reflect.ValueOf @@ -228,7 +228,7 @@ func TestSortValues(t *testing.T) { helpTestSortValues(tests, &cs, t) } -// TestSortValuesWithMethods ensures the sort functionality for relect.Value +// TestSortValuesWithMethods ensures the sort functionality for reflect.Value // based sorting works as intended when using string methods. func TestSortValuesWithMethods(t *testing.T) { v := reflect.ValueOf @@ -263,7 +263,7 @@ func TestSortValuesWithMethods(t *testing.T) { helpTestSortValues(tests, &cs, t) } -// TestSortValuesWithSpew ensures the sort functionality for relect.Value +// TestSortValuesWithSpew ensures the sort functionality for reflect.Value // based sorting works as intended when using spew to stringify keys. func TestSortValuesWithSpew(t *testing.T) { v := reflect.ValueOf diff --git a/internal/spew/config.go b/internal/spew/config.go index 161895fc6..73b09b145 100644 --- a/internal/spew/config.go +++ b/internal/spew/config.go @@ -59,7 +59,7 @@ type ConfigState struct { // // NOTE: This might be an unsafe action since calling one of these methods // with a pointer receiver could technically mutate the value, however, - // in practice, types which choose to satisify an error or Stringer + // in practice, types which choose to satisfy an error or Stringer // interface with a pointer receiver should not be mutating their state // inside these interface methods. As a result, this option relies on // access to the unsafe package, so it will not have any effect when @@ -228,7 +228,7 @@ types similar to the standard %v format specifier. The custom formatter only responds to the %v (most compact), %+v (adds pointer addresses), %#v (adds types), and %#+v (adds types and pointer addresses) verb -combinations. Any other verbs such as %x and %q will be sent to the the +combinations. Any other verbs such as %x and %q will be sent to the standard fmt package for formatting. In addition, the custom formatter ignores the width and precision arguments (however they will still work on the format specifiers not handled by the custom formatter). diff --git a/internal/spew/doc.go b/internal/spew/doc.go index 722e9aa79..a689c9f97 100644 --- a/internal/spew/doc.go +++ b/internal/spew/doc.go @@ -169,7 +169,7 @@ standard %v format specifier. The custom formatter only responds to the %v (most compact), %+v (adds pointer addresses), %#v (adds types), or %#+v (adds types and pointer addresses) verb -combinations. Any other verbs such as %x and %q will be sent to the the +combinations. Any other verbs such as %x and %q will be sent to the standard fmt package for formatting. In addition, the custom formatter ignores the width and precision arguments (however they will still work on the format specifiers not handled by the custom formatter). diff --git a/internal/spew/dumpcgo_test.go b/internal/spew/dumpcgo_test.go index 1bf71fafb..a376ed71a 100644 --- a/internal/spew/dumpcgo_test.go +++ b/internal/spew/dumpcgo_test.go @@ -15,7 +15,7 @@ // NOTE: Due to the following build constraints, this file will only be compiled // when both cgo is supported and "-tags testcgo" is added to the go test // command line. This means the cgo tests are only added (and hence run) when -// specifially requested. This configuration is used because spew itself +// specifically requested. This configuration is used because spew itself // does not require cgo to run even though it does handle certain cgo types // specially. Rather than forcing all clients to require cgo and an external // C compiler just to run the tests, this scheme makes them optional. @@ -90,7 +90,7 @@ func addCgoDumpTests() { addDumpTest(v5, "("+v5t+") "+v5s+"\n", "("+v5t2+") "+v5s+"\n") // C typedefed unsigned char array. - v6, v6l, v6c := testdata.GetCgoTypdefedUnsignedCharArray() + v6, v6l, v6c := testdata.GetCgoTypedefedUnsignedCharArray() v6Len := fmt.Sprintf("%d", v6l) v6Cap := fmt.Sprintf("%d", v6c) v6t := "[6]testdata._Ctype_custom_uchar_t" diff --git a/internal/spew/format.go b/internal/spew/format.go index b04edb7d7..77f300396 100644 --- a/internal/spew/format.go +++ b/internal/spew/format.go @@ -121,7 +121,7 @@ func (f *formatState) formatPtr(v reflect.Value) { // Keep list of all dereferenced pointers to possibly show later. pointerChain := make([]uintptr, 0) - // Figure out how many levels of indirection there are by derferencing + // Figure out how many levels of indirection there are by dereferencing // pointers and unpacking interfaces down the chain while detecting circular // references. nilFound := false @@ -405,7 +405,7 @@ types similar to the standard %v format specifier. The custom formatter only responds to the %v (most compact), %+v (adds pointer addresses), %#v (adds types), or %#+v (adds types and pointer addresses) verb -combinations. Any other verbs such as %x and %q will be sent to the the +combinations. Any other verbs such as %x and %q will be sent to the standard fmt package for formatting. In addition, the custom formatter ignores the width and precision arguments (however they will still work on the format specifiers not handled by the custom formatter). diff --git a/internal/spew/internal_test.go b/internal/spew/internal_test.go index e312b4fad..570fbd009 100644 --- a/internal/spew/internal_test.go +++ b/internal/spew/internal_test.go @@ -15,7 +15,7 @@ */ /* -This test file is part of the spew package rather than than the spew_test +This test file is part of the spew package rather than the spew_test package because it needs access to internals to properly test certain cases which are not possible via the public interface since they should never happen. */ diff --git a/internal/spew/internalunsafe_test.go b/internal/spew/internalunsafe_test.go index aa8fa00b1..051e04572 100644 --- a/internal/spew/internalunsafe_test.go +++ b/internal/spew/internalunsafe_test.go @@ -20,7 +20,7 @@ // +build !js,!appengine,!safe,!disableunsafe,go1.4 /* -This test file is part of the spew package rather than than the spew_test +This test file is part of the spew package rather than the spew_test package because it needs access to internals to properly test certain cases which are not possible via the public interface since they should never happen. */ diff --git a/internal/spew/testdata/dumpcgo.go b/internal/spew/testdata/dumpcgo.go index 368ead024..9008b84b7 100644 --- a/internal/spew/testdata/dumpcgo.go +++ b/internal/spew/testdata/dumpcgo.go @@ -76,8 +76,8 @@ func GetCgoUint8tArray() (interface{}, int, int) { return C.ui8ta, len(C.ui8ta), cap(C.ui8ta) } -// GetCgoTypdefedUnsignedCharArray returns a typedefed unsigned char array via +// GetCgoTypedefedUnsignedCharArray returns a typedefed unsigned char array via // cgo and the array's len and cap. This is only used for tests. -func GetCgoTypdefedUnsignedCharArray() (interface{}, int, int) { +func GetCgoTypedefedUnsignedCharArray() (interface{}, int, int) { return C.tuca, len(C.tuca), cap(C.tuca) } diff --git a/test/deref/deref_test.go b/test/deref/deref_test.go index 4bfb76168..0b3ea5837 100644 --- a/test/deref/deref_test.go +++ b/test/deref/deref_test.go @@ -204,7 +204,7 @@ func TestDeref_nil_in_pointer_of_interface(t *testing.T) { }) } -func TestDeref_сommutative(t *testing.T) { +func TestDeref_commutative(t *testing.T) { a := "ok" b := "ok" From 192ab82e6c5e483def6b1abd82e14bdfc1379fc5 Mon Sep 17 00:00:00 2001 From: Jens Neuse Date: Fri, 10 Jan 2025 11:41:46 +0100 Subject: [PATCH 025/113] add WunderGraph Cosmo to uses section in README (#748) Signed-off-by: Jens Neuse --- README.md | 1 + 1 file changed, 1 insertion(+) diff --git a/README.md b/README.md index afc8d43f7..ab4f2baaa 100644 --- a/README.md +++ b/README.md @@ -169,6 +169,7 @@ func main() { * [Critical Moments](https://criticalmoments.io) uses Expr for its mobile realtime conditional targeting system. * [WoodpeckerCI](https://woodpecker-ci.org) uses Expr for [filtering workflows/steps](https://woodpecker-ci.org/docs/usage/workflow-syntax#evaluate). * [FastSchema](https://github.com/fastschema/fastschema) - A BaaS leveraging Expr for its customizable and dynamic Access Control system. +* [WunderGraph Cosmo](https://github.com/wundergraph/cosmo) - GraphQL Federeration Router uses Expr to customize Middleware behaviour [Add your company too](https://github.com/expr-lang/expr/edit/master/README.md) From 6ef04ecee9673982be2169ab8c2acb1e60219aa3 Mon Sep 17 00:00:00 2001 From: Ville Vesilehto Date: Mon, 27 Jan 2025 12:26:26 +0200 Subject: [PATCH 026/113] test: add comprehensive VM opcode tests (#750) Add extensive test coverage for VM opcodes including: - Basic operations (OpLoadEnv, OpTrue, OpFalse, OpNil) - Arithmetic operations (OpNegate, OpExponent) - String operations (OpEqualString, OpMatches) - Collection operations (OpIn, OpLen) - Type operations (OpCast) - Control flow (OpThrow) - Function calls (OpCall0-3, OpCallN) - Index and count manipulation (OpGetIndex, OpSetIndex) - Profiling operations (OpProfileStart, OpProfileEnd) Also add high-level expression tests for: - Arithmetic expressions - String operations - Data structure operations - Group and sort operations Each test case includes detailed comments and covers both success and error cases. These tests combined with a debugger helped me navigate the VM internals significantly. Signed-off-by: Ville Vesilehto --- vm/vm_test.go | 932 ++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 932 insertions(+) diff --git a/vm/vm_test.go b/vm/vm_test.go index 3ed57d75b..d45ef2d6c 100644 --- a/vm/vm_test.go +++ b/vm/vm_test.go @@ -259,3 +259,935 @@ func TestRun_OpInvalid(t *testing.T) { _, err := vm.Run(program, nil) require.EqualError(t, err, "invalid opcode") } + +func TestVM_OpcodeOperations(t *testing.T) { + tests := []struct { + name string + expr string + env map[string]any + want any + expectError string + }{ + // Arithmetic Operations + { + name: "basic addition", + expr: "2 + 3", + want: 5, + }, + { + name: "mixed type arithmetic", + expr: "2.5 + 3", + want: 5.5, + }, + { + name: "chained arithmetic", + expr: "1 + 2 * 3 - 4 / 2", + want: 5.0, + }, + { + name: "modulo operation", + expr: "5 % 2", + want: 1, + }, + { + name: "exponent operation", + expr: "2 ^ 3", + want: 8.0, + }, + { + name: "negation", + expr: "-5", + want: -5, + }, + + // String Operations + { + name: "string concatenation", + expr: `"hello" + " " + "world"`, + want: "hello world", + }, + { + name: "string starts with", + expr: `"hello world" startsWith "hello"`, + want: true, + }, + { + name: "string ends with", + expr: `"hello world" endsWith "world"`, + want: true, + }, + { + name: "string contains", + expr: `"hello world" contains "lo wo"`, + want: true, + }, + { + name: "string matches regex", + expr: `"hello123" matches "^hello\\d+$"`, + want: true, + }, + + // Data Structure Operations + { + name: "array creation and access", + expr: "[1, 2, 3][1]", + want: 2, + }, + { + name: "map creation and access", + expr: `{"a": 1, "b": 2}.b`, + want: 2, + }, + { + name: "array length", + expr: "len([1, 2, 3])", + want: 3, + }, + { + name: "array slice", + expr: "[1, 2, 3, 4][1:3]", + want: []any{2, 3}, + }, + { + name: "array range", + expr: "1..5", + want: []int{1, 2, 3, 4, 5}, + }, + + // Error Cases + { + name: "invalid array index", + expr: "[1,2,3][5]", + expectError: "index out of range", + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + program, err := expr.Compile(tt.expr, expr.Env(tt.env)) + require.NoError(t, err) + + testVM := &vm.VM{} + got, err := testVM.Run(program, tt.env) + + if tt.expectError != "" { + require.Error(t, err) + require.Contains(t, err.Error(), tt.expectError) + } else { + require.NoError(t, err) + require.Equal(t, tt.want, got) + } + }) + } +} + +func TestVM_GroupAndSortOperations(t *testing.T) { + tests := []struct { + name string + expr string + env map[string]any + want any + expectError string + }{ + { + name: "group by single field", + expr: `groupBy([{"id": 1, "type": "a"}, {"id": 2, "type": "b"}, {"id": 3, "type": "a"}], #.type)`, + want: map[any][]any{ + "a": { + map[string]any{"id": 1, "type": "a"}, + map[string]any{"id": 3, "type": "a"}, + }, + "b": { + map[string]any{"id": 2, "type": "b"}, + }, + }, + }, + { + name: "sort by field ascending", + expr: `sortBy([{"id": 3}, {"id": 1}, {"id": 2}], #.id)`, + want: []any{ + map[string]any{"id": 1}, + map[string]any{"id": 2}, + map[string]any{"id": 3}, + }, + }, + { + name: "sort by field descending", + expr: `sortBy([{"id": 3}, {"id": 1}, {"id": 2}], #.id, "desc")`, + want: []any{ + map[string]any{"id": 3}, + map[string]any{"id": 2}, + map[string]any{"id": 1}, + }, + }, + { + name: "sort by computed value", + expr: `sortBy([1, 2, 3, 4], # % 2)`, + want: []any{2, 4, 1, 3}, + }, + { + name: "group by with complex key", + expr: `groupBy([1, 2, 3, 4, 5, 6], # % 2 == 0 ? "even" : "odd")`, + want: map[any][]any{ + "even": {2, 4, 6}, + "odd": {1, 3, 5}, + }, + }, + { + name: "invalid sort order", + expr: `sortBy([1, 2, 3], #, "invalid")`, + expectError: "unknown order", + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + program, err := expr.Compile(tt.expr, expr.Env(tt.env)) + require.NoError(t, err) + + testVM := &vm.VM{} + got, err := testVM.Run(program, tt.env) + + if tt.expectError != "" { + require.Error(t, err) + require.Contains(t, err.Error(), tt.expectError) + } else { + require.NoError(t, err) + require.Equal(t, tt.want, got) + } + }) + } +} + +// TestVM_ProfileOperations tests the profiling opcodes +func TestVM_ProfileOperations(t *testing.T) { + program := &vm.Program{ + Bytecode: []vm.Opcode{ + vm.OpProfileStart, + vm.OpPush, + vm.OpProfileEnd, + }, + Arguments: []int{0, 0, 0}, + Constants: []any{ + &vm.Span{}, + }, + } + + testVM := &vm.VM{} + _, err := testVM.Run(program, nil) + require.NoError(t, err) + + span := program.Constants[0].(*vm.Span) + require.True(t, span.Duration > 0, "Profile duration should be greater than 0") +} + +// TestVM_IndexOperations tests the index manipulation opcodes +func TestVM_IndexOperations(t *testing.T) { + tests := []struct { + name string + expr string + want any + }{ + { + name: "decrement index in loop", + expr: "reduce([1,2,3], #acc + #, 0)", + want: 6, + }, + { + name: "set index in loop", + expr: "map([1,2,3], # * 2)", + want: []any{2, 4, 6}, + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + program, err := expr.Compile(tt.expr) + require.NoError(t, err) + + testVM := &vm.VM{} + got, err := testVM.Run(program, nil) + require.NoError(t, err) + require.Equal(t, tt.want, got) + }) + } +} + +// TestVM_DirectCallOpcodes tests the specialized call opcodes directly +func TestVM_DirectCallOpcodes(t *testing.T) { + tests := []struct { + name string + bytecode []vm.Opcode + args []int + consts []any + funcs []vm.Function + want any + wantErr bool + }{ + { + name: "OpCall0", + bytecode: []vm.Opcode{vm.OpCall0}, + args: []int{0}, + funcs: []vm.Function{ + func(args ...any) (any, error) { + return 42, nil + }, + }, + want: 42, + }, + { + name: "OpCall1", + bytecode: []vm.Opcode{ + vm.OpPush, + vm.OpCall1, + }, + args: []int{0, 0}, + consts: []any{10}, + funcs: []vm.Function{ + func(args ...any) (any, error) { + return args[0].(int) * 2, nil + }, + }, + want: 20, + }, + { + name: "OpCall2", + bytecode: []vm.Opcode{ + vm.OpPush, + vm.OpPush, + vm.OpCall2, + }, + args: []int{0, 1, 0}, + consts: []any{10, 5}, + funcs: []vm.Function{ + func(args ...any) (any, error) { + return args[0].(int) + args[1].(int), nil + }, + }, + want: 15, + }, + { + name: "OpCall3", + bytecode: []vm.Opcode{ + vm.OpPush, + vm.OpPush, + vm.OpPush, + vm.OpCall3, + }, + args: []int{0, 1, 2, 0}, + consts: []any{10, 5, 2}, + funcs: []vm.Function{ + func(args ...any) (any, error) { + return args[0].(int) + args[1].(int) + args[2].(int), nil + }, + }, + want: 17, + }, + { + name: "OpCallN with error", + bytecode: []vm.Opcode{ + vm.OpLoadFunc, + vm.OpCallN, + }, + args: []int{0, 0}, // Function index, number of args (0) + funcs: []vm.Function{ + func(args ...any) (any, error) { + return nil, fmt.Errorf("test error") + }, + }, + wantErr: true, + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + program := vm.NewProgram( + nil, // source + nil, // node + nil, // locations + 0, // variables + tt.consts, + tt.bytecode, + tt.args, + tt.funcs, + nil, // debugInfo + nil, // span + ) + vm := &vm.VM{} + got, err := vm.Run(program, nil) + if tt.wantErr { + require.Error(t, err) + } else { + require.NoError(t, err) + require.Equal(t, tt.want, got) + } + }) + } +} + +func TestVM_CallN(t *testing.T) { + input := `fn(1, 2, 3)` + + tree, err := parser.Parse(input) + require.NoError(t, err) + + env := map[string]any{ + "fn": func(args ...any) (any, error) { + sum := 0 + for _, arg := range args { + sum += arg.(int) + } + return sum, nil + }, + } + + config := conf.New(env) + program, err := compiler.Compile(tree, config) + require.NoError(t, err) + + out, err := vm.Run(program, env) + require.NoError(t, err) + require.Equal(t, 6, out) +} + +// TestVM_IndexAndCountOperations tests the index and count manipulation opcodes directly +func TestVM_IndexAndCountOperations(t *testing.T) { + tests := []struct { + name string + bytecode []vm.Opcode + args []int + consts []any + want any + wantErr bool + }{ + { + name: "GetIndex", + bytecode: []vm.Opcode{ + vm.OpPush, // Push array to stack + vm.OpBegin, // Start scope + vm.OpGetIndex, // Get current index + }, + args: []int{0, 0, 0}, + consts: []any{[]any{1, 2, 3}}, // Array for scope + want: 0, // Initial index is 0 + }, + { + name: "DecrementIndex", + bytecode: []vm.Opcode{ + vm.OpPush, // Push array to stack + vm.OpBegin, // Start scope + vm.OpDecrementIndex, // Decrement index + vm.OpGetIndex, // Get current index + }, + args: []int{0, 0, 0, 0}, + consts: []any{[]any{1, 2, 3}}, // Array for scope + want: -1, // After decrement + }, + { + name: "GetCount", + bytecode: []vm.Opcode{ + vm.OpPush, // Push array to stack + vm.OpBegin, // Start scope + vm.OpGetCount, // Get current count + }, + args: []int{0, 0, 0}, + consts: []any{[]any{1, 2, 3}}, // Array for scope + want: 0, // Initial count is 0 + }, + { + name: "IncrementCount", + bytecode: []vm.Opcode{ + vm.OpPush, // Push array to stack + vm.OpBegin, // Start scope + vm.OpIncrementCount, // Increment count + vm.OpGetCount, // Get current count + }, + args: []int{0, 0, 0, 0}, + consts: []any{[]any{1, 2, 3}}, // Array for scope + want: 1, // After increment + }, + { + name: "Multiple operations", + bytecode: []vm.Opcode{ + vm.OpPush, // Push array to stack + vm.OpBegin, // Start scope + vm.OpIncrementCount, // Count = 1 + vm.OpIncrementCount, // Count = 2 + vm.OpDecrementIndex, // Index = -1 + vm.OpDecrementIndex, // Index = -2 + vm.OpGetCount, // Push count (2) + vm.OpGetIndex, // Push index (-2) + vm.OpAdd, // Add them together + }, + args: []int{0, 0, 0, 0, 0, 0, 0, 0, 0}, + consts: []any{[]any{1, 2, 3}}, // Array for scope + want: 0, // 2 + (-2) = 0 + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + program := vm.NewProgram( + nil, // source + nil, // node + nil, // locations + 0, // variables + tt.consts, + tt.bytecode, + tt.args, + nil, // functions + nil, // debugInfo + nil, // span + ) + vm := &vm.VM{} + got, err := vm.Run(program, nil) + if tt.wantErr { + require.Error(t, err) + } else { + require.NoError(t, err) + require.Equal(t, tt.want, got) + } + }) + } +} + +// TestVM_DirectBasicOpcodes tests basic opcodes directly +func TestVM_DirectBasicOpcodes(t *testing.T) { + tests := []struct { + name string + bytecode []vm.Opcode + args []int + consts []any + env any + want any + wantErr bool + }{ + { + name: "OpLoadEnv", + bytecode: []vm.Opcode{ + vm.OpLoadEnv, // Load entire environment + }, + args: []int{0}, + env: map[string]any{"key": "value"}, + want: map[string]any{"key": "value"}, + }, + { + name: "OpTrue", + bytecode: []vm.Opcode{ + vm.OpTrue, + }, + args: []int{0}, + want: true, + }, + { + name: "OpFalse", + bytecode: []vm.Opcode{ + vm.OpFalse, + }, + args: []int{0}, + want: false, + }, + { + name: "OpNil", + bytecode: []vm.Opcode{ + vm.OpNil, + }, + args: []int{0}, + want: nil, + }, + { + name: "OpNegate int", + bytecode: []vm.Opcode{ + vm.OpPush, // Push number + vm.OpNegate, // Negate it + }, + args: []int{0, 0}, + consts: []any{42}, + want: -42, + }, + { + name: "OpNegate float", + bytecode: []vm.Opcode{ + vm.OpPush, // Push number + vm.OpNegate, // Negate it + }, + args: []int{0, 0}, + consts: []any{42.5}, + want: -42.5, + }, + { + name: "OpNot true", + bytecode: []vm.Opcode{ + vm.OpTrue, // Push true + vm.OpNot, // Negate it + }, + args: []int{0, 0}, + want: false, + }, + { + name: "OpNot false", + bytecode: []vm.Opcode{ + vm.OpFalse, // Push false + vm.OpNot, // Negate it + }, + args: []int{0, 0}, + want: true, + }, + { + name: "OpNot error", + bytecode: []vm.Opcode{ + vm.OpPush, // Push non-bool + vm.OpNot, // Try to negate it + }, + args: []int{0, 0}, + consts: []any{"not a bool"}, + wantErr: true, + }, + { + name: "OpEqualString equal", + bytecode: []vm.Opcode{ + vm.OpPush, // Push first string + vm.OpPush, // Push second string + vm.OpEqualString, // Compare strings + }, + args: []int{0, 1, 0}, + consts: []any{"hello", "hello"}, + want: true, + }, + { + name: "OpEqualString not equal", + bytecode: []vm.Opcode{ + vm.OpPush, // Push first string + vm.OpPush, // Push second string + vm.OpEqualString, // Compare strings + }, + args: []int{0, 1, 0}, + consts: []any{"hello", "world"}, + want: false, + }, + { + name: "OpEqualString with empty strings", + bytecode: []vm.Opcode{ + vm.OpPush, // Push first string + vm.OpPush, // Push second string + vm.OpEqualString, // Compare strings + }, + args: []int{0, 1, 0}, + consts: []any{"", ""}, + want: true, + }, + { + name: "OpEqualString type error", + bytecode: []vm.Opcode{ + vm.OpPush, // Push non-string + vm.OpPush, // Push string + vm.OpEqualString, // Try to compare + }, + args: []int{0, 1, 0}, + consts: []any{42, "hello"}, + wantErr: true, + }, + { + name: "OpInt", + bytecode: []vm.Opcode{ + vm.OpInt, // Push int directly from args + }, + args: []int{42}, // The value 42 is passed directly in args + consts: []any{}, // No constants needed + want: 42, + }, + { + name: "OpInt negative", + bytecode: []vm.Opcode{ + vm.OpInt, // Push negative int directly from args + }, + args: []int{-42}, // The value -42 is passed directly in args + consts: []any{}, // No constants needed + want: -42, + }, + { + name: "OpInt zero", + bytecode: []vm.Opcode{ + vm.OpInt, // Push zero directly from args + }, + args: []int{0}, // The value 0 is passed directly in args + consts: []any{}, // No constants needed + want: 0, + }, + { + name: "OpIn array true", + bytecode: []vm.Opcode{ + vm.OpPush, // Push element + vm.OpPush, // Push array + vm.OpIn, // Check if element is in array + }, + args: []int{0, 1, 0}, + consts: []any{2, []any{1, 2, 3}}, + want: true, + }, + { + name: "OpIn array false", + bytecode: []vm.Opcode{ + vm.OpPush, // Push element + vm.OpPush, // Push array + vm.OpIn, // Check if element is in array + }, + args: []int{0, 1, 0}, + consts: []any{4, []any{1, 2, 3}}, + want: false, + }, + { + name: "OpIn map true", + bytecode: []vm.Opcode{ + vm.OpPush, // Push key + vm.OpPush, // Push map + vm.OpIn, // Check if key is in map + }, + args: []int{0, 1, 0}, + consts: []any{"b", map[string]any{"a": 1, "b": 2}}, + want: true, + }, + { + name: "OpIn map false", + bytecode: []vm.Opcode{ + vm.OpPush, // Push key + vm.OpPush, // Push map + vm.OpIn, // Check if key is in map + }, + args: []int{0, 1, 0}, + consts: []any{"c", map[string]any{"a": 1, "b": 2}}, + want: false, + }, + { + name: "OpExponent integers", + bytecode: []vm.Opcode{ + vm.OpPush, // Push base + vm.OpPush, // Push exponent + vm.OpExponent, // Calculate power + }, + args: []int{0, 1, 0}, + consts: []any{2, 3}, + want: 8.0, + }, + { + name: "OpExponent floats", + bytecode: []vm.Opcode{ + vm.OpPush, // Push base + vm.OpPush, // Push exponent + vm.OpExponent, // Calculate power + }, + args: []int{0, 1, 0}, + consts: []any{2.0, 3.0}, + want: 8.0, + }, + { + name: "OpExponent negative exponent", + bytecode: []vm.Opcode{ + vm.OpPush, // Push base + vm.OpPush, // Push exponent + vm.OpExponent, // Calculate power + }, + args: []int{0, 1, 0}, + consts: []any{2.0, -2.0}, + want: 0.25, + }, + { + name: "OpMatches valid regex", + bytecode: []vm.Opcode{ + vm.OpPush, // Push string + vm.OpPush, // Push pattern + vm.OpMatches, // Match string against pattern + }, + args: []int{0, 1, 0}, + consts: []any{"hello123", "^hello\\d+$"}, + want: true, + }, + { + name: "OpMatches non-matching regex", + bytecode: []vm.Opcode{ + vm.OpPush, // Push string + vm.OpPush, // Push pattern + vm.OpMatches, // Match string against pattern + }, + args: []int{0, 1, 0}, + consts: []any{"hello", "^\\d+$"}, + want: false, + }, + { + name: "OpMatches invalid regex", + bytecode: []vm.Opcode{ + vm.OpPush, // Push string + vm.OpPush, // Push pattern + vm.OpMatches, // Match string against pattern + }, + args: []int{0, 1, 0}, + consts: []any{"hello", "[invalid"}, + wantErr: true, + }, + { + name: "OpMatches type error", + bytecode: []vm.Opcode{ + vm.OpPush, // Push non-string + vm.OpPush, // Push pattern + vm.OpMatches, // Match against pattern + }, + args: []int{0, 1, 0}, + consts: []any{42, "^\\d+$"}, + wantErr: true, + }, + { + name: "OpCast int to float64", + bytecode: []vm.Opcode{ + vm.OpPush, // Push int + vm.OpCast, // Cast to float64 + }, + args: []int{0, 2}, + consts: []any{42}, + want: float64(42), + }, + { + name: "OpCast int32 to int64", + bytecode: []vm.Opcode{ + vm.OpPush, // Push int32 + vm.OpCast, // Cast to int64 + }, + args: []int{0, 1}, + consts: []any{int32(42)}, + want: int64(42), + }, + { + name: "OpCast invalid type", + bytecode: []vm.Opcode{ + vm.OpPush, // Push string + vm.OpCast, // Try to cast to float64 + }, + args: []int{0, 0}, + consts: []any{"not a number"}, + wantErr: true, + }, + { + name: "OpLen array", + bytecode: []vm.Opcode{ + vm.OpPush, // Push array + vm.OpLen, // Get length + }, + args: []int{0, 0}, + consts: []any{[]any{1, 2, 3}}, + want: 3, + }, + { + name: "OpLen empty array", + bytecode: []vm.Opcode{ + vm.OpPush, // Push empty array + vm.OpLen, // Get length + }, + args: []int{0, 0}, + consts: []any{[]any{}}, + want: 0, + }, + { + name: "OpLen string", + bytecode: []vm.Opcode{ + vm.OpPush, // Push string + vm.OpLen, // Get length + }, + args: []int{0, 0}, + consts: []any{"hello"}, + want: 5, + }, + { + name: "OpLen empty string", + bytecode: []vm.Opcode{ + vm.OpPush, // Push empty string + vm.OpLen, // Get length + }, + args: []int{0, 0}, + consts: []any{""}, + want: 0, + }, + { + name: "OpLen map", + bytecode: []vm.Opcode{ + vm.OpPush, // Push map + vm.OpLen, // Get length + }, + args: []int{0, 0}, + consts: []any{map[string]any{"a": 1, "b": 2, "c": 3}}, + want: 3, + }, + { + name: "OpLen empty map", + bytecode: []vm.Opcode{ + vm.OpPush, // Push empty map + vm.OpLen, // Get length + }, + args: []int{0, 0}, + consts: []any{map[string]any{}}, + want: 0, + }, + { + name: "OpLen invalid type", + bytecode: []vm.Opcode{ + vm.OpPush, // Push number + vm.OpLen, // Try to get length + }, + args: []int{0, 0}, + consts: []any{42}, + wantErr: true, + }, + { + name: "OpThrow with string", + bytecode: []vm.Opcode{ + vm.OpPush, // Push error message + vm.OpThrow, // Throw error + }, + args: []int{0, 0}, + consts: []any{"test error"}, + wantErr: true, + }, + { + name: "OpThrow with error", + bytecode: []vm.Opcode{ + vm.OpPush, // Push error + vm.OpThrow, // Throw error + }, + args: []int{0, 0}, + consts: []any{fmt.Errorf("test error")}, + wantErr: true, + }, + { + name: "OpDefault", + bytecode: []vm.Opcode{ + vm.OpEnd + 1, // OpEnd is always last, this is anunknown opcode + }, + args: []int{0, 0}, + consts: []any{fmt.Errorf("test error")}, + wantErr: true, + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + program := vm.NewProgram( + nil, // source + nil, // node + nil, // locations + 0, // variables + tt.consts, + tt.bytecode, + tt.args, + nil, // functions + nil, // debugInfo + nil, // span + ) + vm := &vm.VM{} + got, err := vm.Run(program, tt.env) + if tt.wantErr { + require.Error(t, err) + } else { + require.NoError(t, err) + require.Equal(t, tt.want, got) + } + }) + } +} From a3b6cd227b56cb9aa8293ef5ab09d5e65bd7a990 Mon Sep 17 00:00:00 2001 From: Olga Novgorodova <75758884+OlgaNovg@users.noreply.github.com> Date: Sun, 23 Feb 2025 14:19:51 +0100 Subject: [PATCH 027/113] Add if-else conditional (#736) Co-authored-by: Anton Medvedev --- docs/language-definition.md | 2 +- expr_test.go | 15 +++++++++++++++ parser/lexer/lexer_test.go | 36 ++++++++++++++++++++++++++++++++++++ parser/lexer/state.go | 4 +--- parser/parser.go | 22 ++++++++++++++++++++++ parser/parser_test.go | 11 +++++++++++ 6 files changed, 86 insertions(+), 4 deletions(-) diff --git a/docs/language-definition.md b/docs/language-definition.md index 2ceeab72c..640c7d63b 100644 --- a/docs/language-definition.md +++ b/docs/language-definition.md @@ -97,7 +97,7 @@ Backticks strings are raw strings, they do not support escape sequences. Conditional - ?: (ternary), ?? (nil coalescing) + ?: (ternary), ?? (nil coalescing), if {} else {} (multiline) diff --git a/expr_test.go b/expr_test.go index ced182a9f..bda5551cc 100644 --- a/expr_test.go +++ b/expr_test.go @@ -1291,6 +1291,21 @@ func TestExpr(t *testing.T) { `1 < 2 < 3 == true`, true, }, + { + `if 1 > 2 { 333 * 2 + 1 } else { 444 }`, + 444, + }, + { + `let a = 3; + let b = 2; + if a>b {let c = Add(a, b); c+1} else {Add(10, b)} + `, + 6, + }, + { + `if "a" < "b" {let x = "a"; x} else {"abc"}`, + "a", + }, } for _, tt := range tests { diff --git a/parser/lexer/lexer_test.go b/parser/lexer/lexer_test.go index 5edcbe5c4..f1cb3f28f 100644 --- a/parser/lexer/lexer_test.go +++ b/parser/lexer/lexer_test.go @@ -239,6 +239,42 @@ func TestLex(t *testing.T) { {Kind: EOF}, }, }, + { + `if a>b {x1+x2} else {x2}`, + []Token{ + {Kind: Operator, Value: "if"}, + {Kind: Identifier, Value: "a"}, + {Kind: Operator, Value: ">"}, + {Kind: Identifier, Value: "b"}, + {Kind: Bracket, Value: "{"}, + {Kind: Identifier, Value: "x1"}, + {Kind: Operator, Value: "+"}, + {Kind: Identifier, Value: "x2"}, + {Kind: Bracket, Value: "}"}, + {Kind: Operator, Value: "else"}, + {Kind: Bracket, Value: "{"}, + {Kind: Identifier, Value: "x2"}, + {Kind: Bracket, Value: "}"}, + {Kind: EOF}, + }, + }, + { + `a>b if {x1} else {x2}`, + []Token{ + {Kind: Identifier, Value: "a"}, + {Kind: Operator, Value: ">"}, + {Kind: Identifier, Value: "b"}, + {Kind: Operator, Value: "if"}, + {Kind: Bracket, Value: "{"}, + {Kind: Identifier, Value: "x1"}, + {Kind: Bracket, Value: "}"}, + {Kind: Operator, Value: "else"}, + {Kind: Bracket, Value: "{"}, + {Kind: Identifier, Value: "x2"}, + {Kind: Bracket, Value: "}"}, + {Kind: EOF}, + }, + }, } for _, test := range tests { diff --git a/parser/lexer/state.go b/parser/lexer/state.go index d351e2f5c..c694a2ca0 100644 --- a/parser/lexer/state.go +++ b/parser/lexer/state.go @@ -129,9 +129,7 @@ loop: switch l.word() { case "not": return not - case "in", "or", "and", "matches", "contains", "startsWith", "endsWith": - l.emit(Operator) - case "let": + case "in", "or", "and", "matches", "contains", "startsWith", "endsWith", "let", "if", "else": l.emit(Operator) default: l.emit(Identifier) diff --git a/parser/parser.go b/parser/parser.go index 0817f6e4b..917e0db4f 100644 --- a/parser/parser.go +++ b/parser/parser.go @@ -132,6 +132,9 @@ func (p *parser) parseExpression(precedence int) Node { if precedence == 0 && p.current.Is(Operator, "let") { return p.parseVariableDeclaration() } + if p.current.Is(Operator, "if") { + return p.parseConditionalIf() + } nodeLeft := p.parsePrimary() @@ -235,6 +238,25 @@ func (p *parser) parseVariableDeclaration() Node { return let } +func (p *parser) parseConditionalIf() Node { + p.next() + nodeCondition := p.parseExpression(0) + p.expect(Bracket, "{") + expr1 := p.parseExpression(0) + p.expect(Bracket, "}") + p.expect(Operator, "else") + p.expect(Bracket, "{") + expr2 := p.parseExpression(0) + p.expect(Bracket, "}") + + return &ConditionalNode{ + Cond: nodeCondition, + Exp1: expr1, + Exp2: expr2, + } + +} + func (p *parser) parseConditional(node Node) Node { var expr1, expr2 Node for p.current.Is(Operator, "?") && p.err == nil { diff --git a/parser/parser_test.go b/parser/parser_test.go index a280bf39a..6bb17e604 100644 --- a/parser/parser_test.go +++ b/parser/parser_test.go @@ -647,6 +647,17 @@ world`}, Right: &BoolNode{Value: true}, }, }, + { + "if a>b {true} else {x}", + &ConditionalNode{ + Cond: &BinaryNode{ + Operator: ">", + Left: &IdentifierNode{Value: "a"}, + Right: &IdentifierNode{Value: "b"}, + }, + Exp1: &BoolNode{Value: true}, + Exp2: &IdentifierNode{Value: "x"}}, + }, } for _, test := range tests { t.Run(test.input, func(t *testing.T) { From b4606bdf394042aba0458a15780683a8cb45f62e Mon Sep 17 00:00:00 2001 From: Anton Medvedev Date: Sat, 1 Mar 2025 20:00:54 +0100 Subject: [PATCH 028/113] Create .gitattributes Signed-off-by: Anton Medvedev --- .gitattributes | 1 + 1 file changed, 1 insertion(+) create mode 100644 .gitattributes diff --git a/.gitattributes b/.gitattributes new file mode 100644 index 000000000..86cc5e2c9 --- /dev/null +++ b/.gitattributes @@ -0,0 +1 @@ +*[generated].go linguist-generated From 829454b8783e3ab7d74f6fd777575871753afbe1 Mon Sep 17 00:00:00 2001 From: Anton Medvedev Date: Sat, 1 Mar 2025 20:03:27 +0100 Subject: [PATCH 029/113] Update .gitattributes Signed-off-by: Anton Medvedev --- .gitattributes | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.gitattributes b/.gitattributes index 86cc5e2c9..05ac79c1f 100644 --- a/.gitattributes +++ b/.gitattributes @@ -1 +1 @@ -*[generated].go linguist-generated +*[generated].go linguist-language=txt From 0bb9c140269c6efae4ac4d41141e3e86c9350221 Mon Sep 17 00:00:00 2001 From: Anton Medvedev Date: Sat, 1 Mar 2025 20:03:45 +0100 Subject: [PATCH 030/113] Update .gitattributes Signed-off-by: Anton Medvedev --- .gitattributes | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.gitattributes b/.gitattributes index 05ac79c1f..9be6de810 100644 --- a/.gitattributes +++ b/.gitattributes @@ -1 +1 @@ -*[generated].go linguist-language=txt +vm/func_types[generated].go linguist-language=txt From c3c5c4db9fee84bd35af721a38e534b0f7782284 Mon Sep 17 00:00:00 2001 From: Anton Medvedev Date: Sat, 1 Mar 2025 20:05:02 +0100 Subject: [PATCH 031/113] Update .gitattributes (#759) Signed-off-by: Anton Medvedev --- .gitattributes | 1 + 1 file changed, 1 insertion(+) diff --git a/.gitattributes b/.gitattributes index 9be6de810..84536852d 100644 --- a/.gitattributes +++ b/.gitattributes @@ -1 +1,2 @@ vm/func_types[generated].go linguist-language=txt +vm/opcodes.go linguist-language=txt From ac42ea0cddafcc72355508252cfe2f6d96c2939d Mon Sep 17 00:00:00 2001 From: Anton Medvedev Date: Sat, 1 Mar 2025 20:05:51 +0100 Subject: [PATCH 032/113] Update .gitattributes Signed-off-by: Anton Medvedev --- .gitattributes | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/.gitattributes b/.gitattributes index 84536852d..ca2d51c62 100644 --- a/.gitattributes +++ b/.gitattributes @@ -1,2 +1 @@ -vm/func_types[generated].go linguist-language=txt -vm/opcodes.go linguist-language=txt +vm/func_types\[generated\].go linguist-language=txt From 867dca6d78cd5ff67b814727b8a48b2d85511e3f Mon Sep 17 00:00:00 2001 From: Anton Medvedev Date: Sat, 1 Mar 2025 20:10:40 +0100 Subject: [PATCH 033/113] Update .gitattributes Signed-off-by: Anton Medvedev --- .gitattributes | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.gitattributes b/.gitattributes index ca2d51c62..efd30300a 100644 --- a/.gitattributes +++ b/.gitattributes @@ -1 +1 @@ -vm/func_types\[generated\].go linguist-language=txt +*\[generated\].go linguist-language=txt From 82281483d791a925f8930dcf60bf07d1d5ccf079 Mon Sep 17 00:00:00 2001 From: Ville Vesilehto Date: Sat, 1 Mar 2025 23:11:57 +0200 Subject: [PATCH 034/113] ci: pin benchstat version and update GitHub Actions (#761) Fix CI workflow compatibility issues and update dependencies: - Pin benchstat to specific commit (884df5) compatible with Go 1.18 instead of using @latest which now requires Go 1.23+ - Add explanatory comment about benchstat version constraints - Upgrade actions/upload-artifact from v3 to v4 in fuzz.yml - Upgrade github/codeql-action from v2 to v3 in fuzz.yml These changes ensure the CI pipeline remains compatible with Go 1.18 while benefiting from the latest improvements in GitHub Actions. Signed-off-by: Ville Vesilehto --- .github/workflows/diff.yml | 4 +++- .github/workflows/fuzz.yml | 4 ++-- 2 files changed, 5 insertions(+), 3 deletions(-) diff --git a/.github/workflows/diff.yml b/.github/workflows/diff.yml index d9fd20c59..3a81ba2e1 100644 --- a/.github/workflows/diff.yml +++ b/.github/workflows/diff.yml @@ -13,7 +13,9 @@ jobs: with: go-version: 1.18 - name: Install benchstat - run: go install golang.org/x/perf/cmd/benchstat@latest + # NOTE: benchstat@latest requires go 1.23 since 2025-02-14 - this is the last go 1.18 ref + # https://cs.opensource.google/go/x/perf/+/c95ad7d5b636f67d322a7e4832e83103d0fdd292 + run: go install golang.org/x/perf/cmd/benchstat@884df5810d2850d775c2cb4885a7ea339128a17d - uses: actions/checkout@v3 - name: Benchmark new code diff --git a/.github/workflows/fuzz.yml b/.github/workflows/fuzz.yml index b883b8393..34e77d6be 100644 --- a/.github/workflows/fuzz.yml +++ b/.github/workflows/fuzz.yml @@ -21,14 +21,14 @@ jobs: fuzz-seconds: 600 output-sarif: true - name: Upload Crash - uses: actions/upload-artifact@v3 + uses: actions/upload-artifact@v4 if: failure() && steps.build.outcome == 'success' with: name: artifacts path: ./out/artifacts - name: Upload Sarif if: always() && steps.build.outcome == 'success' - uses: github/codeql-action/upload-sarif@v2 + uses: github/codeql-action/upload-sarif@v3 with: # Path to SARIF file relative to the root of the repository sarif_file: cifuzz-sarif/results.sarif From 77e876bb7cda24c5aeedbfd1a0efa1465fb503bb Mon Sep 17 00:00:00 2001 From: Ville Vesilehto Date: Sun, 2 Mar 2025 10:31:59 +0200 Subject: [PATCH 035/113] ci: add Go 1.23/1.24 testing and fix example test names (#760) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Expand test coverage to newer Go versions and fix compatibility issues: - Add Go 1.23 and 1.24 to test matrix in test.yml - Add Go 1.24 to build matrix in build.yml - Fix example test names to match Go conventions: * ExampleOperator_Decimal → ExampleOperator_with_decimal * ExampleWithTimezone → ExampleTimezone * ExampleGetUnifiedDiffCode → ExampleGetUnifiedDiffString * ExampleGetContextDiffCode → ExampleGetContextDiffString * ExampleGetContextDiffString → ExampleGetContextDiffString_second These changes maintain compatibility with Go 1.18 (as specified in go.mod) while ensuring the codebase works correctly with the latest Go versions, which enforce stricter naming conventions for example tests. Signed-off-by: Ville Vesilehto Co-authored-by: Anton Medvedev --- .github/workflows/build.yml | 2 +- .github/workflows/test.yml | 2 +- expr_test.go | 4 ++-- internal/difflib/difflib_test.go | 6 +++--- 4 files changed, 7 insertions(+), 7 deletions(-) diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml index d2e6518ca..854ca5348 100644 --- a/.github/workflows/build.yml +++ b/.github/workflows/build.yml @@ -11,7 +11,7 @@ jobs: runs-on: ubuntu-latest strategy: matrix: - go-versions: [ '1.18', '1.22' ] + go-versions: [ '1.18', '1.22', '1.24' ] go-arch: [ '386' ] steps: - uses: actions/checkout@v3 diff --git a/.github/workflows/test.yml b/.github/workflows/test.yml index dc197eb1f..5d0b0744e 100644 --- a/.github/workflows/test.yml +++ b/.github/workflows/test.yml @@ -11,7 +11,7 @@ jobs: runs-on: ubuntu-latest strategy: matrix: - go-versions: [ '1.18', '1.19', '1.20', '1.21', '1.22' ] + go-versions: [ '1.18', '1.19', '1.20', '1.21', '1.22', '1.23', '1.24' ] steps: - uses: actions/checkout@v3 - name: Setup Go ${{ matrix.go-version }} diff --git a/expr_test.go b/expr_test.go index bda5551cc..f10350b22 100644 --- a/expr_test.go +++ b/expr_test.go @@ -312,7 +312,7 @@ func ExampleOperator() { // Output: true } -func ExampleOperator_Decimal() { +func ExampleOperator_with_decimal() { type Decimal struct{ N float64 } code := `A + B - C` @@ -585,7 +585,7 @@ func ExampleWithContext() { // Output: 42 } -func ExampleWithTimezone() { +func ExampleTimezone() { program, err := expr.Compile(`now().Location().String()`, expr.Timezone("Asia/Kamchatka")) if err != nil { fmt.Printf("%v", err) diff --git a/internal/difflib/difflib_test.go b/internal/difflib/difflib_test.go index d72511962..60fb1f9cb 100644 --- a/internal/difflib/difflib_test.go +++ b/internal/difflib/difflib_test.go @@ -102,7 +102,7 @@ group } } -func ExampleGetUnifiedDiffCode() { +func ExampleGetUnifiedDiffString() { a := `one two three @@ -135,7 +135,7 @@ four` // -fmt.Printf("%s,%T",a,b) } -func ExampleGetContextDiffCode() { +func ExampleGetContextDiffString() { a := `one two three @@ -172,7 +172,7 @@ four` // four } -func ExampleGetContextDiffString() { +func ExampleGetContextDiffString_second() { a := `one two three From 0d19441454426d2f58edb22c31f3ba5f99c7a26e Mon Sep 17 00:00:00 2001 From: Ville Vesilehto Date: Fri, 7 Mar 2025 15:09:41 +0200 Subject: [PATCH 036/113] feat: add node budget and memory limits (#762) * feat: add node budget and memory limits Implement compile-time and runtime safeguards against deeply nested expressions: - Add MaxNodes limit to track and limit AST node count during parsing - Move MemoryBudget from VM to Config for better configurability - Add node creation tracking in parser to enforce node budget - Refactor node creation to check limits before allocation - Add RunWithConfig to VM for passing memory budget settings - Set reasonable defaults in Config (10000 nodes, 1M memory) - Add comprehensive tests for both node and memory limits This prevents stack overflows from malicious or poorly written expressions by failing fast with clear error messages during compilation or runtime. Signed-off-by: Ville Vesilehto * Update parser.go Signed-off-by: Anton Medvedev --------- Signed-off-by: Ville Vesilehto Signed-off-by: Anton Medvedev Co-authored-by: Anton Medvedev --- conf/config.go | 46 ++++++--- parser/parser.go | 234 ++++++++++++++++++++++++++++++------------ parser/parser_test.go | 76 ++++++++++++++ vm/utils.go | 3 - vm/vm.go | 23 ++++- vm/vm_test.go | 164 ++++++++++++++++++++++++++++- 6 files changed, 452 insertions(+), 94 deletions(-) diff --git a/conf/config.go b/conf/config.go index 8a6ee70e2..270438b9d 100644 --- a/conf/config.go +++ b/conf/config.go @@ -10,31 +10,43 @@ import ( "github.com/expr-lang/expr/vm/runtime" ) +const ( + // DefaultMemoryBudget represents an upper limit of memory usage + DefaultMemoryBudget uint = 1e6 + + // DefaultMaxNodes represents an upper limit of AST nodes + DefaultMaxNodes uint = 10000 +) + type FunctionsTable map[string]*builtin.Function type Config struct { - EnvObject any - Env nature.Nature - Expect reflect.Kind - ExpectAny bool - Optimize bool - Strict bool - Profile bool - ConstFns map[string]reflect.Value - Visitors []ast.Visitor - Functions FunctionsTable - Builtins FunctionsTable - Disabled map[string]bool // disabled builtins + EnvObject any + Env nature.Nature + Expect reflect.Kind + ExpectAny bool + Optimize bool + Strict bool + Profile bool + MaxNodes uint + MemoryBudget uint + ConstFns map[string]reflect.Value + Visitors []ast.Visitor + Functions FunctionsTable + Builtins FunctionsTable + Disabled map[string]bool // disabled builtins } // CreateNew creates new config with default values. func CreateNew() *Config { c := &Config{ - Optimize: true, - ConstFns: make(map[string]reflect.Value), - Functions: make(map[string]*builtin.Function), - Builtins: make(map[string]*builtin.Function), - Disabled: make(map[string]bool), + Optimize: true, + MaxNodes: DefaultMaxNodes, + MemoryBudget: DefaultMemoryBudget, + ConstFns: make(map[string]reflect.Value), + Functions: make(map[string]*builtin.Function), + Builtins: make(map[string]*builtin.Function), + Disabled: make(map[string]bool), } for _, f := range builtin.Builtins { c.Builtins[f.Name] = f diff --git a/parser/parser.go b/parser/parser.go index 917e0db4f..086554223 100644 --- a/parser/parser.go +++ b/parser/parser.go @@ -45,12 +45,47 @@ var predicates = map[string]struct { } type parser struct { - tokens []Token - current Token - pos int - err *file.Error - depth int // predicate call depth - config *conf.Config + tokens []Token + current Token + pos int + err *file.Error + depth int // predicate call depth + config *conf.Config + nodeCount uint // tracks number of AST nodes created +} + +// checkNodeLimit verifies that adding a new node won't exceed configured limits +func (p *parser) checkNodeLimit() error { + p.nodeCount++ + if p.config.MaxNodes > 0 && p.nodeCount > p.config.MaxNodes { + p.error("compilation failed: expression exceeds maximum allowed nodes") + return nil + } + return nil +} + +// createNode handles creation of regular nodes +func (p *parser) createNode(n Node, loc file.Location) Node { + if err := p.checkNodeLimit(); err != nil { + return nil + } + if n == nil || p.err != nil { + return nil + } + n.SetLocation(loc) + return n +} + +// createMemberNode handles creation of member nodes +func (p *parser) createMemberNode(n *MemberNode, loc file.Location) *MemberNode { + if err := p.checkNodeLimit(); err != nil { + return nil + } + if n == nil || p.err != nil { + return nil + } + n.SetLocation(loc) + return n } type Tree struct { @@ -129,6 +164,10 @@ func (p *parser) expect(kind Kind, values ...string) { // parse functions func (p *parser) parseExpression(precedence int) Node { + if p.err != nil { + return nil + } + if precedence == 0 && p.current.Is(Operator, "let") { return p.parseVariableDeclaration() } @@ -190,19 +229,23 @@ func (p *parser) parseExpression(precedence int) Node { nodeRight = p.parseExpression(op.Precedence) } - nodeLeft = &BinaryNode{ + nodeLeft = p.createNode(&BinaryNode{ Operator: opToken.Value, Left: nodeLeft, Right: nodeRight, + }, opToken.Location) + if nodeLeft == nil { + return nil } - nodeLeft.SetLocation(opToken.Location) if negate { - nodeLeft = &UnaryNode{ + nodeLeft = p.createNode(&UnaryNode{ Operator: "not", Node: nodeLeft, + }, notToken.Location) + if nodeLeft == nil { + return nil } - nodeLeft.SetLocation(notToken.Location) } goto next @@ -229,13 +272,11 @@ func (p *parser) parseVariableDeclaration() Node { value := p.parseExpression(0) p.expect(Operator, ";") node := p.parseExpression(0) - let := &VariableDeclaratorNode{ + return p.createNode(&VariableDeclaratorNode{ Name: variableName.Value, Value: value, Expr: node, - } - let.SetLocation(variableName.Location) - return let + }, variableName.Location) } func (p *parser) parseConditionalIf() Node { @@ -272,10 +313,13 @@ func (p *parser) parseConditional(node Node) Node { expr2 = p.parseExpression(0) } - node = &ConditionalNode{ + node = p.createNode(&ConditionalNode{ Cond: node, Exp1: expr1, Exp2: expr2, + }, p.current.Location) + if node == nil { + return nil } } return node @@ -288,11 +332,13 @@ func (p *parser) parsePrimary() Node { if op, ok := operator.Unary[token.Value]; ok { p.next() expr := p.parseExpression(op.Precedence) - node := &UnaryNode{ + node := p.createNode(&UnaryNode{ Operator: token.Value, Node: expr, + }, token.Location) + if node == nil { + return nil } - node.SetLocation(token.Location) return p.parsePostfixExpression(node) } } @@ -314,8 +360,10 @@ func (p *parser) parsePrimary() Node { p.next() } } - node := &PointerNode{Name: name} - node.SetLocation(token.Location) + node := p.createNode(&PointerNode{Name: name}, token.Location) + if node == nil { + return nil + } return p.parsePostfixExpression(node) } } else { @@ -344,23 +392,31 @@ func (p *parser) parseSecondary() Node { p.next() switch token.Value { case "true": - node := &BoolNode{Value: true} - node.SetLocation(token.Location) + node = p.createNode(&BoolNode{Value: true}, token.Location) + if node == nil { + return nil + } return node case "false": - node := &BoolNode{Value: false} - node.SetLocation(token.Location) + node = p.createNode(&BoolNode{Value: false}, token.Location) + if node == nil { + return nil + } return node case "nil": - node := &NilNode{} - node.SetLocation(token.Location) + node = p.createNode(&NilNode{}, token.Location) + if node == nil { + return nil + } return node default: if p.current.Is(Bracket, "(") { node = p.parseCall(token, []Node{}, true) } else { - node = &IdentifierNode{Value: token.Value} - node.SetLocation(token.Location) + node = p.createNode(&IdentifierNode{Value: token.Value}, token.Location) + if node == nil { + return nil + } } } @@ -407,8 +463,10 @@ func (p *parser) parseSecondary() Node { return node case String: p.next() - node = &StringNode{Value: token.Value} - node.SetLocation(token.Location) + node = p.createNode(&StringNode{Value: token.Value}, token.Location) + if node == nil { + return nil + } default: if token.Is(Bracket, "[") { @@ -428,7 +486,7 @@ func (p *parser) toIntegerNode(number int64) Node { p.error("integer literal is too large") return nil } - return &IntegerNode{Value: int(number)} + return p.createNode(&IntegerNode{Value: int(number)}, p.current.Location) } func (p *parser) toFloatNode(number float64) Node { @@ -436,7 +494,7 @@ func (p *parser) toFloatNode(number float64) Node { p.error("float literal is too large") return nil } - return &FloatNode{Value: number} + return p.createNode(&FloatNode{Value: number}, p.current.Location) } func (p *parser) parseCall(token Token, arguments []Node, checkOverrides bool) Node { @@ -478,25 +536,34 @@ func (p *parser) parseCall(token Token, arguments []Node, checkOverrides bool) N p.expect(Bracket, ")") - node = &BuiltinNode{ + node = p.createNode(&BuiltinNode{ Name: token.Value, Arguments: arguments, + }, token.Location) + if node == nil { + return nil } - node.SetLocation(token.Location) } else if _, ok := builtin.Index[token.Value]; ok && !p.config.Disabled[token.Value] && !isOverridden { - node = &BuiltinNode{ + node = p.createNode(&BuiltinNode{ Name: token.Value, Arguments: p.parseArguments(arguments), + }, token.Location) + if node == nil { + return nil } - node.SetLocation(token.Location) + } else { - callee := &IdentifierNode{Value: token.Value} - callee.SetLocation(token.Location) - node = &CallNode{ + callee := p.createNode(&IdentifierNode{Value: token.Value}, token.Location) + if callee == nil { + return nil + } + node = p.createNode(&CallNode{ Callee: callee, Arguments: p.parseArguments(arguments), + }, token.Location) + if node == nil { + return nil } - node.SetLocation(token.Location) } return node } @@ -534,10 +601,12 @@ func (p *parser) parsePredicate() Node { if expectClosingBracket { p.expect(Bracket, "}") } - predicateNode := &PredicateNode{ + predicateNode := p.createNode(&PredicateNode{ Node: node, + }, startToken.Location) + if predicateNode == nil { + return nil } - predicateNode.SetLocation(startToken.Location) return predicateNode } @@ -558,8 +627,10 @@ func (p *parser) parseArrayExpression(token Token) Node { end: p.expect(Bracket, "]") - node := &ArrayNode{Nodes: nodes} - node.SetLocation(token.Location) + node := p.createNode(&ArrayNode{Nodes: nodes}, token.Location) + if node == nil { + return nil + } return node } @@ -585,8 +656,10 @@ func (p *parser) parseMapExpression(token Token) Node { // * identifier, which is equivalent to a string // * expression, which must be enclosed in parentheses -- (1 + 2) if p.current.Is(Number) || p.current.Is(String) || p.current.Is(Identifier) { - key = &StringNode{Value: p.current.Value} - key.SetLocation(token.Location) + key = p.createNode(&StringNode{Value: p.current.Value}, p.current.Location) + if key == nil { + return nil + } p.next() } else if p.current.Is(Bracket, "(") { key = p.parseExpression(0) @@ -597,16 +670,20 @@ func (p *parser) parseMapExpression(token Token) Node { p.expect(Operator, ":") node := p.parseExpression(0) - pair := &PairNode{Key: key, Value: node} - pair.SetLocation(token.Location) + pair := p.createNode(&PairNode{Key: key, Value: node}, token.Location) + if pair == nil { + return nil + } nodes = append(nodes, pair) } end: p.expect(Bracket, "}") - node := &MapNode{Pairs: nodes} - node.SetLocation(token.Location) + node := p.createNode(&MapNode{Pairs: nodes}, token.Location) + if node == nil { + return nil + } return node } @@ -631,8 +708,10 @@ func (p *parser) parsePostfixExpression(node Node) Node { p.error("expected name") } - property := &StringNode{Value: propertyToken.Value} - property.SetLocation(propertyToken.Location) + property := p.createNode(&StringNode{Value: propertyToken.Value}, propertyToken.Location) + if property == nil { + return nil + } chainNode, isChain := node.(*ChainNode) optional := postfixToken.Value == "?." @@ -641,26 +720,33 @@ func (p *parser) parsePostfixExpression(node Node) Node { node = chainNode.Node } - memberNode := &MemberNode{ + memberNode := p.createMemberNode(&MemberNode{ Node: node, Property: property, Optional: optional, + }, propertyToken.Location) + if memberNode == nil { + return nil } - memberNode.SetLocation(propertyToken.Location) if p.current.Is(Bracket, "(") { memberNode.Method = true - node = &CallNode{ + node = p.createNode(&CallNode{ Callee: memberNode, Arguments: p.parseArguments([]Node{}), + }, propertyToken.Location) + if node == nil { + return nil } - node.SetLocation(propertyToken.Location) } else { node = memberNode } if isChain || optional { - node = &ChainNode{Node: node} + node = p.createNode(&ChainNode{Node: node}, propertyToken.Location) + if node == nil { + return nil + } } } else if postfixToken.Value == "[" { @@ -674,11 +760,13 @@ func (p *parser) parsePostfixExpression(node Node) Node { to = p.parseExpression(0) } - node = &SliceNode{ + node = p.createNode(&SliceNode{ Node: node, To: to, + }, postfixToken.Location) + if node == nil { + return nil } - node.SetLocation(postfixToken.Location) p.expect(Bracket, "]") } else { @@ -692,25 +780,32 @@ func (p *parser) parsePostfixExpression(node Node) Node { to = p.parseExpression(0) } - node = &SliceNode{ + node = p.createNode(&SliceNode{ Node: node, From: from, To: to, + }, postfixToken.Location) + if node == nil { + return nil } - node.SetLocation(postfixToken.Location) p.expect(Bracket, "]") } else { // Slice operator [:] was not found, // it should be just an index node. - node = &MemberNode{ + node = p.createNode(&MemberNode{ Node: node, Property: from, Optional: optional, + }, postfixToken.Location) + if node == nil { + return nil } - node.SetLocation(postfixToken.Location) if optional { - node = &ChainNode{Node: node} + node = p.createNode(&ChainNode{Node: node}, postfixToken.Location) + if node == nil { + return nil + } } p.expect(Bracket, "]") } @@ -722,26 +817,29 @@ func (p *parser) parsePostfixExpression(node Node) Node { } return node } - func (p *parser) parseComparison(left Node, token Token, precedence int) Node { var rootNode Node for { comparator := p.parseExpression(precedence + 1) - cmpNode := &BinaryNode{ + cmpNode := p.createNode(&BinaryNode{ Operator: token.Value, Left: left, Right: comparator, + }, token.Location) + if cmpNode == nil { + return nil } - cmpNode.SetLocation(token.Location) if rootNode == nil { rootNode = cmpNode } else { - rootNode = &BinaryNode{ + rootNode = p.createNode(&BinaryNode{ Operator: "&&", Left: rootNode, Right: cmpNode, + }, token.Location) + if rootNode == nil { + return nil } - rootNode.SetLocation(token.Location) } left = comparator diff --git a/parser/parser_test.go b/parser/parser_test.go index 6bb17e604..efae1f413 100644 --- a/parser/parser_test.go +++ b/parser/parser_test.go @@ -5,6 +5,7 @@ import ( "strings" "testing" + "github.com/expr-lang/expr/conf" "github.com/expr-lang/expr/internal/testify/assert" "github.com/expr-lang/expr/internal/testify/require" @@ -925,3 +926,78 @@ func TestParse_pipe_operator(t *testing.T) { require.NoError(t, err) assert.Equal(t, Dump(expect), Dump(actual.Node)) } + +func TestNodeBudget(t *testing.T) { + tests := []struct { + name string + expr string + maxNodes uint + shouldError bool + }{ + { + name: "simple expression equal to limit", + expr: "a + b", + maxNodes: 3, + shouldError: false, + }, + { + name: "medium expression under limit", + expr: "a + b * c / d", + maxNodes: 20, + shouldError: false, + }, + { + name: "deeply nested expression over limit", + expr: "1 + (2 + (3 + (4 + (5 + (6 + (7 + 8))))))", + maxNodes: 10, + shouldError: true, + }, + { + name: "array expression over limit", + expr: "[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]", + maxNodes: 5, + shouldError: true, + }, + { + name: "disabled node budget", + expr: "1 + (2 + (3 + (4 + (5 + (6 + (7 + 8))))))", + maxNodes: 0, + shouldError: false, + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + config := conf.CreateNew() + config.MaxNodes = tt.maxNodes + config.Disabled = make(map[string]bool, 0) + + _, err := parser.ParseWithConfig(tt.expr, config) + hasError := err != nil && strings.Contains(err.Error(), "exceeds maximum allowed nodes") + + if hasError != tt.shouldError { + t.Errorf("ParseWithConfig(%q) error = %v, shouldError %v", tt.expr, err, tt.shouldError) + } + + // Verify error message format when expected + if tt.shouldError && err != nil { + expected := "compilation failed: expression exceeds maximum allowed nodes" + if !strings.Contains(err.Error(), expected) { + t.Errorf("Expected error message to contain %q, got %q", expected, err.Error()) + } + } + }) + } +} + +func TestNodeBudgetDisabled(t *testing.T) { + config := conf.CreateNew() + config.MaxNodes = 0 // Disable node budget + + expr := strings.Repeat("a + ", 1000) + "b" + _, err := parser.ParseWithConfig(expr, config) + + if err != nil && strings.Contains(err.Error(), "exceeds maximum allowed nodes") { + t.Error("Node budget check should be disabled when MaxNodes is 0") + } +} diff --git a/vm/utils.go b/vm/utils.go index fc2f5e7b8..11005137c 100644 --- a/vm/utils.go +++ b/vm/utils.go @@ -11,9 +11,6 @@ type ( ) var ( - // MemoryBudget represents an upper limit of memory usage. - MemoryBudget uint = 1e6 - errorType = reflect.TypeOf((*error)(nil)).Elem() ) diff --git a/vm/vm.go b/vm/vm.go index fa1223b42..62c6511f4 100644 --- a/vm/vm.go +++ b/vm/vm.go @@ -11,6 +11,7 @@ import ( "time" "github.com/expr-lang/expr/builtin" + "github.com/expr-lang/expr/conf" "github.com/expr-lang/expr/file" "github.com/expr-lang/expr/internal/deref" "github.com/expr-lang/expr/vm/runtime" @@ -20,11 +21,23 @@ func Run(program *Program, env any) (any, error) { if program == nil { return nil, fmt.Errorf("program is nil") } - vm := VM{} return vm.Run(program, env) } +func RunWithConfig(program *Program, env any, config *conf.Config) (any, error) { + if program == nil { + return nil, fmt.Errorf("program is nil") + } + if config == nil { + return nil, fmt.Errorf("config is nil") + } + vm := VM{ + MemoryBudget: config.MemoryBudget, + } + return vm.Run(program, env) +} + func Debug() *VM { vm := &VM{ debug: true, @@ -38,9 +51,9 @@ type VM struct { Stack []any Scopes []*Scope Variables []any + MemoryBudget uint ip int memory uint - memoryBudget uint debug bool step chan struct{} curr chan int @@ -76,7 +89,9 @@ func (vm *VM) Run(program *Program, env any) (_ any, err error) { vm.Variables = make([]any, program.variables) } - vm.memoryBudget = MemoryBudget + if vm.MemoryBudget == 0 { + vm.MemoryBudget = conf.DefaultMemoryBudget + } vm.memory = 0 vm.ip = 0 @@ -599,7 +614,7 @@ func (vm *VM) pop() any { func (vm *VM) memGrow(size uint) { vm.memory += size - if vm.memory >= vm.memoryBudget { + if vm.memory >= vm.MemoryBudget { panic("memory budget exceeded") } } diff --git a/vm/vm_test.go b/vm/vm_test.go index d45ef2d6c..aec358ab7 100644 --- a/vm/vm_test.go +++ b/vm/vm_test.go @@ -4,6 +4,7 @@ import ( "errors" "fmt" "reflect" + "strings" "testing" "github.com/expr-lang/expr/internal/testify/require" @@ -17,8 +18,35 @@ import ( ) func TestRun_NilProgram(t *testing.T) { - _, err := vm.Run(nil, nil) - require.Error(t, err) + t.Run("run with nil program", func(t *testing.T) { + newVM, err := vm.Run(nil, nil) + require.Error(t, err) + require.Nil(t, newVM) + }) + t.Run("run with nil program and nil config", func(t *testing.T) { + newVM, err := vm.RunWithConfig(nil, nil, nil) + require.Error(t, err) + require.Nil(t, newVM) + }) + t.Run("run with nil config", func(t *testing.T) { + program, err := expr.Compile("1") + require.Nil(t, err) + newVM, err := vm.RunWithConfig(program, nil, nil) + require.Error(t, err) + require.Nil(t, newVM) + }) + t.Run("run with config", func(t *testing.T) { + program, err := expr.Compile("1") + require.Nil(t, err) + config := conf.New(nil) + env := map[string]any{ + "a": 1, + } + config.MemoryBudget = 100 + newVM, err := vm.RunWithConfig(program, env, config) + require.Nil(t, err) + require.Equal(t, newVM, 1) + }) } func TestRun_ReuseVM(t *testing.T) { @@ -1191,3 +1219,135 @@ func TestVM_DirectBasicOpcodes(t *testing.T) { }) } } + +func TestVM_MemoryBudget(t *testing.T) { + tests := []struct { + name string + expr string + memBudget uint + expectError string + }{ + { + name: "under budget", + expr: "map(1..10, #)", + memBudget: 100, + }, + { + name: "exceeds budget", + expr: "map(1..1000, #)", + memBudget: 10, + expectError: "memory budget exceeded", + }, + { + name: "zero budget uses default", + expr: "map(1..10, #)", + memBudget: 0, + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + node, err := parser.Parse(tt.expr) + require.NoError(t, err) + + program, err := compiler.Compile(node, nil) + require.NoError(t, err) + + vm := vm.VM{MemoryBudget: tt.memBudget} + out, err := vm.Run(program, nil) + + if tt.expectError != "" { + require.Error(t, err) + require.Contains(t, err.Error(), tt.expectError) + } else { + require.NoError(t, err) + require.NotNil(t, out) + } + }) + } +} + +// Helper functions for creating deeply nested expressions +func createNestedArithmeticExpr(t *testing.T, depth int) string { + t.Helper() + if depth == 0 { + return "a" + } + return fmt.Sprintf("(%s + %d)", createNestedArithmeticExpr(t, depth-1), depth) +} + +func createNestedMapExpr(t *testing.T, depth int) string { + t.Helper() + if depth == 0 { + return `{"value": 1}` + } + return fmt.Sprintf(`{"nested": %s}`, createNestedMapExpr(t, depth-1)) +} + +func TestVM_Limits(t *testing.T) { + tests := []struct { + name string + expr string + memoryBudget uint + maxNodes uint + env map[string]any + expectError string + }{ + { + name: "nested arithmetic allowed with max nodes and memory budget", + expr: createNestedArithmeticExpr(t, 100), + env: map[string]any{"a": 1}, + maxNodes: 1000, + memoryBudget: 1, // arithmetic expressions not counted towards memory budget + }, + { + name: "nested arithmetic blocked by max nodes", + expr: createNestedArithmeticExpr(t, 10000), + env: map[string]any{"a": 1}, + maxNodes: 100, + memoryBudget: 1, // arithmetic expressions not counted towards memory budget + expectError: "compilation failed: expression exceeds maximum allowed nodes", + }, + { + name: "nested map blocked by memory budget", + expr: createNestedMapExpr(t, 100), + env: map[string]any{}, + maxNodes: 1000, + memoryBudget: 10, // Small memory budget to trigger limit + expectError: "memory budget exceeded", + }, + } + + for _, test := range tests { + t.Run(test.name, func(t *testing.T) { + var options []expr.Option + options = append(options, expr.Env(test.env)) + if test.maxNodes > 0 { + options = append(options, func(c *conf.Config) { + c.MaxNodes = test.maxNodes + }) + } + + program, err := expr.Compile(test.expr, options...) + if err != nil { + if test.expectError != "" && strings.Contains(err.Error(), test.expectError) { + return + } + t.Fatal(err) + } + + testVM := &vm.VM{ + MemoryBudget: test.memoryBudget, + } + + _, err = testVM.Run(program, test.env) + + if test.expectError == "" { + require.NoError(t, err) + } else { + require.Error(t, err) + require.Contains(t, err.Error(), test.expectError) + } + }) + } +} From bc77b4b3cd7665412e84f7e421798d2b91de0be7 Mon Sep 17 00:00:00 2001 From: Anton Medvedev Date: Fri, 7 Mar 2025 15:06:45 +0100 Subject: [PATCH 037/113] Remove additional run API (RunWithConfig) from VM This API was introduced in previous PR, but we do not want to expose it. --- vm/vm.go | 13 ------------- vm/vm_test.go | 31 ++----------------------------- 2 files changed, 2 insertions(+), 42 deletions(-) diff --git a/vm/vm.go b/vm/vm.go index 62c6511f4..5c40f26cd 100644 --- a/vm/vm.go +++ b/vm/vm.go @@ -25,19 +25,6 @@ func Run(program *Program, env any) (any, error) { return vm.Run(program, env) } -func RunWithConfig(program *Program, env any, config *conf.Config) (any, error) { - if program == nil { - return nil, fmt.Errorf("program is nil") - } - if config == nil { - return nil, fmt.Errorf("config is nil") - } - vm := VM{ - MemoryBudget: config.MemoryBudget, - } - return vm.Run(program, env) -} - func Debug() *VM { vm := &VM{ debug: true, diff --git a/vm/vm_test.go b/vm/vm_test.go index aec358ab7..615b0a442 100644 --- a/vm/vm_test.go +++ b/vm/vm_test.go @@ -18,35 +18,8 @@ import ( ) func TestRun_NilProgram(t *testing.T) { - t.Run("run with nil program", func(t *testing.T) { - newVM, err := vm.Run(nil, nil) - require.Error(t, err) - require.Nil(t, newVM) - }) - t.Run("run with nil program and nil config", func(t *testing.T) { - newVM, err := vm.RunWithConfig(nil, nil, nil) - require.Error(t, err) - require.Nil(t, newVM) - }) - t.Run("run with nil config", func(t *testing.T) { - program, err := expr.Compile("1") - require.Nil(t, err) - newVM, err := vm.RunWithConfig(program, nil, nil) - require.Error(t, err) - require.Nil(t, newVM) - }) - t.Run("run with config", func(t *testing.T) { - program, err := expr.Compile("1") - require.Nil(t, err) - config := conf.New(nil) - env := map[string]any{ - "a": 1, - } - config.MemoryBudget = 100 - newVM, err := vm.RunWithConfig(program, env, config) - require.Nil(t, err) - require.Equal(t, newVM, 1) - }) + _, err := vm.Run(nil, nil) + require.Error(t, err) } func TestRun_ReuseVM(t *testing.T) { From ed9de341c58b43d844af11244f315300d419e381 Mon Sep 17 00:00:00 2001 From: Ryan Bullock Date: Fri, 7 Mar 2025 06:27:19 -0800 Subject: [PATCH 038/113] Separate patching phases for patchers that require multiple passes. (#659) * Reset tracking of applied operator overloads before every walk of the ast tree. * Remove limit on operator overload resolution * Do separate patcher phase for those that require multiple passes (Currently only need for Operator overloading). This patcher phase is run after other patchers. * Add test to track how many times a patcher is run. Used to detect if patching phases is erroneously applying the patcher multiple times. --------- Co-authored-by: Anton Medvedev --- checker/checker.go | 58 +++++++++++++++++++++----------- patcher/operator_override.go | 5 +++ test/patch/patch_count_test.go | 61 ++++++++++++++++++++++++++++++++++ 3 files changed, 105 insertions(+), 19 deletions(-) create mode 100644 test/patch/patch_count_test.go diff --git a/checker/checker.go b/checker/checker.go index 0ad22f4e1..e71f1d7e0 100644 --- a/checker/checker.go +++ b/checker/checker.go @@ -13,6 +13,40 @@ import ( "github.com/expr-lang/expr/parser" ) +// Run visitors in a given config over the given tree +// runRepeatable controls whether to filter for only vistors that require multiple passes or not +func runVisitors(tree *parser.Tree, config *conf.Config, runRepeatable bool) { + for { + more := false + for _, v := range config.Visitors { + // We need to perform types check, because some visitors may rely on + // types information available in the tree. + _, _ = Check(tree, config) + + r, repeatable := v.(interface { + Reset() + ShouldRepeat() bool + }) + + if repeatable { + if runRepeatable { + r.Reset() + ast.Walk(&tree.Node, v) + more = more || r.ShouldRepeat() + } + } else { + if !runRepeatable { + ast.Walk(&tree.Node, v) + } + } + } + + if !more { + break + } + } +} + // ParseCheck parses input expression and checks its types. Also, it applies // all provided patchers. In case of error, it returns error with a tree. func ParseCheck(input string, config *conf.Config) (*parser.Tree, error) { @@ -22,25 +56,11 @@ func ParseCheck(input string, config *conf.Config) (*parser.Tree, error) { } if len(config.Visitors) > 0 { - for i := 0; i < 1000; i++ { - more := false - for _, v := range config.Visitors { - // We need to perform types check, because some visitors may rely on - // types information available in the tree. - _, _ = Check(tree, config) - - ast.Walk(&tree.Node, v) - - if v, ok := v.(interface { - ShouldRepeat() bool - }); ok { - more = more || v.ShouldRepeat() - } - } - if !more { - break - } - } + // Run all patchers that dont support being run repeatedly first + runVisitors(tree, config, false) + + // Run patchers that require multiple passes next (currently only Operator patching) + runVisitors(tree, config, true) } _, err = Check(tree, config) if err != nil { diff --git a/patcher/operator_override.go b/patcher/operator_override.go index b2d20ec4b..308cbdba3 100644 --- a/patcher/operator_override.go +++ b/patcher/operator_override.go @@ -43,6 +43,11 @@ func (p *OperatorOverloading) Visit(node *ast.Node) { } } +// Tracking must be reset before every walk over the AST tree +func (p *OperatorOverloading) Reset() { + p.applied = false +} + func (p *OperatorOverloading) ShouldRepeat() bool { return p.applied } diff --git a/test/patch/patch_count_test.go b/test/patch/patch_count_test.go new file mode 100644 index 000000000..e877de4a2 --- /dev/null +++ b/test/patch/patch_count_test.go @@ -0,0 +1,61 @@ +package patch_test + +import ( + "testing" + + "github.com/expr-lang/expr/internal/testify/require" + + "github.com/expr-lang/expr" + "github.com/expr-lang/expr/ast" + "github.com/expr-lang/expr/test/mock" +) + +// This patcher tracks how many nodes it patches which can +// be used to verify if it was run too many times or not at all +type countingPatcher struct { + PatchCount int +} + +func (c *countingPatcher) Visit(node *ast.Node) { + switch (*node).(type) { + case *ast.IntegerNode: + c.PatchCount++ + } +} + +// Test over a simple expression +func TestPatch_Count(t *testing.T) { + patcher := countingPatcher{} + + _, err := expr.Compile( + `5 + 5`, + expr.Env(mock.Env{}), + expr.Patch(&patcher), + ) + require.NoError(t, err) + + require.Equal(t, 2, patcher.PatchCount, "Patcher run an unexpected number of times during compile") +} + +// Test with operator overloading +func TestPatchOperator_Count(t *testing.T) { + patcher := countingPatcher{} + + _, err := expr.Compile( + `5 + 5`, + expr.Env(mock.Env{}), + expr.Patch(&patcher), + expr.Operator("+", "_intAdd"), + expr.Function( + "_intAdd", + func(params ...any) (any, error) { + return params[0].(int) + params[1].(int), nil + }, + new(func(int, int) int), + ), + ) + + require.NoError(t, err) + + require.Equal(t, 2, patcher.PatchCount, "Patcher run an unexpected number of times during compile") +} From 4544adfce5320ef71b5503982249357ac8310fcb Mon Sep 17 00:00:00 2001 From: Anton Medvedev Date: Fri, 7 Mar 2025 15:56:31 +0100 Subject: [PATCH 039/113] Exclude pro from go coverage.mjs --- .github/scripts/coverage.mjs | 1 + 1 file changed, 1 insertion(+) diff --git a/.github/scripts/coverage.mjs b/.github/scripts/coverage.mjs index c00242894..1e15806bd 100755 --- a/.github/scripts/coverage.mjs +++ b/.github/scripts/coverage.mjs @@ -9,6 +9,7 @@ const exclude = [ 'internal/difflib', 'internal/spew', 'internal/testify', + 'pro', ] cd(path.resolve(__dirname, '..', '..')) From 156e73d03928799d932a465439a67a6379e94d05 Mon Sep 17 00:00:00 2001 From: Anton Medvedev Date: Fri, 7 Mar 2025 16:24:24 +0100 Subject: [PATCH 040/113] Add coverage.mjs comments --- .github/scripts/coverage.mjs | 17 +++++++++-------- 1 file changed, 9 insertions(+), 8 deletions(-) diff --git a/.github/scripts/coverage.mjs b/.github/scripts/coverage.mjs index 1e15806bd..3bc381313 100755 --- a/.github/scripts/coverage.mjs +++ b/.github/scripts/coverage.mjs @@ -2,14 +2,15 @@ const expected = 90 const exclude = [ - 'expr/test', - 'checker/mock', - 'vm/func_types', - 'vm/runtime/helpers', - 'internal/difflib', - 'internal/spew', - 'internal/testify', - 'pro', + 'expr/test', // We do not need to test the test package. + 'checker/mock', // Mocks only used for testing. + 'vm/func_types', // Generated files. + 'vm/runtime/helpers', // Generated files. + 'internal/difflib', // Test dependency. This is vendored dependency, and ideally we also have good tests for it. + 'internal/spew', // Test dependency. + 'internal/testify', // Test dependency. + 'patcher/value', // Contains a lot of repeating code. Ideally we should have a test for it. + 'pro', // Expr Pro is not a part of the main codebase. ] cd(path.resolve(__dirname, '..', '..')) From af32277333478cfafabf95dcf5a0ddf68d4a1d87 Mon Sep 17 00:00:00 2001 From: zhuliquan Date: Fri, 7 Mar 2025 23:34:41 +0800 Subject: [PATCH 041/113] Fix print with precedence (#678) * feat: extract code for compiling equal operator * fix: fix unary and binary node print consider the precedence of operators and their associative law when printing unary and binary nodes --------- Co-authored-by: Anton Medvedev --- ast/print.go | 25 +++++++++++++++++++++++-- ast/print_test.go | 5 +++++ 2 files changed, 28 insertions(+), 2 deletions(-) diff --git a/ast/print.go b/ast/print.go index b79048b2c..0fd2fa58a 100644 --- a/ast/print.go +++ b/ast/print.go @@ -50,8 +50,13 @@ func (n *UnaryNode) String() string { op = fmt.Sprintf("%s ", n.Operator) } wrap := false - switch n.Node.(type) { - case *BinaryNode, *ConditionalNode: + switch b := n.Node.(type) { + case *BinaryNode: + if operator.Binary[b.Operator].Precedence < + operator.Unary[n.Operator].Precedence { + wrap = true + } + case *ConditionalNode: wrap = true } if wrap { @@ -68,10 +73,21 @@ func (n *BinaryNode) String() string { var lhs, rhs string var lwrap, rwrap bool + if l, ok := n.Left.(*UnaryNode); ok { + if operator.Unary[l.Operator].Precedence < + operator.Binary[n.Operator].Precedence { + lwrap = true + } + } if lb, ok := n.Left.(*BinaryNode); ok { if operator.Less(lb.Operator, n.Operator) { lwrap = true } + if operator.Binary[lb.Operator].Precedence == + operator.Binary[n.Operator].Precedence && + operator.Binary[n.Operator].Associativity == operator.Right { + lwrap = true + } if lb.Operator == "??" { lwrap = true } @@ -83,6 +99,11 @@ func (n *BinaryNode) String() string { if operator.Less(rb.Operator, n.Operator) { rwrap = true } + if operator.Binary[rb.Operator].Precedence == + operator.Binary[n.Operator].Precedence && + operator.Binary[n.Operator].Associativity == operator.Left { + rwrap = true + } if operator.IsBoolean(rb.Operator) && n.Operator != rb.Operator { rwrap = true } diff --git a/ast/print_test.go b/ast/print_test.go index a4b20b0a1..8f950e276 100644 --- a/ast/print_test.go +++ b/ast/print_test.go @@ -78,6 +78,11 @@ func TestPrint(t *testing.T) { {`{("a" + "b"): 42}`, `{("a" + "b"): 42}`}, {`(One == 1 ? true : false) && Two == 2`, `(One == 1 ? true : false) && Two == 2`}, {`not (a == 1 ? b > 1 : b < 2)`, `not (a == 1 ? b > 1 : b < 2)`}, + {`(-(1+1)) ** 2`, `(-(1 + 1)) ** 2`}, + {`2 ** (-(1+1))`, `2 ** -(1 + 1)`}, + {`(2 ** 2) ** 3`, `(2 ** 2) ** 3`}, + {`(3 + 5) / (5 % 3)`, `(3 + 5) / (5 % 3)`}, + {`(-(1+1)) == 2`, `-(1 + 1) == 2`}, } for _, tt := range tests { From 9dc8bb93cc9032381661d74fce640912416b0d4c Mon Sep 17 00:00:00 2001 From: Ville Vesilehto Date: Fri, 7 Mar 2025 17:42:00 +0200 Subject: [PATCH 042/113] refactor(conf): avoid type assertion in map case branch (#749) Simplifies the code by using the type switch variable binding instead of performing an additional type assertion. Signed-off-by: Ville Vesilehto Co-authored-by: Anton Medvedev --- conf/env.go | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/conf/env.go b/conf/env.go index 494bb5b74..99e2f4626 100644 --- a/conf/env.go +++ b/conf/env.go @@ -46,9 +46,9 @@ func Env(env any) Nature { face := elem.Interface() - switch face.(type) { + switch face := face.(type) { case types.Map: - n.Fields[key.String()] = face.(types.Map).Nature() + n.Fields[key.String()] = face.Nature() default: if face == nil { From 79b11706b9759282a07eb27bdb98eaa23c3fbbf1 Mon Sep 17 00:00:00 2001 From: Anton Medvedev Date: Fri, 7 Mar 2025 16:44:02 +0100 Subject: [PATCH 043/113] Add +build comments --- vm/debug.go | 1 + vm/debug_off.go | 1 + vm/debug_test.go | 1 + 3 files changed, 3 insertions(+) diff --git a/vm/debug.go b/vm/debug.go index ab95bf9a0..470bf90e2 100644 --- a/vm/debug.go +++ b/vm/debug.go @@ -1,4 +1,5 @@ //go:build expr_debug +// +build expr_debug package vm diff --git a/vm/debug_off.go b/vm/debug_off.go index e0f2955a1..8a9e965e2 100644 --- a/vm/debug_off.go +++ b/vm/debug_off.go @@ -1,4 +1,5 @@ //go:build !expr_debug +// +build !expr_debug package vm diff --git a/vm/debug_test.go b/vm/debug_test.go index 7360e5833..ca7a28d89 100644 --- a/vm/debug_test.go +++ b/vm/debug_test.go @@ -1,4 +1,5 @@ //go:build expr_debug +// +build expr_debug package vm_test From e8bd7f8689348614b47d71af8a8aef709d2fe8c7 Mon Sep 17 00:00:00 2001 From: Anton Medvedev Date: Fri, 7 Mar 2025 16:58:35 +0100 Subject: [PATCH 044/113] Make len() return runes count for string Fixes #746 --- builtin/lib.go | 5 ++++- expr_test.go | 12 ++++++++++++ 2 files changed, 16 insertions(+), 1 deletion(-) diff --git a/builtin/lib.go b/builtin/lib.go index 13c7d207e..07e631e07 100644 --- a/builtin/lib.go +++ b/builtin/lib.go @@ -5,6 +5,7 @@ import ( "math" "reflect" "strconv" + "unicode/utf8" "github.com/expr-lang/expr/internal/deref" ) @@ -12,8 +13,10 @@ import ( func Len(x any) any { v := reflect.ValueOf(x) switch v.Kind() { - case reflect.Array, reflect.Slice, reflect.Map, reflect.String: + case reflect.Array, reflect.Slice, reflect.Map: return v.Len() + case reflect.String: + return utf8.RuneCountInString(v.String()) default: panic(fmt.Sprintf("invalid argument for len (type %T)", x)) } diff --git a/expr_test.go b/expr_test.go index f10350b22..bebe23a30 100644 --- a/expr_test.go +++ b/expr_test.go @@ -871,6 +871,18 @@ func TestExpr(t *testing.T) { `len("hello, world")`, 12, }, + { + `len('北京')`, + 2, + }, + { + `len('👍🏻')`, // one grapheme cluster, two code points + 2, + }, + { + `len('👍')`, // one grapheme cluster, one code point + 1, + }, { `len(ArrayOfInt)`, 5, From 35bdb68a944c8e8306ba8ac4db97e8400b3fe51a Mon Sep 17 00:00:00 2001 From: Anton Medvedev Date: Fri, 7 Mar 2025 20:39:53 +0100 Subject: [PATCH 045/113] Do not optimize filter_map if #index used Fixes #758 --- expr_test.go | 21 ++++++++++ optimizer/filter_map.go | 10 ++++- optimizer/filter_map_test.go | 74 ++++++++++++++++++++++++++++++++++++ optimizer/optimizer_test.go | 31 --------------- 4 files changed, 104 insertions(+), 32 deletions(-) create mode 100644 optimizer/filter_map_test.go diff --git a/expr_test.go b/expr_test.go index bebe23a30..d1a93cd0c 100644 --- a/expr_test.go +++ b/expr_test.go @@ -2763,3 +2763,24 @@ func TestExpr_env_types_map_error(t *testing.T) { _, err = expr.Run(program, envTypes) require.Error(t, err) } + +func TestIssue758_FilterMapIndex(t *testing.T) { + env := map[string]interface{}{} + + exprStr := ` + let a_map = 0..5 | filter(# % 2 == 0) | map(#index); + let b_filter = 0..5 | filter(# % 2 == 0); + let b_map = b_filter | map(#index); + [a_map, b_map] + ` + + result, err := expr.Eval(exprStr, env) + require.NoError(t, err) + + expected := []interface{}{ + []interface{}{0, 1, 2}, + []interface{}{0, 1, 2}, + } + + require.Equal(t, expected, result) +} diff --git a/optimizer/filter_map.go b/optimizer/filter_map.go index c6de6c73e..17659a914 100644 --- a/optimizer/filter_map.go +++ b/optimizer/filter_map.go @@ -9,7 +9,8 @@ type filterMap struct{} func (*filterMap) Visit(node *Node) { if mapBuiltin, ok := (*node).(*BuiltinNode); ok && mapBuiltin.Name == "map" && - len(mapBuiltin.Arguments) == 2 { + len(mapBuiltin.Arguments) == 2 && + Find(mapBuiltin.Arguments[1], isIndexPointer) == nil { if predicate, ok := mapBuiltin.Arguments[1].(*PredicateNode); ok { if filter, ok := mapBuiltin.Arguments[0].(*BuiltinNode); ok && filter.Name == "filter" && @@ -23,3 +24,10 @@ func (*filterMap) Visit(node *Node) { } } } + +func isIndexPointer(node Node) bool { + if pointer, ok := node.(*PointerNode); ok && pointer.Name == "index" { + return true + } + return false +} diff --git a/optimizer/filter_map_test.go b/optimizer/filter_map_test.go new file mode 100644 index 000000000..d6d423f4e --- /dev/null +++ b/optimizer/filter_map_test.go @@ -0,0 +1,74 @@ +package optimizer_test + +import ( + "testing" + + . "github.com/expr-lang/expr/ast" + "github.com/expr-lang/expr/internal/testify/assert" + "github.com/expr-lang/expr/internal/testify/require" + "github.com/expr-lang/expr/optimizer" + "github.com/expr-lang/expr/parser" +) + +func TestOptimize_filter_map(t *testing.T) { + tree, err := parser.Parse(`map(filter(users, .Name == "Bob"), .Age)`) + require.NoError(t, err) + + err = optimizer.Optimize(&tree.Node, nil) + require.NoError(t, err) + + expected := &BuiltinNode{ + Name: "filter", + Arguments: []Node{ + &IdentifierNode{Value: "users"}, + &PredicateNode{ + Node: &BinaryNode{ + Operator: "==", + Left: &MemberNode{ + Node: &PointerNode{}, + Property: &StringNode{Value: "Name"}, + }, + Right: &StringNode{Value: "Bob"}, + }, + }, + }, + Map: &MemberNode{ + Node: &PointerNode{}, + Property: &StringNode{Value: "Age"}, + }, + } + + assert.Equal(t, Dump(expected), Dump(tree.Node)) +} + +func TestOptimize_filter_map_with_index_pointer(t *testing.T) { + tree, err := parser.Parse(`map(filter(users, true), #index)`) + require.NoError(t, err) + + err = optimizer.Optimize(&tree.Node, nil) + require.NoError(t, err) + + expected := &BuiltinNode{ + Name: "map", + Arguments: []Node{ + &BuiltinNode{ + Name: "filter", + Arguments: []Node{ + &IdentifierNode{Value: "users"}, + &PredicateNode{ + Node: &BoolNode{Value: true}, + }, + }, + Throws: false, + Map: nil, + }, + &PredicateNode{ + Node: &PointerNode{Name: "index"}, + }, + }, + Throws: false, + Map: nil, + } + + assert.Equal(t, Dump(expected), Dump(tree.Node)) +} diff --git a/optimizer/optimizer_test.go b/optimizer/optimizer_test.go index 7830c0e78..03458689f 100644 --- a/optimizer/optimizer_test.go +++ b/optimizer/optimizer_test.go @@ -312,37 +312,6 @@ func TestOptimize_filter_last(t *testing.T) { assert.Equal(t, ast.Dump(expected), ast.Dump(tree.Node)) } -func TestOptimize_filter_map(t *testing.T) { - tree, err := parser.Parse(`map(filter(users, .Name == "Bob"), .Age)`) - require.NoError(t, err) - - err = optimizer.Optimize(&tree.Node, nil) - require.NoError(t, err) - - expected := &ast.BuiltinNode{ - Name: "filter", - Arguments: []ast.Node{ - &ast.IdentifierNode{Value: "users"}, - &ast.PredicateNode{ - Node: &ast.BinaryNode{ - Operator: "==", - Left: &ast.MemberNode{ - Node: &ast.PointerNode{}, - Property: &ast.StringNode{Value: "Name"}, - }, - Right: &ast.StringNode{Value: "Bob"}, - }, - }, - }, - Map: &ast.MemberNode{ - Node: &ast.PointerNode{}, - Property: &ast.StringNode{Value: "Age"}, - }, - } - - assert.Equal(t, ast.Dump(expected), ast.Dump(tree.Node)) -} - func TestOptimize_filter_map_first(t *testing.T) { tree, err := parser.Parse(`first(map(filter(users, .Name == "Bob"), .Age))`) require.NoError(t, err) From 579de74b421df8d8231f3ed09beb84279bbed3ce Mon Sep 17 00:00:00 2001 From: Anton Medvedev Date: Fri, 7 Mar 2025 20:40:02 +0100 Subject: [PATCH 046/113] Add ast.Find --- ast/find.go | 18 ++++++++++++++++++ ast/find_test.go | 31 +++++++++++++++++++++++++++++++ 2 files changed, 49 insertions(+) create mode 100644 ast/find.go create mode 100644 ast/find_test.go diff --git a/ast/find.go b/ast/find.go new file mode 100644 index 000000000..247ff6c00 --- /dev/null +++ b/ast/find.go @@ -0,0 +1,18 @@ +package ast + +func Find(node Node, fn func(node Node) bool) Node { + v := &finder{fn: fn} + Walk(&node, v) + return v.node +} + +type finder struct { + node Node + fn func(node Node) bool +} + +func (f *finder) Visit(node *Node) { + if f.fn(*node) { + f.node = *node + } +} diff --git a/ast/find_test.go b/ast/find_test.go new file mode 100644 index 000000000..e4894c48f --- /dev/null +++ b/ast/find_test.go @@ -0,0 +1,31 @@ +package ast_test + +import ( + "testing" + + "github.com/expr-lang/expr/internal/testify/require" + + "github.com/expr-lang/expr/ast" +) + +func TestFind(t *testing.T) { + left := &ast.IdentifierNode{ + Value: "a", + } + var root ast.Node = &ast.BinaryNode{ + Operator: "+", + Left: left, + Right: &ast.IdentifierNode{ + Value: "b", + }, + } + + x := ast.Find(root, func(node ast.Node) bool { + if n, ok := node.(*ast.IdentifierNode); ok { + return n.Value == "a" + } + return false + }) + + require.Equal(t, left, x) +} From 8f1e8804a632cbad0e5c5f8458875d10532d0ba4 Mon Sep 17 00:00:00 2001 From: Anton Medvedev Date: Fri, 7 Mar 2025 21:52:14 +0100 Subject: [PATCH 047/113] Add more tests for filter_map optimization --- expr_test.go | 2 +- optimizer/filter_map_test.go | 40 ++++++++++++++++++++++++++++++++++++ 2 files changed, 41 insertions(+), 1 deletion(-) diff --git a/expr_test.go b/expr_test.go index d1a93cd0c..446fc6a71 100644 --- a/expr_test.go +++ b/expr_test.go @@ -2764,7 +2764,7 @@ func TestExpr_env_types_map_error(t *testing.T) { require.Error(t, err) } -func TestIssue758_FilterMapIndex(t *testing.T) { +func TestIssue758_filter_map_index(t *testing.T) { env := map[string]interface{}{} exprStr := ` diff --git a/optimizer/filter_map_test.go b/optimizer/filter_map_test.go index d6d423f4e..b45fbdead 100644 --- a/optimizer/filter_map_test.go +++ b/optimizer/filter_map_test.go @@ -72,3 +72,43 @@ func TestOptimize_filter_map_with_index_pointer(t *testing.T) { assert.Equal(t, Dump(expected), Dump(tree.Node)) } + +func TestOptimize_filter_map_with_index_pointer_with_index_pointer_in_first_argument(t *testing.T) { + tree, err := parser.Parse(`1..2 | map(map(filter([#index], true), 42))`) + require.NoError(t, err) + + err = optimizer.Optimize(&tree.Node, nil) + require.NoError(t, err) + + expected := &BuiltinNode{ + Name: "map", + Arguments: []Node{ + &BinaryNode{ + Operator: "..", + Left: &IntegerNode{Value: 1}, + Right: &IntegerNode{Value: 2}, + }, + &PredicateNode{ + Node: &BuiltinNode{ + Name: "filter", + Arguments: []Node{ + &ArrayNode{ + Nodes: []Node{ + &PointerNode{Name: "index"}, + }, + }, + &PredicateNode{ + Node: &BoolNode{Value: true}, + }, + }, + Throws: false, + Map: &IntegerNode{Value: 42}, + }, + }, + }, + Throws: false, + Map: nil, + } + + assert.Equal(t, Dump(expected), Dump(tree.Node)) +} From 8bb9ab77182b96698fd1e6dc46ee2611ac055fc5 Mon Sep 17 00:00:00 2001 From: Anton Medvedev Date: Fri, 7 Mar 2025 22:56:41 +0100 Subject: [PATCH 048/113] Properly check if interface is any Fixes #744 --- checker/checker.go | 8 ++++ checker/checker_test.go | 2 +- checker/nature/nature.go | 9 ++++- checker/nature/utils.go | 4 ++ checker/types.go | 6 ++- .../interface_method_test.go | 2 +- test/interface/interface_test.go | 40 +++++++++++++++++++ 7 files changed, 67 insertions(+), 4 deletions(-) rename test/{interface_method => interface}/interface_method_test.go (96%) create mode 100644 test/interface/interface_test.go diff --git a/checker/checker.go b/checker/checker.go index e71f1d7e0..0d316c0d7 100644 --- a/checker/checker.go +++ b/checker/checker.go @@ -535,6 +535,14 @@ func (v *checker) MemberNode(node *ast.MemberNode) Nature { } } + // Not found. + + if name, ok := node.Property.(*ast.StringNode); ok { + if node.Method { + return v.error(node, "type %v has no method %v", base, name.Value) + } + return v.error(node, "type %v has no field %v", base, name.Value) + } return v.error(node, "type %v[%v] is undefined", base, prop) } diff --git a/checker/checker_test.go b/checker/checker_test.go index 17ec886e4..89f8e10b8 100644 --- a/checker/checker_test.go +++ b/checker/checker_test.go @@ -1055,7 +1055,7 @@ func TestCheck_builtin_without_call(t *testing.T) { err string }{ {`len + 1`, "invalid operation: + (mismatched types func(...interface {}) (interface {}, error) and int) (1:5)\n | len + 1\n | ....^"}, - {`string.A`, "type func(interface {}) string[string] is undefined (1:8)\n | string.A\n | .......^"}, + {`string.A`, "type func(interface {}) string has no field A (1:8)\n | string.A\n | .......^"}, } for _, test := range tests { diff --git a/checker/nature/nature.go b/checker/nature/nature.go index 2b09353b5..01f8b9e49 100644 --- a/checker/nature/nature.go +++ b/checker/nature/nature.go @@ -74,7 +74,7 @@ func (n Nature) Elem() Nature { func (n Nature) AssignableTo(nt Nature) bool { if n.Nil { // Untyped nil is assignable to any interface, but implements only the empty interface. - if nt.Type != nil && nt.Type.Kind() == reflect.Interface { + if isAny(nt) { return true } } @@ -84,6 +84,13 @@ func (n Nature) AssignableTo(nt Nature) bool { return n.Type.AssignableTo(nt.Type) } +func (n Nature) NumMethods() int { + if n.Type == nil { + return 0 + } + return n.Type.NumMethod() +} + func (n Nature) MethodByName(name string) (Nature, bool) { if n.Type == nil { return unknown, false diff --git a/checker/nature/utils.go b/checker/nature/utils.go index c242f91a6..8d07ce48c 100644 --- a/checker/nature/utils.go +++ b/checker/nature/utils.go @@ -6,6 +6,10 @@ import ( "github.com/expr-lang/expr/internal/deref" ) +func isAny(nt Nature) bool { + return nt.Kind() == reflect.Interface && nt.NumMethods() == 0 +} + func fieldName(field reflect.StructField) string { if taggedName := field.Tag.Get("expr"); taggedName != "" { return taggedName diff --git a/checker/types.go b/checker/types.go index ef93cf03d..2fd5cf80e 100644 --- a/checker/types.go +++ b/checker/types.go @@ -74,12 +74,16 @@ func isUnknown(nt Nature) bool { switch { case nt.Type == nil && !nt.Nil: return true - case nt.Kind() == reflect.Interface: + case isAny(nt): return true } return false } +func isAny(nt Nature) bool { + return nt.Kind() == reflect.Interface && nt.NumMethods() == 0 +} + func isInteger(nt Nature) bool { switch nt.Kind() { case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64: diff --git a/test/interface_method/interface_method_test.go b/test/interface/interface_method_test.go similarity index 96% rename from test/interface_method/interface_method_test.go rename to test/interface/interface_method_test.go index 716b390e7..a27215035 100644 --- a/test/interface_method/interface_method_test.go +++ b/test/interface/interface_method_test.go @@ -1,4 +1,4 @@ -package interface_method_test +package interface_test import ( "testing" diff --git a/test/interface/interface_test.go b/test/interface/interface_test.go new file mode 100644 index 000000000..45ce1c427 --- /dev/null +++ b/test/interface/interface_test.go @@ -0,0 +1,40 @@ +package interface_test + +import ( + "testing" + + "github.com/expr-lang/expr" + "github.com/expr-lang/expr/internal/testify/assert" +) + +type StoreInterface interface { + Get(string) int +} + +type StoreImpt struct{} + +func (f StoreImpt) Get(s string) int { + return 42 +} + +func (f StoreImpt) Set(s string, i int) bool { + return true +} + +type Env struct { + Store StoreInterface `expr:"store"` +} + +func TestInterfaceHide(t *testing.T) { + var env Env + p, err := expr.Compile(`store.Get("foo")`, expr.Env(env)) + assert.NoError(t, err) + + out, err := expr.Run(p, Env{Store: StoreImpt{}}) + assert.NoError(t, err) + assert.Equal(t, 42, out) + + _, err = expr.Compile(`store.Set("foo", 100)`, expr.Env(env)) + assert.Error(t, err) + assert.Contains(t, err.Error(), "type interface_test.StoreInterface has no method Set") +} From e750878fa17c0d496210576b1801dc666498890e Mon Sep 17 00:00:00 2001 From: Anton Medvedev Date: Sat, 8 Mar 2025 09:27:09 +0100 Subject: [PATCH 049/113] Add SequenceNode Fixes #717 --- ast/node.go | 7 +++++++ ast/print.go | 16 +++++++++++---- ast/visitor.go | 4 ++++ parser/parser.go | 37 +++++++++++++++++++++++++-------- parser/parser_test.go | 48 +++++++++++++++++++++++++++++++++++++++++++ 5 files changed, 99 insertions(+), 13 deletions(-) diff --git a/ast/node.go b/ast/node.go index 6d98090b8..02923ac52 100644 --- a/ast/node.go +++ b/ast/node.go @@ -216,6 +216,13 @@ type VariableDeclaratorNode struct { Expr Node // Expression of the variable. Like "foo + 1" in "let foo = 1; foo + 1". } +// SequenceNode represents a sequence of nodes separated by semicolons. +// All nodes are executed, only the last node will be returned. +type SequenceNode struct { + base + Nodes []Node +} + // ArrayNode represents an array. type ArrayNode struct { base diff --git a/ast/print.go b/ast/print.go index 0fd2fa58a..e4e45f0fa 100644 --- a/ast/print.go +++ b/ast/print.go @@ -83,8 +83,8 @@ func (n *BinaryNode) String() string { if operator.Less(lb.Operator, n.Operator) { lwrap = true } - if operator.Binary[lb.Operator].Precedence == - operator.Binary[n.Operator].Precedence && + if operator.Binary[lb.Operator].Precedence == + operator.Binary[n.Operator].Precedence && operator.Binary[n.Operator].Associativity == operator.Right { lwrap = true } @@ -99,8 +99,8 @@ func (n *BinaryNode) String() string { if operator.Less(rb.Operator, n.Operator) { rwrap = true } - if operator.Binary[rb.Operator].Precedence == - operator.Binary[n.Operator].Precedence && + if operator.Binary[rb.Operator].Precedence == + operator.Binary[n.Operator].Precedence && operator.Binary[n.Operator].Associativity == operator.Left { rwrap = true } @@ -198,6 +198,14 @@ func (n *VariableDeclaratorNode) String() string { return fmt.Sprintf("let %s = %s; %s", n.Name, n.Value.String(), n.Expr.String()) } +func (n *SequenceNode) String() string { + nodes := make([]string, len(n.Nodes)) + for i, node := range n.Nodes { + nodes[i] = node.String() + } + return strings.Join(nodes, "; ") +} + func (n *ConditionalNode) String() string { var cond, exp1, exp2 string if _, ok := n.Cond.(*ConditionalNode); ok { diff --git a/ast/visitor.go b/ast/visitor.go index 03d72d11d..72cd6366b 100644 --- a/ast/visitor.go +++ b/ast/visitor.go @@ -51,6 +51,10 @@ func Walk(node *Node, v Visitor) { case *VariableDeclaratorNode: Walk(&n.Value, v) Walk(&n.Expr, v) + case *SequenceNode: + for i := range n.Nodes { + Walk(&n.Nodes[i], v) + } case *ConditionalNode: Walk(&n.Cond, v) Walk(&n.Exp1, v) diff --git a/parser/parser.go b/parser/parser.go index 086554223..060d76046 100644 --- a/parser/parser.go +++ b/parser/parser.go @@ -49,12 +49,11 @@ type parser struct { current Token pos int err *file.Error - depth int // predicate call depth config *conf.Config + depth int // predicate call depth nodeCount uint // tracks number of AST nodes created } -// checkNodeLimit verifies that adding a new node won't exceed configured limits func (p *parser) checkNodeLimit() error { p.nodeCount++ if p.config.MaxNodes > 0 && p.nodeCount > p.config.MaxNodes { @@ -64,7 +63,6 @@ func (p *parser) checkNodeLimit() error { return nil } -// createNode handles creation of regular nodes func (p *parser) createNode(n Node, loc file.Location) Node { if err := p.checkNodeLimit(); err != nil { return nil @@ -76,7 +74,6 @@ func (p *parser) createNode(n Node, loc file.Location) Node { return n } -// createMemberNode handles creation of member nodes func (p *parser) createMemberNode(n *MemberNode, loc file.Location) *MemberNode { if err := p.checkNodeLimit(); err != nil { return nil @@ -163,6 +160,27 @@ func (p *parser) expect(kind Kind, values ...string) { // parse functions +func (p *parser) parseSequenceExpression() Node { + nodes := []Node{p.parseExpression(0)} + + for p.current.Is(Operator, ";") && p.err == nil { + p.next() + // If a trailing semicolon is present, break out. + if p.current.Is(EOF) { + break + } + nodes = append(nodes, p.parseExpression(0)) + } + + if len(nodes) == 1 { + return nodes[0] + } + + return p.createNode(&SequenceNode{ + Nodes: nodes, + }, nodes[0].Location()) +} + func (p *parser) parseExpression(precedence int) Node { if p.err != nil { return nil @@ -171,6 +189,7 @@ func (p *parser) parseExpression(precedence int) Node { if precedence == 0 && p.current.Is(Operator, "let") { return p.parseVariableDeclaration() } + if p.current.Is(Operator, "if") { return p.parseConditionalIf() } @@ -283,11 +302,11 @@ func (p *parser) parseConditionalIf() Node { p.next() nodeCondition := p.parseExpression(0) p.expect(Bracket, "{") - expr1 := p.parseExpression(0) + expr1 := p.parseSequenceExpression() p.expect(Bracket, "}") p.expect(Operator, "else") p.expect(Bracket, "{") - expr2 := p.parseExpression(0) + expr2 := p.parseSequenceExpression() p.expect(Bracket, "}") return &ConditionalNode{ @@ -304,13 +323,13 @@ func (p *parser) parseConditional(node Node) Node { p.next() if !p.current.Is(Operator, ":") { - expr1 = p.parseExpression(0) + expr1 = p.parseSequenceExpression() p.expect(Operator, ":") - expr2 = p.parseExpression(0) + expr2 = p.parseSequenceExpression() } else { p.next() expr1 = node - expr2 = p.parseExpression(0) + expr2 = p.parseSequenceExpression() } node = p.createNode(&ConditionalNode{ diff --git a/parser/parser_test.go b/parser/parser_test.go index efae1f413..b1af5d0c1 100644 --- a/parser/parser_test.go +++ b/parser/parser_test.go @@ -659,6 +659,54 @@ world`}, Exp1: &BoolNode{Value: true}, Exp2: &IdentifierNode{Value: "x"}}, }, + { + "true ? 1; 2; 3 : 4", + &ConditionalNode{ + Cond: &BoolNode{Value: true}, + Exp1: &SequenceNode{ + Nodes: []Node{ + &IntegerNode{Value: 1}, + &IntegerNode{Value: 2}, + &IntegerNode{Value: 3}}}, + Exp2: &IntegerNode{Value: 4}}, + }, + { + "true ? 1 : 2; 3 ; 4", + &ConditionalNode{ + Cond: &BoolNode{Value: true}, + Exp1: &IntegerNode{Value: 1}, + Exp2: &SequenceNode{ + Nodes: []Node{ + &IntegerNode{Value: 2}, + &IntegerNode{Value: 3}, + &IntegerNode{Value: 4}}}}, + }, + { + "true ?: 1; 2; 3", + &ConditionalNode{ + Cond: &BoolNode{Value: true}, + Exp1: &BoolNode{Value: true}, + Exp2: &SequenceNode{ + Nodes: []Node{ + &IntegerNode{Value: 1}, + &IntegerNode{Value: 2}, + &IntegerNode{Value: 3}}}}, + }, + { + "if true { 1; 2; 3 } else { 4; 5; 6 }", + &ConditionalNode{ + Cond: &BoolNode{Value: true}, + Exp1: &SequenceNode{ + Nodes: []Node{ + &IntegerNode{Value: 1}, + &IntegerNode{Value: 2}, + &IntegerNode{Value: 3}}}, + Exp2: &SequenceNode{ + Nodes: []Node{ + &IntegerNode{Value: 4}, + &IntegerNode{Value: 5}, + &IntegerNode{Value: 6}}}}, + }, } for _, test := range tests { t.Run(test.input, func(t *testing.T) { From bc0ce17d0e389098a783cbc024937aace912a166 Mon Sep 17 00:00:00 2001 From: Anton Medvedev Date: Sat, 8 Mar 2025 09:49:28 +0100 Subject: [PATCH 050/113] Refactor TestParse_error tests --- parser/parser_test.go | 158 +++++++++++++++--------------------------- 1 file changed, 57 insertions(+), 101 deletions(-) diff --git a/parser/parser_test.go b/parser/parser_test.go index b1af5d0c1..39f6ad7b0 100644 --- a/parser/parser_test.go +++ b/parser/parser_test.go @@ -717,131 +717,87 @@ world`}, } } -const errorTests = ` -foo. -unexpected end of expression (1:4) +func TestParse_error(t *testing.T) { + var tests = []struct { + input string + err string + }{ + {`foo.`, `unexpected end of expression (1:4) | foo. - | ...^ - -a+ -unexpected token EOF (1:2) + | ...^`}, + {`a+`, `unexpected token EOF (1:2) | a+ - | .^ - -a ? (1+2) c -unexpected token Identifier("c") (1:11) + | .^`}, + {`a ? (1+2) c`, `unexpected token Identifier("c") (1:11) | a ? (1+2) c - | ..........^ - -[a b] -unexpected token Identifier("b") (1:4) + | ..........^`}, + {`[a b]`, `unexpected token Identifier("b") (1:4) | [a b] - | ...^ - -foo.bar(a b) -unexpected token Identifier("b") (1:11) + | ...^`}, + {`foo.bar(a b)`, `unexpected token Identifier("b") (1:11) | foo.bar(a b) - | ..........^ - -{-} -a map key must be a quoted string, a number, a identifier, or an expression enclosed in parentheses (unexpected token Operator("-")) (1:2) + | ..........^`}, + {`{-}`, `a map key must be a quoted string, a number, a identifier, or an expression enclosed in parentheses (unexpected token Operator("-")) (1:2) | {-} - | .^ - -foo({.bar}) -a map key must be a quoted string, a number, a identifier, or an expression enclosed in parentheses (unexpected token Operator(".")) (1:6) + | .^`}, + {`foo({.bar})`, `a map key must be a quoted string, a number, a identifier, or an expression enclosed in parentheses (unexpected token Operator(".")) (1:6) | foo({.bar}) - | .....^ - -.foo -cannot use pointer accessor outside predicate (1:1) + | .....^`}, + {`.foo`, `cannot use pointer accessor outside predicate (1:1) | .foo - | ^ - -[1, 2, 3,,] -unexpected token Operator(",") (1:10) + | ^`}, + {`[1, 2, 3,,]`, `unexpected token Operator(",") (1:10) | [1, 2, 3,,] - | .........^ - -[,] -unexpected token Operator(",") (1:2) + | .........^`}, + {`[,]`, `unexpected token Operator(",") (1:2) | [,] - | .^ - -{,} -a map key must be a quoted string, a number, a identifier, or an expression enclosed in parentheses (unexpected token Operator(",")) (1:2) + | .^`}, + {`{,}`, `a map key must be a quoted string, a number, a identifier, or an expression enclosed in parentheses (unexpected token Operator(",")) (1:2) | {,} - | .^ - -{foo:1, bar:2, ,} -unexpected token Operator(",") (1:16) + | .^`}, + {`{foo:1, bar:2, ,}`, `unexpected token Operator(",") (1:16) | {foo:1, bar:2, ,} - | ...............^ - -foo ?? bar || baz -Operator (||) and coalesce expressions (??) cannot be mixed. Wrap either by parentheses. (1:12) + | ...............^`}, + {`foo ?? bar || baz`, `Operator (||) and coalesce expressions (??) cannot be mixed. Wrap either by parentheses. (1:12) | foo ?? bar || baz - | ...........^ - -0b15 -bad number syntax: "0b15" (1:4) + | ...........^`}, + {`0b15`, `bad number syntax: "0b15" (1:4) | 0b15 - | ...^ - -0X10G -bad number syntax: "0X10G" (1:5) + | ...^`}, + {`0X10G`, `bad number syntax: "0X10G" (1:5) | 0X10G - | ....^ - -0o1E -invalid float literal: strconv.ParseFloat: parsing "0o1E": invalid syntax (1:4) + | ....^`}, + {`0o1E`, `invalid float literal: strconv.ParseFloat: parsing "0o1E": invalid syntax (1:4) | 0o1E - | ...^ - -0b1E -invalid float literal: strconv.ParseFloat: parsing "0b1E": invalid syntax (1:4) + | ...^`}, + {`0b1E`, `invalid float literal: strconv.ParseFloat: parsing "0b1E": invalid syntax (1:4) | 0b1E - | ...^ - -0b1E+6 -bad number syntax: "0b1E+6" (1:6) + | ...^`}, + {`0b1E+6`, `bad number syntax: "0b1E+6" (1:6) | 0b1E+6 - | .....^ - -0b1E+1 -invalid float literal: strconv.ParseFloat: parsing "0b1E+1": invalid syntax (1:6) + | .....^`}, + {`0b1E+1`, `invalid float literal: strconv.ParseFloat: parsing "0b1E+1": invalid syntax (1:6) | 0b1E+1 - | .....^ - -0o1E+1 -invalid float literal: strconv.ParseFloat: parsing "0o1E+1": invalid syntax (1:6) + | .....^`}, + {`0o1E+1`, `invalid float literal: strconv.ParseFloat: parsing "0o1E+1": invalid syntax (1:6) | 0o1E+1 - | .....^ - -1E -invalid float literal: strconv.ParseFloat: parsing "1E": invalid syntax (1:2) + | .....^`}, + {`1E`, `invalid float literal: strconv.ParseFloat: parsing "1E": invalid syntax (1:2) | 1E - | .^ - -1 not == [1, 2, 5] -unexpected token Operator("==") (1:7) + | .^`}, + {`1 not == [1, 2, 5]`, `unexpected token Operator("==") (1:7) | 1 not == [1, 2, 5] - | ......^ -` + | ......^`}, + } -func TestParse_error(t *testing.T) { - tests := strings.Split(strings.Trim(errorTests, "\n"), "\n\n") for _, test := range tests { - input := strings.SplitN(test, "\n", 2) - if len(input) != 2 { - t.Errorf("syntax error in test: %q", test) - break - } - _, err := parser.Parse(input[0]) - if err == nil { - err = fmt.Errorf("") - } - assert.Equal(t, input[1], err.Error(), input[0]) + t.Run(test.input, func(t *testing.T) { + _, err := parser.Parse(test.input) + if err == nil { + err = fmt.Errorf("") + } + assert.Equal(t, test.err, err.Error(), test.input) + }) } } From c9f620ee4840b2fce467942b13b1b7fe9e8f8d69 Mon Sep 17 00:00:00 2001 From: Anton Medvedev Date: Sat, 8 Mar 2025 12:02:09 +0100 Subject: [PATCH 051/113] Only allow if on precedence == 0 --- parser/parser.go | 21 +++--- parser/parser_test.go | 153 ++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 166 insertions(+), 8 deletions(-) diff --git a/parser/parser.go b/parser/parser.go index 060d76046..3761919d6 100644 --- a/parser/parser.go +++ b/parser/parser.go @@ -110,7 +110,7 @@ func ParseWithConfig(input string, config *conf.Config) (*Tree, error) { config: config, } - node := p.parseExpression(0) + node := p.parseSequenceExpression() if !p.current.Is(EOF) { p.error("unexpected token %v", p.current) @@ -190,7 +190,7 @@ func (p *parser) parseExpression(precedence int) Node { return p.parseVariableDeclaration() } - if p.current.Is(Operator, "if") { + if precedence == 0 && p.current.Is(Operator, "if") { return p.parseConditionalIf() } @@ -290,7 +290,7 @@ func (p *parser) parseVariableDeclaration() Node { p.expect(Operator, "=") value := p.parseExpression(0) p.expect(Operator, ";") - node := p.parseExpression(0) + node := p.parseSequenceExpression() return p.createNode(&VariableDeclaratorNode{ Name: variableName.Value, Value: value, @@ -364,7 +364,7 @@ func (p *parser) parsePrimary() Node { if token.Is(Bracket, "(") { p.next() - expr := p.parseExpression(0) + expr := p.parseSequenceExpression() p.expect(Bracket, ")") // "an opened parenthesis is not properly closed" return p.parsePostfixExpression(expr) } @@ -607,17 +607,22 @@ func (p *parser) parseArguments(arguments []Node) []Node { func (p *parser) parsePredicate() Node { startToken := p.current - expectClosingBracket := false + withBrackets := false if p.current.Is(Bracket, "{") { p.next() - expectClosingBracket = true + withBrackets = true } p.depth++ - node := p.parseExpression(0) + var node Node + if withBrackets { + node = p.parseSequenceExpression() + } else { + node = p.parseExpression(0) + } p.depth-- - if expectClosingBracket { + if withBrackets { p.expect(Bracket, "}") } predicateNode := p.createNode(&PredicateNode{ diff --git a/parser/parser_test.go b/parser/parser_test.go index 39f6ad7b0..7fcceb3ec 100644 --- a/parser/parser_test.go +++ b/parser/parser_test.go @@ -659,6 +659,29 @@ world`}, Exp1: &BoolNode{Value: true}, Exp2: &IdentifierNode{Value: "x"}}, }, + { + "1; 2; 3", + &SequenceNode{ + Nodes: []Node{ + &IntegerNode{Value: 1}, + &IntegerNode{Value: 2}, + &IntegerNode{Value: 3}, + }, + }, + }, + { + "1; (2; 3)", + &SequenceNode{ + Nodes: []Node{ + &IntegerNode{Value: 1}, + &SequenceNode{ + Nodes: []Node{ + &IntegerNode{Value: 2}, + &IntegerNode{Value: 3}}, + }, + }, + }, + }, { "true ? 1; 2; 3 : 4", &ConditionalNode{ @@ -707,6 +730,115 @@ world`}, &IntegerNode{Value: 5}, &IntegerNode{Value: 6}}}}, }, + { + `all(ls, if true { 1 } else { 2 })`, + &BuiltinNode{ + Name: "all", + Arguments: []Node{ + &IdentifierNode{Value: "ls"}, + &PredicateNode{ + Node: &ConditionalNode{ + Cond: &BoolNode{Value: true}, + Exp1: &IntegerNode{Value: 1}, + Exp2: &IntegerNode{Value: 2}}}}}, + }, + { + `let x = if true { 1 } else { 2 }; x`, + &VariableDeclaratorNode{ + Name: "x", + Value: &ConditionalNode{ + Cond: &BoolNode{Value: true}, + Exp1: &IntegerNode{Value: 1}, + Exp2: &IntegerNode{Value: 2}}, + Expr: &IdentifierNode{Value: "x"}}, + }, + { + `call(if true { 1 } else { 2 })`, + &CallNode{ + Callee: &IdentifierNode{Value: "call"}, + Arguments: []Node{ + &ConditionalNode{ + Cond: &BoolNode{Value: true}, + Exp1: &IntegerNode{Value: 1}, + Exp2: &IntegerNode{Value: 2}}}}, + }, + { + `[if true { 1 } else { 2 }]`, + &ArrayNode{ + Nodes: []Node{ + &ConditionalNode{ + Cond: &BoolNode{Value: true}, + Exp1: &IntegerNode{Value: 1}, + Exp2: &IntegerNode{Value: 2}}}}, + }, + { + `map(ls, { 1; 2; 3 })`, + &BuiltinNode{ + Name: "map", + Arguments: []Node{ + &IdentifierNode{Value: "ls"}, + &PredicateNode{ + Node: &SequenceNode{ + Nodes: []Node{ + &IntegerNode{Value: 1}, + &IntegerNode{Value: 2}, + &IntegerNode{Value: 3}, + }, + }, + }, + }}, + }, + { + `let x = 1; 2; 3 + x`, + &VariableDeclaratorNode{ + Name: "x", + Value: &IntegerNode{Value: 1}, + Expr: &SequenceNode{ + Nodes: []Node{ + &IntegerNode{Value: 2}, + &BinaryNode{ + Operator: "+", + Left: &IntegerNode{Value: 3}, + Right: &IdentifierNode{Value: "x"}, + }, + }, + }, + }, + }, + { + `let x = 1; let y = 2; 3; 4; x + y`, + &VariableDeclaratorNode{ + Name: "x", + Value: &IntegerNode{Value: 1}, + Expr: &VariableDeclaratorNode{ + Name: "y", + Value: &IntegerNode{Value: 2}, + Expr: &SequenceNode{ + Nodes: []Node{ + &IntegerNode{Value: 3}, + &IntegerNode{Value: 4}, + &BinaryNode{ + Operator: "+", + Left: &IdentifierNode{Value: "x"}, + Right: &IdentifierNode{Value: "y"}, + }, + }, + }}}, + }, + { + `let x = (1; 2; 3); x`, + &VariableDeclaratorNode{ + Name: "x", + Value: &SequenceNode{ + Nodes: []Node{ + &IntegerNode{Value: 1}, + &IntegerNode{Value: 2}, + &IntegerNode{Value: 3}, + }, + }, + Expr: &IdentifierNode{Value: "x"}, + }, + }, } for _, test := range tests { t.Run(test.input, func(t *testing.T) { @@ -788,6 +920,27 @@ func TestParse_error(t *testing.T) { {`1 not == [1, 2, 5]`, `unexpected token Operator("==") (1:7) | 1 not == [1, 2, 5] | ......^`}, + {`foo(1; 2; 3)`, `unexpected token Operator(";") (1:6) + | foo(1; 2; 3) + | .....^`}, + { + `map(ls, 1; 2; 3)`, + `unexpected token Operator(";") (1:10) + | map(ls, 1; 2; 3) + | .........^`, + }, + { + `[1; 2; 3]`, + `unexpected token Operator(";") (1:3) + | [1; 2; 3] + | ..^`, + }, + { + `1 + if true { 2 } else { 3 }`, + `unexpected token Operator("if") (1:5) + | 1 + if true { 2 } else { 3 } + | ....^`, + }, } for _, test := range tests { From fdba92bdadc2c10d017125bb518164717c89232f Mon Sep 17 00:00:00 2001 From: Anton Medvedev Date: Sat, 8 Mar 2025 12:14:13 +0100 Subject: [PATCH 052/113] Better error message for predicate with sequence --- parser/parser.go | 3 +++ parser/parser_test.go | 2 +- 2 files changed, 4 insertions(+), 1 deletion(-) diff --git a/parser/parser.go b/parser/parser.go index 3761919d6..febfb051a 100644 --- a/parser/parser.go +++ b/parser/parser.go @@ -619,6 +619,9 @@ func (p *parser) parsePredicate() Node { node = p.parseSequenceExpression() } else { node = p.parseExpression(0) + if p.current.Is(Operator, ";") { + p.error("wrap predicate with brackets { and }") + } } p.depth-- diff --git a/parser/parser_test.go b/parser/parser_test.go index 7fcceb3ec..3a7bb461a 100644 --- a/parser/parser_test.go +++ b/parser/parser_test.go @@ -925,7 +925,7 @@ func TestParse_error(t *testing.T) { | .....^`}, { `map(ls, 1; 2; 3)`, - `unexpected token Operator(";") (1:10) + `wrap predicate with brackets { and } (1:10) | map(ls, 1; 2; 3) | .........^`, }, From 3df78d9f57e0f0f786647778b3d4d4b89d128a98 Mon Sep 17 00:00:00 2001 From: Anton Medvedev Date: Sat, 8 Mar 2025 12:31:51 +0100 Subject: [PATCH 053/113] Add print test for if --- ast/print_test.go | 1 + 1 file changed, 1 insertion(+) diff --git a/ast/print_test.go b/ast/print_test.go index 8f950e276..d0859606f 100644 --- a/ast/print_test.go +++ b/ast/print_test.go @@ -83,6 +83,7 @@ func TestPrint(t *testing.T) { {`(2 ** 2) ** 3`, `(2 ** 2) ** 3`}, {`(3 + 5) / (5 % 3)`, `(3 + 5) / (5 % 3)`}, {`(-(1+1)) == 2`, `-(1 + 1) == 2`}, + {`if true { 1 } else { 2 }`, `true ? 1 : 2`}, } for _, tt := range tests { From 80767230400514bdde27226c923f13766280c9cd Mon Sep 17 00:00:00 2001 From: Anton Medvedev Date: Sat, 8 Mar 2025 12:36:18 +0100 Subject: [PATCH 054/113] Add SequenceNode to type checker --- checker/checker.go | 13 +++++++++++++ checker/checker_test.go | 8 ++++++++ 2 files changed, 21 insertions(+) diff --git a/checker/checker.go b/checker/checker.go index 0d316c0d7..66888e857 100644 --- a/checker/checker.go +++ b/checker/checker.go @@ -178,6 +178,8 @@ func (v *checker) visit(node ast.Node) Nature { nt = v.PointerNode(n) case *ast.VariableDeclaratorNode: nt = v.VariableDeclaratorNode(n) + case *ast.SequenceNode: + nt = v.SequenceNode(n) case *ast.ConditionalNode: nt = v.ConditionalNode(n) case *ast.ArrayNode: @@ -1181,6 +1183,17 @@ func (v *checker) VariableDeclaratorNode(node *ast.VariableDeclaratorNode) Natur return exprNature } +func (v *checker) SequenceNode(node *ast.SequenceNode) Nature { + if len(node.Nodes) == 0 { + return v.error(node, "empty sequence expression") + } + var last Nature + for _, node := range node.Nodes { + last = v.visit(node) + } + return last +} + func (v *checker) lookupVariable(name string) (varScope, bool) { for i := len(v.varScopes) - 1; i >= 0; i-- { if v.varScopes[i].name == name { diff --git a/checker/checker_test.go b/checker/checker_test.go index 89f8e10b8..4950c1a8e 100644 --- a/checker/checker_test.go +++ b/checker/checker_test.go @@ -669,6 +669,14 @@ invalid operation: == (mismatched types int and string) (1:33) invalid operation: > (mismatched types string and int) (1:30) | 1..3 | map("str") | filter(# > 1) | .............................^ +`, + }, + { + `1; 2 + true; 3`, + ` +invalid operation: + (mismatched types int and bool) (1:6) + | 1; 2 + true; 3 + | .....^ `, }, } From 4ae7e34df82f82bc11f13a6893c340b79aa17e2e Mon Sep 17 00:00:00 2001 From: Anton Medvedev Date: Sat, 8 Mar 2025 12:46:59 +0100 Subject: [PATCH 055/113] Add SequenceNode to compiler --- compiler/compiler.go | 11 +++++++++++ compiler/compiler_test.go | 18 ++++++++++++++++++ expr_test.go | 8 ++++++++ 3 files changed, 37 insertions(+) diff --git a/compiler/compiler.go b/compiler/compiler.go index 68eae5ea1..ca2750c18 100644 --- a/compiler/compiler.go +++ b/compiler/compiler.go @@ -266,6 +266,8 @@ func (c *compiler) compile(node ast.Node) { c.PointerNode(n) case *ast.VariableDeclaratorNode: c.VariableDeclaratorNode(n) + case *ast.SequenceNode: + c.SequenceNode(n) case *ast.ConditionalNode: c.ConditionalNode(n) case *ast.ArrayNode: @@ -1142,6 +1144,15 @@ func (c *compiler) VariableDeclaratorNode(node *ast.VariableDeclaratorNode) { c.endScope() } +func (c *compiler) SequenceNode(node *ast.SequenceNode) { + for i, n := range node.Nodes { + c.compile(n) + if i < len(node.Nodes)-1 { + c.emit(OpPop) + } + } +} + func (c *compiler) beginScope(name string, index int) { c.scopes = append(c.scopes, scope{name, index}) } diff --git a/compiler/compiler_test.go b/compiler/compiler_test.go index 526c5d67d..b683b82d6 100644 --- a/compiler/compiler_test.go +++ b/compiler/compiler_test.go @@ -377,6 +377,24 @@ func TestCompile(t *testing.T) { Arguments: []int{0, 0, 1, 12}, }, }, + { + `1; 2; 3`, + vm.Program{ + Constants: []any{ + 1, + 2, + 3, + }, + Bytecode: []vm.Opcode{ + vm.OpPush, + vm.OpPop, + vm.OpPush, + vm.OpPop, + vm.OpPush, + }, + Arguments: []int{0, 0, 1, 0, 2}, + }, + }, } for _, test := range tests { diff --git a/expr_test.go b/expr_test.go index 446fc6a71..ff30b1224 100644 --- a/expr_test.go +++ b/expr_test.go @@ -1318,6 +1318,14 @@ func TestExpr(t *testing.T) { `if "a" < "b" {let x = "a"; x} else {"abc"}`, "a", }, + { + `1; 2; 3`, + 3, + }, + { + `let a = 1; Add(2, 2); let b = 2; a + b`, + 3, + }, } for _, tt := range tests { From e437d57d2051816200cb25732c9d0a6b38f9f7ac Mon Sep 17 00:00:00 2001 From: Anton Medvedev Date: Sat, 8 Mar 2025 13:49:10 +0100 Subject: [PATCH 056/113] Make TestVM_ProfileOperations more robust --- vm/vm_test.go | 10 ++++++++-- 1 file changed, 8 insertions(+), 2 deletions(-) diff --git a/vm/vm_test.go b/vm/vm_test.go index 615b0a442..91752a419 100644 --- a/vm/vm_test.go +++ b/vm/vm_test.go @@ -6,6 +6,7 @@ import ( "reflect" "strings" "testing" + "time" "github.com/expr-lang/expr/internal/testify/require" @@ -466,11 +467,16 @@ func TestVM_ProfileOperations(t *testing.T) { Bytecode: []vm.Opcode{ vm.OpProfileStart, vm.OpPush, + vm.OpCall, vm.OpProfileEnd, }, - Arguments: []int{0, 0, 0}, + Arguments: []int{0, 1, 0, 0}, Constants: []any{ &vm.Span{}, + func() (any, error) { + time.Sleep(time.Millisecond * 10) + return nil, nil + }, }, } @@ -479,7 +485,7 @@ func TestVM_ProfileOperations(t *testing.T) { require.NoError(t, err) span := program.Constants[0].(*vm.Span) - require.True(t, span.Duration > 0, "Profile duration should be greater than 0") + require.Greater(t, span.Duration, time.Millisecond) } // TestVM_IndexOperations tests the index manipulation opcodes From d63c3b5a6c78b8186909edc00cff4bedb3dde5f5 Mon Sep 17 00:00:00 2001 From: Anton Medvedev Date: Sat, 8 Mar 2025 13:54:55 +0100 Subject: [PATCH 057/113] Fix func calls with nil types value Fixes #688 --- test/issues/688/issue_test.go | 52 +++++++++++++++++++++++++++++++++++ vm/vm.go | 6 ++-- 2 files changed, 54 insertions(+), 4 deletions(-) create mode 100644 test/issues/688/issue_test.go diff --git a/test/issues/688/issue_test.go b/test/issues/688/issue_test.go new file mode 100644 index 000000000..837978c13 --- /dev/null +++ b/test/issues/688/issue_test.go @@ -0,0 +1,52 @@ +package issue_test + +import ( + "testing" + + "github.com/expr-lang/expr" + "github.com/expr-lang/expr/internal/testify/require" +) + +type Foo interface { + Add(a int, b *int) int +} + +type FooImpl struct { +} + +func (*FooImpl) Add(a int, b *int) int { + return 0 +} + +type Env struct { + Foo Foo `expr:"foo"` +} + +func (Env) Any(x any) any { + return x +} + +func TestNoInterfaceMethodWithNil(t *testing.T) { + program, err := expr.Compile(`foo.Add(1, nil)`) + require.NoError(t, err) + + _, err = expr.Run(program, Env{Foo: &FooImpl{}}) + require.NoError(t, err) +} + +func TestNoInterfaceMethodWithNil_with_env(t *testing.T) { + program, err := expr.Compile(`foo.Add(1, nil)`, expr.Env(Env{})) + require.NoError(t, err) + + _, err = expr.Run(program, Env{Foo: &FooImpl{}}) + require.NoError(t, err) +} + +func TestNoInterfaceMethodWithNil_with_any(t *testing.T) { + program, err := expr.Compile(`Any(nil)`, expr.Env(Env{})) + require.NoError(t, err) + + out, err := expr.Run(program, Env{Foo: &FooImpl{}}) + require.NoError(t, err) + require.Equal(t, nil, out) +} diff --git a/vm/vm.go b/vm/vm.go index 5c40f26cd..fb1d772c1 100644 --- a/vm/vm.go +++ b/vm/vm.go @@ -334,10 +334,8 @@ func (vm *VM) Run(program *Program, env any) (_ any, err error) { in := make([]reflect.Value, size) for i := int(size) - 1; i >= 0; i-- { param := vm.pop() - if param == nil && reflect.TypeOf(param) == nil { - // In case of nil value and nil type use this hack, - // otherwise reflect.Call will panic on zero value. - in[i] = reflect.ValueOf(¶m).Elem() + if param == nil { + in[i] = reflect.Zero(fn.Type().In(i)) } else { in[i] = reflect.ValueOf(param) } From 6fa83ad539f5c89d0f4bf95a42c28aca68397560 Mon Sep 17 00:00:00 2001 From: Anton Medvedev Date: Sat, 8 Mar 2025 15:33:37 +0100 Subject: [PATCH 058/113] Improve type checker for named types --- builtin/builtin.go | 2 +- builtin/builtin_test.go | 13 +++++ builtin/lib.go | 2 +- checker/checker.go | 22 ++++++++- checker/nature/nature.go | 7 +++ checker/types.go | 24 ++++++--- expr_test.go | 84 ++----------------------------- test/issues/461/issue_test.go | 93 +++++++++++++++++++++++++++++++++++ test/issues/730/issue_test.go | 60 ++++++++++++++++++++++ 9 files changed, 215 insertions(+), 92 deletions(-) create mode 100644 test/issues/461/issue_test.go create mode 100644 test/issues/730/issue_test.go diff --git a/builtin/builtin.go b/builtin/builtin.go index 35a9f687e..f4a14ce58 100644 --- a/builtin/builtin.go +++ b/builtin/builtin.go @@ -164,7 +164,7 @@ var Builtins = []*Function{ if len(args) != 1 { return anyType, fmt.Errorf("invalid number of arguments (expected 1, got %d)", len(args)) } - switch kind(args[0]) { + switch kind(deref.Type(args[0])) { case reflect.Interface: return integerType, nil case reflect.Float32, reflect.Float64, reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64, reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64: diff --git a/builtin/builtin_test.go b/builtin/builtin_test.go index 499a838b7..6427c1aec 100644 --- a/builtin/builtin_test.go +++ b/builtin/builtin_test.go @@ -638,3 +638,16 @@ func Test_int_unwraps_underlying_value(t *testing.T) { require.NoError(t, err) assert.Equal(t, true, out) } + +func TestBuiltin_int_with_deref(t *testing.T) { + x := 42 + env := map[string]any{ + "x": &x, + } + program, err := expr.Compile(`int(x)`, expr.Env(env)) + require.NoError(t, err) + + out, err := expr.Run(program, env) + require.NoError(t, err) + assert.Equal(t, 42, out) +} diff --git a/builtin/lib.go b/builtin/lib.go index 07e631e07..34131dfc0 100644 --- a/builtin/lib.go +++ b/builtin/lib.go @@ -180,7 +180,7 @@ func Round(x any) any { } func Int(x any) any { - switch x := x.(type) { + switch x := deref.Deref(x).(type) { case float32: return int(x) case float64: diff --git a/checker/checker.go b/checker/checker.go index 66888e857..b04d3f135 100644 --- a/checker/checker.go +++ b/checker/checker.go @@ -319,7 +319,10 @@ func (v *checker) BinaryNode(node *ast.BinaryNode) Nature { if isTime(l) && isTime(r) { return boolNature } - if or(l, r, isNumber, isString, isTime) { + if isDuration(l) && isDuration(r) { + return boolNature + } + if or(l, r, isNumber, isString, isTime, isDuration) { return boolNature } @@ -333,6 +336,9 @@ func (v *checker) BinaryNode(node *ast.BinaryNode) Nature { if isTime(l) && isDuration(r) { return timeNature } + if isDuration(l) && isDuration(r) { + return durationNature + } if or(l, r, isNumber, isTime, isDuration) { return unknown } @@ -341,7 +347,16 @@ func (v *checker) BinaryNode(node *ast.BinaryNode) Nature { if isNumber(l) && isNumber(r) { return combined(l, r) } - if or(l, r, isNumber) { + if isNumber(l) && isDuration(r) { + return durationNature + } + if isDuration(l) && isNumber(r) { + return durationNature + } + if isDuration(l) && isDuration(r) { + return durationNature + } + if or(l, r, isNumber, isDuration) { return unknown } @@ -382,6 +397,9 @@ func (v *checker) BinaryNode(node *ast.BinaryNode) Nature { if isDuration(l) && isTime(r) { return timeNature } + if isDuration(l) && isDuration(r) { + return durationNature + } if or(l, r, isNumber, isString, isTime, isDuration) { return unknown } diff --git a/checker/nature/nature.go b/checker/nature/nature.go index 01f8b9e49..6720acb4c 100644 --- a/checker/nature/nature.go +++ b/checker/nature/nature.go @@ -161,6 +161,13 @@ func (n Nature) FieldByName(name string) (Nature, bool) { return Nature{Type: field.Type, FieldIndex: field.Index}, ok } +func (n Nature) PkgPath() string { + if n.Type == nil { + return "" + } + return n.Type.PkgPath() +} + func (n Nature) IsFastMap() bool { if n.Type == nil { return false diff --git a/checker/types.go b/checker/types.go index 2fd5cf80e..7912931c5 100644 --- a/checker/types.go +++ b/checker/types.go @@ -89,7 +89,7 @@ func isInteger(nt Nature) bool { case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64: fallthrough case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64: - return true + return nt.PkgPath() == "" } return false } @@ -97,7 +97,7 @@ func isInteger(nt Nature) bool { func isFloat(nt Nature) bool { switch nt.Kind() { case reflect.Float32, reflect.Float64: - return true + return nt.PkgPath() == "" } return false } @@ -178,15 +178,23 @@ func kind(t reflect.Type) reflect.Kind { } func isComparable(l, r Nature) bool { - switch { - case l.Kind() == r.Kind(): + if isUnknown(l) || isUnknown(r) { + return true + } + if isNil(l) || isNil(r) { return true - case isNumber(l) && isNumber(r): + } + if isNumber(l) && isNumber(r) { + return true + } + if isDuration(l) && isDuration(r) { return true - case isNil(l) || isNil(r): + } + if isTime(l) && isTime(r) { return true - case isUnknown(l) || isUnknown(r): + } + if isArray(l) && isArray(r) { return true } - return false + return l.AssignableTo(r) } diff --git a/expr_test.go b/expr_test.go index ff30b1224..1fc7a524f 100644 --- a/expr_test.go +++ b/expr_test.go @@ -1119,6 +1119,10 @@ func TestExpr(t *testing.T) { `duration("1h") + duration("1m")`, time.Hour + time.Minute, }, + { + `duration("1h") - duration("1m")`, + time.Hour - time.Minute, + }, { `7 * duration("1h")`, 7 * time.Hour, @@ -2328,86 +2332,6 @@ func TestIssue432(t *testing.T) { assert.Equal(t, float64(10), out) } -func TestIssue461(t *testing.T) { - type EnvStr string - type EnvField struct { - S EnvStr - Str string - } - type Env struct { - S EnvStr - Str string - EnvField EnvField - } - var tests = []struct { - input string - env Env - want bool - }{ - { - input: "Str == S", - env: Env{S: "string", Str: "string"}, - want: false, - }, - { - input: "Str == Str", - env: Env{Str: "string"}, - want: true, - }, - { - input: "S == S", - env: Env{Str: "string"}, - want: true, - }, - { - input: `Str == "string"`, - env: Env{Str: "string"}, - want: true, - }, - { - input: `S == "string"`, - env: Env{Str: "string"}, - want: false, - }, - { - input: "EnvField.Str == EnvField.S", - env: Env{EnvField: EnvField{S: "string", Str: "string"}}, - want: false, - }, - { - input: "EnvField.Str == EnvField.Str", - env: Env{EnvField: EnvField{Str: "string"}}, - want: true, - }, - { - input: "EnvField.S == EnvField.S", - env: Env{EnvField: EnvField{Str: "string"}}, - want: true, - }, - { - input: `EnvField.Str == "string"`, - env: Env{EnvField: EnvField{Str: "string"}}, - want: true, - }, - { - input: `EnvField.S == "string"`, - env: Env{EnvField: EnvField{Str: "string"}}, - want: false, - }, - } - - for _, tt := range tests { - t.Run(tt.input, func(t *testing.T) { - program, err := expr.Compile(tt.input, expr.Env(tt.env), expr.AsBool()) - - out, err := expr.Run(program, tt.env) - require.NoError(t, err) - - require.Equal(t, tt.want, out) - }) - } -} - func TestIssue462(t *testing.T) { env := map[string]any{ "foo": func() (string, error) { diff --git a/test/issues/461/issue_test.go b/test/issues/461/issue_test.go new file mode 100644 index 000000000..81202562e --- /dev/null +++ b/test/issues/461/issue_test.go @@ -0,0 +1,93 @@ +package issue_test + +import ( + "testing" + + "github.com/expr-lang/expr" + "github.com/expr-lang/expr/internal/testify/require" +) + +func TestIssue461(t *testing.T) { + type EnvStr string + type EnvField struct { + S EnvStr + Str string + } + type Env struct { + S EnvStr + Str string + EnvField EnvField + } + var tests = []struct { + input string + env Env + want bool + err string + }{ + { + input: "Str == S", + env: Env{S: "string", Str: "string"}, + err: "invalid operation: == (mismatched types string and issue_test.EnvStr)", + }, + { + input: "Str == Str", + env: Env{Str: "string"}, + want: true, + }, + { + input: "S == S", + env: Env{Str: "string"}, + want: true, + }, + { + input: `Str == "string"`, + env: Env{Str: "string"}, + want: true, + }, + { + input: `S == "string"`, + env: Env{Str: "string"}, + err: "invalid operation: == (mismatched types issue_test.EnvStr and string)", + }, + { + input: "EnvField.Str == EnvField.S", + env: Env{EnvField: EnvField{S: "string", Str: "string"}}, + err: "invalid operation: == (mismatched types string and issue_test.EnvStr)", + }, + { + input: "EnvField.Str == EnvField.Str", + env: Env{EnvField: EnvField{Str: "string"}}, + want: true, + }, + { + input: "EnvField.S == EnvField.S", + env: Env{EnvField: EnvField{Str: "string"}}, + want: true, + }, + { + input: `EnvField.Str == "string"`, + env: Env{EnvField: EnvField{Str: "string"}}, + want: true, + }, + { + input: `EnvField.S == "string"`, + env: Env{EnvField: EnvField{Str: "string"}}, + err: "invalid operation: == (mismatched types issue_test.EnvStr and string)", + }, + } + + for _, tt := range tests { + t.Run(tt.input, func(t *testing.T) { + program, err := expr.Compile(tt.input, expr.Env(tt.env), expr.AsBool()) + + if tt.err != "" { + require.Error(t, err) + require.Contains(t, err.Error(), tt.err) + } else { + out, err := expr.Run(program, tt.env) + require.NoError(t, err) + require.Equal(t, tt.want, out) + } + }) + } +} diff --git a/test/issues/730/issue_test.go b/test/issues/730/issue_test.go new file mode 100644 index 000000000..864421bc0 --- /dev/null +++ b/test/issues/730/issue_test.go @@ -0,0 +1,60 @@ +package issue_test + +import ( + "testing" + + "github.com/expr-lang/expr" + "github.com/expr-lang/expr/internal/testify/require" +) + +type ModeEnum int + +const ( + ModeEnumA ModeEnum = 1 +) + +type Env struct { + Mode *ModeEnum +} + +func TestIssue730(t *testing.T) { + code := `int(Mode) == 1` + + tmp := ModeEnumA + + env := map[string]any{ + "Mode": &tmp, + } + + program, err := expr.Compile(code, expr.Env(env)) + require.NoError(t, err) + + output, err := expr.Run(program, env) + require.NoError(t, err) + require.True(t, output.(bool)) +} + +func TestIssue730_warn_about_different_types(t *testing.T) { + code := `Mode == 1` + + _, err := expr.Compile(code, expr.Env(Env{})) + require.Error(t, err) + require.Contains(t, err.Error(), "invalid operation: == (mismatched types issue_test.ModeEnum and int)") +} + +func TestIssue730_eval(t *testing.T) { + code := `Mode == 1` + + tmp := ModeEnumA + + env := map[string]any{ + "Mode": &tmp, + } + + // Golang also does not allow this: + // _ = ModeEnumA == int(1) // will not compile + + out, err := expr.Eval(code, env) + require.NoError(t, err) + require.False(t, out.(bool)) +} From 4a3a8b6bc5167d87d4f152cdc3eb4d32599ee645 Mon Sep 17 00:00:00 2001 From: Anton Medvedev Date: Sat, 8 Mar 2025 15:40:47 +0100 Subject: [PATCH 059/113] Add -update flag to gen tests --- test/gen/gen_test.go | 47 +++++- testdata/examples.txt | 338 ------------------------------------------ 2 files changed, 43 insertions(+), 342 deletions(-) diff --git a/test/gen/gen_test.go b/test/gen/gen_test.go index 6ac07c4f8..ef4a30bc8 100644 --- a/test/gen/gen_test.go +++ b/test/gen/gen_test.go @@ -1,27 +1,66 @@ package main import ( + "bufio" + "flag" "os" "strings" "testing" - "github.com/expr-lang/expr/internal/testify/require" - "github.com/expr-lang/expr" + "github.com/expr-lang/expr/internal/testify/require" ) +var updateFlag = flag.Bool("update", false, "Drop failing lines from examples.txt") + func TestGenerated(t *testing.T) { + flag.Parse() + b, err := os.ReadFile("../../testdata/examples.txt") require.NoError(t, err) examples := strings.TrimSpace(string(b)) + var validLines []string + for _, line := range strings.Split(examples, "\n") { + line := line t.Run(line, func(t *testing.T) { program, err := expr.Compile(line, expr.Env(env)) - require.NoError(t, err) + if err != nil { + if !*updateFlag { + t.Errorf("Compilation failed: %v", err) + } + return + } _, err = expr.Run(program, env) - require.NoError(t, err) + if err != nil { + if !*updateFlag { + t.Errorf("Execution failed: %v", err) + } + return + } + + validLines = append(validLines, line) }) } + + if *updateFlag { + file, err := os.Create("../../testdata/examples.txt") + if err != nil { + t.Fatalf("Failed to update examples.txt: %v", err) + } + defer func(file *os.File) { + _ = file.Close() + }(file) + + writer := bufio.NewWriter(file) + for _, line := range validLines { + _, err := writer.WriteString(line + "\n") + if err != nil { + t.Fatalf("Failed to write to examples.txt: %v", err) + } + } + _ = writer.Flush() + } } diff --git a/testdata/examples.txt b/testdata/examples.txt index e4f6d36c8..a7d574275 100644 --- a/testdata/examples.txt +++ b/testdata/examples.txt @@ -155,16 +155,10 @@ !(1 not in array) !(add != add) !(add != div) -!(add != greet) -!(add != half) !(add != nil) -!(add != score) !(add == add) !(add == div) -!(add == greet) -!(add == half) !(add == nil) -!(add == score) !(array != array) !(array != list) !(array != nil) @@ -173,15 +167,9 @@ !(array == nil) !(div != add) !(div != div) -!(div != greet) -!(div != half) !(div != nil) -!(div != score) !(div == add) !(div == div) -!(div == greet) -!(div == half) -!(div == score) !(f32 != 0.5) !(f32 != 1) !(f32 != f32) @@ -296,29 +284,14 @@ !(foo == reduce(list, #)) !(foo in list) !(foo not in list) -!(greet != add) -!(greet != div) !(greet != greet) -!(greet != half) !(greet != nil) -!(greet != score) -!(greet == add) !(greet == greet) -!(greet == half) !(greet == nil) -!(greet == score) -!(half != add) -!(half != div) -!(half != greet) !(half != half) !(half != nil) -!(half != score) -!(half == add) -!(half == div) -!(half == greet) !(half == half) !(half == nil) -!(half == score) !(i != 0.5) !(i != 1) !(i != f32) @@ -524,16 +497,8 @@ !(ok || false) !(ok || ok) !(ok || true) -!(score != add) -!(score != div) -!(score != greet) -!(score != half) !(score != nil) !(score != score) -!(score == add) -!(score == div) -!(score == greet) -!(score == half) !(score == nil) !(score == score) !(true != false) @@ -580,7 +545,6 @@ !false ? add : i64 !false ? array : add !false ? array : ok -!false ? div != half : map(list, i32) !false ? div : array !false ? div : greet !false ? div : half @@ -618,8 +582,6 @@ !not ("bar" == nil) !not (1 <= 1) !not (1 > 0.5) -!not (greet != score) -!not (greet == div) !not (greet == nil) !not (i32 == f64) !not false @@ -2316,7 +2278,6 @@ 1 / i64 > f64 1 / i64 >= f64 1 < 1 == ok -1 < 1 and half == div 1 < 1 and ok 1 < array[get(array, i32)] 1 < array[i32] @@ -2341,7 +2302,6 @@ 1 == i64 == ok 1 == nil ? ok : half 1 > 0.5 == ok -1 > 1 || add != greet 1 > array[i64] 1 > f32 && ok 1 > f32 == reduce(array, ok) @@ -2916,44 +2876,17 @@ add != add == nil add != div add != div != false add != div == true -add != foo.Qux -add != foo.String -add != foo?.Qux -add != foo?.String -add != greet -add != greet == ok -add != greet ? array : 1 -add != greet ? greet : ok -add != half -add != half == ok -add != half || nil != add add != nil ? f64 : i64 add != reduce(list, add) -add != reduce(list, greet) -add != score add == add add == add != nil add == add == nil add == add ? 1 : i64 add == div add == div ? f64 : list -add == foo.Qux -add == foo.String -add == foo?.Qux -add == foo?.String -add == greet -add == half -add == half != ok -add == half ? nil : f32 add == nil ? false : i32 add == nil ? greet : i32 add == nil ? nil : nil -add == reduce(list, score) -add == score -add == score != ok -add == score != true -add == score == true -add == score or ok add in sort(array) add(1, i) < i add(i, 1) ** f32 @@ -3100,7 +3033,6 @@ all(list, f64 != f32) all(list, f64 < i32) all(list, f64 > i64) all(list, false ? i : true) -all(list, greet == half) all(list, i < f32) all(list, i <= 1) all(list, i <= i32) @@ -3125,8 +3057,6 @@ all(list, none(array, 1 > #)) all(list, not true) all(list, ok) all(list, reduce(array, true)) -all(list, score != add) -all(list, score != div) all(list, type(i) not endsWith .Bar) all(map(array, #), ok && false) all(map(array, #), ok) @@ -3201,7 +3131,6 @@ any(array, 1 > #) any(array, 1 > 1) any(array, 1 >= #) any(array, 1 >= f64) -any(array, add == greet) any(array, all(list, false)) any(array, f32 < i) any(array, f32 > #) @@ -3234,8 +3163,6 @@ any(array, ok != true) any(array, ok) any(array, one(array, # <= 0.5)) any(array, one(array, ok)) -any(array, score != add) -any(array, score == half) any(array, score == nil) any(i32 .. i, half == half) any(list, !ok) @@ -3254,7 +3181,6 @@ any(list, 0.5 < f64) any(list, 0.5 == i64) any(list, 1 >= f64) any(list, 1 >= i32) -any(list, add == score) any(list, any(list, false)) any(list, any(list, ok)) any(list, array == nil) @@ -4008,8 +3934,6 @@ count(list, 0.5 > f32) count(list, 1 != i) count(list, 1 >= 0.5) count(list, 1 >= f32) -count(list, add != half) -count(list, div == score) count(list, f32 == i64) count(list, f32 >= f32) count(list, false && false) @@ -4017,7 +3941,6 @@ count(list, false) + -1 count(list, false) / f64 count(list, false) > f32 count(list, foo == #) -count(list, greet != score) count(list, i != i64) count(list, i < 0.5) count(list, i <= i64) @@ -4065,39 +3988,14 @@ div != div div != div != ok div != div && ok div != div ? "bar" : "foo" -div != foo.Qux -div != foo.String -div != foo?.Qux -div != foo?.String -div != greet -div != greet != ok -div != greet or ok -div != half -div != half != true -div != half ? false : div -div != half ? greet : true div != nil == ok div != nil || f32 < 0.5 div != reduce(array, div) -div != score -div != score != true div == add div == add ? 1 : ok div == div -div == foo.Qux -div == foo.String -div == foo?.Qux -div == foo?.String -div == greet -div == greet == nil -div == greet ? 1 : 1 -div == half -div == half != false div == nil ? f32 : half div == nil ? false : 1 -div == score -div == score ? "bar" : true -div == score or f32 != f64 div(-i, array[i64]) div(-i, i) div(1, i) + i @@ -5511,7 +5409,6 @@ false ? add : 1 / i ^ 0.5 false ? add : i64 - i false ? div : i64 ** i false ? f32 : foo.Qux -false ? f32 : half != score false ? f64 : 0.5 != i32 false ? f64 : 0.5 ** i32 false ? f64 : 1 >= i @@ -5599,7 +5496,6 @@ filter(array, 1 >= #) filter(array, add == add) filter(array, add == nil) filter(array, any(list, ok)) -filter(array, div != score) filter(array, f32 != #) filter(array, f32 < #) filter(array, f32 <= #) @@ -5698,7 +5594,6 @@ filter(list, ok == nil) filter(list, ok and false) filter(list, ok) filter(list, ok)[i] -filter(list, score == half) filter(list, true == ok) filter(list, true || true) filter(list, true) == list @@ -5780,7 +5675,6 @@ find(array, 1 == #) find(array, 1 > #) find(array, 1 >= #) find(array, div != nil) -find(array, div == half) find(array, f32 != #) find(array, f32 != f32) find(array, f32 < #) @@ -5799,7 +5693,6 @@ find(array, false ? # : false) find(array, false) != f64 find(array, floor(#) > #) find(array, greet != greet) -find(array, half == score) find(array, i % # != f64) find(array, i < 0.5) find(array, i <= #) @@ -5865,7 +5758,6 @@ find(list, false && true) find(list, false)?.Bar find(list, foo != #) find(list, foo == #) -find(list, greet != div) find(list, i != 1) find(list, i != f64) find(list, i != i32) @@ -6012,7 +5904,6 @@ findIndex(array, ok) / f64 findIndex(array, ok) / i findIndex(array, ok) <= f32 findIndex(array, one(list, false)) -findIndex(array, score == greet) findIndex(array, true) + f64 findIndex(array, true) - f64 findIndex(array, true) .. i @@ -6099,7 +5990,6 @@ findIndex(true ? "foo" : ok, # == greet) findLast(1 .. i, # <= #) findLast(1 .. i32, 1 >= #) findLast(1 .. i64, ok) -findLast([1, f64], half == add) findLast([false], #) findLast(array, !false) findLast(array, !ok) @@ -6177,7 +6067,6 @@ findLast(array, ok and true) findLast(array, ok) findLast(array, ok) == i64 findLast(array, reduce(list, ok)) -findLast(array, score != div) findLast(array, score != nil) findLast(array, true) % i64 findLast(groupBy(array, #).i32, #) @@ -6328,7 +6217,6 @@ findLastIndex(array, f64 > #) findLastIndex(array, false ? # : false) findLastIndex(array, foo != foo) findLastIndex(array, greet == greet) -findLastIndex(array, half == greet) findLastIndex(array, i - # >= #) findLastIndex(array, i < #) findLastIndex(array, i <= #) @@ -6388,9 +6276,6 @@ findLastIndex(list, f32 != 1) findLastIndex(list, f32 != f64) findLastIndex(list, f64 > 0.5) findLastIndex(list, foo == #) -findLastIndex(list, half != div) -findLastIndex(list, half == greet) -findLastIndex(list, half == score) findLastIndex(list, i <= 1) findLastIndex(list, i32 > 1) findLastIndex(list, i32 > f32) @@ -7092,13 +6977,6 @@ foo.Bar <= foo.Bar foo.Bar matches foo.Bar foo.Bar matches trimPrefix("foo") foo.Qux -foo.Qux != greet -foo.Qux != half -foo.Qux == add -foo.Qux == div -foo.Qux == greet -foo.Qux == half -foo.Qux == score foo.Qux("foo" + "foo") foo.Qux(foo.Bar) foo.Qux(foo.String()) @@ -7109,12 +6987,6 @@ foo.Qux(type("bar")) foo.Qux(type(f64)) foo.Qux(type(half)) foo.String -foo.String != div -foo.String != greet -foo.String != half -foo.String == add -foo.String == div -foo.String == half foo.String() foo.String() != foo?.String() foo.String() in foo @@ -7126,27 +6998,12 @@ foo?.Bar matches toJSON(f64) foo?.Bar not endsWith foo.Bar foo?.Bar not endsWith toJSON(foo) foo?.Qux -foo?.Qux != add -foo?.Qux != greet -foo?.Qux != half -foo?.Qux != score -foo?.Qux == add -foo?.Qux == div -foo?.Qux == greet -foo?.Qux == half -foo?.Qux == score foo?.Qux(foo?.Bar) foo?.Qux(string(i32)) foo?.Qux(toJSON(1)) foo?.Qux(toJSON(i32)) foo?.Qux(upper("bar")) foo?.String -foo?.String != greet -foo?.String != half -foo?.String != score -foo?.String == greet -foo?.String == half -foo?.String == score foo?.String() foo?.String() contains string("foo") fromBase64(string(ok)) @@ -7396,47 +7253,18 @@ get(true ? score : true, half)?.half get(true ? true : i, f64) get({"foo": foo, "bar": false}, type(i)) greet -greet != add -greet != div -greet != div and ok -greet != foo.Qux -greet != foo.String -greet != foo?.Qux -greet != foo?.String greet != greet greet != greet != ok -greet != half greet != nil ? "bar" : add greet != nil ? 0.5 : false greet != nil ? list : false -greet != score -greet != score != false -greet != score or ok -greet == add -greet == add ? i : list -greet == add or ok -greet == div -greet == div || ok -greet == foo.Qux -greet == foo.String -greet == foo?.Qux -greet == foo?.String greet == greet greet == greet ? 0.5 : "bar" greet == greet and ok -greet == half -greet == half ? 1 : ok greet == nil == ok greet == nil ? i64 : ok -greet == reduce(list, div) -greet == reduce(list, half) -greet == score -greet == score ? 1 : ok -greet == score ? add : nil greet in groupBy(array, f64).f32 greet in groupBy(list, #).score -greet not in map(array, score) -greet not in map(list, div) greet not in sort(array) greet("bar" + "bar") greet("foo" + "foo") @@ -7896,8 +7724,6 @@ groupBy(array, bitushr(#, #)) groupBy(array, ceil(#)) groupBy(array, ceil(i)) groupBy(array, ceil(i32)) -groupBy(array, div != score) -groupBy(array, div == half) groupBy(array, div(#, #)) groupBy(array, f32 != #) groupBy(array, f32 ** 0.5) @@ -8067,7 +7893,6 @@ groupBy(array, foo?.Bar) groupBy(array, get(array, #)) groupBy(array, get(list, #)) groupBy(array, get(list, i32)) -groupBy(array, half != add) groupBy(array, half(1)) groupBy(array, half(f64)) groupBy(array, half(f64))?.i64 @@ -8282,7 +8107,6 @@ groupBy(array, reduce(array, #)) groupBy(array, reduce(array, foo)) groupBy(array, reduce(list, #)) groupBy(array, round(#)) -groupBy(array, score == div) groupBy(array, score(#)) groupBy(array, score(#, #)) groupBy(array, score(#, #, #, 1)) @@ -8751,7 +8575,6 @@ groupBy(list, foo.Bar) groupBy(list, foo.String()) groupBy(list, foo?.String()) groupBy(list, greet != greet) -groupBy(list, greet == add) groupBy(list, greet("bar")) groupBy(list, i * i) groupBy(list, i / f64) @@ -9059,20 +8882,6 @@ groupBy(true ? "foo" : 1, foo) groupBy(true ? "foo" : false, # / #) groupBy(true ? "foo" : score, #) half -half != add -half != add ? add : array -half != add ? true : 1 -half != add || ok -half != div -half != div ? i32 : f64 -half != div ? nil : greet -half != foo.Qux -half != foo.String -half != foo?.Qux -half != foo?.String -half != greet -half != greet == ok -half != greet ? score : true half != half half != half != nil half != half and "bar" in foo @@ -9081,29 +8890,10 @@ half != nil ? "bar" : div half != nil ? "bar" : false half != nil ? true : div half != reduce(list, half) -half != score -half != score && i32 > 1 -half == add -half == add == nil -half == add ? list : add -half == add or ok -half == div -half == foo.Qux -half == foo.String -half == foo?.Qux -half == foo?.String -half == greet -half == greet != ok -half == greet ? half : div -half == greet ? i64 : ok -half == greet || true ? i : list half == half half == nil && ok half == nil ? array : 0.5 half == nil ? foo : false -half == score -half == score ? f32 : nil -half == score ? foo : "bar" half(-(0.5 + 1)) half(-(f64 + 1)) half(-(i64 - 0.5)) @@ -12591,7 +12381,6 @@ map(array, 1 == #) map(array, 1 ^ #) map(array, abs(#)) map(array, abs(i64)) -map(array, add == greet) map(array, add == nil) map(array, add(#, #)) map(array, add(#, i)) @@ -12843,7 +12632,6 @@ map(list, [#]) map(list, [foo, 0.5, #]) map(list, [score]) map(list, abs(f32)) -map(list, add == score) map(list, add) map(list, array) map(list, ceil(0.5)) @@ -12881,7 +12669,6 @@ map(list, greet) map(list, groupBy(array, #)) map(list, groupBy(array, i)) map(list, groupBy(list, #)) -map(list, half == greet) map(list, half(0.5)) map(list, half(f64)) map(list, half) @@ -12933,7 +12720,6 @@ map(list, ok) map(list, reduce(array, half)) map(list, reduce(list, foo)) map(list, reduce(list, half)) -map(list, score != add) map(list, score(1)) map(list, score) map(list, score)[i64] @@ -13897,8 +13683,6 @@ none(array, f64 != 1) none(array, f64 == #) none(array, f64 > #) none(array, f64 >= #) -none(array, greet != div) -none(array, greet != half) none(array, i != #) none(array, i < #) none(array, i < f64) @@ -13956,7 +13740,6 @@ none(list, 1 != nil) none(list, 1 == f32) none(list, 1 > 0.5) none(list, all(array, ok)) -none(list, div == #?.Qux) none(list, f32 != 1 ** f64) none(list, f32 >= 0.5) none(list, f32 in array) @@ -14162,15 +13945,9 @@ not (1 >= i64) not (1 in array) not (1 not in array) not (add != add) -not (add != greet) -not (add != half) not (add != nil) -not (add != score) not (add == div) -not (add == greet) -not (add == half) not (add == nil) -not (add == score) not (array != array) not (array != list) not (array != nil) @@ -14180,17 +13957,10 @@ not (array == nil) not (array[i32] > i64) not (div != add) not (div != div) -not (div != foo?.Qux) -not (div != greet) -not (div != half) not (div != nil) -not (div != score) not (div == add) not (div == div) -not (div == greet) -not (div == half) not (div == nil) -not (div == score) not (f32 != 0.5) not (f32 != 1) not (f32 != f32) @@ -14305,31 +14075,14 @@ not (foo == foo) not (foo == nil) not (foo in list) not (foo not in list) -not (greet != add) -not (greet != div) not (greet != greet) -not (greet != half) not (greet != nil) -not (greet != score) -not (greet == add) -not (greet == div) not (greet == greet) -not (greet == half) not (greet == nil) -not (greet == score) -not (half != add) -not (half != div) -not (half != greet) not (half != half) not (half != nil) -not (half != score) -not (half == add) -not (half == div) -not (half == foo?.String) -not (half == greet) not (half == half) not (half == nil) -not (half == score) not (i != 0.5) not (i != 1) not (i != f32) @@ -14539,16 +14292,8 @@ not (ok or ok) not (ok or true) not (ok || ok) not (ok || true) -not (score != add) -not (score != div) -not (score != greet) -not (score != half) not (score != nil) not (score != score) -not (score == add) -not (score == div) -not (score == greet) -not (score == half) not (score == nil) not (score == score) not (true != false) @@ -14777,7 +14522,6 @@ ok && 1 <= f64 ok && 1 == 0.5 ok && 1 == nil ok && 1 >= f64 -ok && add != greet ok && f32 != i ok && f32 >= i64 ok && f64 <= 0.5 @@ -14830,7 +14574,6 @@ ok ? 1 + i : i32 ok ? 1 / i64 : greet ok ? 1 : foo.Bar ok ? 1 : foo?.Qux -ok ? 1 : score != greet ok ? abs(i64) : i64 ok ? add : abs(f32) ok ? add : add @@ -15029,10 +14772,8 @@ ok and 1 < i64 ok and 1 == 1 ok and 1 == i64 ok and add == nil -ok and div == half ok and f32 != 1 ok and f32 >= 1 -ok and greet != div ok and greet == greet ok and i == 0.5 ok and i32 < f32 @@ -15073,9 +14814,7 @@ ok or 0.5 == i ok or 1 != f32 ok or 1 <= 1 ok or 1 <= i -ok or div != half ok or div != nil -ok or div != score ok or f32 != f32 ok or f32 == 0.5 ok or f32 == f32 @@ -15083,8 +14822,6 @@ ok or f64 <= 1 ok or false ? ok : 1 ok or false and false ok or foo != foo -ok or half != add -ok or half == div ok or i < 1 ok or i == 0.5 ok or i == f32 @@ -15122,7 +14859,6 @@ ok || f64 > f64 ok || f64 >= i64 ok || false ? half : i64 ok || foo == foo -ok || greet == half ok || i == i ok || i32 < f32 ok || i32 <= 0.5 @@ -15204,7 +14940,6 @@ one(array, 1 > 0.5) one(array, 1 >= #) one(array, add == div) one(array, all(array, true)) -one(array, div != score) one(array, f32 <= #) one(array, f32 <= 0.5) one(array, f32 >= #) @@ -15235,9 +14970,6 @@ one(array, nil != i64) one(array, not ok) one(array, ok) one(array, one(list, false)) -one(array, score != add) -one(array, score != greet) -one(array, score == div) one(array, true != false) one(array, true == nil) one(array, true) ? greet : add @@ -15574,7 +15306,6 @@ reduce(array, get(array, 1)) reduce(array, get(list, #)) reduce(array, greet("bar")) reduce(array, greet) -reduce(array, greet) != score != nil reduce(array, groupBy(array, #)) reduce(array, groupBy(list, #)) reduce(array, groupBy(list, #)?.f32) @@ -15760,10 +15491,8 @@ reduce(list, 1) + f32 reduce(list, 1) - i reduce(list, add) reduce(list, add) != div -reduce(list, add) in map(array, greet) reduce(list, array != array) reduce(list, array) -reduce(list, div == greet) reduce(list, div) reduce(list, f32 / 0.5) reduce(list, f32 < i32) @@ -15869,7 +15598,6 @@ reduce(list, nil != #) reduce(list, nil != add) reduce(list, nil != half) reduce(list, nil == #) -reduce(list, not (half != score)) reduce(list, not false) reduce(list, not ok) reduce(list, not true) @@ -15884,7 +15612,6 @@ reduce(list, reduce(list, #)) reduce(list, reduce(list, 1)) reduce(list, reduce(list, add)) reduce(list, reduce(list, i32)) -reduce(list, score != half) reduce(list, score(i)) reduce(list, score) reduce(list, string(greet)) @@ -16289,19 +16016,6 @@ round(score(i)) round(sum(array)) round(true ? i : ok) score -score != add -score != add == ok -score != add ? 0.5 : div -score != div -score != foo.Qux -score != foo.String -score != foo?.Qux -score != foo?.String -score != greet -score != greet ? add : i64 -score != greet ? div : i -score != half -score != half || ok score != nil != ok score != nil ? half : f64 score != nil or i32 > 0.5 @@ -16309,28 +16023,13 @@ score != nil || ok score != score score != score != ok score != score ? i32 : i32 -score == add -score == div -score == div != nil -score == div == ok -score == foo.Qux -score == foo.String -score == foo?.Qux -score == foo?.String -score == greet -score == greet != ok -score == half -score == half ? 1 : add -score == half ? half : f64 score == nil != nil score == nil && ok score == nil ? 0.5 : "bar" -score == reduce(array, half) score == score score == score == true score == score ? 0.5 : score score in groupBy(list, #)?.array -score in map(list, add) score in sort(array) score(-1) score(-1, i) @@ -16713,11 +16412,8 @@ string(abs(i)) string(abs(i32)) string(add != add) string(add != div) -string(add != score) string(add == div) -string(add == greet) string(add == nil) -string(add == score) string(add) string(add) in foo ? i64 : i32 string(add) not endsWith foo.Bar @@ -16740,12 +16436,9 @@ string(ceil(f64)) string(ceil(i)) string(ceil(i64)) string(div != div) -string(div != greet) string(div != nil) -string(div != score) string(div == add) string(div == div) -string(div == greet) string(div) string(f32 != 0.5) string(f32 != f64) @@ -16867,11 +16560,9 @@ string(get(array, i64)) string(get(list, 1)) string(get(list, i32)) string(get(list, i64)) -string(greet != add) string(greet != nil) string(greet == greet) string(greet == nil) -string(greet == score) string(greet("bar")) string(greet("foo")) string(greet) @@ -16888,7 +16579,6 @@ string(groupBy(list, f64)) string(groupBy(list, false)) string(groupBy(list, i)) string(half != nil) -string(half != score) string(half == nil) string(half(0.5)) string(half(1)) @@ -17123,11 +16813,7 @@ string(round(1)) string(round(ceil(i32))) string(round(f64)) string(round(i64)) -string(score != div) -string(score != greet) -string(score != half) string(score != nil) -string(score == greet) string(score == nil) string(score(1 % 1)) string(score(1)) @@ -17437,10 +17123,7 @@ toJSON(abs(f64)) toJSON(abs(i)) toJSON(abs(i32)) toJSON(abs(i64)) -toJSON(add != greet) -toJSON(add != half) toJSON(add == add) -toJSON(add == score) toJSON(any(array, false)) toJSON(array == array) toJSON(array == list) @@ -17461,7 +17144,6 @@ toJSON(ceil(i32)) toJSON(ceil(i64)) toJSON(count(array, ok)) toJSON(div != div) -toJSON(div != score) toJSON(div == div) toJSON(f32 != 0.5) toJSON(f32 != 1 || ok) @@ -17553,12 +17235,8 @@ toJSON(get(list, i)) toJSON(get(list, i32)) toJSON(get(list, i64)) toJSON(greet != nil) -toJSON(greet != score) -toJSON(greet == div) toJSON(greet == greet) -toJSON(greet == half) toJSON(greet == nil) -toJSON(greet == score) toJSON(greet("bar")) toJSON(greet("foo")) toJSON(groupBy(array, #)?.div) @@ -17791,10 +17469,7 @@ toJSON(reduce(list, true)) toJSON(round(1)) toJSON(round(f64)) toJSON(round(i32)) -toJSON(score != add) -toJSON(score != div) toJSON(score != score) -toJSON(score == half) toJSON(score(1)) toJSON(score(1, 1)) toJSON(score(i)) @@ -18074,11 +17749,9 @@ true ? greet : ok == ok true ? half : 0.5 / i32 true ? half : foo.String true ? i : 1 * i64 -true ? i : greet == half true ? i32 : i32 - f32 true ? i32 : i32 >= f32 true ? i64 : f64 != i -true ? list : div != greet true ? list : f32 != i true ? nil : foo.String true ? nil : foo?.String @@ -18220,8 +17893,6 @@ type(abs(f64)) type(abs(i)) type(abs(i32)) type(abs(i64)) -type(add != greet) -type(add != half) type(add) type(all(array, ok)) type(all(list, ok)) @@ -18248,7 +17919,6 @@ type(ceil(f64)) type(ceil(i64)) type(count(array, true)) type(div != div) -type(div != half) type(div == div) type(div) type(f32 != 0.5) @@ -18356,8 +18026,6 @@ type(get(list, 1)) type(get(list, i)) type(get(list, i32)) type(get(list, i64)) -type(greet != div) -type(greet == div) type(greet("bar")) type(greet("foo")) type(greet) @@ -18374,9 +18042,6 @@ type(groupBy(list, #)?.Bar) type(groupBy(list, 1)) type(groupBy(list, i64)) type(groupBy(list, true)) -type(half != div) -type(half != greet) -type(half != score) type(half(0.5)) type(half(1)) type(half(f64)) @@ -18594,8 +18259,6 @@ type(round(f64)) type(round(i)) type(round(i64)) type(score != score) -type(score == div) -type(score == greet) type(score == nil) type(score(1)) type(score(1, 1)) @@ -19286,7 +18949,6 @@ values({"foo": ok}) {"bar": one(list, false)} {"bar": reduce(array, i)}.i64 {"bar": reduce(list, half)} -{"bar": score != add} {"bar": score(i)} {"bar": score, "bar": "bar", "bar": "foo"}?.f32 {"bar": score, "bar": add}.String From 8f0751dbdf0c232bce740244a5c62bebc19bbd52 Mon Sep 17 00:00:00 2001 From: Anton Medvedev Date: Sat, 8 Mar 2025 16:19:30 +0100 Subject: [PATCH 060/113] Update fuzz tests --- checker/checker.go | 2 +- conf/config.go | 2 +- conf/env.go | 1 + expr_test.go | 8 + test/fuzz/fuzz_corpus.txt | 23290 ++++++++++++++++++++---------------- test/fuzz/fuzz_test.go | 3 + 6 files changed, 13268 insertions(+), 10038 deletions(-) diff --git a/checker/checker.go b/checker/checker.go index b04d3f135..d410b9549 100644 --- a/checker/checker.go +++ b/checker/checker.go @@ -217,7 +217,7 @@ func (v *checker) IdentifierNode(node *ast.IdentifierNode) Nature { return unknown } - return v.ident(node, node.Value, v.config.Env.Strict, true) + return v.ident(node, node.Value, v.config.Strict, true) } // ident method returns type of environment variable, builtin or function. diff --git a/conf/config.go b/conf/config.go index 270438b9d..d629958e5 100644 --- a/conf/config.go +++ b/conf/config.go @@ -62,9 +62,9 @@ func New(env any) *Config { } func (c *Config) WithEnv(env any) { - c.Strict = true c.EnvObject = env c.Env = Env(env) + c.Strict = c.Env.Strict } func (c *Config) ConstExpr(name string) { diff --git a/conf/env.go b/conf/env.go index 99e2f4626..8b13df1e1 100644 --- a/conf/env.go +++ b/conf/env.go @@ -36,6 +36,7 @@ func Env(env any) Nature { n := Nature{ Type: v.Type(), Fields: make(map[string]Nature, v.Len()), + Strict: true, } for _, key := range v.MapKeys() { diff --git a/expr_test.go b/expr_test.go index 1fc7a524f..4ebe6d4de 100644 --- a/expr_test.go +++ b/expr_test.go @@ -2716,3 +2716,11 @@ func TestIssue758_filter_map_index(t *testing.T) { require.Equal(t, expected, result) } + +func TestExpr_wierd_cases(t *testing.T) { + env := map[string]any{} + + _, err := expr.Compile(`A(A)`, expr.Env(env)) + require.Error(t, err) + require.Contains(t, err.Error(), "unknown name A") +} diff --git a/test/fuzz/fuzz_corpus.txt b/test/fuzz/fuzz_corpus.txt index 59349d3d5..a7d574275 100644 --- a/test/fuzz/fuzz_corpus.txt +++ b/test/fuzz/fuzz_corpus.txt @@ -1,18 +1,15 @@ -!!!true -!!(f32 > f64) -!!(half != greet) -!!(nil == add) -!!(ok or true) +!!!false +!!(1 <= f64) +!!(1 > 0.5) +!!(i64 != f64) +!!all(array, ok) !!false -!!not false !!ok !!true !("bar" != "bar") !("bar" != "foo") !("bar" != nil) -!("bar" < "bar") !("bar" < "foo") -!("bar" <= "bar") !("bar" <= "foo") !("bar" == "bar") !("bar" == "foo") @@ -21,32 +18,32 @@ !("bar" > "foo") !("bar" >= "bar") !("bar" >= "foo") +!("bar" contains "bar") !("bar" contains "foo") +!("bar" endsWith "bar") +!("bar" endsWith "foo") !("bar" in foo) !("bar" matches "foo") !("bar" not contains "bar") -!("bar" not contains "foo") +!("bar" not endsWith "bar") !("bar" not endsWith "foo") !("bar" not in foo) -!("bar" not matches "foo") +!("bar" not matches "bar") !("bar" not startsWith "bar") !("bar" not startsWith "foo") !("bar" startsWith "bar") !("foo" != "bar") -!("foo" != "foo") !("foo" != nil) -!("foo" < "bar") +!("foo" < "foo") !("foo" <= "bar") !("foo" <= "foo") -!("foo" == "foo") +!("foo" == "bar") !("foo" == nil) !("foo" > "bar") !("foo" > "foo") !("foo" >= "bar") -!("foo" >= "foo") !("foo" contains "bar") !("foo" contains "foo") -!("foo" endsWith "bar") !("foo" endsWith "foo") !("foo" in foo) !("foo" matches "bar") @@ -54,14 +51,15 @@ !("foo" not contains "bar") !("foo" not contains "foo") !("foo" not endsWith "bar") -!("foo" not endsWith "foo") -!("foo" not in foo) !("foo" not matches "bar") !("foo" not matches "foo") !("foo" not startsWith "bar") !("foo" not startsWith "foo") !("foo" startsWith "bar") !("foo" startsWith "foo") +!(-f32 < f32) +!(-i < i32) +!(-i32 >= i) !(0.5 != 0.5) !(0.5 != 1) !(0.5 != f32) @@ -70,7 +68,6 @@ !(0.5 != i32) !(0.5 != i64) !(0.5 != nil) -!(0.5 / i32 > i) !(0.5 < 0.5) !(0.5 < 1) !(0.5 < f32) @@ -81,6 +78,7 @@ !(0.5 <= 0.5) !(0.5 <= 1) !(0.5 <= f32) +!(0.5 <= f64) !(0.5 <= i) !(0.5 <= i32) !(0.5 <= i64) @@ -106,7 +104,8 @@ !(0.5 >= i) !(0.5 >= i32) !(0.5 >= i64) -!(0.5 ^ i64 < i64) +!(0.5 in array) +!(0.5 not in array) !(1 != 0.5) !(1 != 1) !(1 != f32) @@ -115,6 +114,7 @@ !(1 != i32) !(1 != i64) !(1 != nil) +!(1 / i64 == i64) !(1 < 0.5) !(1 < 1) !(1 < f32) @@ -139,6 +139,7 @@ !(1 == nil) !(1 > 0.5) !(1 > 1) +!(1 > f32) !(1 > f64) !(1 > i) !(1 > i32) @@ -154,39 +155,29 @@ !(1 not in array) !(add != add) !(add != div) -!(add != greet) -!(add != half) !(add != nil) -!(add != score) !(add == add) !(add == div) -!(add == half) !(add == nil) -!(add == score) !(array != array) +!(array != list) !(array != nil) !(array == array) !(array == list) !(array == nil) !(div != add) !(div != div) -!(div != greet) -!(div != half) !(div != nil) -!(div != score) !(div == add) !(div == div) -!(div == greet) -!(div == half) -!(div == nil) -!(div == score) !(f32 != 0.5) !(f32 != 1) !(f32 != f32) +!(f32 != f64) +!(f32 != i) !(f32 != i32) !(f32 != i64) !(f32 != nil) -!(f32 + i == 0.5 * i) !(f32 < 0.5) !(f32 < 1) !(f32 < f32) @@ -198,7 +189,6 @@ !(f32 <= 1) !(f32 <= f32) !(f32 <= f64) -!(f32 <= i) !(f32 <= i32) !(f32 <= i64) !(f32 == 0.5) @@ -219,39 +209,44 @@ !(f32 >= 0.5) !(f32 >= 1) !(f32 >= f32) -!(f32 >= f64) !(f32 >= i) +!(f32 >= i32) !(f32 >= i64) +!(f32 in array) +!(f32 not in array) !(f64 != 0.5) !(f64 != 1) !(f64 != f32) !(f64 != f64) +!(f64 != i) !(f64 != i32) !(f64 != i64) !(f64 != nil) +!(f64 < 0.5 + 1) !(f64 < 0.5) !(f64 < 1) -!(f64 < f32) !(f64 < f64) !(f64 < i) !(f64 < i32) !(f64 < i64) +!(f64 < max(1)) !(f64 <= 0.5) !(f64 <= 1) -!(f64 <= f32) -!(f64 <= f64) -!(f64 <= i) !(f64 <= i32) !(f64 <= i64) !(f64 == 0.5) !(f64 == 1) !(f64 == f32) +!(f64 == f64) +!(f64 == i) !(f64 == i32) !(f64 == i64) !(f64 == nil) !(f64 > 0.5) !(f64 > 1) +!(f64 > f32) !(f64 > f64) +!(f64 > i) !(f64 > i32) !(f64 > i64) !(f64 >= 0.5) @@ -261,18 +256,24 @@ !(f64 >= i) !(f64 >= i32) !(f64 >= i64) +!(f64 in array) +!(f64 not in array) !(false != false) !(false != nil) !(false != ok) !(false != true) !(false && false) !(false && ok) +!(false && true) !(false == false) !(false == nil) !(false == ok) +!(false == true) +!(false and false) !(false and ok) +!(false and true) +!(false or false) !(false or ok) -!(false or true) !(false || false) !(false || ok) !(false || true) @@ -280,31 +281,17 @@ !(foo != nil) !(foo == foo) !(foo == nil) +!(foo == reduce(list, #)) !(foo in list) !(foo not in list) -!(greet != div) !(greet != greet) -!(greet != half) !(greet != nil) -!(greet != score) -!(greet == add) -!(greet == div) !(greet == greet) -!(greet == half) !(greet == nil) -!(greet == score) -!(half != add) -!(half != div) -!(half != greet) !(half != half) !(half != nil) -!(half != score) -!(half == add) -!(half == div) -!(half == greet) !(half == half) !(half == nil) -!(half == score) !(i != 0.5) !(i != 1) !(i != f32) @@ -315,7 +302,6 @@ !(i != nil) !(i < 0.5) !(i < 1) -!(i < f32) !(i < f64) !(i < i) !(i < i32) @@ -324,9 +310,7 @@ !(i <= 1) !(i <= f32) !(i <= f64) -!(i <= i) !(i <= i32) -!(i <= i64) !(i == 0.5) !(i == 1) !(i == f32) @@ -343,20 +327,23 @@ !(i > i32) !(i > i64) !(i >= 0.5) +!(i >= 1 * i64) !(i >= 1) !(i >= f32) !(i >= f64) +!(i >= i) !(i >= i32) !(i >= i64) !(i in array) +!(i not in array) !(i32 != 0.5) !(i32 != 1) +!(i32 != f32) !(i32 != f64) !(i32 != i) !(i32 != i32) !(i32 != i64) !(i32 != nil) -!(i32 * 0.5 != i32) !(i32 < 0.5) !(i32 < 1) !(i32 < f32) @@ -373,6 +360,7 @@ !(i32 <= i64) !(i32 == 0.5) !(i32 == 1) +!(i32 == f32) !(i32 == f64) !(i32 == i) !(i32 == i32) @@ -380,10 +368,10 @@ !(i32 == nil) !(i32 > 0.5) !(i32 > 1) +!(i32 > f32) !(i32 > f64) !(i32 > i) !(i32 > i32) -!(i32 > i64) !(i32 >= 0.5) !(i32 >= 1) !(i32 >= f32) @@ -399,12 +387,14 @@ !(i64 != f64) !(i64 != i) !(i64 != i32) +!(i64 != i64) !(i64 != nil) !(i64 < 0.5) !(i64 < 1) !(i64 < f32) !(i64 < f64) !(i64 < i) +!(i64 < i32 + i64) !(i64 < i32) !(i64 < i64) !(i64 <= 0.5) @@ -418,8 +408,8 @@ !(i64 == 1) !(i64 == f32) !(i64 == f64) -!(i64 == i) !(i64 == i32) +!(i64 == i64) !(i64 == nil) !(i64 > 0.5) !(i64 > 1) @@ -434,8 +424,9 @@ !(i64 >= f64) !(i64 >= i) !(i64 >= i32) +!(i64 >= i64) !(i64 in array) -!(i64 not in array) +!(len("bar") <= i) !(list != array) !(list != list) !(list != nil) @@ -467,10 +458,12 @@ !(nil == "foo") !(nil == 0.5) !(nil == 1) +!(nil == add) !(nil == array) !(nil == div) !(nil == f32) !(nil == f64) +!(nil == false) !(nil == foo) !(nil == greet) !(nil == half) @@ -493,25 +486,21 @@ !(ok && false) !(ok && ok) !(ok && true) -!(ok == false) !(ok == nil) !(ok == ok) +!(ok == true) !(ok and ok) !(ok and true) +!(ok or false) !(ok or ok) +!(ok or true) !(ok || false) !(ok || ok) -!(score != add) -!(score != div) -!(score != greet) -!(score != half) +!(ok || true) !(score != nil) !(score != score) -!(score == add) -!(score == div) -!(score == greet) -!(score == half) !(score == nil) +!(score == score) !(true != false) !(true != nil) !(true != ok) @@ -523,10 +512,11 @@ !(true == nil) !(true == ok) !(true == true) -!(true and false) !(true and ok) !(true and true) +!(true or ok) !(true or true) +!(true || false) !(true || ok) !(true || true) !all(array, false) @@ -535,445 +525,495 @@ !all(list, false) !all(list, ok) !all(list, true) -!any(array, false) +!any(array, i == #) !any(array, ok) !any(array, true) -!any(list, # != #) +!any(list, false) !any(list, ok) -!false && ok -!false ? "bar" : i -!false ? "foo" : false -!false ? 0.5 : "bar" -!false ? 0.5 : 1 -!false ? 0.5 : div -!false ? 0.5 : i64 -!false ? 1 : add -!false ? 1 : true -!false ? add : array -!false ? add : nil -!false ? array : array -!false ? div : 0.5 -!false ? div : foo -!false ? div : map(list, #) -!false ? div : nil -!false ? f32 : 0.5 -!false ? f32 : greet -!false ? f64 : 1 -!false ? f64 : half -!false ? false : f32 -!false ? false : false -!false ? foo : 1 -!false ? foo : i64 -!false ? greet : array -!false ? greet : i32 -!false ? half : nil -!false ? half : ok -!false ? i : foo -!false ? i32 : "foo" -!false ? i64 : f32 -!false ? i64 : nil -!false ? list : list -!false ? nil : 1 +!any(list, true) +!false != not true +!false != ok +!false && 0.5 == 1 +!false == ok +!false ? "foo" : 0.5 +!false ? "foo" : f32 +!false ? 0.5 : "foo" +!false ? 0.5 : f32 +!false ? 1 : half +!false ? 1 : i +!false ? add : f32 +!false ? add : i64 +!false ? array : add +!false ? array : ok +!false ? div : array +!false ? div : greet +!false ? div : half +!false ? f32 : add +!false ? f32 : false +!false ? f64 : "foo" +!false ? foo : "bar" +!false ? half : 1 +!false ? half : add +!false ? half : list +!false ? half : true +!false ? i : nil +!false ? i32 : list +!false ? i64 : foo +!false ? i64 : i64 !false ? nil : add !false ? nil : f64 !false ? nil : foo -!false ? ok : ok -!false ? true : array -!false and (true or false) -!false and ok -!false or 0.5 != 1 -!false || not false -!hasSuffix("bar", "bar") +!false ? nil : half +!false ? ok : 1 +!false ? score : "bar" +!false ? score : foo +!false ? score : ok +!false ? true : "foo" +!false or 0.5 > i32 +!false or ok +!false || ok +!hasPrefix("foo", "foo") +!none(array, # > #) +!none(array, # >= #) !none(array, false) -!none(array, true) -!none(list, false) +!none(array, ok) !none(list, ok) !none(list, true) -!not (1 != i) -!not (i64 != 0.5) -!not any(list, ok) +!not ("bar" == nil) +!not (1 <= 1) +!not (1 > 0.5) +!not (greet == nil) +!not (i32 == f64) !not false +!not none(list, true) !not ok !not true -!not true ? i64 : true !ok +!ok != !true !ok != ok -!ok && (ok || ok) -!ok == !ok +!ok && ok !ok == ok -!ok ? "bar" : 0.5 -!ok ? "foo" : nil -!ok ? 0.5 : "foo" -!ok ? 1 : 0.5 -!ok ? 1 : 1 +!ok ? "bar" : "foo" +!ok ? "bar" : foo +!ok ? "foo" : 0.5 +!ok ? "foo" : list +!ok ? 0.5 : 1 +!ok ? 0.5 : i +!ok ? 1 : array !ok ? 1 : div -!ok ? 1 : foo -!ok ? 1 : greet +!ok ? 1 : f64 +!ok ? 1 : list !ok ? 1 : ok -!ok ? add : f32 -!ok ? add : false -!ok ? add : i -!ok ? add : score -!ok ? f32 : "foo" -!ok ? f32 : 1 -!ok ? f64 : i -!ok ? false : "foo" -!ok ? false : half -!ok ? greet : "bar" -!ok ? greet : add -!ok ? greet : false -!ok ? half : array +!ok ? add : 0.5 +!ok ? array : div +!ok ? array : f32 +!ok ? array : foo +!ok ? array : i +!ok ? array : i32 +!ok ? div : "foo" +!ok ? div : 1 +!ok ? div : i +!ok ? f32 : "bar" +!ok ? f32 : add +!ok ? f32 : false +!ok ? f32 : greet +!ok ? f64 : "bar" +!ok ? f64 : "foo" +!ok ? f64 : 0.5 +!ok ? f64 : half +!ok ? f64 : score +!ok ? false : ok +!ok ? foo : "foo" +!ok ? foo : f32 +!ok ? foo : false +!ok ? foo : i32 +!ok ? greet : div +!ok ? greet : list +!ok ? greet : nil +!ok ? half : f64 +!ok ? i : "bar" +!ok ? i : array +!ok ? i : div !ok ? i : foo -!ok ? i : greet -!ok ? i : true -!ok ? i64 : list -!ok ? list : "foo" -!ok ? list : true -!ok ? nil : i -!ok ? nil : true -!ok ? ok : 1 -!ok ? ok : i64 -!ok ? ok : score -!ok ? score : array -!ok ? score : i -!ok ? true : greet -!ok and i != f32 +!ok ? i32 : 0.5 +!ok ? i32 : f32 +!ok ? i32 : greet +!ok ? i32 : nil +!ok ? i64 : 0.5 +!ok ? i64 : 1 +!ok ? i64 : f32 +!ok ? i64 : true +!ok ? list : f32 +!ok ? list : i +!ok ? nil : 1 +!ok ? nil : array +!ok ? ok : f32 +!ok ? ok : list !ok and ok -!ok or none(array, ok) +!ok or f32 < i64 +!ok or false or false +!ok or ok +!ok || ok +!one(array, false) !one(array, ok) !one(array, true) !one(list, false) !one(list, ok) !one(list, true) -!true != false ? ok : 0.5 -!true != nil == nil -!true != ok -!true && ok -!true == ok -!true ? "bar" : false -!true ? "bar" : i -!true ? "foo" : ok -!true ? 0.5 : 1 -!true ? 0.5 : div -!true ? 0.5 : i -!true ? add : div -!true ? add : greet -!true ? array : foo -!true ? array : i -!true ? array : i64 -!true ? array : score -!true ? div : f32 -!true ? div : ok -!true ? f32 : 0.5 -!true ? f32 : add -!true ? f32 : foo -!true ? f32 : i32 -!true ? f64 : "bar" +!reduce(array, false) +!reduce(array, ok) +!reduce(array, true) +!reduce(list, # != #) +!reduce(list, false) +!reduce(list, ok) +!reduce(list, true) +!true != all(array, ok) +!true ? "bar" : "foo" +!true ? "bar" : true +!true ? "foo" : "foo" +!true ? "foo" : 0.5 +!true ? "foo" : i +!true ? 1 : "foo" +!true ? 1 : i64 +!true ? add : 0.5 +!true ? add : score +!true ? array : f64 +!true ? array : list +!true ? div : add +!true ? f32 : false !true ? f64 : f64 -!true ? f64 : i32 !true ? foo : 1 -!true ? greet : array -!true ? greet : list -!true ? half : add -!true ? half : greet -!true ? i32 : i64 -!true ? i64 : score -!true ? list : div +!true ? foo : array +!true ? greet : ok +!true ? greet : score +!true ? greet : true +!true ? half : f64 +!true ? i : 1 +!true ? i : add +!true ? i : ok +!true ? i32 : 1 +!true ? i64 : false +!true ? i64 : i64 +!true ? i64 : list +!true ? list : 0.5 +!true ? list : nil !true ? list : score !true ? nil : 0.5 -!true ? nil : f32 -!true ? nil : f64 -!true ? nil : foo -!true ? nil : half -!true ? nil : i -!true ? ok : list -!true ? score : array -!true ? score : nil -!true and ok -!true or !false -!true or nil != ok +!true ? nil : false +!true ? nil : ok +!true ? ok : add +!true ? ok : div +!true ? score : false +!true ? true : f32 +!true ? true : half +!true and foo != nil !true || ok +"bar" != "bar" || ok "bar" != foo.Bar "bar" != foo?.Bar -"bar" != foo?.String() -"bar" != nil and true ? i64 : 0.5 -"bar" + "foo" not endsWith greet("bar") +"bar" + "bar" not in foo "bar" + foo.Bar "bar" + foo?.Bar -"bar" + foo?.String() "bar" < foo.Bar "bar" < foo?.Bar +"bar" < foo?.String() "bar" <= foo.Bar "bar" <= foo.String() "bar" <= foo?.Bar "bar" == foo.Bar "bar" == foo?.Bar +"bar" == foo?.String() +"bar" > "bar" or ok ? f32 : i64 "bar" > foo.Bar -"bar" > foo.String() -"bar" > foo?.Bar -"bar" contains "bar" == ok -"bar" contains "foo" ? array : f64 +"bar" > foo?.String() +"bar" >= foo.Bar +"bar" >= foo.String() +"bar" >= foo?.Bar "bar" contains foo.Bar +"bar" contains foo.String() "bar" contains foo?.Bar -"bar" contains foo?.String() "bar" endsWith foo.Bar "bar" endsWith foo?.Bar "bar" endsWith foo?.String() -"bar" in foo || ok -"bar" matches "bar" != ok +"bar" matches "bar" and ok "bar" matches foo.Bar +"bar" matches foo.String() "bar" matches foo?.Bar +"bar" matches foo?.String() "bar" not contains foo.Bar -"bar" not contains foo.String() "bar" not contains foo?.Bar "bar" not endsWith foo.Bar "bar" not endsWith foo?.Bar "bar" not endsWith foo?.String() -"bar" not in list[i] -"bar" not matches "foo" ? i32 < 0.5 : ok "bar" not matches foo.Bar "bar" not matches foo.String() "bar" not matches foo?.Bar -"bar" not startsWith "foo" ? add : ok +"bar" not matches foo?.String() "bar" not startsWith foo.Bar "bar" not startsWith foo?.Bar +"bar" not startsWith foo?.String() +"bar" startsWith "foo" or list == array "bar" startsWith foo.Bar -"bar" startsWith foo?.Bar -"foo" != "bar" != ok +"bar" startsWith foo.String() +"foo" != "foo" ? f64 : array +"foo" != "foo" or ok "foo" != foo.Bar +"foo" != foo.String() "foo" != foo?.Bar "foo" != foo?.String() -"foo" + "foo" not in foo +"foo" + "bar" not in foo "foo" + foo.Bar -"foo" + foo.String() "foo" + foo?.Bar "foo" + foo?.String() -"foo" < "bar" and i32 != 0.5 -"foo" < "foo" ? list : f32 +"foo" < "bar" and ok "foo" < foo.Bar "foo" < foo?.Bar +"foo" < foo?.String() "foo" <= foo.Bar "foo" <= foo?.Bar -"foo" == "foo" && i32 > 1 +"foo" == "bar" != ok +"foo" == "bar" and ok "foo" == foo.Bar -"foo" == foo.String() +"foo" == foo?.Bar "foo" == foo?.String() -"foo" == nil ? foo : f64 -"foo" > "bar" && ok -"foo" > "foo" == not false +"foo" > foo.Bar +"foo" > foo.String() "foo" > foo?.Bar -"foo" > foo?.String() "foo" >= foo.Bar +"foo" >= foo.String() "foo" >= foo?.Bar -"foo" contains foo.Bar +"foo" >= foo?.String() +"foo" contains "bar" == ok "foo" contains foo?.Bar "foo" endsWith foo.Bar -"foo" endsWith foo.String() "foo" endsWith foo?.Bar -"foo" endsWith foo?.String() -"foo" in foo && nil == 1 -"foo" matches "bar" ? f64 > f64 : half +"foo" matches "bar" ? add : div +"foo" matches "foo" || true ? greet : "bar" "foo" matches foo.Bar "foo" matches foo.String() "foo" matches foo?.Bar "foo" not contains foo.Bar "foo" not contains foo?.Bar +"foo" not contains foo?.String() "foo" not endsWith foo.Bar "foo" not endsWith foo?.Bar -"foo" not endsWith foo?.String() "foo" not matches foo.Bar -"foo" not matches foo.String() "foo" not matches foo?.Bar +"foo" not matches foo?.String() "foo" not startsWith foo.Bar +"foo" not startsWith foo?.Bar "foo" not startsWith foo?.String() "foo" startsWith foo.Bar "foo" startsWith foo?.Bar -"foo" startsWith foo?.String() -("bar" not endsWith "bar") and i64 < i32 -("bar" not endsWith "foo") == ok -("bar" not in foo) == ok -("foo" not matches "bar") and false ? f64 : array -(0.5 * 0.5) ** f32 +("bar" not endsWith "bar") != ok +("bar" not endsWith "foo") != ok +("bar" not endsWith "foo") && false != nil +("bar" not matches "foo") || reduce(list, ok) +("foo" not matches "bar") == ok (0.5 * 0.5) ** i -(0.5 * 0.5) ** i64 (0.5 * 0.5) ^ f32 -(0.5 * 0.5) ^ i32 -(0.5 * f32) ** i +(0.5 * 1) ** f64 +(0.5 * 1) ** i +(0.5 * 1) ^ i32 (0.5 * f64) ^ f32 -(0.5 * i32) ** f32 -(0.5 + 1) * i -(0.5 + 1) ** i64 -(0.5 + 1) / i +(0.5 * i) ^ i +(0.5 + 0.5) * f32 +(0.5 + 0.5) ^ i32 +(0.5 + 1) ^ i +(0.5 + f64) * f64 +(0.5 + f64) / i32 +(0.5 + i) ** i +(0.5 + i) ^ i +(0.5 + i64) ** f32 (0.5 + i64) / f32 -(0.5 - 0.5) ^ half(f64) -(0.5 - 1) * i64 -(0.5 - 1) ** i64 -(0.5 - f32) ** (0.5 * f64) -(0.5 - f64) * f64 +(0.5 + i64) / i +(0.5 - 0.5) * (i32 - 0.5) +(0.5 - 0.5) * i64 +(0.5 - 0.5) ** f32 +(0.5 - 1) * i32 +(0.5 - 1) ** f64 +(0.5 - 1) ^ i64 +(0.5 - f32) ** i +(0.5 - f64) * i (0.5 - f64) / f32 +(0.5 - f64) / f64 (0.5 - i) ^ f32 -(0.5 - i32) ** i64 -(0.5 - i32) ^ f64 +(0.5 - i32) ** (i32 * 1) +(0.5 - i32) / f64 +(0.5 - i32) ^ f32 +(0.5 - i64) * i +(0.5 - i64) / f64 +(0.5 - i64) / i64 +(0.5 / 0.5) ** f32 +(0.5 / 0.5) ** i32 (0.5 / 0.5) ^ f64 -(0.5 / f32) ** f32 -(0.5 / f32) ^ i32 -(0.5 / f64) ** i -(0.5 / f64) ** i32 +(0.5 / 1) ^ f32 +(0.5 / i) ** f64 +(0.5 / i) ** i (0.5 / i32) ** i -(0.5 / i64) ** f32 -(1 % i) ** f32 -(1 % i) ^ i -(1 % i64) ** f32 -(1 * 1) ** f64 -(1 * 1) ^ i -(1 * f32) ** f32 -(1 * i32) ** i -(1 * i64) ** i32 -(1 + 0.5) * f64 -(1 + 0.5) ^ i32 -(1 + 1) / i32 -(1 + 1) ^ i -(1 + f32) / f32 / i64 -(1 + f64) ** i64 -(1 + f64) / i32 -(1 + f64) ^ f64 -(1 + i32) / f32 -(1 + i64) / f64 -(1 - 0.5) / f64 -(1 - 0.5) ^ i32 -(1 - 1) * i -(1 - 1) * i32 -(1 - 1) ** f32 -(1 - 1) / i -(1 - f64) * 1 * i -(1 - f64) ^ i32 -(1 - i) ** i -(1 - i) / i64 -(1 - i32) ** i ^ 0.5 -(1 - i64) % i64 -(1 / 0.5) ^ f32 -(1 / 0.5) ^ f64 -(1 / 1) ** i32 -(1 / 1) ^ i32 -(1 / f64) ** f64 -(1 / i) ** i64 -(1 not in array) and none(list, true) -(f32 * 1) ** f32 -(f32 * 1) ** i64 -(f32 * i) ^ i64 -(f32 * i32) ** i -(f32 * i64) ** i64 -(f32 * i64) ^ i -(f32 + 0.5) / 0.5 ** 0.5 -(f32 + 1) ** i -(f32 + 1) / i -(f32 + 1) / i64 -(f32 + i32) ** i64 -(f32 + i64) ** i32 -(f32 - 0.5) * f64 -(f32 - 0.5) * i -(f32 - f32) ** f32 -(f32 - i) / f64 -(f32 - i) ^ i64 -(f32 - i64) * i64 -(f32 - i64) ** i64 -(f32 - i64) / i64 -(f32 / f64) ^ f32 -(f32 / f64) ^ i -(f32 / i32) ^ i32 -(f64 * 0.5) ^ i -(f64 * f64) ** i32 +(0.5 / i32) ^ f32 +(1 * 0.5) ** (f64 * 1) +(1 * 0.5) ** i32 +(1 * 0.5) ^ f64 +(1 * 1) ^ -1 +(1 * 1) ^ f32 +(1 * f32) ^ i32 +(1 * i) ** i32 +(1 * i32) ^ i +(1 * i64) ** i64 +(1 + 0.5) ** i +(1 + 1) * i64 +(1 + 1) / i +(1 + f32) ^ i +(1 + f64) ^ i +(1 + f64) ^ i32 +(1 + i) ** f32 +(1 + i) / f64 +(1 + i) ^ i64 +(1 + i32) * f64 +(1 + i32) ^ f64 +(1 - 0.5) * f32 ^ 1 +(1 - 0.5) * i64 +(1 - 0.5) / i +(1 - 0.5) ^ min(f32) +(1 - f32) * f32 +(1 - f64) ** f64 +(1 - i) * -i32 +(1 - i32) ^ f32 +(1 - i32) ^ i +(1 - i64) ** f32 +(1 - i64) / f64 +(1 - i64) / i64 +(1 / 0.5) ** f32 +(1 / 0.5) ^ i32 +(1 / 1) ** (f64 * 0.5) +(1 / 1) ^ ceil(i64) +(1 / 1) ^ max(0.5) +(1 / f32) ^ f32 +(1 / i) ^ f32 +(1 / i32) ^ i +(1 / i64) ** i64 +(f32 * 0.5) ** f64 +(f32 * 0.5) ^ i32 +(f32 * f32) ^ -f32 +(f32 * f32) ^ i +(f32 * i) ^ -1 +(f32 * i64) ** i +(f32 + f64) * i +(f32 + i) ^ f64 +(f32 - 0.5) / f64 +(f32 - 0.5) ^ f32 +(f32 - 1) / f64 +(f32 - 1) ^ f64 +(f32 - f32) / i64 +(f32 - i32) * i64 +(f32 / 0.5) ^ f32 +(f32 / i64) ^ f64 +(f64 * 0.5) ** f32 +(f64 * 0.5) ** i64 +(f64 * f32) ** f64 +(f64 * i64) ** f64 (f64 * i64) ** i32 -(f64 + f32) ** i64 -(f64 + i32) * f32 -(f64 + i64) / i32 -(f64 - 0.5) * -i -(f64 - 0.5) * i -(f64 - 0.5) / f32 -(f64 - 0.5) / i64 -(f64 - 0.5) ^ i -(f64 - 0.5) ^ i64 -(f64 - 1) * f32 -(f64 - f32) * i64 -(f64 - f64) / i32 -(f64 - i) * i32 ** 1 -(f64 - i64) / i64 -(f64 / 0.5) ** f64 -(f64 / i) ^ i64 -(false || ok) and ok -(i % 1) ** -f32 -(i % 1) ** f64 -(i % i) ** f32 -(i * 1) ** i -(i * f32) ** i32 -(i * f32) ^ f64 -(i * i) ^ count(array, true) -(i + 0.5) ** i32 -(i + 0.5) ^ f32 -(i + 1) % i32 +(f64 + 0.5) * f32 +(f64 + 0.5) * i64 +(f64 + f32) ** get(array, i) +(f64 + f32) ** i32 +(f64 + f64) * (i64 - i64) +(f64 + f64) ^ f64 +(f64 + i) * (0.5 + i64) +(f64 + i32) ^ i64 +(f64 + i64) ^ i +(f64 - 0.5) ** f64 +(f64 - 1) ** i64 +(f64 - 1) ^ i32 +(f64 - f32) ** i +(f64 - f32) ^ i64 +(f64 - i) * i32 +(f64 - i32) / i +(f64 - i64) ** i +(f64 - i64) / f32 +(f64 - i64) / f64 +(f64 / 1) ** i64 +(f64 / f32) ^ i +(f64 / f64) ** i32 +(f64 / f64) ^ i32 ** 0.5 +(false || ok) == ok +(i % i) ^ i +(i % i32) ^ (1 - i32) +(i % i64) ^ f64 +(i * 0.5) ** f32 +(i * 1) ^ f64 +(i * 1) ^ i +(i * i64) ** f32 +(i + 0.5) ** half(f64) +(i + 1) % i64 (i + 1) / i64 -(i + f64) ^ (f32 * f64) -(i + i) * -f64 -(i + i32) ^ i64 -(i - 0.5) / f32 -(i - 0.5) ^ f64 -(i - 1) ** i64 -(i - 1) / f32 -(i - 1) ^ f64 -(i - i64) ** f64 -(i - i64) ^ i -(i / 0.5) ^ i32 -(i / 1) ** f64 -(i / 1) ** i64 -(i / i32) ^ f32 -(i < i32 ? nil : f64) ** f64 -(i32 * 1) ** f32 -(i32 * f32) ^ i64 -(i32 * i) ^ i -(i32 * i32) ** f64 -(i32 + 0.5) / f64 -(i32 + 0.5) ^ i64 -(i32 + 1) * f64 -(i32 + 1) ** float(1) -(i32 + 1) / i -(i32 + 1) / i64 -(i32 + f32) ** f32 -(i32 + f64) ** i -(i32 + i32) * i32 -(i32 + i32) / i64 -(i32 + i64) ^ i -(i32 - 0.5) * i64 -(i32 - f32) * i32 -(i32 - i32) ** i -(i32 - i32) ** i64 -(i32 / 0.5) ^ i32 -(i32 / i32) ^ f32 -(i32 / i32) ^ i -(i64 * 0.5) ^ f32 -(i64 * 1) ** i64 -(i64 * 1) ^ f32 -(i64 * 1) ^ f64 -(i64 * f32) ** findIndex(list, ok) -(i64 + 1) * i32 -(i64 + f32) ^ f64 -(i64 + f64) / 1 * 1 -(i64 + f64) ^ f64 -(i64 + i) ^ i64 -(i64 + i32) * f32 -(i64 - 0.5) * i64 -(i64 - 0.5) / i32 -(i64 - i) % i32 -(i64 - i32) / len(array) -(i64 - i64) / i64 -(i64 / f64) ** f32 -(i64 / i32) ** f32 -(i64 / i32) ** i -(i64 / i32) ^ -1 -(i64 not in array) && ok -(ok && ok) == ok -(ok or false) and ok -(ok or ok) == not false -(ok || true) && i32 >= f64 +(i + i) ^ i64 +(i + i32) * i64 ^ f64 +(i + i32) / i32 +(i + i32) ^ f32 +(i + i64) ^ i32 +(i - 0.5) / i64 +(i - 1) ^ i64 +(i / 0.5) ** f32 +(i / f32) ^ f64 +(i32 % 1) ** f32 +(i32 % i) ** f32 +(i32 % i32) ** i32 +(i32 % i32) ^ i32 +(i32 * 0.5) ^ f32 +(i32 * 1) ^ i32 +(i32 + 0.5) ** i64 +(i32 + f32) * i64 +(i32 + f64) / i +(i32 + i) / i +(i32 + i32) ^ i32 +(i32 - 0.5) * f64 +(i32 - 0.5) / i64 +(i32 - 1) ^ f64 +(i32 - f32) / i64 +(i32 - i) % i64 +(i32 - i) / f32 +(i32 - i32) ^ (i32 * i) +(i32 - i64) * i32 +(i32 - i64) * i32 * i64 +(i32 / i) ** f32 +(i32 / i) ^ i64 +(i32 < f64 ? nil : i) .. i32 +(i32 not in array) and ok +(i64 % i) ** f32 +(i64 * 0.5) ^ f64 +(i64 * f32) ^ i64 +(i64 * f64) ^ i32 +(i64 * i) ** score(1) +(i64 * i64) ** i ** 0.5 +(i64 * i64) ^ i +(i64 + 0.5) * f32 +(i64 + 0.5) ** i64 +(i64 + 1) % i +(i64 + 1) ^ i +(i64 + f32) * -i32 +(i64 + f32) ** i32 +(i64 + f32) / f64 +(i64 + f32) / i +(i64 + f32) / i32 +(i64 + f64) * i32 +(i64 + i) % i64 +(i64 + i) / f64 +(i64 + i32) * i64 +(i64 + i64) / i64 +(i64 - 0.5) / f64 +(i64 - 0.5) ^ i64 +(i64 - 1) ^ i32 +(i64 - f32) ** f64 +(i64 - f32) ^ i64 +(i64 - i) ** i +(i64 - i32) * i64 +(i64 / 1) ** f32 +(i64 / f64) ** i32 +(nil not in array) || ok +(ok || true) && (ok or true) +-((i64 + 1) % i32) -(0.5 * 0.5) -(0.5 * 1) -(0.5 * f32) @@ -1003,7 +1043,6 @@ -(0.5 - i32) -(0.5 - i64) -(0.5 / 0.5) --(0.5 / 0.5) < i32 -(0.5 / 1) -(0.5 / f32) -(0.5 / f64) @@ -1024,6 +1063,7 @@ -(1 * 0.5) -(1 * 1) -(1 * f32) +-(1 * f64) -(1 * i) -(1 * i32) -(1 * i64) @@ -1081,12 +1121,10 @@ -(f32 + f32) -(f32 + f64) -(f32 + i) --(f32 + i32) -(f32 + i64) -(f32 - 0.5) -(f32 - 1) --(f32 - f64) --(f32 - i - f32) +-(f32 - f32) -(f32 - i) -(f32 - i32) -(f32 - i64) @@ -1100,6 +1138,7 @@ -(f32 ^ 0.5) -(f32 ^ 1) -(f32 ^ f32) +-(f32 ^ f64) -(f32 ^ i) -(f32 ^ i32) -(f32 ^ i64) @@ -1116,7 +1155,6 @@ -(f64 ** f64) -(f64 ** i) -(f64 ** i32) --(f64 ** i32) > i32 -(f64 ** i64) -(f64 + 0.5) -(f64 + 1) @@ -1129,14 +1167,12 @@ -(f64 - f32) -(f64 - f64) -(f64 - i) --(f64 - i32) -(f64 - i64) -(f64 / 0.5) -(f64 / 1) -(f64 / f32) -(f64 / f64) -(f64 / i) --(f64 / i32) -(f64 / i64) -(f64 ^ 0.5) -(f64 ^ 1) @@ -1149,7 +1185,6 @@ -(i % i) -(i % i32) -(i % i64) --(i % score(1)) -(i * 0.5) -(i * 1) -(i * f32) @@ -1157,37 +1192,38 @@ -(i * i) -(i * i32) -(i * i64) +-(i ** 0.5) -(i ** 1) --(i ** f32) -(i ** f64) -(i ** i) -(i ** i32) -(i ** i64) --(i ** int(i)) -(i + 0.5) -(i + 1) --(i + f32) --(i + f64) --(i + i) +-(i + i32) -(i + i64) -(i - 0.5) -(i - 1) -(i - f32) -(i - f64) +-(i - i ** 1) -(i - i) -(i - i32) +-(i - i64) -(i / 0.5) -(i / 1) -(i / f32) -(i / f64) -(i / i) -(i / i32) +-(i / i64) -(i ^ 0.5) -(i ^ 1) -(i ^ f32) -(i ^ f64) -(i ^ i) --(i32 % 1 % i) +-(i ^ i32) +-(i ^ i64) -(i32 % 1) -(i32 % i) -(i32 % i32) @@ -1202,11 +1238,11 @@ -(i32 ** 0.5) -(i32 ** 1) -(i32 ** f32) +-(i32 ** f64) -(i32 ** i) -(i32 ** i32) -(i32 ** i64) -(i32 + 0.5) --(i32 + 1 ^ i64) -(i32 + 1) -(i32 + f32) -(i32 + f64) @@ -1222,7 +1258,6 @@ -(i32 - i64) -(i32 / 0.5) -(i32 / 1) --(i32 / f32) -(i32 / f64) -(i32 / i) -(i32 / i32) @@ -1232,6 +1267,8 @@ -(i32 ^ f32) -(i32 ^ f64) -(i32 ^ i) +-(i32 ^ i32) +-(i32 ^ i64) -(i64 % 1) -(i64 % i) -(i64 % i32) @@ -1254,17 +1291,16 @@ -(i64 + 1) -(i64 + f32) -(i64 + f64) --(i64 + i) -(i64 + i32) -(i64 + i64) -(i64 - 0.5) -(i64 - 1) +-(i64 - f32) -(i64 - f64) -(i64 - i) -(i64 - i32) -(i64 - i64) -(i64 / 0.5) --(i64 / 1 / 1) -(i64 / 1) -(i64 / f32) -(i64 / f64) @@ -1278,248 +1314,285 @@ -(i64 ^ i) -(i64 ^ i32) -(i64 ^ i64) --(max(0.5) + i64) ---(1 * i64) ---(i64 * 1) ----1 ----i +-(max(f32) ^ i32) +-(min(0.5) ^ i32) +--(f64 ** 0.5) +--(i64 ** i64) --0.5 --1 ---abs(f64) +--ceil(1) --f32 --f64 +--f64 ** i64 +--float(f64) --i --i32 --i64 ---max(0.5) --0.5 != 1 ? array : f64 -0.5 != f32 --0.5 != f64 ** 0.5 -0.5 != i32 --0.5 != max(i64) +-0.5 * 1 ** 1 +-0.5 * f32 -0.5 * f64 --0.5 * i -0.5 * i32 -0.5 * i64 --0.5 * len(array) +-0.5 ** -1 +-0.5 ** ceil(i) -0.5 ** f32 +-0.5 ** f64 -0.5 ** i -0.5 ** i32 -0.5 ** i64 --0.5 + f32 -0.5 + f64 --0.5 + f64 / f64 -0.5 + i -0.5 + i32 --0.5 - -i32 --0.5 - 1 + 1 +-0.5 + i64 +-0.5 - abs(i) -0.5 - f32 -0.5 - f64 -0.5 - i -0.5 - i32 --0.5 - i32 * i --0.5 / (f32 + 0.5) --0.5 / -i32 +-0.5 - i64 -0.5 / f32 --0.5 / f64 --0.5 / float(f64) -0.5 / i --0.5 / i64 --0.5 / i64 ** 1 --0.5 < f32 --0.5 < f64 +-0.5 / i32 -0.5 < i32 --0.5 < i32 ? false : "bar" --0.5 < i32 ^ f64 --0.5 <= 1 == false +-0.5 < i64 +-0.5 <= 0.5 + 0.5 -0.5 <= f32 --0.5 <= f64 --0.5 <= f64 + f32 +-0.5 <= i +-0.5 <= i32 -0.5 <= i64 -0.5 == f32 --0.5 == f64 / 0.5 +-0.5 == f64 -0.5 == i -0.5 == i32 +-0.5 == i32 ^ i32 -0.5 == i64 -0.5 > f32 --0.5 > f64 --0.5 > i32 --0.5 > i64 +-0.5 > i +-0.5 >= f32 +-0.5 >= f32 ? f32 : i32 -0.5 >= f64 -0.5 >= i -0.5 >= i32 -0.5 >= i64 -0.5 ^ f32 -0.5 ^ f64 --0.5 ^ i +-0.5 ^ float(f64) -0.5 ^ i32 -0.5 ^ i64 +-0.5 in array +-0.5 not in sort(array) +-1 != -i +-1 != f32 -1 != f64 --1 != i +-1 != i32 -1 != i64 --1 != i64 * f32 +-1 % i -1 % i32 --1 % i64 --1 * 1 ** i64 +-1 * array[i] -1 * f32 +-1 * f64 +-1 * i -1 * i32 -1 * i64 +-1 ** (f32 + f32) +-1 ** (i + i64) +-1 ** ceil(0.5) -1 ** f32 +-1 ** f64 -1 ** i --1 ** i64 --1 + 1 + 0.5 +-1 ** i64 ^ 1 +-1 + -i32 -1 + f32 --1 + half(f64) +-1 + f64 -1 + i +-1 + i32 -1 + i64 --1 - f32 +-1 + reduce(array, #) +-1 + reduce(list, f32) +-1 - f64 -1 - i +-1 - i % i32 -1 - i32 -1 - i64 -1 .. i --1 .. i32 -1 .. i64 --1 / 1 * 1 -1 / f32 +-1 / f64 +-1 / i -1 / i32 --1 < 0.5 ^ i64 --1 < f32 --1 < f64 * 1 --1 < i32 +-1 < f64 +-1 < i -1 < i64 --1 <= f32 --1 <= f32 == true +-1 <= -1 -1 <= f64 +-1 <= i -1 <= i32 +-1 <= i64 -1 == f32 -1 == f64 --1 == nil != nil --1 > -i32 +-1 == floor(f64) +-1 == i +-1 == i32 +-1 == i64 -1 > f32 --1 > half(0.5) -1 > i --1 > i32 -1 > i64 --1 > i64 ? array : nil --1 >= 0.5 * 0.5 --1 >= f32 +-1 >= f32 * f32 -1 >= f64 -1 >= i32 --1 >= i32 - 1 -1 >= i64 -1 ^ f32 -1 ^ f64 +-1 ^ i32 -1 ^ i64 -1 in array -1 not in array --abs(0.5 * f64) -abs(0.5) -abs(1) --abs(1) .. i -abs(f32) -abs(f64) -abs(i) -abs(i32) -abs(i64) --add(1, 1) -add(i, 1) +-add(i, i) -array[1] -array[i32] -array[i64] -array[i] +-bitand(i64, i32) +-bitnand(1, i) +-bitnot(1) +-bitnot(i) +-bitnot(i32) +-bitnot(i64) +-bitor(1, i64) +-bitor(i, i32) +-bitshl(i, 1) +-bitshl(i, i32) +-bitshl(i, i64) +-bitshl(i64, i32) +-bitshr(i, i) +-bitshr(i64, i32) +-bitushr(i, i32) +-bitxor(1, 1) +-bitxor(i, i32) +-ceil(0.5) +-ceil(1) +-ceil(f32) +-ceil(f64) +-ceil(i) +-ceil(i32) +-ceil(i64) -count(array, false) -count(array, ok) -count(array, true) -count(list, ok) -count(list, true) -div(1, 1) --div(1, i) --div(i, i) -f32 --f32 != 1 / i --f32 != f32 --f32 != f64 --f32 != i64 --f32 * 1 ** i32 --f32 * f32 +-f32 != i32 +-f32 * i64 +-f32 ** (i + 1) -f32 ** f32 --f32 ** f32 ** 1 +-f32 ** f64 +-f32 ** i +-f32 ** i32 -f32 ** i64 --f32 + f32 -f32 + i32 --f32 + i64 --f32 - f32 --f32 - f64 -f32 - i --f32 - i32 --f32 - i64 +-f32 - round(i) -f32 / f32 --f32 / i32 --f32 / i64 +-f32 / f64 +-f32 / i +-f32 < f32 ** 0.5 -f32 < f64 +-f32 < i -f32 < i32 --f32 < i64 +-f32 <= f32 -f32 <= i -f32 <= i32 +-f32 <= i64 -f32 == f32 -f32 == f64 --f32 == i --f32 == i32 --f32 == i64 +-f32 > 0.5 ? f32 : "bar" -f32 > f32 -f32 > f64 --f32 > i --f32 > i64 --f32 >= 1 / f32 -f32 >= f32 -f32 >= f64 -f32 >= i64 --f32 ^ f32 --f32 ^ f64 +-f32 ^ i +-f32 ^ i32 -f32 ^ i64 --f32 ^ min(f64) +-f32 in array +-f32 not in array -f64 +-f64 != f32 -f64 != f64 -f64 != i --f64 != i64 +-f64 != i32 +-f64 * -1 +-f64 * -f64 +-f64 * f32 -f64 * f64 +-f64 * i +-f64 * i32 +-f64 * i64 +-f64 ** 0.5 ** f32 -f64 ** f32 +-f64 ** i -f64 ** i32 --f64 ** i64 -f64 + f32 --f64 + i32 -f64 + i64 --f64 - 0.5 / i32 --f64 - f64 +-f64 - 0.5 / i64 +-f64 - f32 +-f64 - i -f64 - i32 +-f64 - i64 +-f64 - int(f64) +-f64 / f32 -f64 / f64 -f64 / i +-f64 / i32 -f64 / i64 --f64 < f32 +-f64 < 0.5 ^ f32 +-f64 < f64 +-f64 < f64 ** 1 +-f64 < half(0.5) +-f64 < half(f64) -f64 < i +-f64 < i ^ f32 +-f64 < i32 +-f64 < i64 -f64 <= f32 -f64 <= f64 --f64 <= i32 --f64 == f32 +-f64 == f64 -f64 == i -f64 == i32 +-f64 == i64 +-f64 > f32 +-f64 > f32 ? false : array -f64 > f64 -f64 > i32 -f64 > i64 +-f64 >= f32 +-f64 >= f32 / f64 -f64 >= f64 --f64 >= f64 ^ 0.5 --f64 >= i --f64 ^ 0.5 ** i64 +-f64 >= i32 -f64 ^ f32 -f64 ^ f64 --f64 ^ i --f64 ^ i32 -f64 ^ i64 +-f64 not in array -find(array, ok) -find(array, true) +-findIndex(array, # <= #) -findIndex(array, ok) -findIndex(array, true) -findIndex(list, ok) +-findIndex(list, true) +-findLast(array, # <= #) -findLast(array, ok) -findLast(array, true) -findLastIndex(array, ok) @@ -1527,847 +1600,968 @@ -findLastIndex(list, ok) -findLastIndex(list, true) -first(array) --float(-1) +-float(0.5 ** 0.5) +-float(0.5 ^ 0.5) -float(0.5) -float(1) --float(f32 ** 0.5) +-float(bitnot(i64)) -float(f32) -float(f64) -float(i) -float(i32) -float(i64) +-floor(0.5) +-floor(1) +-floor(f32) +-floor(f64) +-floor(i) +-floor(i32) +-floor(i64) -get(array, 1) -get(array, i) -get(array, i32) -get(array, i64) +-half(-0.5) -half(-1) -half(0.5) +-half(1) +-half(f32 + i64) -half(f64) +-half(median(array)) -i +-i != f32 -i != f64 +-i != f64 ? foo : 1 +-i != i +-i != i + f64 -i != i32 --i != i32 * 1 -i != i64 --i % i -i % i32 -i % i64 --i * f32 +-i * abs(0.5) -i * f64 --i * i32 +-i * i -i * i64 +-i * reduce(array, 0.5) -i ** f32 -i ** f64 --i ** i32 --i ** i64 +-i ** i -i + f32 --i + i +-i + f64 -i + i32 --i + i64 +-i + i64 * 1 -i - f32 --i - f64 --i - i -i - i64 --i .. i32 --i / f64 --i / i --i / i32 +-i .. i +-i .. i64 +-i / f32 -i / i64 -i < f32 +-i < half(1) +-i < i -i < i64 +-i <= 0.5 ? half : "bar" +-i <= 1 - 0.5 -i <= f32 +-i <= i -i <= i32 --i == -0.5 --i == 1 ** f64 --i == 1 + 0.5 +-i <= i64 +-i <= i64 ** 0.5 +-i == f32 +-i == f64 +-i == f64 ^ f32 +-i == i +-i == i32 -i > f32 -i > i -i > i32 -i >= f32 --i >= i32 --i ^ -i +-i >= f64 +-i >= i +-i >= i64 +-i >= score(1) +-i ^ 0.5 ** 0.5 +-i ^ f32 +-i ^ f32 ^ 0.5 -i ^ f64 --i ^ i32 +-i ^ i +-i ^ i64 +-i in array -i not in array -i32 -i32 != f32 --i32 != f64 -i32 != i +-i32 != i32 ** 1 -i32 != i64 +-i32 % i -i32 % i32 -i32 % i64 --i32 * f32 --i32 * f64 -i32 * i -i32 * i32 +-i32 * i64 +-i32 ** f32 -i32 ** f64 --i32 ** i32 -i32 ** i64 --i32 + 1 + i -i32 + f32 --i32 + f64 -i32 + i -i32 + i32 --i32 - i32 --i32 - i64 --i32 .. i --i32 .. i64 --i32 / (i32 - f64) --i32 / f64 --i32 / i --i32 < 0.5 * 1 --i32 < f32 --i32 < f64 - f64 +-i32 - f32 +-i32 .. i32 +-i32 / i32 +-i32 / i64 +-i32 < i -i32 < i32 -i32 < i64 --i32 <= 0.5 ? f64 : 1 --i32 <= f32 +-i32 < round(f64) -i32 <= f64 --i32 <= f64 + i +-i32 <= i +-i32 <= i32 +-i32 <= i64 +-i32 == 1 % i -i32 == f32 --i32 == i32 +-i32 == f64 +-i32 == i64 +-i32 == max(1) +-i32 > f32 +-i32 > f64 -i32 > i +-i32 > i ** 0.5 -i32 > i32 -i32 > i64 --i32 >= f32 -i32 >= f64 --i32 >= i64 --i32 ^ (i - 0.5) --i32 ^ i +-i32 >= i +-i32 >= i == nil +-i32 >= i32 +-i32 ^ f32 -i32 ^ i32 -i32 ^ i64 --i32 ^ i64 ** i32 +-i32 ^ score(1) -i32 in array --i32 not in array -i64 --i64 != i --i64 != i ? i : foo +-i64 != f32 +-i64 != f64 +-i64 != i32 -i64 != i64 --i64 % i --i64 % i32 +-i64 != i64 ? score : foo +-i64 * (1 + f64) -i64 * f32 --i64 * f64 -i64 * i -i64 * i32 -i64 * i64 --i64 ** f64 --i64 ** i64 --i64 + 0.5 * i32 --i64 + f64 +-i64 * indexOf("foo", "bar") +-i64 ** i +-i64 ** i32 +-i64 + f32 -i64 + i +-i64 + i32 +-i64 + i64 -i64 - f32 --i64 - f64 +-i64 - i -i64 - i32 --i64 - i64 -i64 .. i -i64 .. i32 --i64 / f32 --i64 / i --i64 / i64 --i64 / i64 * f32 --i64 < -0.5 +-i64 .. i64 +-i64 / f64 +-i64 / i32 -i64 < f32 -i64 < f64 --i64 < i +-i64 < half(f64) -i64 < i32 -i64 < i64 +-i64 <= i -i64 <= i32 --i64 <= i64 +-i64 == 1 ^ i64 -i64 == f32 +-i64 == f64 -i64 == i -i64 == i32 --i64 == i64 -i64 > f32 -i64 > f64 +-i64 > i -i64 > i32 +-i64 >= f32 -i64 >= i -i64 >= i32 --i64 >= i64 -i64 ^ f64 +-i64 ^ float(i) +-i64 ^ i -i64 ^ i32 -i64 ^ i64 +-i64 in array -i64 not in array --i64 not in sort(array) -int(0.5) -int(1) -int(f32) -int(f64) -int(i) -int(i32) --int(i64 - i) -int(i64) --int(int(1)) -last(array) -len("bar") -len("foo") --len([foo]) -len(array) --len(false ? greet : "foo") -len(list) --max(0.5 * i) -max(0.5) --max(0.5, 1) +-max(0.5, 0.5, f64) -max(1) -max(f32) --max(f32, 0.5, f32) --max(f32, i64) -max(f64) -max(i) --max(i, 1) --max(i, i64) +-max(i, 0.5) +-max(i32 - 1) -max(i32) --max(i32, 0.5) +-max(i32, f32) +-max(i64 * 0.5) -max(i64) --max(score(1)) +-max(i64, f64) +-max(i64, i) +-mean(array) +-median(array) +-min(-1) -min(0.5) --min(0.5, 1) --min(0.5, i32) -min(1) --min(1, f32) +-min(1, 0.5) -min(f32) --min(f32, 0.5) +-min(f32, 1) -min(f64) --min(f64, 0.5) --min(f64, f32) --min(f64, i64) +-min(float(0.5)) -min(i) --min(i, i) +-min(i, 1) -min(i32) --min(i32, 1) --min(i32, f64) +-min(i32, 0.5) -min(i64) --min(i64, f32) --min(i64, f64) +-min(i64, i, 0.5) +-reduce(array, #) +-reduce(array, -#) +-reduce(array, 0.5) +-reduce(array, 1) +-reduce(array, 1) - f32 +-reduce(array, f64) +-reduce(array, i) +-reduce(array, i32) +-reduce(array, i64) +-reduce(list, 0.5) +-reduce(list, 1) +-reduce(list, f32) +-reduce(list, f64) +-reduce(list, i) +-reduce(list, i32) +-round(0.5) +-round(1) +-round(f32) +-round(f64) +-round(i) +-round(i32) +-round(i64) -score(1) -score(1, 1) -score(1, i) -score(i) --score(i, 1) --score(i32 * i) -0.5 != 0.5 ? f64 : half -0.5 != 0.5 ? i64 : f64 -0.5 != 0.5 ? list : array -0.5 != 0.5 or ok -0.5 != f32 || 0.5 > 0.5 -0.5 != i && i64 > 1 -0.5 != i64 != ok -0.5 != i64 ? -f32 : add -0.5 != nil or ok -0.5 * 0.5 != i / 1 -0.5 * 0.5 * i -0.5 * 0.5 * i32 -0.5 * 0.5 + i32 -0.5 * 0.5 - i +-score(i32 + i) +-score(int(i)) +-sum(array) +-sum(i .. 1) +0.5 != 0.5 == ok +0.5 != f64 ? list : f32 +0.5 != f64 and !true +0.5 != f64 and ok +0.5 != i == ok +0.5 != i32 && ok +0.5 != i32 == ok +0.5 != i32 ? ok : ok +0.5 != i32 and 1 > f64 +0.5 != nil == ok +0.5 * 0.5 * f64 +0.5 * 0.5 / f32 0.5 * 0.5 / f64 -0.5 * 0.5 / i32 -0.5 * 0.5 < f32 -0.5 * 0.5 < i -0.5 * 0.5 > i32 -0.5 * 1 + f32 -0.5 * 1 + half(f64) -0.5 * 1 < f64 -0.5 * 1 > f64 +0.5 * 0.5 < f64 +0.5 * 0.5 >= i64 +0.5 * 1 * i64 +0.5 * 1 <= f32 0.5 * 1 > i32 -0.5 * f32 / i64 +0.5 * 1 not in array +0.5 * f32 * f32 +0.5 * f32 * i32 +0.5 * f32 + f32 +0.5 * f32 - f64 +0.5 * f32 / half(1) 0.5 * f32 == i32 -0.5 * f64 * f64 -0.5 * f64 + i64 -0.5 * f64 > i -0.5 * f64 >= i -0.5 * f64 >= i64 -0.5 * i - i -0.5 * i / i64 -0.5 * i / i64 ^ 0.5 -0.5 * i == f32 -0.5 * i32 < i32 -0.5 * i32 in [f64] -0.5 * i64 != f32 -0.5 * i64 != i -0.5 * i64 + f32 -0.5 * i64 <= i64 -0.5 ** 0.5 != i -0.5 ** 0.5 ** f32 -0.5 ** 0.5 / f32 -0.5 ** 0.5 / i -0.5 ** 0.5 < i / i32 -0.5 ** 0.5 == f32 -0.5 ** 0.5 == i32 -0.5 ** 1 + i64 -0.5 ** 1 / f32 -0.5 ** f32 < 1 / f64 -0.5 ** f32 < i -0.5 ** f32 < i32 -0.5 ** f32 < min(i64) -0.5 ** f32 == f64 -0.5 ** f32 ^ f32 -0.5 ** f32 ^ i64 -0.5 ** f64 * f32 -0.5 ** f64 + -i -0.5 ** i * 0.5 ** i -0.5 ** i < f32 -0.5 ** i <= i32 -0.5 ** i > f32 -0.5 ** i ^ f64 -0.5 ** i32 != f64 -0.5 ** i32 <= i32 -0.5 ** i32 ^ f32 -0.5 ** i64 != f32 -0.5 ** i64 - f32 -0.5 ** i64 - i64 -0.5 ** i64 ^ min(i) -0.5 + 0.5 != i32 -0.5 + 0.5 - f32 -0.5 + 0.5 - i64 -0.5 + 0.5 < 1 ? f32 : score -0.5 + 0.5 <= f32 -0.5 + 0.5 == f64 -0.5 + 0.5 > i64 -0.5 + 0.5 >= i64 -0.5 + 1 != i -0.5 + 1 < f32 -0.5 + 1 >= i -0.5 + f32 != i -0.5 + f32 != i + i64 -0.5 + f32 >= i -0.5 + f64 == i32 -0.5 + f64 > f64 -0.5 + i > f32 -0.5 + i32 + i64 -0.5 + i32 < f32 -0.5 + i64 + f64 -0.5 + i64 < f64 -0.5 + i64 <= 0.5 + 1 -0.5 + i64 == i32 -0.5 + i64 >= i64 -0.5 - 0.5 != i64 -0.5 - 0.5 + i32 -0.5 - 0.5 - f64 -0.5 - 0.5 < 0.5 * f32 -0.5 - 0.5 == f32 -0.5 - 1 != i ? "foo" : div -0.5 - 1 + f32 -0.5 - 1 - f64 -0.5 - 1 <= i32 -0.5 - 1 <= i64 -0.5 - f32 + i -0.5 - f64 <= i32 -0.5 - i - i32 -0.5 - i > f64 -0.5 - i > i -0.5 - i32 + 0.5 ^ i -0.5 - i32 + f32 -0.5 - i32 < i -0.5 - i32 <= i64 -0.5 - i64 == f64 -0.5 - i64 > f32 -0.5 - i64 >= f64 -0.5 - i64 >= i -0.5 / 0.5 != i32 -0.5 / 0.5 / i -0.5 / 0.5 / i32 -0.5 / 0.5 < i -0.5 / 0.5 == i -0.5 / 0.5 >= i32 -0.5 / 0.5 >= min(i32) -0.5 / 1 != i32 == nil -0.5 / 1 - i -0.5 / 1 < f32 -0.5 / 1 < i32 -0.5 / 1 == i64 -0.5 / 1 > 1 ** 0.5 -0.5 / f32 != i32 +0.5 * f32 > i +0.5 * f64 != i64 +0.5 * f64 < i +0.5 * f64 <= i +0.5 * i + i +0.5 * i + mean(array) +0.5 * i - i32 +0.5 * i == 0.5 ? ok : ok +0.5 * i32 / f32 +0.5 * i64 < f64 +0.5 * i64 == 1 ** i64 +0.5 ** 0.5 != i64 +0.5 ** 0.5 * max(1) +0.5 ** 0.5 ** i64 +0.5 ** 0.5 + -f32 +0.5 ** 0.5 < f64 +0.5 ** 0.5 == i +0.5 ** 0.5 ^ f32 +0.5 ** 0.5 not in array +0.5 ** 1 != i +0.5 ** 1 != i32 +0.5 ** 1 - f64 +0.5 ** 1 / f64 +0.5 ** 1 / i32 +0.5 ** 1 ^ i64 +0.5 ** f32 + f32 / i64 +0.5 ** f32 <= f32 +0.5 ** f32 ^ i +0.5 ** f64 * f64 +0.5 ** f64 > f64 ? 1 : nil +0.5 ** f64 >= i64 +0.5 ** i / i +0.5 ** i > i +0.5 ** i32 * i32 +0.5 ** i32 > f64 +0.5 ** i32 >= mean(array) +0.5 + 0.5 != i +0.5 + 0.5 == i32 +0.5 + 0.5 > f32 +0.5 + 1 != f64 +0.5 + 1 + i32 +0.5 + 1 - i32 +0.5 + 1 < float(1) +0.5 + 1 == f32 +0.5 + f32 - i64 +0.5 + f32 <= ceil(f32) +0.5 + f32 <= i32 +0.5 + f32 > f32 +0.5 + f64 != i64 +0.5 + f64 <= i32 +0.5 + f64 == 1 / 0.5 +0.5 + i + i +0.5 + i > i64 +0.5 + i in array +0.5 + i32 - i64 +0.5 + i32 <= f32 +0.5 + i64 - i +0.5 + i64 > i64 * 0.5 +0.5 - 0.5 - i32 +0.5 - 0.5 >= f32 +0.5 - 0.5 >= i +0.5 - 0.5 >= i32 +0.5 - 1 + i +0.5 - 1 + i / i +0.5 - 1 <= f64 +0.5 - f32 != i64 +0.5 - f32 >= i64 +0.5 - f64 - f32 +0.5 - f64 < i +0.5 - f64 in array +0.5 - i != i64 +0.5 - i + i +0.5 - i > f32 +0.5 - i32 != f32 +0.5 - i64 + -f64 +0.5 - i64 == i +0.5 - i64 not in array +0.5 / 0.5 + i +0.5 / 0.5 - i +0.5 / 0.5 - i32 +0.5 / 0.5 - i64 +0.5 / 0.5 / half(0.5) +0.5 / 0.5 < i32 +0.5 / 0.5 == i64 +0.5 / 0.5 >= f32 +0.5 / 0.5 >= f64 +0.5 / 1 * i +0.5 / 1 / f64 +0.5 / 1 < f64 +0.5 / 1 == i +0.5 / 1 > f32 +0.5 / 1 >= i32 +0.5 / 1 not in array 0.5 / f32 * f64 -0.5 / f64 / i -0.5 / f64 <= f64 -0.5 / f64 == i -0.5 / f64 == i64 -0.5 / f64 >= f64 ^ 1 -0.5 / i < f64 ? i64 : i64 +0.5 / f64 + f64 +0.5 / f64 - i +0.5 / f64 / f64 +0.5 / f64 < i +0.5 / f64 == f32 +0.5 / i != i64 +0.5 / i * i64 +0.5 / i / i32 0.5 / i <= i -0.5 / i == i64 - f32 -0.5 / i32 + i32 -0.5 / i32 < f32 +0.5 / i32 + i64 +0.5 / i32 > i ^ i +0.5 / i32 > i64 +0.5 / i32 >= f64 +0.5 / i64 != f64 +0.5 / i64 != i +0.5 / i64 != min(f32) 0.5 / i64 * i32 -0.5 < 0.5 == nil ? true : foo -0.5 < 0.5 || ok -0.5 < 1 and ok -0.5 < 1 or fromJSON("foo")?.Bar -0.5 < f32 ? map(list, i32) : i -0.5 < f64 != false ? f32 : score -0.5 < f64 ? list : greet -0.5 < f64 || ok -0.5 < i ? f64 : foo -0.5 < i32 or i32 == 1 -0.5 < i64 or ok -0.5 <= 0.5 and ok -0.5 <= 1 ? half : greet -0.5 <= array[i32] -0.5 <= f32 or ok -0.5 <= f64 and !true -0.5 <= f64 or ok -0.5 <= i == ok -0.5 <= i and nil == list -0.5 <= i32 and i < i64 -0.5 <= i64 && f64 >= f64 -0.5 == 0.5 ? score : i -0.5 == 1 == ok -0.5 == 1 == ok ? "foo" : div -0.5 == 1 or ok -0.5 == 1 || nil != score -0.5 == f32 ? score : i32 -0.5 == f64 && ok -0.5 == nil || div != score +0.5 < 0.5 ? f32 : array +0.5 < 0.5 ? foo : greet +0.5 < 1 == ok +0.5 < 1 || ok +0.5 < f32 && ok +0.5 < f32 || ok +0.5 <= f64 ? i : i64 +0.5 <= f64 || ok +0.5 == 1 and ok +0.5 == 1 || ok +0.5 == array[ok ? 0.5 : score] +0.5 == f32 and i64 == i32 +0.5 == f64 ? i : (false ? i : i64) +0.5 == f64 and i64 == 0.5 +0.5 == i or ok +0.5 == i32 and ok +0.5 == i64 and ok +0.5 == nil or "foo" endsWith "bar" +0.5 == nil or ok 0.5 == nil || ok -0.5 > 1 == ok -0.5 > 1 or ok -0.5 > f32 or !true -0.5 > f64 != ok -0.5 >= 0.5 == ok -0.5 >= 0.5 || ok -0.5 >= 1 != ok -0.5 >= 1 and ok -0.5 >= i32 && i > f32 -0.5 >= i64 and ok -0.5 ^ 0.5 != i32 -0.5 ^ 0.5 + i32 -0.5 ^ 0.5 / i -0.5 ^ 0.5 < f64 -0.5 ^ 0.5 > i -0.5 ^ 0.5 > i64 +0.5 > 0.5 == ok +0.5 > array[i64] +0.5 > f32 and ok +0.5 > i && 0.5 < i64 +0.5 > i64 ? -i : array +0.5 >= 0.5 ? array[i64] : f32 +0.5 >= 0.5 and ok +0.5 >= i && 1 < 0.5 +0.5 >= i32 == ok +0.5 >= i32 and ok +0.5 ^ 0.5 == f64 0.5 ^ 0.5 >= i32 -0.5 ^ 1 * f64 -0.5 ^ 1 * i -0.5 ^ 1 + i64 -0.5 ^ 1 - -i -0.5 ^ 1 / i -0.5 ^ 1 == f32 -0.5 ^ 1 == i32 -0.5 ^ f32 + i32 +0.5 ^ 0.5 >= i64 +0.5 ^ 1 ** i64 +0.5 ^ 1 - f32 +0.5 ^ 1 < f32 +0.5 ^ 1 < i +0.5 ^ 1 <= i32 +0.5 ^ 1 > f64 / 1 +0.5 ^ 1 >= i +0.5 ^ f32 * i +0.5 ^ f32 ** i64 0.5 ^ f32 <= i32 -0.5 ^ f32 > f64 ? array : nil -0.5 ^ f32 >= f64 -0.5 ^ f32 ^ i32 -0.5 ^ f64 - i32 -0.5 ^ f64 > f32 -0.5 ^ f64 >= f32 -0.5 ^ f64 >= f64 -0.5 ^ f64 >= i -0.5 ^ f64 ^ i64 -0.5 ^ i == i64 -0.5 ^ i >= i32 -0.5 ^ i32 * i -0.5 ^ i32 * score(i) -0.5 ^ i32 / i -0.5 ^ i32 == i -0.5 ^ i64 < i -0.5 ^ i64 <= f32 -0.5 ^ i64 == f64 -0.5 ^ i64 > f64 -0.5 ^ i64 > i +0.5 ^ f32 > i64 +0.5 ^ f32 >= i +0.5 ^ f64 - i64 +0.5 ^ f64 / f32 +0.5 ^ f64 < f32 +0.5 ^ f64 > i32 +0.5 ^ i != f64 +0.5 ^ i * reduce(array, i) +0.5 ^ i ** floor(0.5) +0.5 ^ i / (0.5 + i32) +0.5 ^ i < -f64 +0.5 ^ i <= i32 +0.5 ^ i >= i64 +0.5 ^ i32 * reduce(list, f64) +0.5 ^ i32 ** f32 +0.5 ^ i32 < f32 ? ok : i32 +0.5 ^ i32 == i64 +0.5 ^ i32 ^ f64 +0.5 ^ i32 in array +0.5 ^ i64 * i +0.5 ^ i64 ** i +0.5 ^ i64 ** i64 0.5 ^ i64 > i32 -0.5 ^ i64 >= f32 -1 != 1 != hasPrefix("bar", "bar") -1 != array[i - 1] -1 != f32 && i32 <= 0.5 -1 != f32 == ok -1 != f32 ? i64 : foo -1 != f32 and i in array -1 != f64 != ok -1 != i32 ? score : greet -1 != i64 && ok -1 != i64 ? f32 : greet +0.5 in array != ok +0.5 in array && ok +1 != 0.5 != ok +1 != 0.5 and 1 == 1 +1 != 1 && ok +1 != 1 ? f64 : 0.5 > i +1 != 1 ? list : score +1 != f32 != ok +1 != f32 ? ok : half +1 != i or ok +1 != i64 ? add : div 1 != nil && ok -1 != nil ? half : foo -1 % 1 != f64 -1 % 1 * f32 -1 % 1 < f32 -1 % 1 > f32 -1 % 1 > i -1 % 1 >= i64 -1 % i / i32 -1 % i < f64 +1 != nil == ok +1 != nil or not false +1 % 1 != i +1 % 1 != i32 +1 % 1 % i +1 % 1 / f32 +1 % 1 / i32 +1 % 1 < f64 +1 % 1 < i +1 % 1 == f64 +1 % 1 == i ? nil : 0.5 +1 % 1 == i32 +1 % array[i32] +1 % array[i] +1 % i != -i64 +1 % i != 1 != nil +1 % i - i64 1 % i < i32 -1 % i == f32 -1 % i32 * i64 -1 % i32 < max(i64) -1 % i64 != f32 -1 % i64 * f64 -1 % i64 + f32 -1 % i64 .. i64 -1 % i64 <= i64 +1 % i >= f64 +1 % i >= i +1 % i not in array +1 % i32 != i +1 % i32 <= f32 +1 % i32 > i64 +1 % i32 >= f64 +1 % i64 - f32 +1 % i64 < score(i) 1 % i64 > f32 -1 % i64 > i32 -1 * 0.5 + i -1 * 0.5 - -i -1 * 0.5 <= f32 -1 * 0.5 > f32 -1 * 1 % i -1 * 1 + i32 -1 * 1 <= f64 -1 * array[i64] -1 * f32 < i -1 * f32 < i32 -1 * f32 <= i32 -1 * f64 * -i -1 * f64 * f32 -1 * f64 + i -1 * i % i -1 * i + f32 -1 * i < int(1) -1 * i <= 1 % 1 -1 * i > f32 +1 * 0.5 + f64 +1 * 0.5 + i32 +1 * 0.5 + round(f64) +1 * 0.5 / i +1 * 0.5 / i64 +1 * 0.5 < i64 +1 * 0.5 == f32 +1 * 0.5 >= f32 +1 * 1 - i32 +1 * 1 <= int(i) +1 * 1 >= f32 +1 * f32 != f64 - 0.5 +1 * f32 <= reduce(array, #) +1 * f32 >= f64 +1 * f64 * i64 +1 * f64 <= i64 +1 * f64 > i +1 * f64 >= f64 +1 * i * f32 +1 * i - i32 +1 * i / f64 +1 * i < f32 +1 * i > i32 1 * i not in array -1 * i32 % i64 -1 * i32 * i32 -1 * i32 / i32 -1 * i32 > f32 -1 * i64 + f64 -1 * i64 == i32 -1 * i64 > i64 -1 ** 0.5 * f64 -1 ** 0.5 - i -1 ** 0.5 > i32 +1 * i32 + i32 +1 * i32 - i +1 * i32 < i +1 * i64 * f32 +1 * i64 + i +1 * i64 - f64 +1 * i64 / f64 +1 * i64 <= f64 +1 * i64 in array +1 ** 0.5 * i +1 ** 0.5 ** f32 +1 ** 0.5 ** f64 +1 ** 0.5 ** i64 +1 ** 0.5 - f32 +1 ** 0.5 - i32 +1 ** 0.5 - i64 +1 ** 0.5 < -f32 +1 ** 0.5 > i +1 ** 0.5 > i64 1 ** 0.5 ^ f64 -1 ** 1 != i -1 ** 1 != i64 -1 ** 1 - i -1 ** 1 / i64 -1 ** 1 < i64 -1 ** 1 == i32 +1 ** 1 ** f64 +1 ** 1 + f64 +1 ** 1 + i64 +1 ** 1 - round(0.5) +1 ** 1 / f64 +1 ** 1 < f32 +1 ** 1 == 0.5 + i32 1 ** 1 >= i -1 ** f32 != i64 -1 ** f32 / i -1 ** f64 != i64 -1 ** f64 ** i64 -1 ** f64 + i -1 ** f64 / f32 -1 ** f64 < i -1 ** i != i -1 ** i ** i64 -1 ** i < f64 -1 ** i < i32 -1 ** i > f64 -1 ** i32 ** (1 / 1) -1 ** i32 == i -1 ** i32 > i -1 ** i64 ** f64 -1 ** i64 - f64 -1 + 0.5 != i -1 + 0.5 <= f64 / f32 -1 + 0.5 <= i32 -1 + 1 - i32 +1 ** 1 >= i32 +1 ** 1 ^ i +1 ** 1 ^ i32 +1 ** 1 in array +1 ** array[i32] +1 ** f32 / i32 +1 ** f32 / i64 +1 ** f32 <= f32 +1 ** f32 <= i64 +1 ** f32 == i64 ? i32 : array +1 ** f32 >= f32 +1 ** f32 >= i +1 ** f32 ^ f32 +1 ** f32 ^ i64 +1 ** i + i32 +1 ** i >= i +1 ** i32 != i32 +1 ** i32 + f32 +1 ** i32 + i64 +1 ** i64 <= f32 +1 ** i64 <= f64 +1 ** i64 <= i32 +1 ** i64 > f32 +1 + 0.5 != i32 +1 + 0.5 + i +1 + 0.5 - i64 +1 + 0.5 < f32 +1 + 0.5 < i +1 + 0.5 == f64 +1 + 0.5 == f64 != nil +1 + 0.5 > i64 +1 + 0.5 not in array +1 + 1 != 0.5 ? 0.5 : half +1 + 1 - f32 +1 + 1 - i 1 + 1 < i -1 + 1 == f64 -1 + 1 == i64 -1 + 1 >= i64 -1 + f32 != i -1 + f32 > i -1 + f64 != f64 -1 + f64 - i -1 + f64 >= i32 +1 + 1 == f64 * i64 +1 + 1 > f32 +1 + 1 >= half(0.5) +1 + 1 >= i +1 + f32 != i32 +1 + f32 < i32 +1 + f32 <= i +1 + f32 > i64 +1 + f64 == i64 +1 + f64 >= f64 +1 + i .. i32 +1 + i <= ceil(f32) 1 + i <= f64 -1 + i in map(list, i32) -1 + i32 - i64 -1 + i32 < i -1 + i64 >= f32 -1 - 0.5 != half(0.5) +1 + i >= min(i64) +1 + i32 != i32 +1 + i32 - f64 +1 + i32 < f32 +1 + i32 < i32 +1 + i32 <= f64 +1 + i32 > reduce(array, #) +1 + i32 >= f64 +1 + i64 != i32 +1 + i64 != i64 +1 + i64 < i32 +1 + i64 <= i64 +1 - 0.5 != f32 1 - 0.5 + i -1 - 0.5 + i32 -1 - 0.5 - i64 -1 - 0.5 <= f64 -1 - 0.5 == i64 -1 - 1 .. i64 -1 - 1 < i64 +1 - 0.5 - f32 +1 - 0.5 <= i32 +1 - 0.5 <= i64 +1 - 1 < i64 ? 0.5 : "foo" +1 - 1 <= i32 + i64 1 - 1 == f64 -1 - 1 > -f32 -1 - f32 != i -1 - f32 <= f64 -1 - f32 <= i32 -1 - f64 - f32 -1 - f64 - f64 -1 - f64 < i64 +1 - 1 > i32 / i32 +1 - f32 != f32 +1 - f32 <= i64 +1 - f64 != f32 +1 - f64 + f32 +1 - f64 + i - 0.5 1 - f64 <= i -1 - i .. i64 -1 - i < min(f64) -1 - i32 < f64 -1 - i32 <= f64 -1 - i32 <= i32 -1 - i32 >= f64 -1 - i64 + i -1 - i64 - f32 -1 .. 1 == list -1 .. array[i] -1 .. i == list -1 .. i64 == list -1 / 0.5 + f64 -1 / 0.5 - array[i64] -1 / 0.5 < f64 -1 / 1 + -0.5 -1 / 1 + i32 -1 / 1 - -0.5 -1 / 1 / f64 -1 / 1 < f32 -1 / 1 <= f32 -1 / 1 <= i -1 / 1 == f64 -1 / 1 == i -1 / 1 == i32 -1 / 1 > f32 -1 / 1 > i64 -1 / f32 + -1 -1 / f64 * i -1 / f64 * i32 -1 / f64 + i32 -1 / f64 / f32 -1 / f64 == f32 -1 / f64 == i -1 / f64 > i -1 / i * i -1 / i < f64 ? ok : add -1 / i32 <= f32 -1 / i32 == i -1 / i32 == i64 -1 / i32 > i -1 / i64 + i64 -1 / i64 == i64 -1 / i64 > i -1 / i64 >= i32 -1 < array[i64] -1 < f64 != ok -1 < i32 and 1 == nil -1 < i64 ? "foo" not endsWith "foo" : i -1 <= 0.5 and i32 == 1 -1 <= 0.5 || ok -1 <= 1 && greet != greet -1 <= 1 and ok -1 <= f32 != ok -1 <= f32 == !ok -1 <= f64 ? add : f64 -1 <= i64 or nil == f32 -1 == array[i] -1 > 0.5 != ok -1 > 1 and ok -1 > 1 || ok -1 > f32 and ok -1 > f64 == ok -1 > f64 and ok -1 > i32 == ok -1 > i64 || i32 < i -1 >= 1 || ok -1 >= i || ok -1 >= i64 or nil in list -1 ^ 0.5 - f32 -1 ^ 0.5 <= f32 -1 ^ 0.5 <= i64 -1 ^ 0.5 ^ i32 -1 ^ 1 - f64 -1 ^ 1 - i32 -1 ^ 1 - i64 -1 ^ 1 / f32 -1 ^ 1 < f32 -1 ^ 1 < i64 / f32 -1 ^ 1 <= 1 ** f64 -1 ^ 1 == f64 -1 ^ 1 >= f32 -1 ^ 1 >= i64 -1 ^ f32 == i64 -1 ^ f32 > max(f32) -1 ^ f64 != i32 -1 ^ f64 * f32 -1 ^ f64 ** f64 -1 ^ i != findLast(array, false) -1 ^ i != i -1 ^ i * f64 -1 ^ i < i32 -1 ^ i <= f32 -1 ^ i == abs(1) -1 ^ i32 + i -1 ^ i32 < i -1 ^ i32 < i64 +1 - f64 in array +1 - f64 not in array +1 - i > f64 +1 - i > i +1 - i > i32 +1 - i >= i64 +1 - i not in array +1 - i32 < i32 +1 - i32 < i64 +1 - i32 == i32 +1 - i64 <= i32 +1 .. i != list +1 / 0.5 <= abs(f32) +1 / 0.5 <= i32 +1 / 0.5 == f64 +1 / 0.5 > f32 +1 / 0.5 >= i +1 / 0.5 >= i - i +1 / 0.5 >= i32 +1 / 1 != i32 +1 / 1 * f32 +1 / 1 <= f64 +1 / 1 in array +1 / f32 != f64 +1 / f32 / i64 +1 / f32 <= f32 +1 / f32 <= f64 +1 / f32 == i32 +1 / f32 == i32 / i +1 / f32 > f32 +1 / f32 >= f64 +1 / f64 + f64 +1 / f64 < f32 +1 / f64 == f64 +1 / i * f32 +1 / i / f64 +1 / i < i +1 / i == f64 +1 / i >= i32 +1 / i in map(list, 1) +1 / i32 > f32 +1 / i32 >= i64 +1 / i64 * i +1 / i64 > f32 / f64 +1 / i64 > f64 +1 / i64 >= f64 +1 < 1 == ok +1 < 1 and ok +1 < array[get(array, i32)] +1 < array[i32] +1 < f32 != not true +1 < f64 || ok +1 < i ? array : foo +1 < i32 || 1 >= f32 +1 < i64 == ok +1 < i64 ? ok : list +1 <= 1 == ok +1 <= 1 || add == add +1 <= f32 && ok +1 <= f64 || ok +1 <= i32 ? foo : f32 +1 == 0.5 ? i32 : greet +1 == 0.5 and ok +1 == 1 || ok +1 == f64 && 0.5 != nil +1 == f64 || ok +1 == i32 && ok +1 == i32 == ok +1 == i64 == ok +1 == nil ? ok : half +1 > 0.5 == ok +1 > array[i64] +1 > f32 && ok +1 > f32 == reduce(array, ok) +1 > f64 != ok +1 > i == ok +1 > i64 or i != 1 +1 >= 1 != (nil not in list) +1 >= f32 ? i64 : half +1 >= f64 ? ok : half +1 >= i and ok +1 ^ 0.5 != f32 +1 ^ 0.5 != i +1 ^ 0.5 ** f32 +1 ^ 0.5 ** i32 +1 ^ 0.5 - i32 +1 ^ 0.5 < i32 +1 ^ 0.5 <= f64 +1 ^ 0.5 == i +1 ^ 0.5 ^ f32 +1 ^ 0.5 ^ i64 +1 ^ 1 != f64 +1 ^ 1 != i64 +1 ^ 1 ** i +1 ^ 1 + f64 +1 ^ 1 / i +1 ^ 1 < i +1 ^ 1 < i64 +1 ^ 1 >= i +1 ^ 1 >= i32 +1 ^ f32 < i32 +1 ^ f32 <= f64 +1 ^ f64 / f64 +1 ^ f64 == f32 +1 ^ f64 > f32 +1 ^ f64 >= 1 / f64 +1 ^ i != i * f32 +1 ^ i - i32 +1 ^ i < i +1 ^ i32 * i32 +1 ^ i32 ** i64 +1 ^ i32 / i 1 ^ i32 >= i32 -1 ^ i64 ** f64 -1 ^ i64 ** i32 -1 ^ i64 + i -1 ^ i64 <= i -1 ^ i64 <= i32 +1 ^ i32 >= i64 +1 ^ i64 * i64 +1 ^ i64 ** reduce(list, 1) +1 ^ i64 - i64 +1 ^ i64 / f64 1 ^ i64 > i -1 ^ i64 >= i64 +1 ^ i64 >= i32 + i32 +1 in array ? f32 : foo [!false] [!ok] -["foo" != nil] -["foo" endsWith "bar"] +[!true] +["bar" + "foo"] +["bar" < "bar"] +["bar" not contains "bar"] [-0.5] +[-1] [-f32] [-f64] -[-i32] -[-i64, add] [-i64] -[0.5 * 1] -[0.5 + 0.5] -[0.5 / i] -[0.5 <= f64] -[0.5 <= i, -1] -[0.5 >= i] -[0.5 ^ 1] +[0.5 != f32] +[0.5 != i] +[0.5 * 0.5] +[0.5 * f32] +[0.5 ** i] +[0.5 - 0.5] +[0.5 - i] +[0.5 / i32] +[0.5 <= i32, half] +[0.5 > 1] +[0.5 > f32] +[0.5 > i64] +[0.5 >= f64] +[0.5 ^ 0.5] [1 != 1] -[1 % 1, !true] -[1 < 0.5] +[1 * 0.5] +[1 ** 0.5] +[1 + i64, add] +[1 == i64] [1 == i] -[abs(0.5)] -[add != div] -[add == nil] -[add, array] +[[f32]] +[add != nil] +[add, add] [add, f32] -[add, f64] -[add, greet] -[add, half] -[add, i64] -[add, score] -[add, toJSON(array)] +[add, i] [add] -[array == list] +[all(list, false)] +[any(list, ok)] +[array, add] +[array, array] [array, f32] -[array, f64] [array, greet] -[array, half] +[array, i64] +[array, i] [array, list] -[array, ok] -[array, score] -[array[1]] -[array[i64]] +[array, ok, add] +[array, string(nil)] [array] -[div == half] -[div, f32] -[div, greet] -[div, map(list, half)] -[div, ok] -[div, score] +[bitnot(1)] +[ceil(i32)] +[div(1, 1)] +[div, add] +[div, foo] +[div, i32] +[div, i64, array] [div] -[f32 + 1] -[f32 - 0.5] -[f32 < i] -[f32 ^ 0.5] -[f32 ^ f64] +[f32 * i] +[f32 + f64] +[f32 >= i] [f32, f64] -[f32, half] -[f32, max(f64)] +[f32, foo, greet] +[f32, greet] +[f32, i32] +[f32, list] +[f32, ok] +[f32, score] [f32] -[f64 != 1] -[f64 != i32] -[f64 * f64] +[f64 + f64] +[f64 / f64] +[f64 < 0.5] [f64 < f32] -[f64 >= 1] +[f64 < i64] +[f64 <= 1] +[f64 in array] +[f64, add] [f64, f64] -[f64, foo] -[f64, i32] +[f64, half] [f64, i64] -[f64, list] -[f64, score] [f64] -[false ? f64 : f32] -[findIndex(array, true)] -[first(array)] -[float(i64)] +[f64] == array +[find(array, true)] +[findIndex(list, false)] +[findLast(list, ok)] +[float(0.5)] +[float(1)] [foo, add] -[foo, f32] -[foo, foo] +[foo, array] +[foo, half] [foo, i] -[foo, list] +[foo, ok] +[foo, reduce(array, #)] +[foo.Bar] [foo.Qux] -[foo.String(), greet] -[foo.String()] +[foo?.Bar, f32, f64] +[foo?.Bar, i32] [foo?.Bar] [foo?.Qux] +[foo?.String()] [foo] +[greet != nil] +[greet, array] [greet, div] -[greet, f32 ^ 0.5] -[greet, f32] -[greet, f64] +[greet, foo] +[greet, greet] [greet, half] -[greet, i32] [greet, i64] [greet, list] [greet] +[greet] == list +[groupBy(array, "bar")] +[groupBy(array, #), half] +[groupBy(array, #)] +[groupBy(array, f64)] +[groupBy(list, #)?.Qux] +[half(0.5)] +[half(f64)] +[half(i64 ^ 1)] +[half, array] [half, div] -[half, foo] -[half, greet] +[half, f64] +[half, i64 < f64] +[half, list] [half] [i != i64] -[i != i] -[i - 1] [i .. 1] -[i / 0.5] -[i < f32] -[i > f64] -[i, add] -[i, half] -[i32 * 1] -[i32 <= 0.5] -[i32 == 0.5] +[i / i] +[i < i64, score] +[i <= 0.5] +[i == i32] +[i >= i32] +[i ^ 1] +[i, array, list] +[i, array] +[i, greet("bar")] +[i, greet] +[i, i32] +[i, i] +[i, list] +[i32 < i] [i32 > 1] -[i32 > f32] -[i32, i] -[i32, score] +[i32, -1] +[i32, div] +[i32, f64] +[i32, i32] +[i32, list] +[i32, type(greet)] [i32] +[i64 != f64] +[i64 + 0.5] [i64 / f64] -[i64 == i32] +[i64 <= i64] [i64 >= 1] -[i64 ^ i, i32] -[i64, add] +[i64 ^ 1] [i64, div] [i64, foo] -[i64, i32] -[i64, ok] +[i64, half] +[i64, score] [i64] -[i64] == array [i] -[int(1)] -[len(array)] -[list == list] +[list != nil] [list, div] -[list, f64] +[list, f32] +[list, greet] +[list, half] [list, i] +[list, ok] [list] [map(array, #)] -[map(array, 1 >= i32)] +[map(array, add)] +[map(array, f64)] [map(array, foo)] -[map(list, #)] -[map(list, half)] -[map(list, ok)] [max(1)] -[max(i32)] -[min(0.5)] -[min(f64)] -[min(i32)] -[nil != ok, foo] -[nil == 0.5] -[nil not in list] +[nil != 0.5] [not false] -[not ok] -[not true] -[ok && ok] +[ok ? 1 : greet] [ok, f32] [ok, half] -[ok, score] +[ok, i64] +[ok, i] +[ok, list, 0.5] == list +[ok, ok] [ok] -[score != add] -[score(1)] -[score(i)] -[score, array, foo] +[reduce(array, foo)] +[reduce(list, #)] +[reduce(list, div)] +[score == nil] +[score, div] [score, f32] [score, f64] [score, greet] +[score, half] +[score, one(array, # > i32)] +[score, score] [score] -[string(0.5), foo] -[string(f64)] -[string(i32)] -[toJSON(1)] -[toJSON(nil)] -[type(0.5)] +[string(0.5)] +[string(1)] +[string(foo)] +[string(i)] +[string(i64)] +[toJSON(list)] +[trimPrefix("bar")] +[true ? add : f64] +[true and ok] +[true || ok] [type(1)] [type(add)] -[type(false)] -[type(i32)] -[{"foo": foo}] +[type(div)] +[type(greet)] +[type(nil)] abs(-0.5) abs(-1) abs(-f32) @@ -2377,159 +2571,153 @@ abs(-i32) abs(-i64) abs(0.5 * 0.5) abs(0.5 * 1) -abs(0.5 * f64) -abs(0.5 * i32) +abs(0.5 * i) abs(0.5 * i64) abs(0.5 ** 0.5) abs(0.5 ** 1) -abs(0.5 ** f32) -abs(0.5 ** f64) -abs(0.5 ** i64) +abs(0.5 ** i32) abs(0.5 + 0.5) +abs(0.5 + 1) abs(0.5 + f32) abs(0.5 + i) abs(0.5 + i64) abs(0.5 - 0.5) -abs(0.5 - f32) +abs(0.5 - 1) abs(0.5 - i) +abs(0.5 - i32) abs(0.5 - i64) abs(0.5 / 0.5) abs(0.5 / 1) -abs(0.5 / f32) abs(0.5 / f64) -abs(0.5 / i) -abs(0.5 / i64) abs(0.5 ^ 0.5) abs(0.5 ^ 1) -abs(0.5 ^ f64) -abs(0.5 ^ i32) -abs(0.5) * i -abs(0.5) - i -abs(0.5) - i64 -abs(0.5) / i32 -abs(0.5) < f32 -abs(0.5) == i32 -abs(0.5) > f32 -abs(0.5) >= f32 -abs(0.5) >= i -abs(0.5) >= i32 -abs(0.5) ^ f64 -abs(1 % 1) -abs(1 % i) -abs(1 * 0.5) -abs(1 * 1) +abs(0.5 ^ f32) +abs(0.5) - i32 +abs(0.5) / f32 +abs(0.5) < f64 +abs(0.5) < i32 +abs(0.5) <= i64 +abs(0.5) == -0.5 +abs(0.5) == half(1) +abs(0.5) > i32 +abs(0.5) >= f64 +abs(0.5) ^ i64 +abs(0.5) not in array abs(1 * f32) +abs(1 * f64) +abs(1 * i32) +abs(1 ** 0.5) abs(1 ** 1) abs(1 ** i) abs(1 + 1) -abs(1 + f64) +abs(1 + i) +abs(1 + i64) abs(1 - 0.5) -abs(1 - i) -abs(1 - i32) +abs(1 - 1) +abs(1 - i64) abs(1 / 0.5) abs(1 / 1) -abs(1 / f32) -abs(1 / f64) +abs(1 / i) abs(1 / i32) -abs(1 / i64) -abs(1 ^ 0.5) -abs(1 ^ 1) -abs(1 ^ f64) -abs(1) * f64 -abs(1) * i -abs(1) ** f64 -abs(1) + f64 -abs(1) + i -abs(1) - f64 +abs(1 ^ f32) +abs(1 ^ i) +abs(1 ^ i32) +abs(1) - i32 abs(1) .. i -abs(1) / f32 -abs(1) < f32 -abs(1) < i -abs(1) == f64 ? 1 : foo -abs(1) > i -abs(1) ^ f32 -abs(1) ^ i32 +abs(1) / f64 +abs(1) / i64 +abs(1) < i64 +abs(1) <= i32 +abs(1) == i32 +abs(1) >= i +abs(1) ^ f64 abs(abs(0.5)) abs(abs(1)) -abs(abs(abs(i))) -abs(abs(f32)) abs(abs(f64)) -abs(abs(i)) abs(abs(i32)) abs(abs(i64)) -abs(array[1]) -abs(array[i]) -abs(count(list, true)) +abs(add(i, 1)) +abs(bitand(i64, i32)) +abs(bitnand(i64, i)) +abs(bitnot(1)) +abs(bitnot(i)) +abs(bitnot(i32)) +abs(bitnot(i64)) +abs(bitushr(1, 1)) +abs(ceil(0.5)) +abs(ceil(1)) +abs(ceil(f32)) +abs(ceil(i)) +abs(ceil(i32)) +abs(ceil(i64)) +abs(count(array, ok)) +abs(count(array, true)) +abs(count(list, false)) +abs(div(i, i)) abs(f32 * 0.5) -abs(f32 * 1) -abs(f32 * f64) -abs(f32 ** 0.5) abs(f32 ** 1) +abs(f32 ** f32) abs(f32 ** i32) abs(f32 + 0.5) abs(f32 + 1) -abs(f32 + f32) -abs(f32 + f64) abs(f32 + i) abs(f32 + i32) abs(f32 - 0.5) abs(f32 - 1) -abs(f32 - f32) +abs(f32 - i32) +abs(f32 - i64) +abs(f32 / 0.5) abs(f32 / 1) abs(f32 / f32) abs(f32 / f64) abs(f32 / i32) -abs(f32 ^ 1) -abs(f32 ^ f64) -abs(f32 ^ i32) +abs(f32 ^ i) abs(f32 ^ i64) abs(f32) -abs(f32) != i64 / i64 -abs(f32) * i32 -abs(f32) + i32 -abs(f32) <= i64 -abs(f32) == i -abs(f32) ^ f64 -abs(f64 * 1) +abs(f32) ** f32 +abs(f32) ** i +abs(f32) + i64 +abs(f32) - i32 +abs(f32) / f64 +abs(f32) < f64 +abs(f32) >= 0.5 / 1 +abs(f32) ^ f32 abs(f64 * f32) -abs(f64 * i32) +abs(f64 * f64) abs(f64 ** 1) -abs(f64 ** f32) -abs(f64 ** i32) abs(f64 + 0.5) abs(f64 + 1) -abs(f64 + i32) -abs(f64 + i64) -abs(f64 - 0.5) +abs(f64 + f64) abs(f64 - 1) abs(f64 - f32) -abs(f64 - i32) abs(f64 / 0.5) +abs(f64 / 1) abs(f64 / f64) abs(f64 / i) -abs(f64 / i64) -abs(f64 ^ i32) +abs(f64 ^ 0.5) +abs(f64 ^ f32) +abs(f64 ^ i) +abs(f64 ^ i64) abs(f64) -abs(f64) * i64 -abs(f64) - f32 -abs(f64) - i64 - i32 -abs(f64) / i -abs(f64) / i64 -abs(f64) < f64 -abs(f64) <= abs(i32) -abs(f64) <= i -abs(f64) <= i32 -abs(f64) == i -abs(false ? 1 : f32) -abs(false ? f64 : 0.5) -abs(false ? false : i64) -abs(findIndex(array, # > i32)) -abs(findIndex(array, ok)) -abs(findIndex(array, true)) +abs(f64) + f32 +abs(f64) + f64 +abs(f64) + i32 +abs(f64) + i64 / i +abs(f64) - i +abs(f64) < i32 +abs(f64) <= f64 +abs(f64) > i64 +abs(f64) ^ f32 +abs(f64) ^ i64 +abs(f64) in array +abs(false ? f32 : 1) +abs(false ? half : 0.5) +abs(false ? list : 1) +abs(find(array, ok)) +abs(find(array, true)) +abs(findIndex(list, ok)) abs(findIndex(list, true)) abs(findLastIndex(array, ok)) -abs(findLastIndex(array, true)) -abs(findLastIndex(list, ok)) abs(first(array)) abs(float(0.5)) abs(float(1)) @@ -2537,383 +2725,363 @@ abs(float(f32)) abs(float(f64)) abs(float(i)) abs(float(i32)) -abs(float(i64)) +abs(floor(0.5)) +abs(floor(f32)) +abs(floor(i32)) +abs(get(array, 1)) +abs(get(array, i)) abs(get(array, i32)) abs(get(array, i64)) abs(half(0.5)) +abs(half(1)) abs(half(f64)) -abs(i % i64) abs(i * 1) -abs(i * i) -abs(i * i32) -abs(i ** 0.5) +abs(i * f32) abs(i ** 1) +abs(i ** f32) abs(i ** i32) -abs(i + 1) -abs(i + i32) +abs(i + 0.5) +abs(i + f64) abs(i - 0.5) abs(i - 1) -abs(i / 1) +abs(i - f32) +abs(i - f64) +abs(i - i32) +abs(i / 0.5) +abs(i / f64) +abs(i / i) abs(i / i32) +abs(i / i64) abs(i ^ 0.5) -abs(i ^ f32) +abs(i ^ f64) +abs(i ^ i) abs(i ^ i32) +abs(i ^ i64) abs(i) -abs(i) != float(0.5) -abs(i) % i64 -abs(i) * f32 -abs(i) ** i -abs(i) ** max(1) -abs(i) / i64 -abs(i) <= i32 +abs(i) % i +abs(i) * i32 +abs(i) ** f32 +abs(i) + f64 +abs(i) - f32 +abs(i) .. i +abs(i) .. i32 +abs(i) / f32 +abs(i) < f64 abs(i) <= i64 -abs(i) > f64 +abs(i) == 0.5 / i +abs(i) > i64 +abs(i) ^ f64 +abs(i) ^ half(1) +abs(i) ^ i +abs(i) ^ i32 +abs(i32 % i32) abs(i32 % i64) -abs(i32 * 0.5) -abs(i32 * 1) +abs(i32 * f64) abs(i32 * i32) -abs(i32 * i64) abs(i32 ** 0.5) abs(i32 ** 1) -abs(i32 ** f64) -abs(i32 ** i) -abs(i32 ** i64) +abs(i32 ** i32) abs(i32 + 0.5) +abs(i32 + 1) abs(i32 + f64) +abs(i32 + i) abs(i32 + i32) -abs(i32 - 1) -abs(i32 - f32) -abs(i32 - f64) +abs(i32 - 0.5) abs(i32 - i64) -abs(i32 / 1) +abs(i32 / 0.5) abs(i32 / i) -abs(i32 / i32) -abs(i32 ^ 0.5) -abs(i32 ^ 1) -abs(i32 ^ i) -abs(i32 ^ i64) +abs(i32 / i64) abs(i32) -abs(i32) % i32 -abs(i32) ** i64 -abs(i32) / -f32 -abs(i32) < f32 -abs(i32) > min(i64, f64, i32) -abs(i32) ^ f64 -abs(i32) not in array -abs(i64 % 1) -abs(i64 % i32) -abs(i64 * 1) +abs(i32) != f64 +abs(i32) * f32 +abs(i32) * i +abs(i32) ** i +abs(i32) - i32 +abs(i32) / -1 +abs(i32) / i32 ** f64 +abs(i32) < i64 == false +abs(i32) <= i +abs(i32) <= i32 +abs(i32) == i32 +abs(i32) ^ i64 +abs(i32) in array +abs(i64 * 0.5) abs(i64 * f32) -abs(i64 * i) abs(i64 * i32) -abs(i64 * i64) abs(i64 ** 0.5) -abs(i64 ** 1) +abs(i64 ** f64) abs(i64 ** i64) abs(i64 + 0.5) abs(i64 + 1) +abs(i64 + f32) +abs(i64 + f64) abs(i64 + i) -abs(i64 + i32) -abs(i64 + i64) -abs(i64 - 1) -abs(i64 - f64) -abs(i64 - i32) +abs(i64 - 0.5) +abs(i64 - i) +abs(i64 / f32) abs(i64 / i32) -abs(i64 ^ i64) +abs(i64 ^ f64) +abs(i64 ^ i) +abs(i64 ^ i32) abs(i64) -abs(i64) != f64 -abs(i64) - f64 -abs(i64) - i64 -abs(i64) .. i64 -abs(i64) == f32 -abs(i64) == i -abs(i64) == i32 -abs(i64) == nil ? i : f64 -abs(i64) > i64 -abs(i64) >= f64 -abs(i64) in array +abs(i64) * i32 +abs(i64) ** i +abs(i64) + f32 +abs(i64) / i +abs(i64) > i32 +abs(i64) ^ i32 +abs(i64) not in array abs(int(0.5)) abs(int(1)) -abs(int(f32)) -abs(int(f64)) abs(int(i)) abs(int(i32)) abs(int(i64)) abs(last(array)) -abs(len("bar")) abs(len("foo")) -abs(len(array)) abs(len(list)) abs(max(0.5)) -abs(max(1)) -abs(max(1, 1)) -abs(max(1, i64, f64)) abs(max(f32)) abs(max(f64)) -abs(max(i)) abs(max(i32)) abs(max(i64)) +abs(mean(array)) +abs(median(array)) abs(min(0.5)) -abs(min(0.5, 1)) abs(min(1)) -abs(min(1, f32)) abs(min(f32)) abs(min(f64)) abs(min(i)) abs(min(i32)) -abs(min(i64)) abs(ok ? 1 : "foo") -abs(ok ? f32 : 1) -abs(ok ? i : "bar") +abs(ok ? f32 : 0.5) +abs(ok ? f32 : nil) +abs(ok ? f64 : ok) +abs(ok ? i32 : foo) +abs(reduce(array, #)) +abs(reduce(array, i)) +abs(reduce(list, 1)) +abs(reduce(list, i32)) +abs(round(0.5)) +abs(round(1)) +abs(round(f32)) +abs(round(i)) +abs(round(i64)) abs(score(1)) abs(score(i)) -abs(true ? f32 : "bar") -abs(true ? f64 : i32) +abs(sum(array)) +abs(true ? 1 : ok) add add != add +add != add == nil add != div -add != div ? foo : i64 -add != div and ok -add != foo.Qux -add != foo.String -add != foo?.Qux -add != foo?.String -add != greet -add != greet ? score : f32 -add != half -add != half == nil -add != half ? 0.5 : ok -add != nil == nil -add != nil ? "bar" : f32 -add != nil ? half : f32 -add != score +add != div != false +add != div == true +add != nil ? f64 : i64 +add != reduce(list, add) add == add -add == add == ok +add == add != nil +add == add == nil +add == add ? 1 : i64 add == div -add == div ? i32 : f64 -add == div or ok -add == foo.Qux -add == foo.String -add == foo?.Qux -add == foo?.String -add == greet -add == greet ? 1 : 1 -add == half -add == nil && ok -add == nil ? "foo" : list -add == nil ? add : half -add == nil ? add : score -add == nil ? i32 : div -add == nil ? score : i64 -add == nil || ok -add == score -add == score != true -add == score and i32 >= 1 -add == score or 0.5 < 1 -add in [div] -add not in sort(array) -add(1, 1) ** i -add(1, 1) ^ i -add(1, i) .. i64 -add(i, 1 - i32) -add(i, abs(i)) +add == div ? f64 : list +add == nil ? false : i32 +add == nil ? greet : i32 +add == nil ? nil : nil +add in sort(array) +add(1, i) < i +add(i, 1) ** f32 add(i, i) -add(i, i64 % 1) -add(i, min(i)) -add(min(1, 1), i32 * 1) -add(score(i, i), i) -all(1 .. i32, ok) -all(array, !(# <= #)) -all(array, !false) +add(i, i32 + 1) +all(1 .. i64, ok) +all(["bar"], # >= #) +all(["foo"], # not matches #) +all([false], # && false) +all([false], #) +all(array, !(# >= f64)) all(array, !ok) -all(array, !true or 0.5 < #) -all(array, "bar" in foo) -all(array, "bar" matches "bar") +all(array, !true) +all(array, "foo" < "bar") all(array, # != #) all(array, # != 1) all(array, # != f32) all(array, # != f64) -all(array, # != i64) +all(array, # != i32) all(array, # != nil) -all(array, # + # >= 0.5 + i) all(array, # < #) all(array, # < 0.5) all(array, # < 1) +all(array, # < f64) +all(array, # < i) +all(array, # < i64) all(array, # <= #) all(array, # <= 0.5) -all(array, # <= f64) all(array, # <= i) +all(array, # == # + #) all(array, # == #) all(array, # == 0.5) +all(array, # == 1) +all(array, # == f64) +all(array, # == i) all(array, # == i32) all(array, # == i64) -all(array, # == nil) all(array, # > #) all(array, # > 0.5) all(array, # > 1) -all(array, # > f32) all(array, # > f64) all(array, # > i) +all(array, # > i32) all(array, # > i64) all(array, # >= #) all(array, # >= 0.5) +all(array, # >= f32) all(array, # >= f64) -all(array, # >= i) -all(array, # ^ # == i64) +all(array, # >= i32) +all(array, # >= i64) all(array, # in array) -all(array, # not in array) all(array, 0.5 != #) -all(array, 0.5 != f32) -all(array, 0.5 + 0.5 >= #) all(array, 0.5 < #) -all(array, 0.5 < 1) -all(array, 0.5 < i64) +all(array, 0.5 < f32) all(array, 0.5 <= #) -all(array, 0.5 == #) -all(array, 0.5 == f32) -all(array, 0.5 > #) -all(array, 0.5 > 1) +all(array, 0.5 <= f32) +all(array, 0.5 <= i) +all(array, 0.5 > f32) +all(array, 0.5 > f64) +all(array, 0.5 > i32) all(array, 0.5 >= #) +all(array, 0.5 >= 0.5) +all(array, 0.5 in array) all(array, 1 != #) -all(array, 1 != i) -all(array, 1 != i64) -all(array, 1 != nil) +all(array, 1 != f32) all(array, 1 < #) -all(array, 1 <= #) +all(array, 1 < f32) all(array, 1 == #) all(array, 1 > #) -all(array, 1 in array) -all(array, all(array, add != score)) -all(array, all(array, false)) -all(array, all(list, false)) +all(array, 1 > i64) +all(array, 1 >= #) +all(array, 1 >= 1) +all(array, 1 >= i64) +all(array, f32 < #) +all(array, f32 <= #) +all(array, f32 <= f32) +all(array, f32 > i) all(array, f32 >= #) all(array, f64 != #) -all(array, f64 != i32) -all(array, f64 < #) all(array, f64 <= #) +all(array, f64 <= f32) all(array, f64 == #) -all(array, f64 > #) -all(array, false or ok) -all(array, i != f32) +all(array, f64 == 0.5) +all(array, f64 == i64) +all(array, f64 >= i64) +all(array, false && true) +all(array, false ? 1 : true) +all(array, i != 0.5) +all(array, i <= 0.5) +all(array, i <= f32) +all(array, i <= i32) all(array, i == #) -all(array, i > #) -all(array, i >= #) +all(array, i32 != #) all(array, i32 != i64) -all(array, i32 < #) -all(array, i32 <= #) -all(array, i32 <= i32) -all(array, i32 > #) -all(array, i32 >= 1 % #) -all(array, i64 < #) -all(array, i64 < 1) -all(array, i64 < i64) -all(array, i64 == #) -all(array, i64 == 0.5) +all(array, i32 < i) +all(array, i32 >= #) +all(array, i64 != #) +all(array, i64 != i64) +all(array, i64 == i32) all(array, i64 > #) -all(array, list != list) +all(array, i64 > 0.5) +all(array, i64 >= #) +all(array, nil != "bar") all(array, nil != #) -all(array, nil != i) +all(array, nil != list) +all(array, nil != ok) all(array, nil == "foo") -all(array, nil == div) -all(array, nil in list) -all(array, not (nil in array)) +all(array, nil == i32) +all(array, nil == list) +all(array, none(list, true)) all(array, not false) all(array, not true) all(array, ok) -all(array, one(array, ok)) -all(array, score == add) -all(array, score(#) > f32) -all(array, true || false) -all(array, true) or ok -all(false ? greet : "foo", # == i32) -all(filter(array, ok), # < #) +all(false ? add : "bar", ok) all(filter(array, true), ok) -all(i32 .. 1, 0.5 < i32) -all(i64 .. i64, # != #) -all(list, !any(array, false)) +all(groupBy(array, f32).score, 0.5 in #?.f64) +all(groupBy(list, #).i, #?.half() not in # + #) +all(i32 .. 1, ok) all(list, !false) -all(list, !ok) +all(list, "bar" in #) all(list, "bar" not in #) -all(list, "foo" >= "foo") +all(list, "foo" > "foo") all(list, # != #) -all(list, # != foo) +all(list, # != nil) +all(list, # == # || f64 != i64) all(list, # == #) all(list, # == foo) -all(list, 0.5 != f64) -all(list, 0.5 != nil) -all(list, 0.5 <= f64) -all(list, 0.5 > 1) -all(list, 1 != 0.5) -all(list, 1 != i) -all(list, 1 < f32) -all(list, 1 < i) -all(list, 1 <= 0.5) -all(list, 1 == 1) -all(list, 1 > f32) -all(list, 1 >= i64) -all(list, all(array, true)) -all(list, array != nil) -all(list, div != div) -all(list, f32 != 0.5) -all(list, f32 == f64) -all(list, f64 < 1) -all(list, f64 <= 1) -all(list, f64 <= i) -all(list, f64 <= i32) -all(list, f64 >= 1) -all(list, false) or 0.5 <= 1 -all(list, foo != #) -all(list, greet != half) -all(list, greet == score) -all(list, i <= i64) -all(list, i32 != i64) -all(list, i32 < i64) +all(list, # in list) +all(list, # not in list) +all(list, 0.5 < f64) +all(list, 0.5 < i64) +all(list, 0.5 <= i64) +all(list, 0.5 >= i) +all(list, 0.5 >= i32) +all(list, 1 != 1) +all(list, 1 <= 1) +all(list, 1 > i32) +all(list, 1 >= f64) +all(list, add == div) +all(list, all(array, ok)) +all(list, div != nil) +all(list, f64 != 0.5) +all(list, f64 != f32) +all(list, f64 < i32) +all(list, f64 > i64) +all(list, false ? i : true) +all(list, i < f32) +all(list, i <= 1) +all(list, i <= i32) +all(list, i > f64) +all(list, i > i32) +all(list, i >= 1) +all(list, i32 < 1) all(list, i32 <= 0.5) -all(list, i32 <= f64) -all(list, int(i32) != i32) +all(list, i32 == f32) +all(list, i64 != nil) +all(list, i64 <= 0.5) +all(list, i64 > 1) all(list, list != nil) all(list, nil != 1) -all(list, nil != foo) +all(list, nil != i64) +all(list, nil != nil) +all(list, nil != score) all(list, nil == #) -all(list, nil == greet) -all(list, nil in list) -all(list, none(array, ok)) -all(list, not false) -all(list, not ok) +all(list, nil == score) +all(list, nil in array) +all(list, none(array, 1 > #)) all(list, not true) -all(list, ok and false) all(list, ok) -all(list, ok) or ok -all(list, true != false) -all(list, true != true) -all(list, true ? true : 1) -all(list[i64:i32], !false) -all(map(array, #), # != #) -all(map(array, #), # != 0.5) -all(map(array, #), # >= #) -all(map(array, #), i64 == #) -all(map(array, #), true or false) -all(map(array, 1), ok) -all(map(array, i), f64 > #) -all(map(array, ok), #) -all(map(list, "bar"), ok) -all(map(list, #), "bar" not in #) -all(map(list, #), f32 > 1) -all(map(list, 1), ok) -all(map(list, false), #) -all(map(list, i64), # <= #) +all(list, reduce(array, true)) +all(list, type(i) not endsWith .Bar) +all(map(array, #), ok && false) +all(map(array, #), ok) +all(map(array, f32), !ok) +all(map(array, false), #) +all(map(array, score), # != #) +all(map(array, score), ok) +all(map(list, "bar" not in #), #) +all(map(list, 0.5), 0.5 <= #) +all(map(list, i), # == 0.5) +all(map(list, list), 1 == 0.5) all(map(list, ok), #) -all(map(list, true), # == #) -all(map(list, true), #) -all(map(list, true), ok) -any([0.5, add, 0.5], # == #) -any([1], i64 >= #) -any(array, !false) -any(array, "foo" <= "foo") +all(reduce(array, array), # > #) +all(reduce(array, list), ok) +all(true ? list : false, not true) +any(["bar"], # not endsWith #) +any([greet], ok) +any(array, !(i32 <= #)) +any(array, "foo" >= "foo") +any(array, "foo" not endsWith "bar") +any(array, # != # or # > #) any(array, # != #) any(array, # != 0.5) -any(array, # != 1) -any(array, # != i) +any(array, # != f32) +any(array, # != f64) any(array, # != i32) any(array, # != i64) any(array, # != nil) @@ -2926,259 +3094,734 @@ any(array, # < i) any(array, # < i32) any(array, # <= #) any(array, # <= 0.5) -any(array, # <= 1 ^ #) any(array, # <= 1) +any(array, # <= f32) any(array, # <= i) any(array, # <= i32) +any(array, # <= i64) any(array, # == #) +any(array, # == 0.5) any(array, # == 1) -any(array, # == f64) -any(array, # == i) any(array, # == i32) any(array, # == i64) -any(array, # == nil) any(array, # > #) +any(array, # > 0.5) any(array, # > 1) +any(array, # > f64) any(array, # > i32) -any(array, # > i64) any(array, # >= #) any(array, # >= 0.5) any(array, # >= 1) -any(array, # >= f64) -any(array, # >= i) +any(array, # >= f32) any(array, # >= i32) +any(array, # >= i64) any(array, # in array) -any(array, # not in array) any(array, 0.5 != #) -any(array, 0.5 != f64) -any(array, 0.5 != i) -any(array, 0.5 < 0.5) -any(array, 0.5 <= #) any(array, 0.5 == #) -any(array, 0.5 == 0.5) +any(array, 0.5 == i32) any(array, 0.5 > #) -any(array, 0.5 > f32) +any(array, 0.5 > f64) +any(array, 0.5 >= #) +any(array, 1 != i64) any(array, 1 < #) -any(array, 1 <= i64) +any(array, 1 < 0.5) +any(array, 1 <= #) any(array, 1 == #) -any(array, 1 > f64) -any(array, 1 >= i) -any(array, 1 >= i32) -any(array, all(list, true)) -any(array, array == array) -any(array, div != nil) -any(array, f32 < #) +any(array, 1 > #) +any(array, 1 > 1) +any(array, 1 >= #) +any(array, 1 >= f64) +any(array, all(list, false)) +any(array, f32 < i) any(array, f32 > #) +any(array, f32 > 0.5) +any(array, f32 >= #) any(array, f64 != #) -any(array, f64 != 1) -any(array, f64 < #) -any(array, f64 <= 0.5) -any(array, f64 <= f32) +any(array, f64 < i) +any(array, f64 <= #) any(array, f64 == #) any(array, f64 > #) any(array, f64 > 0.5) -any(array, f64 >= i64) -any(array, false != nil) -any(array, false) and f32 != f32 -any(array, greet != half) -any(array, half != div) -any(array, half != nil) -any(array, i != 1) -any(array, i < # ** #) -any(array, i <= #) -any(array, i == #) -any(array, i == i) +any(array, false && false) +any(array, greet == greet) +any(array, i != #) +any(array, i < #) any(array, i > #) any(array, i >= #) -any(array, i32 != #) -any(array, i32 != i64) -any(array, i32 <= #) -any(array, i32 == #) -any(array, i32 > #) -any(array, i32 >= i64) -any(array, i64 != #) -any(array, i64 != i64) -any(array, i64 <= 0.5) -any(array, i64 == #) -any(array, i64 > #) -any(array, i64 > 1) -any(array, i64 > f32) -any(array, i64 >= i) +any(array, i32 > i64) +any(array, i64 < #) +any(array, i64 == f64) +any(array, i64 >= #) any(array, nil != #) -any(array, nil != f64) -any(array, nil != greet) +any(array, nil != 1) +any(array, nil != i) +any(array, nil != ok) +any(array, nil == "foo") any(array, nil == #) any(array, nil == 1) -any(array, not ok) -any(array, not true) +any(array, ok != true) any(array, ok) -any(array, one(list, false)) -any(array, true ? ok : f32) -any(array, true) and ok -any(filter(array, ok), ok) -any(filter(list, false), ok) -any(filter(list, true), # == #) +any(array, one(array, # <= 0.5)) +any(array, one(array, ok)) +any(array, score == nil) +any(i32 .. i, half == half) +any(list, !ok) any(list, !true) -any(list, "bar" contains "foo") -any(list, "bar" matches "foo") +any(list, "bar" < "foo") any(list, "bar" not in #) any(list, "bar" not startsWith "foo") +any(list, "foo" not in foo) any(list, # != #) -any(list, # != foo) -any(list, # != nil) any(list, # == #) +any(list, # == foo) any(list, # == nil) -any(list, # in list) -any(list, # not in list) +any(list, 0.5 != 1) any(list, 0.5 < 1) -any(list, 0.5 <= f32) -any(list, 0.5 == 0.5) -any(list, 0.5 >= 0.5) -any(list, 0.5 >= f32) -any(list, 0.5 >= i64) -any(list, 1 <= 0.5) -any(list, 1 == f32) -any(list, f32 != i) -any(list, f32 == nil) -any(list, f32 >= i) -any(list, f64 <= 1) -any(list, f64 > 0.5) -any(list, false ? nil : false) -any(list, foo == foo) -any(list, greet == div) -any(list, half != nil) -any(list, i != 1) -any(list, i < f32) -any(list, i < f64) +any(list, 0.5 < f64) +any(list, 0.5 == i64) +any(list, 1 >= f64) +any(list, 1 >= i32) +any(list, any(list, false)) +any(list, any(list, ok)) +any(list, array == nil) +any(list, f32 < 1) +any(list, f32 <= i64) +any(list, f32 > 1) +any(list, f32 > i64) +any(list, f32 >= i32) +any(list, f64 != i64) +any(list, f64 >= 1) +any(list, false) == (foo not in list) +any(list, false) || false ? nil : add any(list, i > i64) -any(list, i32 != i32) -any(list, i32 < 0.5) -any(list, i32 == f64) -any(list, i64 < 1) -any(list, i64 < f64) -any(list, i64 < i64) -any(list, i64 <= i32) -any(list, i64 >= 1) -any(list, i64 >= f32) -any(list, list != nil) -any(list, nil != #) -any(list, nil != #?.String()) -any(list, nil != nil) -any(list, nil == #) -any(list, nil == 1) -any(list, nil == i64) +any(list, i >= 0.5) +any(list, i32 != 0.5) +any(list, i64 <= 1) +any(list, i64 == 0.5) +any(list, i64 == i) +any(list, i64 >= i32) +any(list, i64 not in array) +any(list, nil == false) any(list, nil == nil) -any(list, not false) +any(list, none(array, false)) any(list, not ok) -any(list, ok and foo != #) +any(list, ok || # == #) any(list, ok) -any(list, ok) && i <= 1 -any(list, ok) ? array : foo -any(list, true or ok) -any(list, true) ? f64 : foo.Bar -any(map(array, #), # == #) +any(list, reduce(list, true)) +any(list, true ? false : f64) +any(map(array, #), # >= #) any(map(array, #), ok) -any(map(array, 0.5), # <= #) -any(map(array, f64), # < #) any(map(array, false), #) +any(map(array, ok), # and #) any(map(array, ok), #) -any(map(list, #), i == f64) -any(map(list, #), ok) -any(map(list, 1), # != #) -any(map(list, array), ok) -any(map(list, foo), # != #) -any(map(list, greet), # == #) -any(ok ? "bar" : half, ok) -any(splitAfter("bar", "foo"), # not startsWith #) +any(map(list, #), nil == #) +any(map(list, false), nil == i32) +any(map(list, ok), #) +any(ok ? "foo" : 1, ok) +any(ok ? "foo" : f32, i > #) +any(reduce(array, array), 1 == #) array -array != [array] array != array -array != filter(list, true) +array != array ? 1 : false +array != array ? score : i32 array != list -array != map(array, i) -array != nil != ok -array != nil ? 0.5 : i32 -array != nil ? true : nil -array != nil or nil == f32 -array != nil || ok -array != sort(array) -array != {"bar": f32, "foo": 1}.ok +array != list ? list : f64 +array != map(array, #) +array != map(array, 1) +array != map(list, #) +array != map(list, true) +array != nil ? add : 0.5 array == array -array == array ? "foo" : 0.5 +array == array ? half : false array == list -array == list ? i : half -array == map(array, #) -array == map(array, add) -array == nil != nil -array == nil != true ? 0.5 : 0.5 -array == nil && (false || ok) -array[-1] +array == map(array, score) +array == map(list, #) +array == nil ? list : float(f32) +array not in sort(array) array[-i32] array[-i64] array[-i] -array[1 % 1] -array[1 % i:i64] -array[1] != f32 -array[1] != score(i) -array[1] <= f64 -array[1] == f32 -array[1] == i64 -array[1] ^ 0.5 ^ f64 -array[1] ^ i32 -array[false ? half : 0.5] -array[false ? i : i32] -array[i - i64] -array[i32:i32] +array[1 % i64] +array[1 + 1] +array[1] * i32 +array[1] * i64 +array[1] - f64 +array[1] / i32 +array[1] == -i +array[1] > i +array[1] ^ i +array[abs(1)] +array[array[i32]] +array[bitnot(1)] +array[bitor(1, i)] +array[count(list, ok)] +array[get(array, 1)] +array[i32 * 1] +array[i32:i] array[i32] +array[i32] != i +array[i32] % i32 +array[i32] * f64 +array[i32] ** i32 +array[i32] + i64 array[i32] - f64 -array[i32] .. i32 -array[i64 % 1] -array[i64:i32] -array[i64:i] +array[i32] / f32 +array[i32] == i32 +array[i32] == i64 +array[i32] > f64 +array[i32] >= f32 +array[i64:i64] array[i64] -array[i64] ** f32 -array[i64] / i -array[i64] < i -array[i64] == f64 -array[i64] > f32 -array[i64] >= -i64 +array[i64] .. i32 +array[i64] == floor(0.5) +array[i64] == i +array[i64] > half(f64) +array[i64] ^ f64 +array[i:i32] array[i:i64] -array[i:i] array[i] -array[i] ** i64 +array[i] * f64 array[i] + f32 -array[i] < i -array[i] == min(i32, i) -array[i] > i32 -array[int(1)] -array[int(i32)] -array[max(i64)] -array[min(1)] -array[min(i32)] -array[min(i64)] +array[i] - f32 +array[i] / f64 +array[i] < round(i) +array[i] == i32 +array[i] > f64 +array[i] >= 0.5 ** i +array[max(1)] +array[reduce(list, 1)] +array[score(1):i] array[score(1)] array[score(i)] -count([list], false or ok) +bitand(1 * i64, i) +bitand(1, 1) != i +bitand(1, i64) == f64 +bitand(i, i) +bitand(i, i32) +bitand(i, i64) +bitand(i32, 1) != f32 +bitand(i32, i) +bitand(i32, i) - i32 +bitand(i32, i32 * i) +bitand(i32, i32) +bitand(i32, i64) +bitand(i64, 1) <= i32 +bitand(i64, i + i64) +bitand(i64, i) +bitand(i64, i) ^ f64 +bitand(i64, i32) +bitand(i64, i64) +bitand(int(i32), i64) +bitnand(1, i64) != int(i64) +bitnand(i, i) +bitnand(i, i32 + i32) +bitnand(i, i32) +bitnand(i, i64) +bitnand(i32, bitnot(1)) +bitnand(i32, i) +bitnand(i32, i32) +bitnand(i32, i64) +bitnand(i64 + i, i32) +bitnand(i64 + i64, i64) +bitnand(i64, -1) +bitnand(i64, 1) + i64 + 1 +bitnand(i64, i) +bitnand(i64, i32) +bitnand(i64, i32) > f64 +bitnand(i64, i64) +bitnot(-1) +bitnot(-i) +bitnot(-i32) +bitnot(-i64) +bitnot(1 % 1) +bitnot(1 % i32) +bitnot(1 % i64) +bitnot(1 * 1) +bitnot(1 * i64) +bitnot(1 + 1) +bitnot(1 - i) +bitnot(1 - i32) +bitnot(1) * i % 1 +bitnot(1) ** f32 +bitnot(1) ** i +bitnot(1) + i32 +bitnot(1) - i +bitnot(1) - i32 +bitnot(1) / min(i) +bitnot(1) < i32 +bitnot(1) < i64 +bitnot(1) == i32 +bitnot(1) > f64 +bitnot(1) >= i +bitnot(1) >= i64 +bitnot(abs(1)) +bitnot(abs(i32)) +bitnot(abs(i64)) +bitnot(array[1]) +bitnot(array[i64]) +bitnot(array[i]) +bitnot(bitnot(i)) +bitnot(bitushr(1, 1)) +bitnot(bitushr(i32, 1)) +bitnot(bitxor(i, i64)) +bitnot(count(array, false)) +bitnot(findLast(array, ok)) +bitnot(first(array)) +bitnot(get(array, 1)) +bitnot(get(array, i)) +bitnot(i % i64) +bitnot(i * i) +bitnot(i * i32) +bitnot(i + 1) +bitnot(i - 1) +bitnot(i - i64) +bitnot(i) +bitnot(i) % i32 +bitnot(i) * i +bitnot(i) + f64 +bitnot(i) .. i64 +bitnot(i) == 1 - i +bitnot(i) > i +bitnot(i) >= i32 +bitnot(i) ^ f32 +bitnot(i) ^ f64 +bitnot(i) in array +bitnot(i32 % 1) +bitnot(i32 % i64) +bitnot(i32 + i) +bitnot(i32 + i32) +bitnot(i32 - 1) +bitnot(i32 - i32) +bitnot(i32) +bitnot(i32) != f64 +bitnot(i32) != i32 +bitnot(i32) * i +bitnot(i32) * i64 +bitnot(i32) ** f32 +bitnot(i32) - i32 +bitnot(i32) / f64 +bitnot(i32) == i64 +bitnot(i32) > 1 != true +bitnot(i32) >= f32 +bitnot(i64 % 1) +bitnot(i64 % i) +bitnot(i64 % i32) +bitnot(i64 * 1) +bitnot(i64 * i) +bitnot(i64 * i32) +bitnot(i64 * i64) +bitnot(i64 - 1) +bitnot(i64 - i) +bitnot(i64 - i64) +bitnot(i64) +bitnot(i64) % i32 +bitnot(i64) * f32 +bitnot(i64) < f32 +bitnot(i64) > f64 +bitnot(i64) > i % i +bitnot(i64) >= i32 ^ f32 +bitnot(i64) ^ f64 +bitnot(i64) not in array +bitnot(int(f32)) +bitnot(int(f64)) +bitnot(int(i)) +bitnot(int(i32)) +bitnot(int(i64)) +bitnot(last(array)) +bitnot(len("bar")) +bitnot(len("foo")) +bitnot(len(list)) +bitnot(max(1)) +bitnot(max(1, i64)) +bitnot(max(i)) +bitnot(max(i32)) +bitnot(min(1)) +bitnot(min(i32)) +bitnot(min(i64)) +bitnot(ok ? 1 : array) +bitnot(ok ? 1 : ok) +bitnot(ok ? i : add) +bitnot(reduce(array, #)) +bitnot(reduce(array, 1)) +bitnot(reduce(list, 1)) +bitnot(score(1)) +bitnot(score(i)) +bitnot(sum(array)) +bitor(1, 1) < i +bitor(1, 1) == i +bitor(1, i32) != i64 +bitor(i, -i64) +bitor(i, i) +bitor(i, i64) +bitor(i32, i) +bitor(i32, i32) +bitor(i32, i64) +bitor(i64 % 1, i32) +bitor(i64, i) +bitor(i64, i32) +bitor(i64, i64) +bitor(min(i64), i) +bitor(score(i), i64) +bitshl(bitnot(i), i) +bitshl(i, i) +bitshl(i, i32) +bitshl(i, i64) +bitshl(i32, i) +bitshl(i32, i32) +bitshl(i32, i64) +bitshl(i64, i32) +bitshl(i64, i64) +bitshl(len(array), i) +bitshl(score(i), i32) +bitshr(i % 1, i32) +bitshr(i, 1) - i64 +bitshr(i, i32) +bitshr(i, i64) +bitshr(i32, i) +bitshr(i32, i) - f32 +bitshr(i32, i32) +bitshr(i32, i64) +bitshr(i64, i32) +bitshr(i64, i64) +bitushr(-i64, i64) +bitushr(1 % i, i) +bitushr(1, i) * i +bitushr(abs(1), i32) +bitushr(i, i) +bitushr(i, i) % i64 +bitushr(i, i32) +bitushr(i, i64) +bitushr(i32, i) +bitushr(i32, i32) +bitushr(i32, i64) +bitushr(i64, i) +bitushr(i64, i32) +bitushr(i64, i64) +bitxor(-i, i64) +bitxor(1, i) * i +bitxor(bitnot(1), -i) +bitxor(i, i32) +bitxor(i, i64) +bitxor(i32, 1) > i64 +bitxor(i32, i) +bitxor(i32, i) ** f64 +bitxor(i32, i32) +bitxor(i32, i64) +bitxor(i32, i64) ** i32 +bitxor(i64, i) +bitxor(i64, i32) +bitxor(i64, i64) +bitxor(score(1), i) +ceil(-0.5) +ceil(-1) +ceil(-f32) +ceil(-f64) +ceil(-i) +ceil(-i32) +ceil(-i64) +ceil(0.5 * 0.5) +ceil(0.5 * 1) +ceil(0.5 * f64) +ceil(0.5 * i) +ceil(0.5 ** 1) +ceil(0.5 ** f64) +ceil(0.5 ** i) +ceil(0.5 + 0.5) +ceil(0.5 + 1) +ceil(0.5 + f32) +ceil(0.5 + f64) +ceil(0.5 + i) +ceil(0.5 + i32) +ceil(0.5 + i64) +ceil(0.5 - 0.5) +ceil(0.5 - f64) +ceil(0.5 - i) +ceil(0.5 / 0.5) +ceil(0.5 / 1) +ceil(0.5 / f32) +ceil(0.5 / i) +ceil(0.5 / i32) +ceil(0.5 ^ 1) +ceil(0.5 ^ f32) +ceil(0.5 ^ i32) +ceil(0.5 ^ i64) +ceil(0.5) != 0.5 * 0.5 +ceil(0.5) != i +ceil(0.5) != nil ? score : "foo" +ceil(0.5) ** round(f32) +ceil(0.5) - i +ceil(0.5) < i +ceil(0.5) == f32 +ceil(0.5) == i ? div : half +ceil(0.5) == i64 +ceil(0.5) > f64 +ceil(0.5) >= i +ceil(0.5) >= i64 +ceil(0.5) ^ i64 +ceil(1 % i64) +ceil(1 * 0.5) +ceil(1 * 1) +ceil(1 ** 1) +ceil(1 + 0.5) +ceil(1 + 1) +ceil(1 + f64) +ceil(1 + i) +ceil(1 - 0.5) +ceil(1 - f64) +ceil(1 / 0.5) +ceil(1 / 1) +ceil(1 / f64) +ceil(1 / i64) +ceil(1 ^ f64) +ceil(1 ^ i) +ceil(1 ^ i64) +ceil(1) ** f32 +ceil(1) + i32 +ceil(1) / i +ceil(1) < f32 ^ i +ceil(1) <= f32 +ceil(1) <= i64 +ceil(1) == f32 +ceil(1) > f32 +ceil(1) >= f32 +ceil(1) >= i64 ** 0.5 +ceil(1) ^ i +ceil(abs(0.5)) +ceil(abs(1)) +ceil(abs(f32)) +ceil(abs(f64)) +ceil(abs(i32)) +ceil(abs(i64)) +ceil(add(1, 1)) +ceil(array[1]) +ceil(array[i64]) +ceil(array[i]) +ceil(bitnot(1)) +ceil(bitnot(i)) +ceil(ceil(0.5)) +ceil(ceil(f64)) +ceil(ceil(i)) +ceil(ceil(i32)) +ceil(count(list, ok)) +ceil(f32 * 0.5) +ceil(f32 * i) +ceil(f32 * i32) +ceil(f32 ** i) +ceil(f32 ** i32) +ceil(f32 + 1) +ceil(f32 + i64) +ceil(f32 - f32) +ceil(f32 - i) +ceil(f32 - i32) +ceil(f32 - i64) +ceil(f32 / 0.5) +ceil(f32 / f64) +ceil(f32 / i32) +ceil(f32 ^ 0.5) +ceil(f32 ^ 1) +ceil(f32 ^ i64) +ceil(f32) +ceil(f32) != i64 +ceil(f32) * i64 +ceil(f32) ** -1 +ceil(f32) ** i +ceil(f32) + i +ceil(f32) + i64 +ceil(f32) - i32 +ceil(f32) / i64 +ceil(f32) < i +ceil(f32) < i32 +ceil(f64 * 1) +ceil(f64 * i) +ceil(f64 ** i) +ceil(f64 ** i64) +ceil(f64 + 1) +ceil(f64 + f32) +ceil(f64 - 0.5) +ceil(f64 - f32) +ceil(f64 - f64) +ceil(f64 - i32) +ceil(f64 / 0.5) +ceil(f64 / f64) +ceil(f64 / i32) +ceil(f64 / i64) +ceil(f64 ^ 0.5) +ceil(f64 ^ f32) +ceil(f64 ^ f64) +ceil(f64 ^ i32) +ceil(f64 ^ i64) +ceil(f64) +ceil(f64) != i +ceil(f64) != i64 +ceil(f64) * f32 +ceil(f64) ** f32 +ceil(f64) - i32 +ceil(f64) / f64 +ceil(f64) / i / i64 +ceil(f64) in array +ceil(false ? add : 0.5) +ceil(find(array, ok)) +ceil(findLast(array, true)) +ceil(findLastIndex(list, ok)) +ceil(findLastIndex(list, true)) +ceil(first(array)) +ceil(float(0.5)) +ceil(float(1)) +ceil(float(f64)) +ceil(float(i)) +ceil(float(i32)) +ceil(float(i64)) +ceil(floor(0.5)) +ceil(floor(1)) +ceil(floor(f64)) +ceil(floor(i)) +ceil(floor(i32)) +ceil(floor(i64)) +ceil(get(array, 1)) +ceil(get(array, i)) +ceil(half(0.5)) +ceil(half(1)) +ceil(half(f64)) +ceil(i % i) +ceil(i * 0.5) +ceil(i * i) +ceil(i ** f64) +ceil(i ** i) +ceil(i + 0.5) +ceil(i + 1) +ceil(i + f32) +ceil(i + i64) +ceil(i - i) +ceil(i / f32) +ceil(i / i) +ceil(i / i64) +ceil(i ^ i) +ceil(i ^ i32) +ceil(i) +ceil(i) != i32 +ceil(i) * f64 +ceil(i) * i64 +ceil(i) ** f64 +ceil(i) + i +ceil(i) - f32 +ceil(i) / f32 +ceil(i) <= f64 +ceil(i) == i32 +ceil(i) > i64 +ceil(i32 * i) +ceil(i32 * i32) +ceil(i32 ** i32) +ceil(i32 + 0.5) +ceil(i32 + i32) +ceil(i32 - 0.5) +ceil(i32 - 1) +ceil(i32 - i) +ceil(i32 - i64) +ceil(i32 / 0.5) +ceil(i32 / f32) +ceil(i32 / i) +ceil(i32 / i32) +ceil(i32 ^ 0.5) +ceil(i32 ^ i64) +ceil(i32) +ceil(i32) * 1 ^ i32 +ceil(i32) * i32 +ceil(i32) ** max(i) +ceil(i32) + f32 +ceil(i32) + i +ceil(i32) + i32 +ceil(i32) <= i64 +ceil(i32) not in array +ceil(i64 % 1) +ceil(i64 % i32) +ceil(i64 * f32) +ceil(i64 * f64) +ceil(i64 ** i32) +ceil(i64 ** i64) +ceil(i64 + 0.5) +ceil(i64 + f64) +ceil(i64 + i32) +ceil(i64 - 0.5) +ceil(i64 - f64) +ceil(i64 / 0.5) +ceil(i64 / 1) +ceil(i64 / f64) +ceil(i64 ^ 0.5) +ceil(i64 ^ i) +ceil(i64 ^ i32) +ceil(i64 ^ i64) +ceil(i64) +ceil(i64) - -1 +ceil(i64) - f32 +ceil(i64) - i32 +ceil(i64) / (0.5 - f32) +ceil(i64) >= f32 +ceil(i64) ^ i32 +ceil(int(0.5)) +ceil(int(f32)) +ceil(int(f64)) +ceil(int(i)) +ceil(int(i64)) +ceil(len("bar")) +ceil(len(array)) +ceil(len(list)) +ceil(max(1, i)) +ceil(max(f32, 0.5)) +ceil(max(f64)) +ceil(max(i)) +ceil(mean(array)) +ceil(median(array)) +ceil(min(0.5, f32)) +ceil(min(1)) +ceil(min(f32)) +ceil(min(f64)) +ceil(min(i)) +ceil(min(i64)) +ceil(ok ? f32 : nil) +ceil(ok ? i32 : "bar") +ceil(ok ? i32 : i64) +ceil(reduce(array, #)) +ceil(reduce(array, 0.5)) +ceil(reduce(list, 1)) +ceil(round(0.5)) +ceil(round(1)) +ceil(round(f32)) +ceil(round(f64)) +ceil(round(i)) +ceil(round(i32)) +ceil(round(i64)) +ceil(score(1)) +ceil(score(i)) +ceil(true ? 1 : half) +ceil(true ? 1 : nil) +ceil(true ? f64 : nil) +count(["bar", score, i], 1 != #) +count(["bar"], # startsWith #) +count([0.5], ok) +count([greet], ok) +count([i32], f32 != #) +count([list, 0.5], # not in list) +count([nil], ok) count(array, !ok) -count(array, "bar" != "bar") +count(array, !true) +count(array, "bar" <= "bar") count(array, "bar" not endsWith "bar") +count(array, "foo" matches "foo") count(array, # != #) -count(array, # != f32) -count(array, # != i32) +count(array, # != 0.5) +count(array, # != i) +count(array, # != i64) +count(array, # != nil) count(array, # < #) -count(array, # < 0.5) -count(array, # < 1) -count(array, # < f32) -count(array, # < f64) count(array, # < i) -count(array, # < i64) +count(array, # < i32) count(array, # <= #) count(array, # <= 0.5) -count(array, # <= f32) -count(array, # <= f64) +count(array, # <= 1) count(array, # <= i) count(array, # <= i32) count(array, # == #) +count(array, # == 0.5) count(array, # == 1) count(array, # == f32) count(array, # == i) @@ -3188,2511 +3831,2520 @@ count(array, # > #) count(array, # > 0.5) count(array, # > i) count(array, # > i64) -count(array, # >= # / #) count(array, # >= #) count(array, # >= 0.5) count(array, # >= 1) -count(array, # >= f64) +count(array, # >= f32) count(array, # >= i) -count(array, # >= i64) +count(array, # in array) +count(array, # not in array) count(array, 0.5 != #) +count(array, 0.5 < #) count(array, 0.5 <= #) +count(array, 0.5 <= f32) +count(array, 0.5 <= f64) count(array, 0.5 == #) +count(array, 0.5 == f32) +count(array, 0.5 == i) count(array, 0.5 > #) -count(array, 0.5 > 1) -count(array, 0.5 >= #) -count(array, 0.5 >= 0.5) -count(array, 0.5 >= i) count(array, 1 != #) +count(array, 1 != 0.5) count(array, 1 < #) -count(array, 1 < 0.5) -count(array, 1 < 1) count(array, 1 <= #) -count(array, 1 > #) +count(array, 1 == #) count(array, 1 >= #) -count(array, add == half) -count(array, f32 != i) -count(array, f32 < # ? true : half) -count(array, f32 < #) -count(array, f32 < 0.5) +count(array, any(array, true)) +count(array, div(#, 1) >= #) count(array, f32 <= #) -count(array, f32 <= 1) -count(array, f32 <= i) count(array, f32 == #) -count(array, f32 == 1) -count(array, f64 != #) count(array, f64 < #) +count(array, f64 < f32) count(array, f64 <= #) +count(array, f64 <= 1) count(array, f64 == #) -count(array, f64 > #) -count(array, false == true) -count(array, false) != f64 -count(array, false) / i -count(array, false) >= f32 +count(array, false) ** i32 +count(array, false) + f32 +count(array, false) - i64 +count(array, false) / f64 +count(array, false) > i64 * i64 +count(array, foo in list) count(array, foo not in list) -count(array, greet != greet) -count(array, greet == score) -count(array, i != f32) -count(array, i == nil) -count(array, i > #) +count(array, i != #) +count(array, i < #) +count(array, i < 0.5) +count(array, i <= #) +count(array, i == #) +count(array, i > i64) count(array, i >= #) -count(array, i32 != 1) +count(array, i32 != #) +count(array, i32 != i) count(array, i32 < #) -count(array, i32 < 0.5) +count(array, i32 < 1) +count(array, i32 <= #) +count(array, i32 <= f32) count(array, i32 == #) -count(array, i32 > i) +count(array, i32 == 0.5) +count(array, i32 > #) count(array, i32 >= #) -count(array, i32 >= 1) -count(array, i64 != #) +count(array, i32 >= f32) +count(array, i32 >= i32) +count(array, i64 != i32) +count(array, i64 != i64) count(array, i64 < #) -count(array, i64 <= 1) -count(array, i64 <= f64) +count(array, i64 <= #) count(array, i64 == #) count(array, i64 == i64) count(array, i64 > 1) -count(array, i64 > f32) -count(array, nil != #) -count(array, nil == #) -count(array, nil == foo) -count(array, not ok) +count(array, list != array) +count(array, list != nil) +count(array, nil != "foo") +count(array, nil != f64) +count(array, nil == 1) +count(array, nil == list) +count(array, nil == nil) +count(array, none(array, false)) +count(array, not false) +count(array, ok or false) count(array, ok) -count(array, ok) + i64 -count(array, ok) - i64 -count(array, ok) .. i64 -count(array, one(array, false)) -count(array, true ? false : 0.5) -count(array, true) != 1 ^ f32 -count(array, true) ** f32 -count(array, true) / int(0.5) -count(array, true) >= f64 / 0.5 -count(filter(list, false), ok) -count(i .. 1, # > #) -count(i .. i32, # > #) -count(i32 .. 1, # == #) -count(i64 .. i, div == nil) -count(i64 .. i, ok) +count(array, ok) * i32 +count(array, ok) ^ i +count(array, reduce(list, false)) +count(array, true == ok) +count(array, true) / f64 +count(filter(list, true), ok) +count(groupBy(list, #).String, .div?.array) +count(i .. 1, # == i) +count(i .. i, ok) +count(i32 .. i, # >= #) +count(i64 .. 1, nil != f32) count(list, !false) -count(list, !ok) -count(list, "bar" == "bar") -count(list, "bar" in #) -count(list, "bar" matches "foo") -count(list, "bar" not in #) +count(list, !true) +count(list, "bar" not matches "bar") count(list, "foo" in #) -count(list, "foo" not in #) count(list, # != #) -count(list, # != nil) count(list, # == #) count(list, # == nil) -count(list, 0.5 == f32) +count(list, # in list) +count(list, 0.5 < f32) +count(list, 0.5 <= 0.5) +count(list, 0.5 <= i64) count(list, 0.5 > 0.5) -count(list, 0.5 >= i32) -count(list, 1 != 1) -count(list, 1 != f32) -count(list, 1 < 0.5) -count(list, 1 <= i) +count(list, 0.5 > 1) +count(list, 0.5 > f32) +count(list, 1 != i) +count(list, 1 >= 0.5) count(list, 1 >= f32) -count(list, 1 >= i32) -count(list, all(list, true)) -count(list, f32 <= i32) -count(list, f64 != i) -count(list, false ? # : ok) -count(list, false or ok) -count(list, false || false) -count(list, false) .. i32 -count(list, false) > i64 -count(list, foo != #) -count(list, half == div) -count(list, i == i64) -count(list, i32 == i) -count(list, i32 == i32) -count(list, list == array) +count(list, f32 == i64) +count(list, f32 >= f32) +count(list, false && false) +count(list, false) + -1 +count(list, false) / f64 +count(list, false) > f32 +count(list, foo == #) +count(list, i != i64) +count(list, i < 0.5) +count(list, i <= i64) +count(list, i > 1) +count(list, i32 < f32) +count(list, i32 < i64) +count(list, i64 not in array) count(list, nil != #) -count(list, nil != score) -count(list, nil == #) -count(list, nil == add) -count(list, nil == true) -count(list, none(list, ok)) +count(list, nil != false) +count(list, nil == list) count(list, not false) -count(list, not ok) -count(list, not true) -count(list, ok == nil) count(list, ok) -count(list, ok) - i32 -count(list, ok) < f64 -count(list, ok) > -0.5 -count(list, ok) >= i -count(list, true and ok) -count(list, true) ** i64 -count(list, true) == f64 -count(list, true) ^ i64 -count(map(array, #), # != #) -count(map(array, #), # > #) -count(map(array, #), i == #) +count(list, ok) % i64 +count(list, ok) / half(1) +count(list, ok) / i +count(list, ok) >= i32 +count(list, ok) ^ i +count(list, ok) ^ i64 +count(list, true or ok) +count(list, true || true) +count(list, true) * f32 +count(list, true) == i +count(map(array, #), # == i32) +count(map(array, #), not true) count(map(array, #), ok) -count(map(array, add), ok) -count(map(array, div), ok) -count(map(array, foo), ok) -count(map(array, i32), 0.5 == f32) -count(map(array, i32), 1 != #) -count(map(array, i64), # == 0.5) -count(map(array, true), #) -count(map(list, #), "bar" in #) -count(map(list, #), # == #) -count(map(list, #), # == nil) -count(map(list, 0.5), # != nil) -count(map(list, f32), # <= #) -count(map(list, true), #) -count(sort(array), foo == #) -count(sort(array), ok) -date("bar", "bar")?.String +count(map(array, false), #) +count(map(array, i), ok) +count(map(array, i32), 1 == #) +count(map(array, i64), f64 != nil) +count(map(array, ok), !#) +count(map(list, 0.5), "bar" == "foo") +count(map(list, div), ok) +count(map(list, f32), # == #) +count(map(list, greet), ok) +count(map(list, i32), # != i64) +count(map(list, ok), #) +count(map(list, ok), 0.5 <= i64) +count(ok ? array : i64, # > 0.5) +count(sort(array), 1 <= #) div div != add -div != add != ok +div != add != nil +div != add == ok div != div -div != div ? score : 0.5 -div != div or half != greet -div != foo.Qux -div != foo.String -div != foo?.Qux -div != greet -div != half -div != half ? f32 : ok -div != half and !ok -div != nil != ok -div != nil ? array : add -div != nil ? i : i64 -div != score +div != div != ok +div != div && ok +div != div ? "bar" : "foo" +div != nil == ok +div != nil || f32 < 0.5 +div != reduce(array, div) div == add +div == add ? 1 : ok div == div -div == div ? 0.5 : half -div == div ? nil : i -div == div || true ? f32 : add -div == foo.Qux -div == foo.String -div == foo?.Qux -div == foo?.String -div == greet -div == greet != ok -div == greet || !false -div == half -div == nil ? greet : foo -div == nil ? half : half -div == nil ? score : i64 -div == nil || ok -div == score -div == score == ok -div == score ? true : "bar" -div in map(list, add) -div not in [add] -div not in [half, f32, false] -div not in map(array, div) -div(-1, i) -div(1, 1) > i64 -div(1, i) >= i64 -div(i, 1) / f32 -div(i, 1) == i +div == nil ? f32 : half +div == nil ? false : 1 +div(-i, array[i64]) +div(-i, i) +div(1, i) + i +div(findLast(array, true), i) +div(i, -1) div(i, i) +div(last(array), 1 * i32) +div(score(1), bitnot(1)) f32 -f32 != --f64 +f32 != -0.5 f32 != -1 -f32 != 0.5 * f32 -f32 != 0.5 + i64 -f32 != 0.5 / i64 +f32 != -f32 +f32 != 0.5 != false +f32 != 0.5 * 1 +f32 != 0.5 * i64 +f32 != 0.5 ** f32 +f32 != 0.5 + 1 +f32 != 0.5 - i64 +f32 != 0.5 / 0.5 +f32 != 0.5 / i32 f32 != 0.5 == ok -f32 != 0.5 ? array : ok -f32 != 0.5 ? list : 1 -f32 != 0.5 ^ i32 -f32 != 1 % i32 -f32 != 1 * 1 -f32 != 1 * i64 -f32 != 1 ** 0.5 -f32 != 1 - i -f32 != 1 ? "foo" : foo -f32 != 1 ^ f32 -f32 != abs(i64) +f32 != 0.5 == true +f32 != 0.5 ? array : score +f32 != 0.5 ? foo : f64 +f32 != 0.5 ? true : i32 +f32 != 0.5 ^ 1 +f32 != 0.5 ^ f32 +f32 != 1 && ok +f32 != 1 * i +f32 != 1 + i64 f32 != f32 -f32 != f32 + f64 -f32 != f32 - f64 +f32 != f32 / 0.5 +f32 != f32 / f32 f32 != f64 -f32 != f64 ** i32 -f32 != f64 + i32 -f32 != f64 - f32 -f32 != f64 ^ i32 -f32 != findIndex(list, ok) -f32 != float(i) +f32 != findLast(array, ok) +f32 != findLastIndex(array, ok) +f32 != floor(0.5) +f32 != half(0.5) f32 != i -f32 != i * i64 -f32 != i - f64 +f32 != i != true +f32 != i % 1 +f32 != i % i +f32 != i ** i64 +f32 != i / f64 f32 != i32 +f32 != i32 % i +f32 != i32 * i32 +f32 != i32 + 0.5 f32 != i64 -f32 != i64 * 1 -f32 != i64 ? f64 : f32 +f32 != i64 != nil +f32 != i64 != true +f32 != i64 ? 0.5 : f64 +f32 != i64 ^ i32 +f32 != int(f32) +f32 != int(i32) f32 != len(array) -f32 != max(i) -f32 != min(1) -f32 != min(f64) -f32 != nil ? half : greet +f32 != nil ? true : score +f32 != nil || ok +f32 != round(i) f32 != score(1) -f32 * (1 - f32) -f32 * (i + 1) -f32 * (i32 + f32) -f32 * (i64 + f32) -f32 * (i64 - i64) +f32 != score(1, i) +f32 * (0.5 + f64) +f32 * (0.5 + i32) +f32 * (0.5 - f32) +f32 * (f64 + f64) +f32 * (f64 + i64) +f32 * (f64 - i) f32 * -0.5 -f32 * -f32 +f32 * -1 f32 * -f64 -f32 * -i32 -f32 * 0.5 != f32 -f32 * 0.5 ** f32 -f32 * 0.5 - f32 -f32 * 0.5 < f64 -f32 * 0.5 < i32 -f32 * 0.5 <= f32 -f32 * 0.5 <= f32 ? "bar" : array -f32 * 0.5 <= i64 +f32 * -i +f32 * -i64 +f32 * -len(array) +f32 * 0.5 * 0.5 +f32 * 0.5 * i +f32 * 0.5 * i32 +f32 * 0.5 - i32 +f32 * 0.5 / i +f32 * 0.5 <= i +f32 * 0.5 ^ f32 +f32 * 0.5 not in array f32 * 1 != f32 -f32 * 1 * 1 -f32 * 1 ** f64 -f32 * 1 + i -f32 * 1 - i -f32 * 1 / i64 -f32 * 1 < f64 -f32 * 1 <= f32 -f32 * 1 >= i32 -f32 * array[i64] -f32 * count(array, ok) +f32 * 1 * f64 +f32 * 1 * i32 +f32 * 1 ** 0.5 +f32 * 1 + f64 +f32 * 1 < i64 +f32 * 1 >= i64 +f32 * 1 ^ i64 +f32 * ceil(i) f32 * f32 -f32 * f32 * i -f32 * f32 ^ i64 +f32 * f32 * 0.5 +f32 * f32 < i32 +f32 * f32 <= i64 +f32 * f32 > f32 - 1 +f32 * f32 ^ 0.5 +f32 * f32 in array f32 * f64 -f32 * f64 * i64 -f32 * f64 + f32 -f32 * f64 - i -f32 * f64 ^ f32 -f32 * findIndex(list, true) -f32 * float(0.5) +f32 * f64 + f64 +f32 * f64 + i32 +f32 * f64 / i64 +f32 * f64 >= 1 - i +f32 * float(i) +f32 * float(i32) +f32 * floor(0.5) +f32 * floor(i) +f32 * half(0.5) +f32 * half(1) +f32 * half(f64) f32 * i -f32 * i < f64 -f32 * i <= -i64 -f32 * i <= min(0.5, f64) +f32 * i != i32 +f32 * i - i +f32 * i / f64 +f32 * i == i64 f32 * i32 -f32 * i32 ** 1 -f32 * i32 - i64 +f32 * i32 != max(i) +f32 * i32 * i32 +f32 * i32 ** 0.5 +f32 * i32 >= i f32 * i64 -f32 * i64 ** 0.5 -f32 * i64 ** i64 -f32 * i64 < f64 -f32 * i64 < half(f64) -f32 * i64 ^ i -f32 * i64 ^ i64 -f32 * int(f64) -f32 * max(f32) -f32 * min(0.5) -f32 * min(f64) -f32 * score(1) -f32 ** (0.5 + i) -f32 ** (0.5 - 0.5) -f32 ** (1 - i64) -f32 ** (1 / 0.5) -f32 ** (f32 * i) -f32 ** (f32 + 0.5) -f32 ** (f32 + i64) -f32 ** (f32 - 1) -f32 ** (f64 - i32) -f32 ** (i32 * 1) -f32 ** (i32 * i) +f32 * i64 != f64 +f32 * i64 ** i +f32 * int(i64) +f32 * min(i64) +f32 * reduce(array, 1) +f32 * reduce(list, 1) +f32 * round(f64) +f32 ** (0.5 + 0.5) +f32 ** (0.5 - 1) +f32 ** (0.5 / f32) +f32 ** (1 / f64) +f32 ** (f32 - 0.5) +f32 ** (f64 - i64) +f32 ** (i % 1) +f32 ** (i64 * i32) +f32 ** (i64 + 0.5) +f32 ** (i64 - 1) f32 ** -0.5 -f32 ** -1 +f32 ** -f32 f32 ** -f64 f32 ** -i -f32 ** -i32 -f32 ** -i64 -f32 ** 0.5 >= i64 +f32 ** 0.5 != f32 +f32 ** 0.5 + f32 +f32 ** 0.5 >= -i64 +f32 ** 0.5 ^ (f32 / f64) f32 ** 0.5 ^ i64 -f32 ** 1 * f32 -f32 ** 1 ** 0.5 -f32 ** 1 / i32 -f32 ** 1 <= i -f32 ** array[i64] +f32 ** 1 + i64 +f32 ** 1 / i +f32 ** 1 < f64 +f32 ** 1 < i64 +f32 ** 1 <= i64 +f32 ** ceil(i64) f32 ** f32 -f32 ** f32 * i ^ f64 -f32 ** f32 + f32 -f32 ** f32 - 0.5 + 1 -f32 ** f32 ^ 1 -f32 ** f32 ^ i +f32 ** f32 * f32 +f32 ** f32 ** f32 +f32 ** f32 < f64 +f32 ** f32 ^ f32 +f32 ** f32 ^ f64 f32 ** f64 -f32 ** f64 + i64 +f32 ** f64 ** 1 f32 ** f64 <= f64 -f32 ** f64 >= f32 -f32 ** float(i64) -f32 ** half(f64) +f32 ** f64 >= i +f32 ** float(f32) +f32 ** float(f64) +f32 ** half(0.5) +f32 ** half(1) f32 ** i -f32 ** i * f64 -f32 ** i / f64 -f32 ** i == score(i) +f32 ** i != half(1) +f32 ** i ** f64 +f32 ** i ** i32 +f32 ** i <= i64 f32 ** i32 -f32 ** i32 ** i32 -f32 ** i32 >= i32 +f32 ** i32 / i32 +f32 ** i32 == f64 +f32 ** i32 ^ f32 f32 ** i64 -f32 ** i64 * i32 -f32 ** i64 + i64 -f32 ** i64 / i64 -f32 ** int(0.5) -f32 ** int(1) +f32 ** i64 / f32 +f32 ** i64 == i32 +f32 ** i64 > i32 +f32 ** int(f64) f32 ** len("foo") -f32 ** len(list) f32 ** max(f32) -f32 ** max(f64) -f32 ** max(i64) +f32 ** max(i32) +f32 ** median(array) +f32 ** reduce(array, 0.5) +f32 ** round(f64) f32 + -0.5 f32 + -1 f32 + -f32 f32 + -i -f32 + -i64 -f32 + 0.5 + 1 -f32 + 0.5 + f32 +f32 + 0.5 ** f32 +f32 + 0.5 + i32 +f32 + 0.5 - i +f32 + 0.5 - i32 +f32 + 0.5 / f32 +f32 + 0.5 == i +f32 + 0.5 > i64 +f32 + 0.5 ^ 0.5 f32 + 1 * 0.5 -f32 + 1 * i32 -f32 + 1 ** f64 -f32 + 1 - f32 +f32 + 1 * 1 +f32 + 1 + i +f32 + 1 - f64 f32 + 1 - i64 -f32 + 1 < i32 -f32 + abs(0.5) -f32 + abs(f32) -f32 + count(array, true) +f32 + 1 / f64 +f32 + 1 < f32 +f32 + 1 < i +f32 + 1 >= ceil(0.5) +f32 + bitnot(i64) +f32 + ceil(-1) +f32 + ceil(1) +f32 + ceil(f32) f32 + f32 -f32 + f32 + i32 -f32 + f32 == 0.5 ^ i +f32 + f32 * 0.5 +f32 + f32 ** i64 +f32 + f32 - i32 +f32 + f32 / 1 +f32 + f32 > i32 +f32 + f32 ^ 0.5 f32 + f64 -f32 + f64 - 0.5 -f32 + f64 - f32 -f32 + f64 / f64 -f32 + f64 < f32 -f32 + f64 ^ f32 -f32 + find(array, ok) -f32 + float(f64) -f32 + half(0.5) +f32 + f64 in array +f32 + findIndex(array, true) +f32 + first(array) +f32 + float(i) +f32 + floor(1) +f32 + floor(i64) +f32 + half(1) +f32 + half(f64) f32 + i -f32 + i != i -f32 + i - i -f32 + i ^ f64 +f32 + i != i64 +f32 + i + 1 +f32 + i + i +f32 + i - i32 +f32 + i == f64 f32 + i32 -f32 + i32 * 0.5 -f32 + i32 + 0.5 -f32 + i32 >= f32 +f32 + i32 != f32 +f32 + i32 % i +f32 + i32 / f32 +f32 + i32 <= i +f32 + i32 ^ 0.5 f32 + i64 -f32 + i64 % 1 -f32 + i64 - 1 -f32 + i64 - f32 +f32 + i64 != f32 +f32 + i64 + 0.5 +f32 + i64 < f32 +f32 + i64 <= i32 +f32 + i64 >= i +f32 + i64 >= i32 f32 + int(1) f32 + int(f64) -f32 + int(i32) -f32 + len(array) f32 + max(0.5) f32 + max(f64) -f32 + max(i64) -f32 + min(1) -f32 + min(f32) -f32 + min(i32) -f32 + min(i64, 1, 1) +f32 + reduce(array, #) +f32 + round(1) +f32 + round(i32) f32 + score(1) f32 + score(i) -f32 - -0.5 f32 - -1 f32 - -f64 f32 - -i -f32 - -i32 +f32 - 0.5 ** i64 +f32 - 0.5 + 0.5 f32 - 0.5 + f64 -f32 - 0.5 - i32 f32 - 0.5 - i64 -f32 - 0.5 <= f64 +f32 - 0.5 < i +f32 - 0.5 <= i32 f32 - 0.5 <= i64 -f32 - 0.5 >= i64 -f32 - 0.5 ^ f64 -f32 - 0.5 ^ i32 -f32 - 1 != i64 -f32 - 1 % 1 +f32 - 0.5 > f64 f32 - 1 % i64 +f32 - 1 * i64 f32 - 1 + 1 -f32 - 1 + i32 % i -f32 - 1 - f32 +f32 - 1 / 0.5 +f32 - 1 < i32 +f32 - 1 <= i32 +f32 - 1 == f32 +f32 - 1 >= f64 f32 - abs(i32) -f32 - array[i] +f32 - abs(i64) +f32 - bitshl(i, i32) +f32 - ceil(f64) f32 - f32 -f32 - f32 - f64 -f32 - f32 - i32 +f32 - f32 ** i32 +f32 - f32 + i f32 - f32 == i -f32 - f32 == min(1) -f32 - f32 >= i f32 - f64 -f32 - f64 * 1 -f32 - f64 ** i32 -f32 - f64 + f32 -f32 - f64 + i64 -f32 - f64 - f32 +f32 - f64 + f64 f32 - f64 - i f32 - f64 <= f32 -f32 - f64 ^ 1 -f32 - float(0.5) -f32 - float(1) -f32 - float(i32) -f32 - half(0.5) f32 - i -f32 - i % 1 -f32 - i * f32 -f32 - i + i32 % 1 -f32 - i + i32 ** 0.5 -f32 - i - 0.5 +f32 - i >= f32 f32 - i32 -f32 - i32 * 1 -f32 - i32 ** f32 -f32 - i32 ** i32 -f32 - i32 + 1 -f32 - i32 >= i -f32 - i32 ^ i +f32 - i32 * 0.5 +f32 - i32 * f64 +f32 - i32 ** 1 +f32 - i32 <= f32 +f32 - i32 <= i32 +f32 - i32 >= abs(0.5) f32 - i64 -f32 - i64 - 1 -f32 - i64 <= i32 -f32 - i64 ^ 1 -f32 - int(0.5) -f32 - int(i64) -f32 - len("bar") -f32 - len(list) -f32 - max(i32) -f32 - min(1) -f32 - min(i64) +f32 - i64 ** 0.5 +f32 - len(array) +f32 - max(1) +f32 - min(0.5) +f32 - min(0.5, 0.5) +f32 - reduce(array, #) +f32 - score(1) f32 - score(i) -f32 / (0.5 + i64) -f32 / (1 - i) -f32 / (i64 - f64) -f32 / -0.5 -f32 / -f32 +f32 / (0.5 - i32) +f32 / (1 + i) +f32 / (f64 - 0.5) +f32 / (i - i32) +f32 / (i32 + 1) +f32 / -1 f32 / -f64 -f32 / -i -f32 / -i32 -f32 / 0.5 * 0.5 -f32 / 0.5 * i -f32 / 0.5 - f64 -f32 / 0.5 - i -f32 / 0.5 - i64 -f32 / 0.5 > f64 -f32 / 1 != f64 -f32 / 1 * i64 -f32 / 1 ** f32 -f32 / 1 - f64 - i64 +f32 / -i64 +f32 / 0.5 ** f64 +f32 / 0.5 / i +f32 / 0.5 <= i64 +f32 / 0.5 ^ f64 +f32 / 1 * i32 +f32 / 1 <= f32 +f32 / 1 >= 0.5 ? f64 : foo f32 / 1 >= f32 -f32 / 1 ^ 0.5 -f32 / 1 ^ i -f32 / abs(1) -f32 / abs(f32) +f32 / 1 >= i32 +f32 / array[1] +f32 / array[i32] +f32 / bitnot(i) +f32 / ceil(1) +f32 / ceil(f32) +f32 / count(list, false) f32 / f32 -f32 / f32 / f32 -f32 / f32 < f32 +f32 / f32 / 0.5 +f32 / f32 ^ 1 f32 / f64 -f32 / f64 ^ 0.5 +f32 / f64 * i32 +f32 / f64 + f32 +f32 / f64 - i32 +f32 / f64 / 1 +f32 / f64 / f64 +f32 / f64 / i64 +f32 / f64 < i +f32 / float(1) +f32 / float(i32) f32 / float(i64) -f32 / get(array, 1) +f32 / floor(i) f32 / half(0.5) +f32 / half(1) +f32 / half(f64) f32 / i -f32 / i <= i64 +f32 / i * 0.5 +f32 / i / 0.5 +f32 / i <= i +f32 / i == i32 +f32 / i > f64 f32 / i32 -f32 / i32 != i -f32 / i32 ** i -f32 / i32 / f64 -f32 / i32 >= i +f32 / i32 * 1 +f32 / i32 * f32 +f32 / i32 ** f32 +f32 / i32 + i +f32 / i32 + i64 +f32 / i32 < f64 + 0.5 +f32 / i32 >= i32 f32 / i64 -f32 / i64 * i64 -f32 / i64 > i32 -f32 / i64 ^ 1 -f32 / i64 ^ i -f32 / int(f32) -f32 / int(f64) -f32 / int(i) -f32 / int(i32) -f32 / last(array) +f32 / i64 - f64 +f32 / i64 ^ 0.5 +f32 / int(0.5) +f32 / int(1 * i64) f32 / max(0.5) -f32 / max(1) -f32 / min(f32) +f32 / min(i32) +f32 / reduce(array, #) +f32 / reduce(list, 1) +f32 / score(i) f32 < -0.5 -f32 < -f32 f32 < -f64 -f32 < -i32 +f32 < -i f32 < -i64 -f32 < 0.5 != true -f32 < 0.5 ? array : array -f32 < 0.5 ? false : score -f32 < 0.5 ? i64 : i32 -f32 < 0.5 ? ok : f32 +f32 < 0.5 + 0.5 +f32 < 0.5 + 1 f32 < 0.5 ^ f32 -f32 < 1 != ok -f32 < 1 * f32 -f32 < 1 ** 1 -f32 < 1 ** i -f32 < 1 - i -f32 < 1 / 0.5 -f32 < 1 ? f32 : i64 -f32 < 1 ? foo : i -f32 < 1 ? i64 : foo -f32 < 1 || not ok -f32 < abs(1) -f32 < abs(i) -f32 < array[i64] -f32 < array[i] -f32 < div(1, 1) +f32 < 0.5 ^ i64 +f32 < 1 % 1 +f32 < 1 + f64 +f32 < 1 ? f64 : i +f32 < 1 and ok +f32 < abs(0.5) +f32 < ceil(0.5) +f32 < ceil(f64) +f32 < count(array, ok) +f32 < count(list, ok) f32 < f32 -f32 < f32 ** 1 -f32 < f32 ^ 0.5 +f32 < f32 / 1 +f32 < f32 ^ f64 f32 < f64 -f32 < f64 != ok -f32 < f64 / f64 -f32 < f64 == nil -f32 < f64 == true -f32 < f64 ? "foo" : half -f32 < float(f32) -f32 < float(i64) -f32 < half(f64) +f32 < f64 ** 1 +f32 < f64 + 0.5 +f32 < f64 + i +f32 < f64 / i64 +f32 < f64 ? 0.5 : array +f32 < f64 ? div : i32 +f32 < f64 and ok +f32 < floor(0.5) +f32 < floor(i) +f32 < half(0.5) +f32 < half(1) f32 < i -f32 < i * 1 -f32 < i - i32 -f32 < i ? greet : "foo" +f32 < i != ok +f32 < i / 1 +f32 < i ? 1 : i f32 < i32 -f32 < i32 ** 0.5 +f32 < i32 ** i64 +f32 < i32 ? f64 : i +f32 < i32 ? greet : i32 f32 < i32 or ok -f32 < i32 || ok f32 < i64 -f32 < i64 != nil -f32 < i64 && ok -f32 < i64 * i32 -f32 < i64 - f32 -f32 < int(f64) -f32 < max(1) -f32 < score(1) -f32 < score(i) +f32 < i64 - i32 +f32 < i64 / 0.5 +f32 < i64 ? foo : i32 +f32 < i64 ? foo?.Bar : div +f32 < i64 ^ 0.5 +f32 < max(i) +f32 < max(i32, 1) +f32 < min(0.5) +f32 < reduce(array, #) +f32 < reduce(list, 1) +f32 < round(i64) f32 <= -0.5 f32 <= -1 -f32 <= -f32 f32 <= -f64 -f32 <= -i f32 <= -i64 -f32 <= -min(i64) +f32 <= 0.5 != true f32 <= 0.5 * 0.5 -f32 <= 0.5 ** i32 -f32 <= 0.5 - 1 -f32 <= 0.5 / 0.5 -f32 <= 0.5 == ok -f32 <= 0.5 == true -f32 <= 1 != nil -f32 <= 1 % i -f32 <= 1 * 0.5 -f32 <= 1 * i32 -f32 <= 1 == ok -f32 <= abs(1) +f32 <= 0.5 + i +f32 <= 0.5 / i64 +f32 <= 0.5 ? i64 : i +f32 <= 1 - 0.5 +f32 <= 1 == nil +f32 <= 1 ? f64 : add +f32 <= 1 ? i64 : i64 % 1 +f32 <= 1 ? list : div +f32 <= 1 || ok f32 <= f32 -f32 <= f32 ** i64 -f32 <= f32 ? 0.5 : foo +f32 <= f32 * 1 +f32 <= f32 + f64 +f32 <= f32 + i +f32 <= f32 ? greet : half f32 <= f64 -f32 <= f64 ? ok : f64 -f32 <= f64 ^ f32 -f32 <= f64 and ok -f32 <= findIndex(list, ok) -f32 <= first(array) +f32 <= findIndex(list, ok) * f64 +f32 <= float(1) +f32 <= float(i) +f32 <= float(i64) +f32 <= float(toJSON(1)) +f32 <= floor(0.5) f32 <= half(0.5) +f32 <= half(1) +f32 <= half(f64) f32 <= i -f32 <= i != nil -f32 <= i % i64 -f32 <= i ** i32 -f32 <= i - 0.5 -f32 <= i / f32 -f32 <= i == ok +f32 <= i == nil +f32 <= i and i32 <= f32 f32 <= i32 -f32 <= i32 * i64 f32 <= i32 ** i32 -f32 <= i32 + i32 -f32 <= i32 - 1 +f32 <= i32 + 1 f32 <= i32 / 1 -f32 <= i32 ? 0.5 : i32 -f32 <= i32 and ok f32 <= i64 -f32 <= i64 * i -f32 <= i64 ? true : array -f32 <= i64 or ok -f32 <= int(0.5) -f32 <= int(i) -f32 <= len("foo") -f32 <= max(f32) -f32 <= max(i64) -f32 <= min(i64, i32) +f32 <= i64 ** i64 +f32 <= i64 - f32 +f32 <= i64 ? f64 : f64 +f32 <= i64 ^ i32 +f32 <= i64 || nil in array +f32 <= last(array) +f32 <= min(0.5) +f32 <= min(1) +f32 <= min(f64) +f32 <= round(0.5) f32 <= score(1) -f32 <= score(i) -f32 == --f64 f32 == -0.5 f32 == -1 f32 == -f32 f32 == -i32 f32 == -i64 -f32 == 0.5 && i32 == i32 -f32 == 0.5 * i32 -f32 == 0.5 ** 1 -f32 == 0.5 and ok -f32 == 1 && ok ? add : f32 -f32 == 1 ^ i -f32 == abs(1) -f32 == array[1] -f32 == count(array, ok) +f32 == 0.5 != ok +f32 == 0.5 * 0.5 +f32 == 0.5 * 1 +f32 == 0.5 ** i32 +f32 == 0.5 + 1 +f32 == 0.5 / i32 +f32 == 0.5 / i64 +f32 == 0.5 ? array : greet +f32 == 0.5 ? true : score +f32 == 0.5 ^ 0.5 +f32 == 0.5 || f64 >= 1 +f32 == 1 != nil +f32 == 1 + f32 +f32 == 1 - 1 +f32 == 1 - i +f32 == 1 == ok +f32 == 1 ? foo : f32 +f32 == 1 ? ok : add != nil +f32 == add(i, 1) +f32 == array[i32] +f32 == bitnot(i) +f32 == ceil(1) +f32 == ceil(i32) +f32 == ceil(i64) f32 == f32 -f32 == f32 ** f32 -f32 == f32 - i32 -f32 == f32 ? 1 : greet -f32 == f32 ? list : "bar" +f32 == f32 ? f32 : list +f32 == f32 and ok f32 == f64 -f32 == f64 - 1 -f32 == f64 - f64 -f32 == f64 ? ok : i64 -f32 == find(array, ok) -f32 == findLast(array, ok) -f32 == findLastIndex(list, true) -f32 == get(array, 1) +f32 == f64 + f64 +f32 == f64 ^ 1 +f32 == findLastIndex(array, ok) +f32 == first(array) +f32 == float(0.5) +f32 == float(1) +f32 == floor(f64) +f32 == half(1) +f32 == half(f64) f32 == i -f32 == i * i64 -f32 == i + f64 + 0.5 -f32 == i - f64 -f32 == i - i32 -f32 == i / 0.5 -f32 == i ? "foo" : i64 -f32 == i ? i : 0.5 +f32 == i != nil +f32 == i - 0.5 +f32 == i - i64 f32 == i32 -f32 == i32 % 1 -f32 == i32 - 0.5 +f32 == i32 + i32 +f32 == i32 ? 0.5 : array +f32 == i32 ? i64 : i64 +f32 == i32 ? true : half +f32 == i32 ^ i32 +f32 == i32 or ok f32 == i64 -f32 == i64 % i -f32 == i64 * 0.5 -f32 == int(1) -f32 == max(0.5, 1) -f32 == max(i) +f32 == i64 * i64 +f32 == i64 + 0.5 +f32 == i64 - 0.5 +f32 == i64 - 1 +f32 == i64 ? div : 0.5 +f32 == last(array) +f32 == max(f64) f32 == min(0.5) -f32 == min(i64) -f32 == nil ? "foo" : div -f32 == nil ? i32 : greet +f32 == min(f32) +f32 == nil ? array : add +f32 == nil ? i : div +f32 == round(1) f32 == score(1) +f32 == score(i) +f32 > -(0.5 / 1) f32 > -0.5 -f32 > -f64 -f32 > -i +f32 > -f32 f32 > -i32 -f32 > -i64 -f32 > 0.5 != false -f32 > 0.5 != ok -f32 > 0.5 - 0.5 -f32 > 0.5 / 0.5 -f32 > 0.5 ? foo : f64 -f32 > 0.5 ? greet : half -f32 > 1 % 1 -f32 > 1 ** 0.5 -f32 > 1 + f32 -f32 > 1 / i64 -f32 > 1 == true -f32 > 1 ? nil : half -f32 > 1 ^ i32 -f32 > array[i32] +f32 > 0.5 / f32 +f32 > 0.5 / i32 +f32 > 0.5 == true ? i32 : array +f32 > 0.5 ? half : false +f32 > 0.5 ^ f64 +f32 > 1 ** i +f32 > 1 ? 1 : false +f32 > 1 ? list : "foo" +f32 > abs(1) +f32 > abs(f32) +f32 > abs(f64) +f32 > count(array, ok) f32 > f32 -f32 > f32 ** f32 -f32 > f32 - i -f32 > f32 == true +f32 > f32 + f32 +f32 > f32 - f32 +f32 > f32 == nil f32 > f64 -f32 > f64 - i32 -f32 > f64 / i64 -f32 > f64 ? array : false -f32 > f64 ? true : array -f32 > f64 or ok +f32 > f64 * i +f32 > f64 ** 0.5 +f32 > float(0.5) +f32 > float(i32) +f32 > floor(1) +f32 > half(1) +f32 > half(f64) f32 > i -f32 > i * 0.5 -f32 > i + f32 +f32 > i != ok +f32 > i * 1 +f32 > i ? array : 1 +f32 > i ? foo : list f32 > i32 -f32 > i32 != ok -f32 > i32 * i +f32 > i32 != nil +f32 > i32 * f64 +f32 > i32 ? 0.5 : greet +f32 > i32 and ok f32 > i64 -f32 > i64 ? 1 : f64 -f32 > i64 ? ok : greet -f32 > int(0.5) -f32 > int(f64) -f32 > max(i32) -f32 > max(i32, 1) -f32 > min(f64) -f32 > score(1) -f32 > score(i) +f32 > i64 % i64 +f32 > i64 ** i +f32 > i64 + 0.5 +f32 > i64 - i64 +f32 > i64 ? i : 0.5 +f32 > mean(array) +f32 > min(f32) +f32 > min(i64) +f32 > reduce(array, #) +f32 > reduce(array, i64) +f32 > reduce(list, f32) +f32 > round(0.5) +f32 > score(1, 1) +f32 >= -0.5 +f32 >= -f32 f32 >= -f64 -f32 >= -i -f32 >= -i32 -f32 >= -i64 -f32 >= 0.5 ** f64 -f32 >= 0.5 - 0.5 -f32 >= 0.5 == ok -f32 >= 1 != ok -f32 >= 1 != true -f32 >= 1 % 1 -f32 >= 1 % i -f32 >= 1 - 1 -f32 >= 1 - i -f32 >= 1 - i64 -f32 >= 1 ? "foo" endsWith "foo" : f64 -f32 >= abs(1) +f32 >= 0.5 * f64 +f32 >= 0.5 / i64 +f32 >= 0.5 ? i64 : nil +f32 >= 0.5 ^ i64 +f32 >= 1 == false +f32 >= 1 == ok ? add : array +f32 >= 1 ? i : 1 +f32 >= abs(0.5) +f32 >= abs(f32) +f32 >= abs(i) +f32 >= array[1] +f32 >= array[i32] +f32 >= bitnot(i32) +f32 >= count(list, false) f32 >= f32 f32 >= f32 ** 1 -f32 >= f32 ** f32 -f32 >= f32 + i32 +f32 >= f32 - i64 +f32 >= f32 ? half : greet +f32 >= f32 or nil != ok f32 >= f64 -f32 >= f64 + i32 -f32 >= first(array) -f32 >= float(i32) -f32 >= float(i64) +f32 >= f64 && ok +f32 >= f64 ** 0.5 +f32 >= f64 ** i32 +f32 >= f64 - f64 +f32 >= f64 / i64 +f32 >= f64 or ok +f32 >= float(0.5) f32 >= half(f64) f32 >= i -f32 >= i != true -f32 >= i * 0.5 -f32 >= i ** 0.5 -f32 >= i ** i32 -f32 >= i + f64 -f32 >= i ? "bar" : nil -f32 >= i ? ok : i +f32 >= i - f32 +f32 >= i ? 1 : nil +f32 >= i ^ i f32 >= i32 -f32 >= i32 * 0.5 -f32 >= i32 ? array : foo -f32 >= i32 ^ i32 +f32 >= i32 % i +f32 >= i32 - f32 +f32 >= i32 / i64 +f32 >= i32 ? f32 : 0.5 +f32 >= i32 or not ok f32 >= i64 -f32 >= i64 % i64 -f32 >= i64 ** 0.5 -f32 >= i64 ? 1 : i32 -f32 >= i64 ? i64 : add -f32 >= i64 || ok -f32 >= len("foo") +f32 >= i64 * i32 +f32 >= i64 + f64 +f32 >= i64 / 1 +f32 >= len("bar") f32 >= max(i) -f32 >= min(i) +f32 >= max(i64) +f32 >= reduce(array, #) f32 >= score(1) -f32 ^ (1 * f32) -f32 ^ (1 + 1) -f32 ^ (1 - 0.5) -f32 ^ (f32 * 0.5) -f32 ^ (f32 / 1) -f32 ^ (i + i) -f32 ^ (i32 % 1) -f32 ^ (i32 % i64) -f32 ^ (i32 / 1) -f32 ^ (i32 / f64) +f32 >= sum(array) +f32 ^ (0.5 * f64) +f32 ^ (0.5 / 1) +f32 ^ (0.5 / i) +f32 ^ (1 * i) +f32 ^ (1 + f64) +f32 ^ (f32 * i64) +f32 ^ (f64 * f64) +f32 ^ (f64 - 1) +f32 ^ (f64 / i) +f32 ^ (i64 * f64) +f32 ^ (i64 * i32) +f32 ^ (i64 * i64) +f32 ^ (i64 + i64) f32 ^ (i64 - f32) f32 ^ -0.5 f32 ^ -1 -f32 ^ -f32 -f32 ^ -i f32 ^ -i32 -f32 ^ -i64 -f32 ^ 0.5 != i64 -f32 ^ 0.5 + f32 -f32 ^ 0.5 + i64 -f32 ^ 0.5 - f64 -f32 ^ 0.5 <= 0.5 ^ 0.5 -f32 ^ 0.5 ^ f32 -f32 ^ 1 - i -f32 ^ 1 - i32 -f32 ^ 1 <= 1 * 1 -f32 ^ 1 <= i32 -f32 ^ 1 ^ 0.5 +f32 ^ 0.5 ** i32 +f32 ^ 0.5 - f32 +f32 ^ 0.5 - i32 +f32 ^ 0.5 == i64 +f32 ^ 0.5 ^ 0.5 +f32 ^ 1 != i64 +f32 ^ 1 / f32 +f32 ^ 1 >= -0.5 +f32 ^ abs(1) +f32 ^ abs(f32) +f32 ^ array[i64] +f32 ^ array[i] +f32 ^ bitnot(1) +f32 ^ bitor(1, i32) f32 ^ f32 -f32 ^ f32 ** i -f32 ^ f32 + f32 -f32 ^ f32 / f32 +f32 ^ f32 ^ 0.5 +f32 ^ f32 in array f32 ^ f64 -f32 ^ f64 < f64 -f32 ^ f64 < i64 -f32 ^ f64 <= f64 -f32 ^ f64 == f64 -f32 ^ f64 > i +f32 ^ f64 ** f64 +f32 ^ f64 / 1 * 1 +f32 ^ f64 / f64 +f32 ^ f64 == i64 +f32 ^ f64 not in array +f32 ^ floor(0.5) +f32 ^ floor(1) +f32 ^ half(1) f32 ^ half(f64) f32 ^ i -f32 ^ i ** i32 +f32 ^ i - f64 +f32 ^ i <= i +f32 ^ i >= f64 +f32 ^ i ^ f32 f32 ^ i32 -f32 ^ i32 + f32 +f32 ^ i32 ** i64 f32 ^ i64 -f32 ^ last(array) -f32 ^ max(0.5) -f32 ^ max(f32) -f32 ^ max(i64) +f32 ^ i64 ** 1 +f32 ^ i64 + i64 +f32 ^ i64 - f32 +f32 ^ i64 >= f64 +f32 ^ i64 ^ f32 +f32 ^ int(i32) +f32 ^ len("foo") +f32 ^ len(array) f32 ^ min(1) -f32 ^ min(1, 1) +f32 ^ min(f64) +f32 ^ min(i) +f32 ^ reduce(array, 1) +f32 ^ round(i) +f32 ^ round(i32) f32 ^ score(i) -f32 in [false, list] +f32 ^ score(reduce(array, #)) +f32 in [i] f32 in [nil] -f32 not in sort(array) +f32 in array +f32 in array == nil +f32 in array ? 1 : i +f32 in array ? false : 0.5 +f32 in array ? nil : "bar" +f32 in groupBy(array, #) +f32 in groupBy(list, #) +f32 in groupBy(list, ok) +f32 in map(array, #) +f32 not in [f32, "bar"] +f32 not in array +f32 not in array ? foo : i +f32 not in array ? i32 : div f64 -f64 != -(0.5 ** 0.5) +f64 != -0.5 f64 != -1 -f64 != -f64 +f64 != -f32 f64 != -i -f64 != -i32 -f64 != 0.5 && ok -f64 != 0.5 + 1 -f64 != 0.5 + f64 -f64 != 0.5 == nil -f64 != 0.5 == true -f64 != 0.5 ? false : array -f64 != 0.5 and ok -f64 != 1 ? list : false -f64 != 1 ^ i64 -f64 != abs(f32) -f64 != array[i64] +f64 != -i64 +f64 != 0.5 != false +f64 != 0.5 ** 1 +f64 != 0.5 ** f64 +f64 != 0.5 + f32 +f64 != 0.5 ^ 0.5 +f64 != 1 - 1 +f64 != 1 / 0.5 +f64 != 1 ? half : div +f64 != 1 ^ i +f64 != abs(i32) +f64 != bitnot(i64) +f64 != ceil(i) f64 != f32 -f64 != f32 * i32 +f64 != f32 != nil +f64 != f32 + 0.5 +f64 != f32 + i32 +f64 != f32 - i32 +f64 != f32 ? array : nil +f64 != f32 ? i32 : "bar" +f64 != f32 ? ok : i +f64 != f32 or greet == nil f64 != f64 f64 != f64 * f32 -f64 != f64 ^ 1 -f64 != findLastIndex(list, ok) +f64 != f64 ? f64 : true f64 != first(array) -f64 != get(array, i32) +f64 != floor(1) f64 != half(0.5) -f64 != half(f64) +f64 != half(1) f64 != i -f64 != i && ok -f64 != i + 1 +f64 != i * 0.5 +f64 != i / 1 +f64 != i / f32 +f64 != i ^ f64 f64 != i32 -f64 != i32 + f64 -f64 != i32 ? "bar" : nil -f64 != i32 ? add : 1 -f64 != i32 ^ 0.5 +f64 != i32 * f32 +f64 != i32 == ok +f64 != i32 ? f64 : ok +f64 != i32 ? foo : ok +f64 != i32 ^ i32 f64 != i64 -f64 != i64 ** 0.5 +f64 != i64 * f64 +f64 != i64 - i32 +f64 != i64 or ok f64 != int(i64) -f64 != max(i64) -f64 != min(1) -f64 != min(i32) -f64 != nil == ok -f64 != score(1) -f64 != score(i) -f64 * (0.5 - f32) -f64 * (0.5 - i64) -f64 * (f32 + i32) -f64 * (i32 - 0.5) -f64 * (i64 - f64) +f64 != min(f64) +f64 != nil != ok +f64 != nil && f64 > 0.5 +f64 != nil == true +f64 != nil ? array : foo +f64 != nil ? f64 : half +f64 != nil ? i64 : 0.5 +f64 != nil ? nil : half +f64 != round(1) +f64 * (0.5 - 1) +f64 * (i64 + 0.5) f64 * -1 f64 * -f32 f64 * -f64 -f64 * -i32 -f64 * -i64 -f64 * 0.5 * 0.5 ^ i64 +f64 * 0.5 * 1 +f64 * 0.5 * i64 +f64 * 0.5 ** 0.5 +f64 * 0.5 / 0.5 +f64 * 0.5 / f32 f64 * 0.5 / i32 +f64 * 0.5 < f32 +f64 * 0.5 <= i +f64 * 0.5 == f64 f64 * 0.5 ^ 1 -f64 * 1 ** 0.5 -f64 * 1 + i64 -f64 * 1 / i32 -f64 * 1 < 0.5 * 0.5 -f64 * abs(i) +f64 * 1 * f64 +f64 * 1 * i32 +f64 * 1 ** 1 +f64 * 1 + f64 +f64 * 1 - i32 +f64 * 1 <= 1 + 1 +f64 * 1 == i64 +f64 * 1 > f32 +f64 * 1 > f64 +f64 * 1 >= f64 +f64 * bitnot(i64) +f64 * ceil(i) +f64 * ceil(i64) f64 * f32 -f64 * f32 * f32 -f64 * f32 - f32 -f64 * f32 - f64 -f64 * f32 / f64 -f64 * f32 >= f64 +f64 * f32 != i +f64 * f32 / i64 +f64 * f32 > f64 +f64 * f32 > i f64 * f64 -f64 * f64 / i -f64 * f64 < f64 -f64 * f64 >= score(1) -f64 * float(i) +f64 * f64 * f64 +f64 * f64 / 1 +f64 * f64 <= f64 +f64 * f64 > f64 +f64 * f64 in array +f64 * float(f32) +f64 * floor(0.5) +f64 * get(array, 1) +f64 * half(f64) f64 * i -f64 * i != i -f64 * i * 0.5 -f64 * i * i -f64 * i * i64 -f64 * i - f64 +f64 * i / f64 f64 * i32 -f64 * i32 * 1 -f64 * i32 > f64 +f64 * i32 != i64 * f64 +f64 * i32 - i32 f64 * i64 -f64 * i64 + f32 -f64 * i64 + i -f64 * i64 - f32 +f64 * i64 ** i +f64 * i64 == i +f64 * i64 > i32 f64 * i64 ^ i32 -f64 * int(0.5) -f64 * int(f32) -f64 * int(f64) -f64 * last(array) -f64 * len(list) -f64 * max(i64) -f64 * min(i32) -f64 * score(1) -f64 * score(i) -f64 ** (0.5 * i32) -f64 ** (0.5 + 1) -f64 ** (0.5 + i) -f64 ** (1 + 1) -f64 ** (1 + f64) -f64 ** (1 - 1) -f64 ** (1 / i64) -f64 ** (f32 * i) -f64 ** (f64 + 0.5) -f64 ** (f64 + f64) -f64 ** (f64 + i) -f64 ** (i % 1) -f64 ** (i % i32) -f64 ** (i32 * 1) -f64 ** (i32 + 0.5) -f64 ** (i32 - f32) -f64 ** (i64 * 1) +f64 * median(array) +f64 * min(1) +f64 * min(f64) +f64 * min(i) +f64 * round(1) +f64 * round(i64) +f64 ** (0.5 - i) +f64 ** (0.5 / i64) +f64 ** (1 * i) +f64 ** (f64 * i32) +f64 ** (f64 / 1) +f64 ** (i * 1) +f64 ** (i * i64) +f64 ** (i32 * i) +f64 ** (i32 + i32) +f64 ** (i32 - f64) +f64 ** (i32 / i64) +f64 ** (i64 % 1) f64 ** (i64 + 0.5) -f64 ** (i64 / i) +f64 ** (i64 + i64) +f64 ** (i64 - i32) +f64 ** (i64 / 0.5) f64 ** -0.5 f64 ** -1 -f64 ** -f32 -f64 ** -f64 f64 ** -i -f64 ** -i32 -f64 ** -i64 -f64 ** 0.5 ** i64 -f64 ** 0.5 <= 1 - 1 -f64 ** 1 ** 0.5 ** 0.5 -f64 ** 1 < 1 - i64 -f64 ** 1 == f64 + f32 -f64 ** 1 ^ i -f64 ** 1 ^ i64 -f64 ** abs(1) -f64 ** abs(f64) +f64 ** 0.5 ** f32 +f64 ** 0.5 == i32 +f64 ** 1 + f64 +f64 ** 1 / i +f64 ** 1 < f32 +f64 ** 1 > i32 +f64 ** 1 ^ f32 +f64 ** abs(i) +f64 ** bitand(1, 1) +f64 ** ceil(0.5) +f64 ** ceil(f64) f64 ** f32 -f64 ** f32 ** 0.5 -f64 ** f32 == i64 +f64 ** f32 != f64 +f64 ** f32 ** f64 +f64 ** f32 > f64 f64 ** f64 -f64 ** f64 != f32 -f64 ** f64 ** 0.5 -f64 ** f64 / f32 -f64 ** f64 < f64 -f64 ** f64 <= f64 -f64 ** f64 ^ f64 -f64 ** f64 ^ i32 -f64 ** float(i32) -f64 ** get(array, i64) +f64 ** f64 - f32 +f64 ** f64 / min(1) +f64 ** f64 <= f32 +f64 ** f64 <= i64 +f64 ** f64 ^ 0.5 f64 ** half(0.5) f64 ** i -f64 ** i != i -f64 ** i - i32 -f64 ** i / f32 -f64 ** i >= i32 -f64 ** i ^ i32 +f64 ** i * f64 +f64 ** i ** i +f64 ** i + -i32 +f64 ** i + f32 f64 ** i32 -f64 ** i32 != max(f64, 0.5) -f64 ** i32 ** 1 -f64 ** i32 ^ 1 +f64 ** i32 != f64 +f64 ** i32 > f64 f64 ** i64 -f64 ** i64 ** i64 -f64 ** i64 / f64 -f64 ** i64 ^ i -f64 ** int(0.5) -f64 ** int(1) -f64 ** max(i32) -f64 ** min(1) +f64 ** i64 + f32 +f64 ** i64 <= f32 +f64 ** i64 not in map(array, 0.5) +f64 ** last(array) +f64 ** len("bar") +f64 ** max(i) f64 ** min(f32) -f64 ** score(1, 1) +f64 ** reduce(array, #) +f64 ** reduce(list, i32) +f64 ** score(i) f64 + -0.5 +f64 + -1 f64 + -f64 f64 + -i f64 + -i32 -f64 + -i64 -f64 + 0.5 * 1 -f64 + 0.5 * i32 f64 + 0.5 / f32 -f64 + 0.5 == i64 -f64 + 1 != f64 -f64 + 1 + f64 -f64 + 1 - 0.5 -f64 + 1 < i64 -f64 + 1 > 0.5 ? 1 : 0.5 -f64 + 1 > i64 -f64 + 1 >= f32 -f64 + abs(i) -f64 + abs(i64) -f64 + array[1] -f64 + array[i64] -f64 + count(array, ok) +f64 + 0.5 < i32 +f64 + 0.5 <= f64 +f64 + 0.5 <= float(f32) +f64 + 0.5 <= i +f64 + 0.5 > f64 +f64 + 0.5 ^ i +f64 + 0.5 ^ i64 +f64 + 1 % i +f64 + 1 * 0.5 +f64 + 1 * 1 +f64 + 1 * f64 +f64 + 1 ** 0.5 +f64 + 1 + i32 +f64 + 1 / i64 +f64 + 1 ^ i +f64 + 1 not in map(array, #) +f64 + ceil(0.5) +f64 + count(list, true) f64 + f32 -f64 + f32 * i32 -f64 + f32 - i64 +f64 + f32 == i != true f64 + f64 -f64 + f64 + i64 -f64 + f64 == i32 -f64 + f64 > i32 -f64 + f64 ^ 0.5 -f64 + float(i64) +f64 + f64 < f32 +f64 + f64 <= i32 +f64 + f64 ^ i32 +f64 + float(f64) +f64 + floor(f64) +f64 + get(array, i32) f64 + half(0.5) -f64 + half(f64) +f64 + half(1) f64 + i -f64 + i ** 0.5 -f64 + i + 1 +f64 + i + 0.5 f64 + i / 0.5 +f64 + i / i32 +f64 + i > 0.5 != true +f64 + i > f64 +f64 + i >= f64 f64 + i32 -f64 + i32 ** i64 -f64 + i32 + i32 -f64 + i32 / 1 -f64 + i32 <= i -f64 + i32 >= i64 +f64 + i32 != i64 +f64 + i32 % i32 +f64 + i32 ** 1 +f64 + i32 > i64 f64 + i64 -f64 + i64 - f64 -f64 + i64 ^ f32 -f64 + int(0.5) -f64 + int(i32) -f64 + len(array) -f64 + min(0.5, 0.5) -f64 + min(f32) -f64 + score(i) +f64 + i64 + i64 +f64 + i64 / f64 +f64 + i64 > i32 / i +f64 + i64 > i64 +f64 + i64 ^ i32 +f64 + reduce(array, #) +f64 + reduce(list, f32) +f64 + score(1) f64 - -0.5 f64 - -1 f64 - -f64 f64 - -i -f64 - -i32 f64 - -i64 -f64 - 0.5 != f64 -f64 - 0.5 * 0.5 -f64 - 0.5 ** i -f64 - 0.5 + f32 -f64 - 0.5 + i -f64 - 0.5 + i32 -f64 - 0.5 >= -0.5 -f64 - 1 * f32 -f64 - 1 ** f32 -f64 - 1 ** i32 -f64 - 1 + 1 +f64 - 0.5 - 0.5 +f64 - 0.5 - 1 +f64 - 0.5 - i32 +f64 - 0.5 >= f64 +f64 - 0.5 ^ i64 +f64 - 1 * i32 +f64 - 1 + i64 f64 - 1 - f64 -f64 - 1 / 0.5 +f64 - 1 / i64 f64 - 1 < f32 -f64 - 1 ^ 0.5 -f64 - 1 ^ 1 -f64 - abs(0.5) -f64 - abs(i) -f64 - array[i64] +f64 - 1 < f32 ? i64 : false +f64 - 1 >= len(array) +f64 - 1 ^ i64 f64 - f32 -f64 - f32 * f64 -f64 - f32 + 1 + 0.5 -f64 - f32 - f64 +f64 - f32 != i64 +f64 - f32 + f32 f64 - f32 < f64 -f64 - f32 >= i32 +f64 - f32 ^ f32 f64 - f64 -f64 - f64 - 0.5 -f64 - f64 - i32 -f64 - f64 <= i -f64 - f64 == f64 -f64 - f64 > f32 -f64 - f64 >= get(array, i64) -f64 - get(array, i) -f64 - half(0.5) +f64 - f64 + -1 +f64 - f64 < f64 +f64 - float(f32) +f64 - floor(1) +f64 - half(1) f64 - i -f64 - i % i32 +f64 - i + 0.5 f64 - i + 1 -f64 - i / 1 -f64 - i < i32 -f64 - i < i64 -f64 - i == i -f64 - i == i64 -f64 - i > f64 +f64 - i + i32 +f64 - i / i +f64 - i ^ f32 f64 - i32 -f64 - i32 + i -f64 - i32 - i64 -f64 - i32 >= i32 +f64 - i32 / 0.5 +f64 - i32 >= i64 +f64 - i32 ^ 0.5 f64 - i64 -f64 - i64 * 0.5 -f64 - i64 * 1 -f64 - i64 - f32 -f64 - int(0.5) +f64 - i64 ** i32 +f64 - int(i) f64 - int(i32) -f64 - max(1) -f64 - min(1) -f64 - min(i32, i64) +f64 - reduce(array, -#) +f64 - round(1) f64 - score(i) -f64 / (0.5 + f32) -f64 / (0.5 - 0.5) -f64 / (0.5 - f64) -f64 / (0.5 - i32) -f64 / (1 + i32) -f64 / (1 - 1) -f64 / (i32 + f64) -f64 / (i32 - 1) -f64 / (i64 - i64) +f64 / (0.5 - 1) +f64 / (0.5 - i64) +f64 / (f32 + 1) +f64 / (i + 0.5) +f64 / (i32 + i64) f64 / -0.5 f64 / -1 -f64 / -f32 +f64 / -f64 f64 / -i f64 / -i32 -f64 / 0.5 * i -f64 / 0.5 ** 0.5 -f64 / 0.5 ** f64 -f64 / 0.5 / f64 -f64 / 0.5 / i64 -f64 / 0.5 > f64 -f64 / 0.5 ^ i +f64 / -i64 +f64 / 0.5 != f64 +f64 / 0.5 * f32 +f64 / 0.5 + f64 +f64 / 0.5 / 1 +f64 / 0.5 < i32 +f64 / 0.5 == i32 +f64 / 0.5 >= i64 f64 / 1 != i -f64 / 1 * abs(i64) -f64 / 1 * i -f64 / 1 ** 0.5 -f64 / 1 ^ i64 -f64 / array[i32] -f64 / array[i] +f64 / 1 * i32 +f64 / 1 ** 1 +f64 / 1 / i +f64 / 1 <= i64 +f64 / 1 ^ i +f64 / abs(f64) +f64 / array[1] +f64 / array[i64] +f64 / ceil(i32) f64 / f32 -f64 / f32 != f64 f64 / f32 * i -f64 / f32 > f64 -f64 / f32 ^ i32 -f64 / f32 in [f32] +f64 / f32 * i64 +f64 / f32 / 0.5 +f64 / f32 == f32 +f64 / f32 ^ 0.5 f64 / f64 -f64 / f64 != f32 -f64 / f64 * f32 -f64 / f64 - f32 -f64 / f64 - f64 -f64 / get(array, i64) +f64 / f64 / 0.5 +f64 / f64 >= f64 +f64 / f64 >= i32 +f64 / f64 >= i64 +f64 / float(1) +f64 / float(f64) +f64 / floor(i64) +f64 / get(array, 1) +f64 / get(array, i32) f64 / half(0.5) +f64 / half(1) f64 / i -f64 / i * i32 +f64 / i != f64 f64 / i ** 0.5 -f64 / i ** i32 -f64 / i + i64 -f64 / i < f64 -f64 / i > 1 ** 1 -f64 / i > f64 -f64 / i >= f64 +f64 / i ** f32 +f64 / i + i32 +f64 / i == i64 +f64 / i >= i f64 / i32 -f64 / i32 / i32 -f64 / i32 < f64 +f64 / i32 != 0.5 - i64 +f64 / i32 == f64 ** i +f64 / i32 == i32 +f64 / i32 >= f32 f64 / i64 -f64 / i64 * i64 ^ i -f64 / i64 - f32 -f64 / i64 / 0.5 -f64 / i64 / i64 -f64 / i64 <= f64 -f64 / i64 > i +f64 / i64 < f64 f64 / int(f32) -f64 / int(i64) +f64 / last(array) f64 / max(i) -f64 / min(0.5) -f64 / score(i) +f64 / reduce(array, #) +f64 / reduce(array, f64) +f64 / reduce(list, f32) +f64 / round(1) +f64 / round(i64) +f64 / score(1) f64 < -0.5 -f64 < -1 f64 < -i32 f64 < -i64 -f64 < 0.5 ** f32 +f64 < 0.5 + i64 +f64 < 0.5 / 0.5 +f64 < 0.5 / i f64 < 0.5 == true -f64 < 0.5 ? 0.5 : foo -f64 < 0.5 ? 1 : array -f64 < 0.5 ? greet : false -f64 < 0.5 ^ 1 -f64 < 0.5 or ok -f64 < 1 == not ok -f64 < 1 ? 1 : half -f64 < 1 ? 1 : i -f64 < 1 ? ok : i -f64 < 1 and nil == i32 +f64 < 0.5 ? f64 : array +f64 < 1 % 1 +f64 < 1 * 0.5 +f64 < 1 ** i32 +f64 < 1 / f32 +f64 < 1 == false +f64 < 1 ? i : "foo" f64 < abs(1) -f64 < abs(i32) -f64 < array[i32] -f64 < count(list, true) +f64 < abs(f32) +f64 < array[i64] +f64 < bitnot(1) +f64 < ceil(f64) +f64 < count(array, false) f64 < f32 -f64 < f32 * 0.5 -f64 < f32 * f64 -f64 < f32 ** i32 -f64 < f32 - 1 -f64 < f32 ? array : 0.5 +f64 < f32 * i +f64 < f32 / i64 +f64 < f32 ^ 1 +f64 < f32 ^ f64 f64 < f64 -f64 < f64 * f32 +f64 < f64 == ok +f64 < floor(i64) f64 < get(array, i) -f64 < half(0.5) f64 < i -f64 < i - f64 -f64 < i == ok -f64 < i ? false : nil +f64 < i && "bar" < "bar" +f64 < i && ok +f64 < i ** i32 +f64 < i + 1 +f64 < i ? 0.5 : "bar" +f64 < i ? div : nil f64 < i32 -f64 < i32 % i32 -f64 < i32 % i64 -f64 < i32 == ok -f64 < i32 and ok +f64 < i32 * f64 +f64 < i32 * i +f64 < i32 ** f32 +f64 < i32 ** i64 +f64 < i32 + f32 +f64 < i32 + f64 +f64 < i32 + i64 +f64 < i32 ? false : ok +f64 < i32 ? true : 1 +f64 < i32 ^ 1 +f64 < i32 ^ i32 f64 < i64 -f64 < i64 * i +f64 < i64 * f64 +f64 < i64 ^ i f64 < int(0.5) -f64 < max(1, i64) -f64 < min(1) -f64 < min(f64) -f64 < min(i64) +f64 < max(1) +f64 < max(f64, i32) +f64 < min(0.5, i64) +f64 < min(f32) +f64 < min(f64, f32) +f64 < min(i32) +f64 < round(0.5) +f64 < score(1) f64 <= -0.5 f64 <= -1 -f64 <= -f32 f64 <= -i f64 <= -i32 -f64 <= 0.5 != ok -f64 <= 0.5 - 1 -f64 <= 0.5 / 0.5 -f64 <= 0.5 == true -f64 <= 0.5 ? foo : list -f64 <= 0.5 ? nil : add -f64 <= 1 != true -f64 <= 1 ** 0.5 +f64 <= 0.5 != false +f64 <= 0.5 + 0.5 +f64 <= 0.5 / f32 +f64 <= 0.5 ? greet : f64 +f64 <= 0.5 ? score : array +f64 <= 1 * i32 f64 <= 1 + 0.5 -f64 <= 1 == false -f64 <= 1 ? array : foo -f64 <= 1 ^ i64 -f64 <= abs(f32) +f64 <= 1 / i +f64 <= 1 == nil +f64 <= 1 ? "bar" : array +f64 <= 1 ? half : list +f64 <= 1 ^ f64 +f64 <= abs(0.5) f64 <= abs(i) -f64 <= array[i] +f64 <= array[i64] +f64 <= ceil(i) f64 <= f32 -f64 <= f32 + f64 -f64 <= f32 - 0.5 -f64 <= f32 ? false : "foo" -f64 <= f32 ? false : i -f64 <= f32 ? i64 : false +f64 <= f32 ** 0.5 +f64 <= f32 - i64 +f64 <= f32 ? f64 : div +f64 <= f32 ^ f32 f64 <= f64 +f64 <= f64 != ok f64 <= f64 + f64 -f64 <= f64 - 0.5 -f64 <= f64 - f64 -f64 <= f64 ^ 0.5 -f64 <= find(array, true) -f64 <= float(f64) +f64 <= f64 + i32 +f64 <= f64 - 1 +f64 <= f64 ^ i +f64 <= float(i) +f64 <= float(i64) f64 <= half(0.5) +f64 <= half(1) f64 <= i -f64 <= i * i32 -f64 <= i ? false : false -f64 <= i ? foo : false +f64 <= i * i64 +f64 <= i - 1 +f64 <= i - f32 +f64 <= i ^ f64 f64 <= i32 -f64 <= i32 == true -f64 <= i32 ? "bar" : nil -f64 <= i32 ? add : ok -f64 <= i32 ? i32 : false +f64 <= i32 ** 1 +f64 <= i32 ? div : foo +f64 <= i32 or all(list, ok) f64 <= i64 -f64 <= i64 % 1 -f64 <= i64 - f32 -f64 <= i64 - i64 -f64 <= i64 ^ 1 -f64 <= i64 and ok -f64 <= int(1) -f64 <= int(f64) -f64 <= int(i) -f64 <= max(f32) -f64 <= min(0.5) -f64 <= score(1) +f64 <= i64 + 1 +f64 <= i64 - 0.5 +f64 <= int(f32) +f64 <= max(i) +f64 <= max(i64, i32) +f64 <= min(i32) +f64 <= min(i64) +f64 <= reduce(array, #) f64 == -0.5 f64 == -1 f64 == -f32 f64 == -f64 f64 == -i -f64 == -i32 -f64 == 0.5 != ok +f64 == -i64 f64 == 0.5 ** 0.5 -f64 == 0.5 ** i32 -f64 == 0.5 / i -f64 == 0.5 / i32 -f64 == 0.5 ? i64 : div -f64 == 1 * f64 -f64 == 1 == nil -f64 == 1 ? false : "foo" -f64 == abs(1) -f64 == abs(i32) -f64 == array[i32] -f64 == array[i64] +f64 == 0.5 - i +f64 == 0.5 ? 0.5 : i64 +f64 == 0.5 ? 1 : 1 +f64 == 1 != ok +f64 == 1 % 1 +f64 == 1 * i64 +f64 == 1 ** 0.5 +f64 == 1 == false +f64 == abs(0.5) +f64 == abs(i64) +f64 == ceil(i) f64 == f32 -f64 == f32 + i64 -f64 == f32 - 1 -f64 == f32 / 0.5 +f64 == f32 && ok +f64 == f32 + len(array) +f64 == f32 ? 0.5 : i +f64 == f32 ^ i32 f64 == f64 -f64 == f64 ** i32 -f64 == f64 - 1 -f64 == f64 / 1 +f64 == f64 ** i +f64 == f64 - f64 f64 == float(0.5) -f64 == float(i) -f64 == get(array, i64) +f64 == floor(0.5) +f64 == half(0.5) f64 == half(f64) f64 == i -f64 == i ** f32 -f64 == i + 0.5 -f64 == i / i32 -f64 == i ? false : f32 -f64 == i ^ f32 +f64 == i != false +f64 == i * 1 +f64 == i ? i32 : score f64 == i32 -f64 == i32 * 1 -f64 == i32 + f64 -f64 == i32 / 1 -f64 == i32 ? greet : array +f64 == i32 == ok ? 1 : list +f64 == i32 == true +f64 == i32 || ok f64 == i64 -f64 == i64 - f32 -f64 == i64 == true -f64 == int(0.5) +f64 == i64 / i +f64 == i64 ? 1 : 0.5 +f64 == i64 ? greet : i32 f64 == int(f32) -f64 == min(0.5) -f64 == min(i64) -f64 == nil == ok -f64 == nil ? i32 : div -f64 == nil ? nil : 0.5 -f64 == score(1) +f64 == max(0.5) +f64 == max(i) +f64 == min(i32) +f64 == nil && ok +f64 == nil ? 0.5 : add +f64 == nil ? foo : "foo" +f64 == reduce(list, i32) +f64 == round(i) +f64 == score(i, 1) f64 > -0.5 f64 > -1 -f64 > -f32 f64 > -f64 f64 > -i f64 > -i32 -f64 > 0.5 - f64 -f64 > 0.5 / 0.5 -f64 > 0.5 ? 0.5 : nil -f64 > 0.5 ? score(1, 1) : nil == nil -f64 > 0.5 ^ 1 -f64 > 0.5 || ok -f64 > 1 != ok -f64 > 1 != true -f64 > 1 % i -f64 > 1 * 0.5 -f64 > 1 - 0.5 -f64 > 1 - i32 -f64 > 1 / 0.5 -f64 > 1 / f64 -f64 > 1 ? 0.5 : ok -f64 > 1 ? false : true -f64 > 1 ^ 1 -f64 > abs(0.5) -f64 > abs(1) -f64 > abs(i) -f64 > abs(i32) -f64 > count(array, true) +f64 > 0.5 ** f32 +f64 > 0.5 / i +f64 > 0.5 ^ i +f64 > 0.5 or i <= 0.5 +f64 > 1 + f32 +f64 > 1 + i32 +f64 > 1 ? div : i32 +f64 > 1 ^ i32 +f64 > array[i64] +f64 > ceil(0.5) +f64 > ceil(1) +f64 > ceil(f32) f64 > f32 -f64 > f32 - 0.5 +f64 > f32 / 1 f64 > f64 -f64 > f64 ** 0.5 -f64 > f64 ? f64 : list -f64 > f64 ^ 0.5 -f64 > findIndex(array, ok) -f64 > float(1) -f64 > float(f32) +f64 > f64 - 0.5 +f64 > float(0.5 * i64) +f64 > floor(f64) +f64 > get(array, 1) f64 > half(0.5) +f64 > half(1) +f64 > half(f64) f64 > i -f64 > i != ok -f64 > i ** i32 -f64 > i - i32 +f64 > i - 0.5 f64 > i32 -f64 > i32 ** f32 -f64 > i32 - f32 f64 > i32 == ok -f64 > i32 ? i : 0.5 +f64 > i32 ? f32 : array +f64 > i32 ? list : half +f64 > i32 ^ i32 +f64 > i32 ^ i64 f64 > i64 -f64 > i64 ** i64 -f64 > int(0.5) -f64 > int(i64) +f64 > i64 - 1 +f64 > i64 ? array : half +f64 > i64 ? list : div +f64 > i64 || ok or ok +f64 > int(f32) +f64 > last(array) f64 > max(0.5) -f64 > max(i64) -f64 > min(1) -f64 > min(f64) -f64 > min(i) -f64 > min(i32) -f64 > score(i) +f64 > max(0.5, i64) +f64 > max(f32) +f64 > median(array) +f64 > min(f32) f64 >= -0.5 f64 >= -1 -f64 >= -f64 -f64 >= -i32 f64 >= -i64 -f64 >= 0.5 * 1 -f64 >= 0.5 ** 0.5 -f64 >= 0.5 ** i32 -f64 >= 0.5 + 0.5 -f64 >= 0.5 + i -f64 >= 0.5 - i -f64 >= 0.5 - i32 -f64 >= 0.5 ? nil : 0.5 -f64 >= 0.5 ^ 0.5 -f64 >= 1 * i -f64 >= 1 - 0.5 -f64 >= 1 / i64 -f64 >= 1 == ok -f64 >= 1 ^ 1 -f64 >= 1 || ok -f64 >= abs(1) -f64 >= abs(f32) -f64 >= abs(f64) -f64 >= count(list, true) +f64 >= 0.5 + i32 +f64 >= 0.5 - 1 +f64 >= 0.5 - f32 +f64 >= 0.5 / i64 +f64 >= 0.5 ? list : i32 +f64 >= 0.5 ^ i64 +f64 >= array[1] f64 >= f32 -f64 >= f32 != true -f64 >= f32 - f32 -f64 >= f32 ? true : nil +f64 >= f32 - i32 +f64 >= f32 ^ 1 f64 >= f64 -f64 >= f64 * 0.5 -f64 >= f64 ? nil : f64 -f64 >= f64 ? score : f32 -f64 >= half(f64) +f64 >= f64 != nil +f64 >= f64 != ok +f64 >= findIndex(array, ok) +f64 >= floor(f32) +f64 >= floor(i) +f64 >= half(0.5) +f64 >= half(1) f64 >= i -f64 >= i - 1 +f64 >= i * 0.5 +f64 >= i ** 0.5 +f64 >= i ** i32 +f64 >= i / i32 +f64 >= i ^ 1 f64 >= i32 -f64 >= i32 != nil -f64 >= i32 ** 0.5 -f64 >= i32 + f32 -f64 >= i32 + i64 -f64 >= i32 ^ f32 +f64 >= i32 - f64 +f64 >= i32 ? ok : add +f64 >= i32 ^ 1 f64 >= i64 -f64 >= i64 * 0.5 -f64 >= i64 * f64 -f64 >= i64 * i64 -f64 >= i64 ? list : i >= f32 -f64 >= i64 ? ok : true -f64 >= i64 || ok -f64 >= max(f64) -f64 >= min(0.5) -f64 >= score(1) +f64 >= i64 + f64 +f64 >= i64 ? 0.5 : score +f64 >= i64 ? 1 : f32 +f64 >= max(1) +f64 >= median(array) +f64 >= reduce(array, #) +f64 >= reduce(array, i32) f64 >= score(i) -f64 ^ (0.5 * 1) -f64 ^ (0.5 * f32) -f64 ^ (0.5 / i) -f64 ^ (1 + i) -f64 ^ (1 - f32) -f64 ^ (1 / 0.5) -f64 ^ (1 / i64) -f64 ^ -1 -f64 ^ 0.5 != f32 -f64 ^ 0.5 * i64 -f64 ^ 0.5 + f64 -f64 ^ 0.5 < 0.5 ^ 0.5 -f64 ^ 0.5 <= i64 -f64 ^ 0.5 > i == nil -f64 ^ 0.5 >= i32 / i64 -f64 ^ 1 != i +f64 ^ (0.5 * i) +f64 ^ (0.5 + 1) +f64 ^ (1 * f64) +f64 ^ (1 - 1) +f64 ^ (f32 + 1) +f64 ^ (f32 - 0.5) +f64 ^ (f32 - i) +f64 ^ (f32 / -f64) +f64 ^ (i32 - 1) +f64 ^ (i32 / f32) +f64 ^ (i64 - 1) +f64 ^ -0.5 +f64 ^ -i32 +f64 ^ 0.5 * f64 +f64 ^ 0.5 ** f32 +f64 ^ 0.5 ** i32 +f64 ^ 0.5 > ceil(f32) +f64 ^ 0.5 > i +f64 ^ 0.5 >= f64 +f64 ^ 0.5 >= i32 +f64 ^ 0.5 ^ i32 +f64 ^ 0.5 not in array f64 ^ 1 ** i -f64 ^ 1 + i -f64 ^ 1 / f32 -f64 ^ 1 / i64 -f64 ^ 1 <= i32 +f64 ^ 1 ** i64 f64 ^ 1 ^ i -f64 ^ abs(i32) -f64 ^ count(array, true) +f64 ^ abs(0.5) +f64 ^ array[i64] f64 ^ f32 -f64 ^ f32 != i32 -f64 ^ f32 * f32 -f64 ^ f32 ** i -f64 ^ f32 + f64 -f64 ^ f32 / i64 -f64 ^ f32 < i -f64 ^ f32 >= i64 -f64 ^ f32 ^ i64 +f64 ^ f32 ** 1 +f64 ^ f32 < score(1) +f64 ^ f32 >= i32 f64 ^ f64 -f64 ^ f64 != f32 -f64 ^ f64 * i -f64 ^ f64 + int(0.5) -f64 ^ float(i64) -f64 ^ half(0.5) +f64 ^ f64 - -i +f64 ^ f64 == i32 +f64 ^ f64 > f64 +f64 ^ f64 ^ i +f64 ^ f64 ^ i64 +f64 ^ findIndex(array, true) +f64 ^ float(abs(i)) +f64 ^ floor(f64) +f64 ^ half(1) f64 ^ half(f64) f64 ^ i -f64 ^ i ** i32 -f64 ^ i / i -f64 ^ i <= f32 +f64 ^ i ** 1 +f64 ^ i + f32 +f64 ^ i + i32 +f64 ^ i <= i32 +f64 ^ i ^ i64 f64 ^ i32 -f64 ^ i32 ** i -f64 ^ i32 + f64 +f64 ^ i32 / f64 +f64 ^ i32 <= i32 f64 ^ i32 >= i -f64 ^ i32 ^ f64 f64 ^ i64 -f64 ^ i64 + i64 -f64 ^ i64 - i -f64 ^ i64 < i -f64 ^ i64 >= i32 +f64 ^ i64 ** i64 +f64 ^ int(0.5) f64 ^ int(f64) f64 ^ last(array) f64 ^ len(list) -f64 ^ max(0.5) +f64 ^ min(1) +f64 ^ reduce(array, #) +f64 ^ round(i) f64 ^ score(1) -false != true || 1 > f64 -false && ok or ok -false ? "bar" : 0.5 == f32 -false ? "bar" : 1 != i -false ? "bar" : foo.Qux -false ? 0.5 : foo.Qux -false ? 1 : half != div -false ? 1 : true != ok -false ? add : foo?.Bar -false ? f32 : foo.Bar -false ? f32 : foo?.String() -false ? f32 : i .. i32 -false ? f64 : 0.5 >= f64 -false ? f64 : f32 / f32 -false ? false : 0.5 + i32 -false ? false : i64 >= i -false ? foo : foo.Qux -false ? greet : i64 != i -false ? half : 0.5 > 1 + i64 -false ? half : f32 > min(0.5) -false ? i : 1 != i -false ? i32 : 1 >= f64 -false ? i64 : "foo" < toJSON(f64) -false ? i64 : foo?.Qux -false ? list : 1 < f32 -false ? list : f32 ** i32 -false ? list : foo.Bar -false ? nil : 1 >= get(array, 1) +f64 in array +f64 in array != nil +f64 in groupBy(list, i64) +f64 not in array +f64 not in array != ok +f64 not in array != true +f64 not in array == true +f64 not in groupBy(array, #) +f64 not in groupBy(array, bitnand(#, 1)) +f64 not in i .. i32 +f64 not in map(array, #) +false != false ? foo : greet +false && i not in array +false && nil not in array +false && nil not in list +false == nil ? i32 : f64 +false == nil ? i32 : i32 +false ? "bar" : 0.5 - i +false ? "foo" : f32 * i +false ? "foo" : f32 / i32 +false ? "foo" : foo.Qux +false ? add : 1 / i ^ 0.5 +false ? add : i64 - i +false ? div : i64 ** i +false ? f32 : foo.Qux +false ? f64 : 0.5 != i32 +false ? f64 : 0.5 ** i32 +false ? f64 : 1 >= i +false ? f64 : foo?.Qux +false ? f64 : i ^ f32 +false ? false : foo?.Qux +false ? foo : i32 - i +false ? half : 0.5 == f32 +false ? half : i ^ i64 +false ? i : foo?.Qux +false ? i : nil in list +false ? i32 : 1 <= i32 +false ? i32 : foo.Qux +false ? i64 : 1 <= f32 +false ? i64 : foo.Qux +false ? i64 : i64 ** i64 +false ? list : list == list false ? nil : foo?.Qux -false ? ok : foo.String -false ? score : 0.5 == i -false ? score : 1 / i64 -false ? score : f64 - -f32 -false ? true : 0.5 == f32 -false or ok ? string(1) : f64 == f32 -filter(1 .. 1, # == 0.5) -filter(1 .. i64, ok) -filter([div], any(array, true)) -filter([i32, i], # <= f64) -filter(array, !false) -filter(array, !ok) -filter(array, "bar" == "bar") -filter(array, "bar" matches "bar") -filter(array, "foo" not matches "bar") +false ? nil : i32 > i32 +false ? ok : foo.String() +false ? ok : i64 < i64 +false and false || 0.5 > f32 +false or 1 not in array +false or true or ok +false or true || ok +filter(1 .. 1, # > i) +filter(1 .. i, i >= #) +filter([0.5], # > 0.5) +filter([nil], # != false) +filter(array, !true) +filter(array, "bar" != "foo") +filter(array, "foo" == nil) filter(array, # != #) +filter(array, # != f32) filter(array, # != f64) filter(array, # != i) -filter(array, # != i32) filter(array, # != i64) filter(array, # < #) -filter(array, # < 1) -filter(array, # < f32) filter(array, # < f64) -filter(array, # < i) -filter(array, # < i32) filter(array, # <= #) -filter(array, # <= 0.5) filter(array, # <= 1) -filter(array, # <= f64) +filter(array, # <= bitshr(#, #)) filter(array, # <= i) -filter(array, # <= i32) +filter(array, # <= i64) filter(array, # == #) -filter(array, # == 1) +filter(array, # == 0.5) filter(array, # == f32) filter(array, # == f64) filter(array, # == i) +filter(array, # == i32) +filter(array, # == i64) filter(array, # == nil) filter(array, # > #) +filter(array, # > 0.5) filter(array, # > 1) filter(array, # > i) +filter(array, # > i32) filter(array, # >= #) +filter(array, # >= 0.5) filter(array, # >= 1) filter(array, # >= f32) -filter(array, # >= f64) +filter(array, # >= i) filter(array, # >= i32) -filter(array, # in array) -filter(array, # not in array) +filter(array, # >= i64) filter(array, 0.5 != #) +filter(array, 0.5 != f64) +filter(array, 0.5 != i) filter(array, 0.5 < #) -filter(array, 0.5 < f32) filter(array, 0.5 < f64) +filter(array, 0.5 < i32) +filter(array, 0.5 <= #) +filter(array, 0.5 <= i) +filter(array, 0.5 <= i32) filter(array, 0.5 == #) -filter(array, 0.5 > 0.5) +filter(array, 0.5 == f64) +filter(array, 0.5 > #) filter(array, 0.5 >= #) filter(array, 1 != #) -filter(array, 1 != f32) -filter(array, 1 < #) -filter(array, 1 < f64) -filter(array, 1 <= #) +filter(array, 1 < i) filter(array, 1 == #) -filter(array, 1 > #) -filter(array, 1 > 0.5) -filter(array, add == div) -filter(array, all(list, ok)) +filter(array, 1 == 0.5) +filter(array, 1 == i) +filter(array, 1 > i) +filter(array, 1 >= #) +filter(array, add == add) +filter(array, add == nil) +filter(array, any(list, ok)) filter(array, f32 != #) -filter(array, f32 < i32) -filter(array, f32 <= f32) +filter(array, f32 < #) +filter(array, f32 <= #) filter(array, f32 == #) -filter(array, f32 > 1) +filter(array, f32 == i64) +filter(array, f32 > #) filter(array, f32 >= #) -filter(array, f64 != #) -filter(array, f64 != 0.5) +filter(array, f64 < #) filter(array, f64 <= #) -filter(array, f64 == #) -filter(array, f64 > #) -filter(array, f64 >= 1) -filter(array, foo == nil) -filter(array, greet == add) -filter(array, greet == half) -filter(array, i <= 1) -filter(array, i <= f64) -filter(array, i == f32) -filter(array, i >= 1) -filter(array, i >= f64 != false) -filter(array, i32 != #) -filter(array, i32 <= #) -filter(array, i32 == #) -filter(array, i32 == 1) -filter(array, i32 > # % #) +filter(array, f64 == i32) +filter(array, f64 >= #) +filter(array, half != nil) +filter(array, half == half) +filter(array, half(1) >= # ^ i) +filter(array, i != #) +filter(array, i != f64) +filter(array, i <= i32) +filter(array, i == #) +filter(array, i > #) +filter(array, i > f32) +filter(array, i32 != i64) +filter(array, i32 < 0.5) filter(array, i32 > #) -filter(array, i32 > 0.5) -filter(array, i32 >= #) -filter(array, i64 != #) filter(array, i64 < #) -filter(array, i64 < 1) filter(array, i64 < i64) -filter(array, i64 <= #) -filter(array, i64 == 1) +filter(array, i64 == #) +filter(array, i64 == i32) +filter(array, i64 >= #) filter(array, nil != #) filter(array, nil != greet) filter(array, nil == #) -filter(array, nil == f32) -filter(array, nil in list) -filter(array, none(array, ok)) +filter(array, nil == 1) +filter(array, nil == i32) +filter(array, not false) +filter(array, not ok) +filter(array, not true) +filter(array, ok && true) filter(array, ok) -filter(array, score(#) != #) -filter(array, true && ok) -filter(array, true or false) -filter(array, true)[i:i32] -filter(filter(array, true), i >= f32) -filter(filter(list, false), "bar" in #) -filter(filter(list, ok), ok) -filter(i .. 1, not ok) -filter(i32 .. i32, nil == true) -filter(i32 .. i64, ok) -filter(list, !false) +filter(array, ok)[i64] +filter(array, score == nil) +filter(array, true == true) +filter(array, true and true) +filter(false ? ok : array, # == nil) +filter(filter(list, true), ok) +filter(groupBy(list, #).f64, # not matches #?.foo) +filter(i .. i64, ok) filter(list, !ok) filter(list, !true) -filter(list, "bar" not in #) +filter(list, "bar" < "foo") filter(list, "bar" not matches "foo") -filter(list, "bar" startsWith "bar") +filter(list, "foo" == "foo") filter(list, "foo" in #) -filter(list, "foo" not in #) +filter(list, "foo" not endsWith "bar") +filter(list, "foo" startsWith "bar") filter(list, # != #) filter(list, # != foo) filter(list, # != nil) filter(list, # == #) filter(list, # == foo) -filter(list, # == nil) -filter(list, 0.5 != f64) -filter(list, 0.5 != i) -filter(list, 0.5 > f32) -filter(list, 1 != 0.5) -filter(list, 1 != i32) -filter(list, 1 != nil) -filter(list, 1 < 0.5) +filter(list, # in list) +filter(list, 0.5 < 1) +filter(list, 0.5 <= 0.5) +filter(list, 0.5 >= 1) +filter(list, 0.5 >= i) +filter(list, 0.5 >= i64) filter(list, 1 < 1) -filter(list, all(array, false)) -filter(list, all(array, true)) -filter(list, div == half) -filter(list, f32 < 0.5) -filter(list, f32 <= f32) -filter(list, f32 == i64) -filter(list, f32 >= 1) -filter(list, f64 >= 0.5) -filter(list, false == ok) -filter(list, foo != #) +filter(list, 1 <= f32) +filter(list, any(array, ok)) +filter(list, any(list, true)) +filter(list, div != div) +filter(list, f32 <= 1) +filter(list, f32 == f64) +filter(list, f32 > i) +filter(list, f64 <= 1) +filter(list, f64 == 0.5) +filter(list, false != false) +filter(list, false or ok) filter(list, foo == #) -filter(list, foo == foo) -filter(list, foo in list) -filter(list, greet != nil) -filter(list, half != half) -filter(list, i <= 0.5) -filter(list, i <= i) -filter(list, i == f32) -filter(list, i == i32) -filter(list, i == i64) -filter(list, i >= i32) -filter(list, i32 != 1) -filter(list, i32 != nil) -filter(list, i32 < i64) -filter(list, i32 <= i32) -filter(list, i32 == i) -filter(list, i64 > f32) -filter(list, nil != f64) -filter(list, nil != score) -filter(list, nil != true) +filter(list, i < 0.5) +filter(list, i < f32) +filter(list, i >= 0.5) +filter(list, i64 > 0.5) +filter(list, nil != "foo") +filter(list, nil != #) +filter(list, nil != #?.Bar) +filter(list, nil != add) +filter(list, nil != greet) +filter(list, nil != i64) filter(list, nil == #) -filter(list, not ok) -filter(list, ok or true) -filter(list, ok || true) +filter(list, nil == 0.5) +filter(list, nil == f32) +filter(list, nil == half) +filter(list, nil == i32) +filter(list, nil == score) +filter(list, ok == nil) +filter(list, ok and false) filter(list, ok) -filter(list, true == nil) -filter(map(array, "bar"), # >= #) -filter(map(array, "foo"), ok) -filter(map(array, #), # != 0.5) -filter(map(array, #), ok) -filter(map(array, 0.5 >= #), ok) -filter(map(list, "bar"), i >= i) -filter(map(list, "foo"), "bar" not matches #) -filter(map(list, #), # != #) +filter(list, ok)[i] +filter(list, true == ok) +filter(list, true || true) +filter(list, true) == list +filter(map(array, #), # == 1) +filter(map(array, #), # > #) +filter(map(array, 1), ok) +filter(map(array, greet), ok) +filter(map(array, i32), ok) +filter(map(array, i64), nil == div) +filter(map(array, ok), true || ok) +filter(map(array, score), # != nil) +filter(map(list, #), # == #) +filter(map(list, #), half != nil) filter(map(list, #), ok) -filter(map(list, 1), f32 != #) +filter(map(list, array), # == #) +filter(map(list, f32), # == #) +filter(map(list, f32), ok) filter(map(list, false), #) -filter(sort(array), ok) -filter(split("foo", "bar"), ok) -find(1 .. 1, # <= #) -find([nil], 0.5 == 0.5) +filter(map(list, i32), i64 <= i32) +filter(map(list, ok), #) +filter(map(list, true), #) +filter(ok ? "foo" : 0.5, # <= i64) +filter(true ? list : score, # != #) +find(1 .. i, ok) find([ok], #) +find([score, score], # == #) +find(array, !(# <= i32)) find(array, !ok) find(array, !true) -find(array, "bar" startsWith "foo") +find(array, "bar" not startsWith "foo") +find(array, "foo" not contains "bar") find(array, # != #) -find(array, # != 0.5) -find(array, # != f32) +find(array, # != 1) +find(array, # != i) find(array, # != i32) -find(array, # - # != #) +find(array, # != nil) +find(array, # - i != #) find(array, # < #) find(array, # < 0.5) find(array, # < 1) find(array, # < f32) -find(array, # < f64) +find(array, # < i) find(array, # < i32) +find(array, # < i64) find(array, # <= #) find(array, # <= 0.5) find(array, # <= 1) -find(array, # <= f32) -find(array, # <= i) +find(array, # <= i32) find(array, # == #) find(array, # == 0.5) find(array, # == 1) -find(array, # == f32) -find(array, # == f64) find(array, # == i) -find(array, # == i32) +find(array, # == i64) find(array, # == nil) find(array, # > #) -find(array, # > 0.5) -find(array, # > i) +find(array, # > 1) +find(array, # > i32) find(array, # > i64) find(array, # >= #) find(array, # >= 1) +find(array, # >= f64) find(array, # >= i) -find(array, # >= i32) -find(array, 0.5 < i64) +find(array, # not in array) +find(array, 0.5 != 1) +find(array, 0.5 / i64 <= #) +find(array, 0.5 < #) +find(array, 0.5 < f64) find(array, 0.5 <= #) -find(array, 0.5 == #) -find(array, 0.5 > #) -find(array, 0.5 > 1) +find(array, 0.5 >= #) +find(array, 0.5 >= 0.5) +find(array, 0.5 >= f64) +find(array, 1 != #) +find(array, 1 < #) +find(array, 1 < i32) +find(array, 1 < i64) find(array, 1 <= #) -find(array, 1 <= 0.5) -find(array, 1 == f32) -find(array, 1 == i64) +find(array, 1 <= i) +find(array, 1 == #) find(array, 1 > #) -find(array, 1 > 0.5) -find(array, 1 > i32) -find(array, 1 > i64) find(array, 1 >= #) -find(array, 1 >= i) -find(array, add != div) -find(array, add != nil) -find(array, any(array, true)) -find(array, array == list) -find(array, div == half) +find(array, div != nil) +find(array, f32 != #) +find(array, f32 != f32) +find(array, f32 < #) find(array, f32 <= #) +find(array, f32 == #) +find(array, f32 == i32) find(array, f32 > #) -find(array, f32 > 0.5) find(array, f32 >= #) -find(array, f32 >= 1) find(array, f64 != #) -find(array, f64 != i32) -find(array, f64 != nil) find(array, f64 < #) -find(array, f64 == nil) -find(array, f64 >= 0.5) -find(array, false == false) -find(array, false) != i32 -find(array, i < #) +find(array, f64 < 1) +find(array, f64 <= #) +find(array, f64 == #) +find(array, f64 == i64) +find(array, false ? # : false) +find(array, false) != f64 +find(array, floor(#) > #) +find(array, greet != greet) +find(array, i % # != f64) +find(array, i < 0.5) find(array, i <= #) -find(array, i == #) -find(array, i > #) +find(array, i > 0.5) find(array, i >= #) -find(array, i >= i64) +find(array, i >= 1) find(array, i32 != #) -find(array, i32 != 1) -find(array, i32 < #) -find(array, i32 <= #) -find(array, i32 <= f32) -find(array, i32 <= f64) +find(array, i32 != i32) find(array, i32 == #) -find(array, i32 == 1) -find(array, i32 == f64) find(array, i32 > #) +find(array, i32 >= #) find(array, i64 != #) +find(array, i64 != 1) find(array, i64 < #) -find(array, nil != "bar") -find(array, nil != #) +find(array, i64 <= #) +find(array, i64 == #) +find(array, i64 > #) +find(array, nil != nil) find(array, nil == #) -find(array, nil not in array) -find(array, not false) -find(array, not true) -find(array, ok && ok) +find(array, nil == 0.5) +find(array, nil == i32) +find(array, none(array, true)) +find(array, not (# == #)) find(array, ok == nil) +find(array, ok and false) find(array, ok) -find(array, ok) * f64 -find(array, ok) ** i64 -find(array, ok) ^ i32 -find(array, score(#) >= #) -find(array, true) / get(array, i64) -find(array, true) > i -find(array, true) ^ i32 -find(filter(array, ok), # >= #) -find(filter(array, true), # != #) -find(i32 .. 1, # > 0.5) -find(i64 .. 1, ok) -find(list, !true) -find(list, "bar" startsWith "foo") -find(list, "foo" < "foo") -find(list, "foo" in #) -find(list, "foo" not in #) +find(array, ok) % i32 +find(array, ok) ** i +find(array, ok) >= i32 +find(array, true) > f64 +find(array, true) > i64 +find(filter(list, false), i64 not in array) +find(groupBy(array, #).Qux, .String?.f32) +find(groupBy(array, #).ok, first(#[1])) +find(i .. i64, ok) +find(i64 .. i32, # != #) +find(list, !false) +find(list, !ok) +find(list, "bar" not in #) +find(list, "foo" contains "foo") find(list, # != #) +find(list, # != nil) find(list, # == #) +find(list, # == foo) find(list, # == nil) -find(list, # not in list) -find(list, 0.5 < f64) -find(list, 0.5 <= i64) -find(list, 0.5 > i) -find(list, 1 < 0.5) -find(list, 1 <= 0.5) +find(list, 0.5 != 1) +find(list, 0.5 <= 0.5) +find(list, 1 != 0.5) +find(list, 1 < 1) +find(list, 1 < i64) +find(list, 1 == f64) +find(list, 1 > 0.5) find(list, 1 > i) -find(list, add == add) -find(list, f32 != f32) -find(list, f32 < f64) -find(list, f32 <= f32) +find(list, 1 > i64) +find(list, f32 < 1) +find(list, f32 <= 0.5) find(list, f32 <= i32) -find(list, f32 == f32) -find(list, f64 != f32) -find(list, f64 <= i64) -find(list, f64 >= f32) +find(list, f32 == i64) +find(list, f32 > f64) +find(list, f32 not in array) +find(list, f64 < f64) +find(list, false && true) find(list, false)?.Bar find(list, foo != #) find(list, foo == #) -find(list, i < 1) -find(list, i >= f64) -find(list, i32 <= f32) -find(list, i64 != f64) -find(list, i64 >= 0.5) -find(list, list != array) +find(list, i != 1) +find(list, i != f64) +find(list, i != i32) +find(list, i32 != 1) +find(list, i32 != f64) +find(list, i32 < i) +find(list, i32 == i32) find(list, nil != #) -find(list, nil != greet) -find(list, nil != half) find(list, nil != ok) -find(list, nil == #) -find(list, nil == half) -find(list, nil == score) -find(list, nil not in array) -find(list, nil not in list) -find(list, not ok) -find(list, ok or ok) +find(list, nil == array) +find(list, nil == div) +find(list, not false) +find(list, ok != false) find(list, ok) -find(list, ok).Bar -find(list, ok).Qux find(list, ok).String +find(list, ok).String() +find(list, ok)?.Bar find(list, ok)?.Qux find(list, ok)?.String -find(list, score != add) -find(list, score != greet) +find(list, score == score) +find(list, true != nil) +find(list, true == true) +find(list, true or false) find(list, true).Bar find(list, true).Qux find(list, true).String find(list, true)?.Bar -find(list, true)?.Qux find(list, true)?.String -find(list, true)?.String() -find(map(array, #), # == #) +find(map(array, #), # != f32) +find(map(array, #), # <= 1) +find(map(array, #), # == 0.5) find(map(array, #), ok) -find(map(array, i), ok) -find(map(array, true), #) -find(map(list, "foo"), ok) +find(map(array, false), #) +find(map(array, foo), ok) +find(map(array, ok), #) find(map(list, #), # != #) -find(map(list, 0.5), # >= #) -find(map(list, ok), ok) +find(map(list, #), ok) +find(map(list, 0.5), # != #) +find(map(list, add), 0.5 >= i64) +find(map(list, div), # == #) +find(map(list, f32), # > 0.5) +find(map(list, false), #) +find(map(list, i), # == i64) +find(map(list, ok), #) find(map(list, true), #) -find(ok ? "bar" : 0.5, # != i32) -find(sort(array), ok) -find(true ? array : false, 0.5 > #)?.list -findIndex(["bar"], ok) -findIndex(["foo"], 0.5 > i64) -findIndex(["foo"], ok) -findIndex([1], # < #) -findIndex([f64, greet], 1 > f64) -findIndex([false], #) -findIndex(array, !(# != #)) -findIndex(array, !(# == 1)) -findIndex(array, !false) +find(ok ? "foo" : f64, f32 >= #) findIndex(array, !ok) -findIndex(array, !true) -findIndex(array, "bar" not endsWith "bar") -findIndex(array, "bar" not startsWith "foo") +findIndex(array, "bar" == "foo") +findIndex(array, "foo" > "foo") +findIndex(array, "foo" in foo) findIndex(array, # != #) findIndex(array, # != 0.5) findIndex(array, # != f32) findIndex(array, # != f64) -findIndex(array, # != i32) +findIndex(array, # != i) findIndex(array, # != i64) findIndex(array, # != nil) -findIndex(array, # ** # > #) findIndex(array, # < #) findIndex(array, # < 1) -findIndex(array, # < f64) -findIndex(array, # < i) findIndex(array, # < i32) -findIndex(array, # < i64) findIndex(array, # <= #) +findIndex(array, # <= 0.5) findIndex(array, # <= 1) -findIndex(array, # <= i) -findIndex(array, # <= i32) findIndex(array, # == #) +findIndex(array, # == 0.5) findIndex(array, # == 1) -findIndex(array, # == f64) findIndex(array, # == i32) +findIndex(array, # == nil) findIndex(array, # > #) findIndex(array, # > 0.5) findIndex(array, # > 1) -findIndex(array, # > f32) findIndex(array, # > f64) -findIndex(array, # > i64 - i) +findIndex(array, # > i) findIndex(array, # > i64) findIndex(array, # >= #) +findIndex(array, # >= 0.5) findIndex(array, # >= 1) findIndex(array, # >= f32) +findIndex(array, # >= f64) findIndex(array, # >= i) findIndex(array, # >= i32) -findIndex(array, # in array) -findIndex(array, # not in array) -findIndex(array, 0.5 < #) -findIndex(array, 0.5 <= 1) -findIndex(array, 0.5 <= f32) +findIndex(array, # >= i64) +findIndex(array, 0.5 != #) +findIndex(array, 0.5 != 1) +findIndex(array, 0.5 < 1) +findIndex(array, 0.5 <= #) findIndex(array, 0.5 == #) -findIndex(array, 0.5 > i64) -findIndex(array, 0.5 >= #) -findIndex(array, 0.5 >= i) +findIndex(array, 0.5 == i64) +findIndex(array, 0.5 > #) +findIndex(array, 0.5 > 0.5) +findIndex(array, 0.5 > i) +findIndex(array, 0.5 > i32) +findIndex(array, 0.5 >= 0.5) +findIndex(array, 0.5 >= 1) +findIndex(array, 0.5 not in array) findIndex(array, 1 != #) +findIndex(array, 1 != i64) +findIndex(array, 1 != nil) findIndex(array, 1 < #) -findIndex(array, 1 < f32) -findIndex(array, 1 < i64) findIndex(array, 1 <= #) -findIndex(array, 1 == #) findIndex(array, 1 > #) +findIndex(array, 1 > i) findIndex(array, 1 >= #) -findIndex(array, add != half) -findIndex(array, any(array, f32 < #)) -findIndex(array, f32 <= #) +findIndex(array, add != div) +findIndex(array, add != nil) +findIndex(array, f32 != #) +findIndex(array, f32 != 1) +findIndex(array, f32 < #) findIndex(array, f32 == #) -findIndex(array, f32 == nil) -findIndex(array, f32 > #) findIndex(array, f32 >= #) -findIndex(array, f64 <= #) -findIndex(array, f64 <= i64) -findIndex(array, f64 == #) -findIndex(array, f64 > #) +findIndex(array, f32 >= i32) findIndex(array, f64 >= #) -findIndex(array, f64 >= 1) -findIndex(array, half != greet) -findIndex(array, i != #) -findIndex(array, i < 0.5) +findIndex(array, f64 >= i32) +findIndex(array, false) == -f64 +findIndex(array, i != f64) +findIndex(array, i < #) +findIndex(array, i < i32) findIndex(array, i <= #) -findIndex(array, i <= i32) +findIndex(array, i <= 0.5) findIndex(array, i == #) -findIndex(array, i == i) -findIndex(array, i > #) findIndex(array, i >= i) +findIndex(array, i >= i32) findIndex(array, i32 != #) findIndex(array, i32 < #) -findIndex(array, i32 < f64) -findIndex(array, i32 < i) -findIndex(array, i32 <= #) findIndex(array, i32 == #) -findIndex(array, i32 == nil) -findIndex(array, i32 > #) +findIndex(array, i32 > f32) findIndex(array, i64 != #) -findIndex(array, i64 == #) +findIndex(array, i64 != nil) +findIndex(array, i64 < 0.5) +findIndex(array, i64 <= #) +findIndex(array, i64 <= i64) findIndex(array, i64 > #) findIndex(array, i64 >= #) -findIndex(array, nil != #) -findIndex(array, nil != 1) -findIndex(array, nil != list) -findIndex(array, nil == foo) -findIndex(array, nil == i) -findIndex(array, not ok) +findIndex(array, i64 >= f64) +findIndex(array, i64 >= i32) +findIndex(array, nil != half) +findIndex(array, nil != ok) +findIndex(array, nil == #) +findIndex(array, nil == 1) +findIndex(array, nil == nil) +findIndex(array, not false) findIndex(array, ok) -findIndex(array, ok) * f64 -findIndex(array, ok) - i32 findIndex(array, ok) / f64 -findIndex(array, ok) >= f64 -findIndex(array, score == greet) -findIndex(array, true or false) -findIndex(false ? div : list, ok) +findIndex(array, ok) / i +findIndex(array, ok) <= f32 +findIndex(array, one(list, false)) +findIndex(array, true) + f64 +findIndex(array, true) - f64 +findIndex(array, true) .. i +findIndex(filter(array, false), # > 1) +findIndex(filter(array, true), # not in array) +findIndex(filter(list, false), 1 <= i64) +findIndex(groupBy(array, #).f64, .Bar(half(add, half, div, greet, f64))) +findIndex(groupBy(array, false).String, #?.i64()) +findIndex(groupBy(array, foo).String, #) +findIndex(groupBy(list, #).Qux, #) +findIndex(i32 .. 1, # >= #) findIndex(list, !false) +findIndex(list, !ok) findIndex(list, !true) -findIndex(list, "bar" == "bar") -findIndex(list, "foo" != "bar") -findIndex(list, "foo" contains "bar") -findIndex(list, "foo" matches "bar") +findIndex(list, "bar" > "foo") +findIndex(list, "bar" in #) +findIndex(list, "bar" not in #) findIndex(list, # != #) -findIndex(list, # != foo) findIndex(list, # != nil) findIndex(list, # == #) -findIndex(list, # == nil) +findIndex(list, # == foo) findIndex(list, # in list) -findIndex(list, 0.5 < i) -findIndex(list, 0.5 <= f64) -findIndex(list, 0.5 <= i64) -findIndex(list, 0.5 > f64) -findIndex(list, 0.5 >= f32) -findIndex(list, 1 == nil) -findIndex(list, array != list) -findIndex(list, f32 < f64) -findIndex(list, f64 <= f32) -findIndex(list, f64 <= f64) -findIndex(list, f64 == nil) -findIndex(list, f64 > f64) -findIndex(list, false && true) +findIndex(list, #?.Bar not in #) +findIndex(list, 0.5 != i) +findIndex(list, 0.5 > 1) +findIndex(list, 0.5 >= i) +findIndex(list, 1 != i32) +findIndex(list, 1 < f64) +findIndex(list, 1 < i32) +findIndex(list, 1 == f32) +findIndex(list, 1 > 0.5) +findIndex(list, 1 > i32) +findIndex(list, 1 >= 1) +findIndex(list, 1 >= i) +findIndex(list, f32 != f32) +findIndex(list, f32 != i) +findIndex(list, f32 < i32) +findIndex(list, f32 == bitshl(i, i64)) +findIndex(list, f32 > 1) +findIndex(list, f64 != 0.5) +findIndex(list, f64 < 1) +findIndex(list, f64 < i) +findIndex(list, f64 > 1) +findIndex(list, f64 >= f64) +findIndex(list, false != nil) +findIndex(list, false || ok) findIndex(list, foo != #) -findIndex(list, foo == #) -findIndex(list, greet != half) -findIndex(list, half == add) -findIndex(list, i32 == i) -findIndex(list, i32 > f64) -findIndex(list, i32 >= i32) -findIndex(list, i64 < 0.5) -findIndex(list, i64 > f64) -findIndex(list, nil != #) -findIndex(list, nil != f64) -findIndex(list, nil != false) -findIndex(list, nil == #) -findIndex(list, nil == 0.5) -findIndex(list, nil == ok) -findIndex(list, nil in list) -findIndex(list, not false) +findIndex(list, greet == nil) +findIndex(list, i < 0.5) +findIndex(list, i <= i32) +findIndex(list, i32 == 1) +findIndex(list, i32 >= i64) +findIndex(list, i64 != f32) +findIndex(list, nil != 0.5) +findIndex(list, nil != f32) +findIndex(list, nil != i64) +findIndex(list, nil == "foo") +findIndex(list, nil == f64) findIndex(list, not ok) -findIndex(list, ok != ok) -findIndex(list, ok or ok) +findIndex(list, not true) findIndex(list, ok) -findIndex(list, ok) + f32 -findIndex(list, ok) / i -findIndex(list, ok) > i32 -findIndex(list, one(list, ok)) -findIndex(list, true ? true : true) -findIndex(list, true) .. i -findIndex(list, true) == 0.5 ^ i32 -findIndex(list, true) > i32 ** f32 -findIndex(list, true) not in array -findIndex(map(array, #), # > #) -findIndex(map(array, #), # >= f32) -findIndex(map(array, 1), # != #) -findIndex(map(array, add), i64 >= i64) -findIndex(map(array, div), # == #) -findIndex(map(array, false), #) -findIndex(map(array, i64), ok) -findIndex(map(list, #), !ok) -findIndex(map(list, #), div == div) -findIndex(map(list, #), ok) -findIndex(map(list, f32), i32 == f64) -findIndex(map(list, list), ok) -findIndex(map(list, ok), # == ok) -findIndex(sort(array), # < #) -findIndex(true ? "bar" : i32, # < #) -findIndex(true ? "bar" : true, ok) -findLast([0.5], i64 != 0.5) +findIndex(list, ok) * i +findIndex(list, ok) ** i +findIndex(list, ok) >= f64 +findIndex(list, ok) ^ i32 +findIndex(list, true ? ok : #) +findIndex(list, true) % i64 +findIndex(map(array, #), # < #) +findIndex(map(array, #), # >= #) +findIndex(map(array, #), i > #) +findIndex(map(array, f32), i32 == #) +findIndex(map(array, i), # != #) +findIndex(map(array, i), ok) +findIndex(map(list, #), # != #) +findIndex(map(list, #), # == #) +findIndex(map(list, i64), # == 0.5) +findIndex(map(list, i64), i64 < #) +findIndex(map(list, true), #) +findIndex(map(list, true), ok) +findIndex(ok ? "foo" : greet, !ok) +findIndex(ok ? "foo" : i, # == #) +findIndex(sort(array), i32 == #) +findIndex(true ? "foo" : ok, # == greet) +findLast(1 .. i, # <= #) +findLast(1 .. i32, 1 >= #) +findLast(1 .. i64, ok) +findLast([false], #) findLast(array, !false) -findLast(array, !true) -findLast(array, "bar" > "bar") -findLast(array, "foo" startsWith "foo") +findLast(array, !ok) +findLast(array, "foo" > "bar") findLast(array, # != #) +findLast(array, # != 0.5) +findLast(array, # != 1) +findLast(array, # != f32) findLast(array, # != f64) -findLast(array, # != nil) +findLast(array, # != i) findLast(array, # < #) findLast(array, # < 0.5) -findLast(array, # < 1) findLast(array, # < f32) findLast(array, # < f64) -findLast(array, # < i) +findLast(array, # < i + #) findLast(array, # <= #) findLast(array, # <= 0.5) findLast(array, # <= 1) findLast(array, # <= f32) -findLast(array, # <= f64) -findLast(array, # <= i) findLast(array, # <= i64) findLast(array, # == #) findLast(array, # == 0.5) -findLast(array, # == f64) -findLast(array, # == i64) +findLast(array, # == nil) findLast(array, # > #) findLast(array, # > 0.5) +findLast(array, # > 1) findLast(array, # > i) findLast(array, # > i32) findLast(array, # > i64) findLast(array, # >= #) findLast(array, # >= 0.5) -findLast(array, # >= f64) -findLast(array, # >= i) +findLast(array, # >= 1) +findLast(array, # >= f32) findLast(array, # >= i32) -findLast(array, # not in array) -findLast(array, 0.5 != #) -findLast(array, 0.5 != 0.5) -findLast(array, 0.5 != i) -findLast(array, 0.5 < #) -findLast(array, 0.5 < i64) findLast(array, 0.5 <= #) -findLast(array, 0.5 == #) -findLast(array, 0.5 > 0.5) +findLast(array, 0.5 <= i64) +findLast(array, 0.5 > #) +findLast(array, 0.5 >= #) findLast(array, 0.5 >= 1) -findLast(array, 0.5 >= f64) findLast(array, 1 != #) -findLast(array, 1 != i64) -findLast(array, 1 < #) findLast(array, 1 <= #) -findLast(array, 1 <= 0.5) -findLast(array, 1 <= f32) findLast(array, 1 == #) -findLast(array, 1 == nil) -findLast(array, 1 > #) -findLast(array, 1 >= #) -findLast(array, 1 >= 1) -findLast(array, add != greet) -findLast(array, array == array) -findLast(array, div != score) -findLast(array, f32 != nil) -findLast(array, f32 < #) findLast(array, f32 >= #) -findLast(array, f32 >= 1) -findLast(array, f64 != i) -findLast(array, f64 < i64) -findLast(array, f64 >= #) -findLast(array, foo != nil) -findLast(array, half == nil) -findLast(array, i != i32) +findLast(array, f64 != #) +findLast(array, f64 != nil) +findLast(array, f64 <= #) +findLast(array, f64 <= 1) +findLast(array, f64 == #) +findLast(array, f64 == nil) +findLast(array, f64 >= 1) +findLast(array, f64 >= i64) +findLast(array, false != true) +findLast(array, false or true) +findLast(array, greet != nil) findLast(array, i < #) -findLast(array, i <= #) -findLast(array, i >= #) -findLast(array, i32 != #) -findLast(array, i32 <= f32) -findLast(array, i32 == 1) +findLast(array, i == i32) +findLast(array, i > #) +findLast(array, i >= 0.5) +findLast(array, i32 < #) +findLast(array, i32 == 0.5) findLast(array, i32 > #) findLast(array, i32 >= #) -findLast(array, i32 >= 0.5) +findLast(array, i32 >= i32) findLast(array, i64 != #) -findLast(array, i64 != 1) findLast(array, i64 < #) findLast(array, i64 <= #) -findLast(array, i64 <= 0.5) findLast(array, i64 == #) -findLast(array, i64 == nil) -findLast(array, i64 >= #) -findLast(array, i64 >= i32) -findLast(array, nil != #) -findLast(array, nil != nil) -findLast(array, nil == #) -findLast(array, nil == nil) +findLast(array, i64 > 0.5) +findLast(array, list != nil) +findLast(array, nil != array) +findLast(array, not (array == array)) findLast(array, not false) -findLast(array, not true) +findLast(array, not ok) +findLast(array, ok and true) findLast(array, ok) -findLast(array, ok) < f64 -findLast(array, true) + i -findLast(array, true) + i32 -findLast(array, true) <= f64 -findLast(array, true) > i -findLast(i .. 1, # > f32) -findLast(i32 .. 1, # >= #) -findLast(i32 .. i32, ok) -findLast(i64 .. 1, f32 <= #) -findLast(list, !true) -findLast(list, "bar" in #) -findLast(list, "bar" not contains "bar") -findLast(list, "bar" not in #) -findLast(list, "bar" not matches "bar") -findLast(list, "foo" == "foo") -findLast(list, "foo" > "foo") +findLast(array, ok) == i64 +findLast(array, reduce(list, ok)) +findLast(array, score != nil) +findLast(array, true) % i64 +findLast(groupBy(array, #).i32, #) +findLast(groupBy(list, "bar").div, #?.f32?.half()) +findLast(groupBy(list, #)[ok], .ok) +findLast(groupBy(list, f64).foo, .f32(#, #)?.Qux(#?.i64(add, nil))) +findLast(i .. 1, # < #) +findLast(i .. i32, # != i64) +findLast(i .. i32, ok) +findLast(i32 .. i64, # >= i) +findLast(i64 .. 1, # < #) +findLast(list, !false) +findLast(list, !ok) findLast(list, "foo" in #) -findLast(list, "foo" not in #) findLast(list, # != #) +findLast(list, # != nil) findLast(list, # == #) findLast(list, # == foo) -findLast(list, # == nil) +findLast(list, # in list) findLast(list, # not in list) -findLast(list, 0.5 == nil) -findLast(list, 0.5 > f32) -findLast(list, 1 != 0.5) -findLast(list, 1 != 1) -findLast(list, 1 <= i) -findLast(list, 1 > 1) -findLast(list, 1 > i) -findLast(list, 1 >= 0.5) -findLast(list, 1 >= 1) -findLast(list, add == nil) -findLast(list, all(list, false)) -findLast(list, f32 < f64) +findLast(list, 0.5 != i64) +findLast(list, 0.5 <= 1) +findLast(list, 0.5 == i64) +findLast(list, 1 != f32) +findLast(list, 1 != nil) +findLast(list, 1 <= 1) +findLast(list, 1 > f32) +findLast(list, 1 >= f64) +findLast(list, f32 != i) +findLast(list, f32 > f32) +findLast(list, f32 >= 1) +findLast(list, f64 <= i) +findLast(list, f64 in array) findLast(list, false)?.Bar -findLast(list, foo != #)?.Bar -findLast(list, foo == #) -findLast(list, greet == half) -findLast(list, i != 1) -findLast(list, i != i64) -findLast(list, i >= f32) -findLast(list, i32 == 1) -findLast(list, i64 <= 0.5) -findLast(list, i64 <= i) -findLast(list, i64 == i32) -findLast(list, i64 > 0.5) +findLast(list, foo != #) +findLast(list, foo in list) +findLast(list, i != i) +findLast(list, i <= 1) +findLast(list, i <= i) +findLast(list, i == i32) +findLast(list, i >= i) +findLast(list, i32 != f32) +findLast(list, i64 > f32) findLast(list, i64 > i) -findLast(list, i64 >= i32) -findLast(list, nil != "bar") +findLast(list, i64 >= 1) findLast(list, nil != #) -findLast(list, nil != add) -findLast(list, nil != false) -findLast(list, nil != foo) -findLast(list, nil != nil) -findLast(list, nil != ok) -findLast(list, nil == #) -findLast(list, nil == i32) -findLast(list, nil == i64) -findLast(list, nil == list) -findLast(list, nil == nil) -findLast(list, not ok) -findLast(list, ok ? ok : nil) +findLast(list, nil not in array) +findLast(list, nil not in list) +findLast(list, none(array, ok)) +findLast(list, not false) +findLast(list, not true) +findLast(list, ok or true) findLast(list, ok) +findLast(list, ok) not in list findLast(list, ok).Bar findLast(list, ok).Qux findLast(list, ok).String -findLast(list, ok).String() findLast(list, ok)?.Bar findLast(list, ok)?.Qux findLast(list, ok)?.String -findLast(list, one(list, true)) -findLast(list, true != nil) +findLast(list, true or ok) findLast(list, true).Bar findLast(list, true).Qux findLast(list, true).String findLast(list, true)?.Bar findLast(list, true)?.Qux findLast(list, true)?.String -findLast(map(array, #), # > f32) -findLast(map(array, #), # >= #) +findLast(map(array, #), # < #) +findLast(map(array, #), # < i32) +findLast(map(array, #), # <= 1) +findLast(map(array, #), # == f64) +findLast(map(array, #), 0.5 != 0.5) findLast(map(array, #), i32 == #) findLast(map(array, #), ok) -findLast(map(array, f64), # <= #) -findLast(map(array, i), # <= #) -findLast(map(array, ok), #) -findLast(map(array, ok), not #) -findLast(map(array, true), #) -findLast(map(list, #), # != #) -findLast(map(list, array), # == #) -findLast(map(list, i), # >= #) -findLast(map(list, list), ok) -findLast(map(list, score), 0.5 > f32) -findLast(ok ? array : div, # >= #) -findLast(sort(array), # && false) -findLastIndex([i32], # >= 0.5) -findLastIndex(array, !false) -findLastIndex(array, !ok) -findLastIndex(array, !true) -findLastIndex(array, "bar" != "bar") +findLast(map(array, f64 * #), # + # > f32) +findLast(map(array, score), ok) +findLast(map(list, #), # == #) +findLast(map(list, #), greet == nil) +findLast(map(list, #), ok) +findLast(map(list, ok), # ? # : #) +findLastIndex(1 .. 1, i64 < #) +findLastIndex([i64, half], ok) +findLastIndex(array, "bar" not matches "foo") +findLastIndex(array, "bar" startsWith "foo") +findLastIndex(array, "foo" == nil) +findLastIndex(array, "foo" >= "foo") +findLastIndex(array, "foo" contains "foo") findLastIndex(array, # != #) -findLastIndex(array, # != 0.5) +findLastIndex(array, # != 1) +findLastIndex(array, # != f32) +findLastIndex(array, # != f64) +findLastIndex(array, # != i32) findLastIndex(array, # != i64) findLastIndex(array, # != nil) -findLastIndex(array, # / f32 == #) -findLastIndex(array, # < # ** i32) findLastIndex(array, # < #) -findLastIndex(array, # < 0.5) findLastIndex(array, # < 1) -findLastIndex(array, # < f32) findLastIndex(array, # < f64) findLastIndex(array, # < i) findLastIndex(array, # < i64) findLastIndex(array, # <= #) findLastIndex(array, # <= 0.5) -findLastIndex(array, # <= 1) -findLastIndex(array, # <= f32) -findLastIndex(array, # <= f64) -findLastIndex(array, # <= i) -findLastIndex(array, # <= i32) findLastIndex(array, # <= i64) findLastIndex(array, # == #) findLastIndex(array, # == 0.5) findLastIndex(array, # == 1) -findLastIndex(array, # == i32) +findLastIndex(array, # == f64) +findLastIndex(array, # == i64) findLastIndex(array, # == nil) findLastIndex(array, # > #) findLastIndex(array, # > 0.5) -findLastIndex(array, # > 1) +findLastIndex(array, # > f32) +findLastIndex(array, # > f64) findLastIndex(array, # > i) -findLastIndex(array, # > i64) findLastIndex(array, # >= #) +findLastIndex(array, # >= 0.5) findLastIndex(array, # >= 1) -findLastIndex(array, # >= f64) -findLastIndex(array, # in array) +findLastIndex(array, # >= f32) +findLastIndex(array, # >= i32) +findLastIndex(array, # ^ # >= #) findLastIndex(array, # not in array) findLastIndex(array, 0.5 != #) -findLastIndex(array, 0.5 != 0.5) +findLastIndex(array, 0.5 != i64) findLastIndex(array, 0.5 < #) -findLastIndex(array, 0.5 < i) +findLastIndex(array, 0.5 < i32) findLastIndex(array, 0.5 <= #) -findLastIndex(array, 0.5 <= 0.5) -findLastIndex(array, 0.5 == #) findLastIndex(array, 0.5 > #) -findLastIndex(array, 0.5 > i) -findLastIndex(array, 0.5 >= #) -findLastIndex(array, 0.5 >= f32) +findLastIndex(array, 0.5 >= 0.5) +findLastIndex(array, 0.5 >= f64) findLastIndex(array, 1 != #) -findLastIndex(array, 1 < #) findLastIndex(array, 1 <= #) -findLastIndex(array, 1 <= i) -findLastIndex(array, 1 <= i64) findLastIndex(array, 1 == #) -findLastIndex(array, 1 > #) -findLastIndex(array, 1 > 1) -findLastIndex(array, 1 >= #) -findLastIndex(array, 1 in array) -findLastIndex(array, add != add) -findLastIndex(array, any(list, false)) +findLastIndex(array, 1 == f64) +findLastIndex(array, 1 >= i32) +findLastIndex(array, array == nil) findLastIndex(array, f32 != #) +findLastIndex(array, f32 != f32) findLastIndex(array, f32 < #) -findLastIndex(array, f32 <= f64) -findLastIndex(array, f32 == f64) +findLastIndex(array, f32 == #) +findLastIndex(array, f32 == nil) findLastIndex(array, f32 > #) -findLastIndex(array, f32 >= f64) findLastIndex(array, f64 != #) findLastIndex(array, f64 < #) +findLastIndex(array, f64 <= #) +findLastIndex(array, f64 <= i32) findLastIndex(array, f64 == #) -findLastIndex(array, f64 > i) -findLastIndex(array, f64 >= #) -findLastIndex(array, i == #) -findLastIndex(array, i > #) -findLastIndex(array, i > 1) -findLastIndex(array, i >= #) -findLastIndex(array, i32 != #) -findLastIndex(array, i32 < #) -findLastIndex(array, i32 <= 0.5) -findLastIndex(array, i32 == #) -findLastIndex(array, i32 == i32) -findLastIndex(array, i32 > #) -findLastIndex(array, i64 != #) -findLastIndex(array, i64 != f32) -findLastIndex(array, i64 >= #) -findLastIndex(array, list != nil) -findLastIndex(array, nil != "foo") +findLastIndex(array, f64 == 0.5) +findLastIndex(array, f64 > #) +findLastIndex(array, false ? # : false) +findLastIndex(array, foo != foo) +findLastIndex(array, greet == greet) +findLastIndex(array, i - # >= #) +findLastIndex(array, i < #) +findLastIndex(array, i <= #) +findLastIndex(array, i > 0.5) +findLastIndex(array, i32 <= #) +findLastIndex(array, i32 <= 1) +findLastIndex(array, i32 <= f32) +findLastIndex(array, i32 > 0.5) +findLastIndex(array, i32 >= #) +findLastIndex(array, i64 <= # + #) +findLastIndex(array, i64 > #) +findLastIndex(array, min(1, #) <= i32 + #) findLastIndex(array, nil != #) -findLastIndex(array, nil != 0.5) -findLastIndex(array, nil != foo) -findLastIndex(array, nil != nil) +findLastIndex(array, nil != add) +findLastIndex(array, nil != i32) findLastIndex(array, nil == #) -findLastIndex(array, nil == i) -findLastIndex(array, nil not in list) -findLastIndex(array, none(array, true)) -findLastIndex(array, not (# != #)) -findLastIndex(array, not false) +findLastIndex(array, not (i32 != 0.5)) +findLastIndex(array, not ok) +findLastIndex(array, ok && true) findLastIndex(array, ok) -findLastIndex(array, ok) * f64 -findLastIndex(array, ok) / i64 -findLastIndex(array, ok) <= i64 -findLastIndex(array, ok) ^ f32 -findLastIndex(array, true ? ok : 1) +findLastIndex(array, ok) % i64 +findLastIndex(array, ok) + f64 +findLastIndex(array, one(list, ok)) +findLastIndex(array, score == nil) +findLastIndex(array, true == false) findLastIndex(array, true) / f32 -findLastIndex(array, true) <= i64 -findLastIndex(array, true) > f64 -findLastIndex(false ? i : "bar", ok) -findLastIndex(filter(list, true), ok) -findLastIndex(i .. i32, # == 1) -findLastIndex(i32 .. i, ok) -findLastIndex(i32 .. i64, f64 == nil) -findLastIndex(i64 .. 1, # != nil) -findLastIndex(i64 .. 1, add == nil) +findLastIndex(array, true) not in array +findLastIndex(filter(array, false), ok) +findLastIndex(groupBy(list, #).ok, #) +findLastIndex(groupBy(list, 0.5).Bar, #?.String endsWith .f32(list)) +findLastIndex(i32 .. i32, ok) +findLastIndex(i64 .. 1, ok) +findLastIndex(list, !(nil != #)) +findLastIndex(list, !false) findLastIndex(list, !ok) findLastIndex(list, !true) findLastIndex(list, "bar" in #) -findLastIndex(list, "foo" matches "bar") +findLastIndex(list, "bar" matches "foo") +findLastIndex(list, "bar" not endsWith "foo") +findLastIndex(list, "bar" not matches "bar") +findLastIndex(list, "foo" <= "bar") +findLastIndex(list, "foo" not in #) findLastIndex(list, # != #) findLastIndex(list, # != foo) -findLastIndex(list, # != nil) findLastIndex(list, # == #) +findLastIndex(list, # == foo) findLastIndex(list, # == nil) findLastIndex(list, # in list) -findLastIndex(list, 0.5 != i) -findLastIndex(list, 0.5 <= 0.5) -findLastIndex(list, 0.5 <= f32) -findLastIndex(list, 1 != 0.5) -findLastIndex(list, 1 != f64) -findLastIndex(list, 1 != i64) -findLastIndex(list, 1 < i32) -findLastIndex(list, 1 <= f32) -findLastIndex(list, 1 <= i) -findLastIndex(list, array != list) +findLastIndex(list, # not in list) +findLastIndex(list, 1 != f32) +findLastIndex(list, 1 != nil) +findLastIndex(list, 1 > 1) +findLastIndex(list, 1 >= 0.5) findLastIndex(list, array != nil) -findLastIndex(list, array == list) -findLastIndex(list, div == add) -findLastIndex(list, div == score) -findLastIndex(list, f32 != 0.5) -findLastIndex(list, f32 < f64) -findLastIndex(list, f32 < i32) -findLastIndex(list, f32 <= i64) -findLastIndex(list, f32 == i32) -findLastIndex(list, f32 > f32) -findLastIndex(list, f64 <= 1) -findLastIndex(list, f64 == f64) -findLastIndex(list, false == false) -findLastIndex(list, false and false) -findLastIndex(list, false and ok) -findLastIndex(list, foo != #) -findLastIndex(list, foo == foo) -findLastIndex(list, greet != half) -findLastIndex(list, greet == nil) -findLastIndex(list, half != nil) -findLastIndex(list, i < i64) -findLastIndex(list, i <= i) -findLastIndex(list, i32 != nil) -findLastIndex(list, i32 < f64) -findLastIndex(list, i32 <= i32) -findLastIndex(list, i32 >= 0.5) -findLastIndex(list, i32 >= i) -findLastIndex(list, i64 < f64) -findLastIndex(list, i64 == f32) -findLastIndex(list, i64 >= i) +findLastIndex(list, div != nil) +findLastIndex(list, f32 != 1) +findLastIndex(list, f32 != f64) +findLastIndex(list, f64 > 0.5) +findLastIndex(list, foo == #) +findLastIndex(list, i <= 1) +findLastIndex(list, i32 > 1) +findLastIndex(list, i32 > f32) +findLastIndex(list, i64 == i64) +findLastIndex(list, i64 >= 0.5) findLastIndex(list, i64 not in array) +findLastIndex(list, nil != "bar") findLastIndex(list, nil != #) +findLastIndex(list, nil != f64) findLastIndex(list, nil == #) -findLastIndex(list, none(array, ok)) -findLastIndex(list, not ok) +findLastIndex(list, nil == 1) +findLastIndex(list, nil == half) +findLastIndex(list, not false) findLastIndex(list, not true) -findLastIndex(list, ok != nil) +findLastIndex(list, ok ? ok : 0.5) +findLastIndex(list, ok and false) findLastIndex(list, ok) -findLastIndex(list, ok) ** f32 -findLastIndex(list, ok) ** f64 -findLastIndex(list, ok) - i -findLastIndex(list, ok) >= i64 -findLastIndex(list, true == nil) -findLastIndex(list, true) ** i64 -findLastIndex(list, true) + i -findLastIndex(list, true) .. i64 -findLastIndex(list, true) < i -findLastIndex(list, true) > f32 -findLastIndex(list, true) >= f32 -findLastIndex(list, true) in array -findLastIndex(map(array, "foo"), # == #) -findLastIndex(map(array, #), i < #) -findLastIndex(map(array, #), nil != half) +findLastIndex(list, ok) != i64 +findLastIndex(list, ok) > f32 +findLastIndex(list, ok) > i64 +findLastIndex(list, one(array, true)) +findLastIndex(list, true && ok) +findLastIndex(list, true) * i32 +findLastIndex(list, true) - i32 +findLastIndex(list, true) < i64 +findLastIndex(list, true) > i64 +findLastIndex(list, true) ^ f64 +findLastIndex(map(array, "bar"), # not endsWith #) +findLastIndex(map(array, #), # < f64) +findLastIndex(map(array, #), # <= #) findLastIndex(map(array, #), ok) -findLastIndex(map(array, 0.5), ok) -findLastIndex(map(array, array), 1 != i) -findLastIndex(map(array, false), #) -findLastIndex(map(array, true), #) -findLastIndex(map(list, #), !ok) -findLastIndex(map(list, #), 0.5 < f32) -findLastIndex(map(list, 0.5), # <= #) -findLastIndex(map(list, f32), # == #) -findLastIndex(map(list, f32), # >= #) -findLastIndex(map(list, f32), ok) +findLastIndex(map(array, div), 0.5 <= 0.5) +findLastIndex(map(array, f32), nil == nil) +findLastIndex(map(array, list), ok) +findLastIndex(map(array, ok), # and #) +findLastIndex(map(list, "bar"), # >= #) +findLastIndex(map(list, #), !true) +findLastIndex(map(list, #), nil == 0.5) findLastIndex(map(list, false), #) -findLastIndex(map(list, half), ok) -findLastIndex(map(list, ok), # or #) -findLastIndex(map(list, ok), #) -findLastIndex(sort(array), ok) -first(1 .. i) -first(1 .. i32) +findLastIndex(map(list, foo), ok) +findLastIndex(map(list, i32), # >= #) +findLastIndex(map(list, i64), ok) +findLastIndex(ok ? "bar" : add, not false) +findLastIndex(true ? "foo" : 1, # and false) +first(1 .. 1) +first(1 .. i64) first([f32]) -first([f64]) -first([false, list]) -first([i64, nil]) -first([list, i32]) -first([not false]) +first([foo]) +first([ok]) first(array) first(array) * i -first(array) ** i32 -first(array) ** i64 -first(array) + i32 -first(array) / 1 * 0.5 -first(array) <= i32 -first(array) <= i64 +first(array) * i64 +first(array) + f32 +first(array) <= i +first(array) == f32 +first(array) == f64 first(array) == i64 -first(array) > i32 +first(array) > 0.5 ** i first(array) > i64 -first(array) in array -first(false ? f64 : true) -first(false ? greet : i) -first(filter(array, false)) -first(filter(list, ok)) -first(i .. 1) +first(array) ^ f64 +first(array[1:1]) +first(false ? foo : 1) +first(false ? greet : foo) +first(get(groupBy(array, #), i)) +first(groupBy(array, #).greet) +first(groupBy(list, #)?.div) first(i .. i) -first(i .. i32) -first(i32 .. 1) -first(i32 .. i) -first(i32 .. i64) first(i64 .. i32) +first(i64 .. i64) first(list) first(list) not in list first(list).Bar @@ -5703,44 +6355,33 @@ first(list)?.Bar first(list)?.Qux first(list)?.String first(list)?.String() -first(map(array, "bar")) first(map(array, #)) first(map(array, 0.5)) first(map(array, 1)) first(map(array, add)) -first(map(array, f32)) -first(map(array, f64)) -first(map(array, foo)) -first(map(array, greet)) +first(map(array, array)) +first(map(array, div)) first(map(array, half)) first(map(array, i)) -first(map(array, list)) +first(map(array, i32)) +first(map(array, i64)) first(map(array, ok)) -first(map(array, score)) first(map(list, #)) first(map(list, 0.5)) -first(map(list, add)) -first(map(list, array)) -first(map(list, div)) first(map(list, f32)) -first(map(list, f64)) -first(map(list, i32)) +first(map(list, greet)) +first(map(list, i)) first(map(list, list)) first(map(list, score)) -first(ok ? "bar" : 0.5) -first(ok ? 1 : "foo") -first(ok ? add : f32) -first(ok ? array : "bar") -first(ok ? list : nil) -first(ok ? ok : array) -first(ok ? ok : foo) -first(ok ? ok : score) +first(ok ? 0.5 : false) +first(ok ? array : add) +first(ok ? greet : i64) +first(ok ? list : ok) +first(reduce(list, array)) first(sort(array)) -first(true ? 0.5 : i64) -first(true ? add : ok) -first(true ? array : false) -first(true ? ok : div) -float(-(1 / i32)) +first(true ? f32 : div) +first(true ? greet : div) +first(true ? score : div) float(-0.5) float(-1) float(-f32) @@ -5749,184 +6390,149 @@ float(-i) float(-i32) float(-i64) float(0.5 * 0.5) +float(0.5 * 1) float(0.5 * f32) -float(0.5 * i) -float(0.5 * i32) float(0.5 * i64) float(0.5 ** 0.5) -float(0.5 ** 1) float(0.5 ** f32) -float(0.5 ** i32) float(0.5 + 1) -float(0.5 + f32) -float(0.5 + i) +float(0.5 + i32) float(0.5 + i64) float(0.5 - 0.5) float(0.5 - 1) -float(0.5 - f32) -float(0.5 - i) -float(0.5 - i32) float(0.5 - i64) float(0.5 / 0.5) -float(0.5 / 1) -float(0.5 / f32) -float(0.5 / f64) -float(0.5 / i) -float(0.5 ^ 0.5) +float(0.5 / i32) +float(0.5 / i64) float(0.5 ^ 1) -float(0.5 ^ f64) -float(0.5 ^ i32) -float(0.5 ^ i64) +float(0.5 ^ i) +float(0.5) != f32 float(0.5) != i32 -float(0.5) ** (1 % 1) -float(0.5) + 0.5 - f64 -float(0.5) + f32 -float(0.5) + i32 -float(0.5) - -f32 -float(0.5) - f32 +float(0.5) * f32 +float(0.5) * i32 +float(0.5) * i64 +float(0.5) ** f64 +float(0.5) ** i +float(0.5) ** i32 +float(0.5) - i +float(0.5) - i64 float(0.5) / f32 -float(0.5) < i32 -float(0.5) >= i32 -float(1 % 1) -float(1 % i) -float(1 % i32) +float(0.5) / f64 +float(0.5) / i32 +float(0.5) == i32 * 0.5 +float(0.5) ^ i64 +float(0.5) in array float(1 % i64) float(1 * 0.5) -float(1 * 1) +float(1 * f32) float(1 * i) -float(1 * i32) float(1 * i64) float(1 ** 0.5) +float(1 ** 1) +float(1 ** f64) float(1 ** i) -float(1 + 0.5) -float(1 + 1) -float(1 + f32) float(1 + f64) -float(1 + i) +float(1 + i32) float(1 - 0.5) -float(1 - 1) -float(1 - f32) -float(1 - i) float(1 / 0.5) -float(1 / 1) -float(1 / f64) -float(1 / i) -float(1 ^ 1) -float(1 ^ f32) float(1 ^ f64) -float(1 ^ i) -float(1 ^ i32) -float(1 ^ i64) -float(1) != abs(f32) -float(1) != {"foo": i32}?.add +float(1) * f32 +float(1) * i64 +float(1) ** i float(1) ** i64 -float(1) - i64 -float(1) / i -float(1) / i64 -float(1) < i32 +float(1) - f64 float(1) <= i64 -float(1) == int(0.5) -float(1) > i -float(1) >= f32 -float(1) >= i - i -float(abs(0.5)) -float(abs(1)) +float(1) == i64 +float(1) > -0.5 +float(1) > i64 +float(1) >= f64 +float(1) >= i float(abs(f32)) +float(abs(f64)) float(abs(i)) float(abs(i32)) -float(abs(i64)) -float(add(i, 1)) -float(array[1]) +float(add(1, 1)) float(array[i32]) float(array[i64]) float(array[i]) -float(count(array, true)) -float(count(list, false) * (i - 1)) -float(count(list, false)) -float(div(1, i)) -float(div(i, 1)) -float(f32 * 0.5) -float(f32 * f32) +float(bitnot(1)) +float(bitnot(i)) +float(bitnot(i32)) +float(bitnot(i64)) +float(ceil(0.5)) +float(ceil(f32)) +float(ceil(f64)) +float(ceil(i32)) +float(ceil(i64)) +float(count(array, false)) +float(count(array, ok)) +float(count(list, i32 == 0.5)) +float(f32 * f64) +float(f32 * i) float(f32 * i32) -float(f32 * i64) -float(f32 ** 0.5) float(f32 ** 1) +float(f32 ** f32) float(f32 ** i) float(f32 ** i64) float(f32 + 0.5) float(f32 + 1) -float(f32 + f32) +float(f32 + f64) float(f32 + i32) +float(f32 + i64) float(f32 - 0.5) -float(f32 - 1) float(f32 - f64) -float(f32 - i) +float(f32 - i64) float(f32 / 0.5) float(f32 / 1) -float(f32 / f32) float(f32 / i) -float(f32 / i64) float(f32 ^ 0.5) +float(f32 ^ 1) float(f32 ^ f32) -float(f32 ^ f64) -float(f32 ^ i64) +float(f32 ^ i) +float(f32 ^ i32) float(f32) -float(f32) * f32 -float(f32) + f32 -float(f32) - f32 -float(f32) - f64 -float(f32) - i64 -float(f32) / f64 float(f32) < i32 float(f32) <= f32 -float(f32) >= f32 -float(f32) >= f32 ** f32 +float(f32) <= f64 / f32 +float(f32) <= i +float(f32) > i +float(f32) >= i64 float(f32) ^ f64 -float(f32) ^ i32 +float(f32) ^ i64 float(f64 * 0.5) +float(f64 * 1) float(f64 * f32) -float(f64 * i) +float(f64 * f64) float(f64 * i32) -float(f64 ** 1) float(f64 ** f32) -float(f64 + 0.5) float(f64 + 1) float(f64 + i) -float(f64 - 0.5) +float(f64 + i32) +float(f64 - 1) float(f64 - i) -float(f64 - i32) -float(f64 - i32) / i -float(f64 / -i32) +float(f64 / 0.5) float(f64 / 1) -float(f64 / f32) -float(f64 / i32) -float(f64 ^ 0.5) -float(f64 ^ 1) +float(f64 / i64) float(f64 ^ f32) -float(f64 ^ f64) float(f64) -float(f64) != int(i32) -float(f64) * i32 -float(f64) / f32 -float(f64) / f64 -float(f64) / i64 -float(f64) < i -float(f64) < i32 -float(f64) <= f32 -float(f64) <= i64 -float(f64) == i32 -float(f64) > i32 -float(f64) >= f64 +float(f64) * f32 +float(f64) * i +float(f64) / -i32 +float(f64) / i +float(f64) == f64 +float(f64) > f64 +float(f64) > i64 +float(f64) >= f32 float(f64) >= i -float(f64) >= i32 -float(f64) ^ i -float(false ? div : i32) -float(false ? f32 : 0.5) +float(f64) >= i64 +float(f64) ^ i64 +float(false ? f64 : 0.5) +float(false ? half : f64) +float(false ? list : f64) float(find(array, ok)) -float(find(array, true)) -float(findIndex(list, true)) -float(findLast(array, ok)) -float(findLast(array, true)) +float(findIndex(array, ok)) +float(findLastIndex(array, ok)) +float(findLastIndex(list, true)) float(first(array)) float(float(0.5)) float(float(1)) @@ -5934,351 +6540,619 @@ float(float(f32)) float(float(f64)) float(float(i)) float(float(i32)) -float(float(i64)) +float(floor(0.5)) +float(floor(1)) +float(floor(f32)) +float(floor(f64)) +float(floor(i32)) +float(floor(i64)) float(get(array, 1)) float(get(array, i)) -float(get(array, i64)) -float(half(-f64)) float(half(0.5)) +float(half(1)) float(half(f64)) -float(i % 1) +float(i % i32) float(i * 0.5) -float(i * 1) float(i * f64) -float(i * i) -float(i * i32 * i32) -float(i * i32) float(i * i64) -float(i ** 1) -float(i ** f64) +float(i ** f32) float(i ** i32) float(i + 0.5) -float(i + f64) +float(i + 1) float(i + i64) -float(i - 0.5) float(i - 1) -float(i - findIndex(array, true)) +float(i - f64) +float(i / 0.5) float(i / 1) -float(i / f64) -float(i / i64) -float(i ^ f32) -float(i ^ f64) -float(i ^ i64) +float(i ^ 0.5) +float(i ^ i32) float(i) -float(i) != f32 -float(i) != i32 -float(i) != i64 -float(i) ** f32 -float(i) / i32 -float(i) < f32 -float(i) < i64 -float(i) <= f32 -float(i) == i32 +float(i) != 1 ? nil : foo +float(i) != f64 +float(i) + f32 +float(i) + f64 +float(i) < i +float(i) == f32 +float(i) == i float(i) > f64 -float(i) ^ f64 -float(i) ^ i64 -float(i32 % 1) float(i32 % i) -float(i32 * 1) -float(i32 * f32) -float(i32 ** 0.5) -float(i32 ** f64) -float(i32 ** i32) -float(i32 ** i64) -float(i32 + 1) -float(i32 + f32) -float(i32 - 0.5) -float(i32 - f64) -float(i32 - i) -float(i32 - i32) -float(i32 / 0.5) +float(i32 % i64) +float(i32 * f64) +float(i32 * i32) +float(i32 ** 1) +float(i32 + f64) +float(i32 + i64) float(i32 / 1) -float(i32 / 1) > f64 -float(i32 / i) -float(i32 ^ 1) +float(i32 / f32) +float(i32 / i32) float(i32 ^ f64) -float(i32 ^ i) +float(i32 ^ i32) float(i32) float(i32) != f64 -float(i32) * i64 -float(i32) + i -float(i32) + i64 -float(i32) - i64 -float(i32) / i -float(i32) / i32 -float(i32) < -0.5 -float(i32) == f32 -float(i32) == i32 -float(i32) > f32 +float(i32) ** f32 +float(i32) ** i float(i32) > i32 -float(i32) >= f32 -float(i32) >= f64 -float(i32) ^ f32 -float(i32) ^ f64 -float(i32) ^ i32 -float(i64 % i) -float(i64 % i32) -float(i64 * 0.5) -float(i64 * 1) -float(i64 ** f64) -float(i64 ** i64) -float(i64 + 0.5) -float(i64 + f64) +float(i32) >= i +float(i64 % i64) +float(i64 * i64) +float(i64 ** 1) +float(i64 + f32) +float(i64 + i) +float(i64 - 0.5) float(i64 - 1) float(i64 - f32) -float(i64 - f64) -float(i64 - i32) -float(i64 - i64) -float(i64 / 0.5) float(i64 / 1) -float(i64 / f32) -float(i64 ^ f64) +float(i64 ^ f32) float(i64) -float(i64) ** i +float(i64) != i +float(i64) ** max(f64) +float(i64) + i32 +float(i64) - 0.5 ^ f32 +float(i64) - f64 float(i64) / i32 -float(i64) > f64 ^ f32 -float(i64) >= i -float(i64) >= i64 +float(i64) < i32 +float(i64) == i +float(i64) == i64 +float(i64) > i +float(i64) ^ f32 float(int(0.5)) float(int(1)) float(int(f32)) -float(int(f64)) float(int(i)) float(int(i32)) -float(int(i64)) +float(last(array)) float(len("bar")) -float(len("foo")) float(len(array)) float(len(list)) float(max(0.5)) -float(max(0.5, i32)) +float(max(0.5, i64)) float(max(1)) -float(max(1, i)) -float(max(1, i64)) +float(max(1, 1)) +float(max(f32)) float(max(f64)) float(max(i)) float(max(i32)) float(max(i64)) -float(min(0.5)) +float(mean(array)) float(min(1)) -float(min(f32)) float(min(f64)) -float(min(i)) +float(min(f64, i64)) float(min(i32)) float(min(i64)) -float(ok ? f64 : half) -float(ok ? i : greet) +float(ok ? 0.5 : foo) +float(ok ? 0.5 : list) +float(reduce(array, #)) +float(reduce(array, 0.5)) +float(reduce(array, f64)) +float(reduce(array, i32)) +float(reduce(list, i64)) +float(round(0.5)) +float(round(1)) +float(round(i32)) +float(round(i64)) float(score(1)) +float(score(1, 1)) float(score(i)) -float(score(i, i)) <= f32 -float(score(score(i))) float(string(0.5)) float(string(1)) -float(string(f32)) -float(string(f64)) +float(string(f64 - 0.5)) float(string(i)) +float(string(i32)) float(string(i64)) +float(sum(array)) float(toJSON(0.5)) float(toJSON(1)) float(toJSON(f32)) float(toJSON(f64)) -float(toJSON(i)) float(toJSON(i32)) -float(true ? 1 : div) -float(true ? 1 : i64) -float(true ? f64 : div) +float(toJSON(i64)) +float(true ? f32 : "foo") +floor(-0.5) +floor(-1) +floor(-f32) +floor(-f64) +floor(-i) +floor(-i32) +floor(-i64) +floor(0.5 * 0.5) +floor(0.5 * 1) +floor(0.5 * i32) +floor(0.5 ** 1) +floor(0.5 ** f64) +floor(0.5 ** i) +floor(0.5 + 1) +floor(0.5 + f32) +floor(0.5 + i) +floor(0.5 + i32) +floor(0.5 + i64) +floor(0.5 - 1) +floor(0.5 - f32) +floor(0.5 - i) +floor(0.5 / 0.5) +floor(0.5 / 1) +floor(0.5 / i32) +floor(0.5 ^ 0.5) +floor(0.5 ^ 1) +floor(0.5 ^ f32) +floor(0.5 ^ f64) +floor(0.5 ^ i) +floor(0.5) != i64 +floor(0.5) ** f32 +floor(0.5) - i +floor(0.5) - i64 +floor(0.5) / i +floor(0.5) <= i64 +floor(0.5) > i32 +floor(0.5) > i64 != ok +floor(0.5) >= f32 +floor(0.5) ^ i +floor(1 % 1) +floor(1 % i) +floor(1 * 0.5) +floor(1 * 1) +floor(1 ** 1) +floor(1 ** f64) +floor(1 ** i32) +floor(1 + 0.5) +floor(1 + 1) +floor(1 + f32) +floor(1 + f64) +floor(1 + i32) +floor(1 - 0.5) +floor(1 - 1) +floor(1 - i) +floor(1 - i32) +floor(1 - i64) +floor(1 / 0.5) +floor(1 / 1) +floor(1 / i) +floor(1 / i64) +floor(1 ^ i) +floor(1 ^ i32) +floor(1 ^ i64) +floor(1) * i64 +floor(1) - f32 +floor(1) - i +floor(1) <= f32 +floor(1) >= half(0.5) +floor(abs(0.5)) +floor(abs(1)) +floor(abs(f32)) +floor(abs(f64)) +floor(abs(i32)) +floor(abs(i64)) +floor(array[1]) +floor(array[i32]) +floor(array[i64]) +floor(array[i]) +floor(bitnot(1)) +floor(bitnot(i)) +floor(bitnot(i32)) +floor(bitnot(i64)) +floor(ceil(0.5)) +floor(ceil(1)) +floor(ceil(f64)) +floor(ceil(i)) +floor(ceil(i32)) +floor(ceil(i64)) +floor(count(array, false)) +floor(count(array, ok)) +floor(count(list, ok)) +floor(f32 ** 1) +floor(f32 ** f64) +floor(f32 ** i32) +floor(f32 + f32) +floor(f32 + i32) +floor(f32 + i64) +floor(f32 - 0.5) +floor(f32 - f64) +floor(f32 / 0.5) +floor(f32 / f64) +floor(f32 / i) +floor(f32 / i32) +floor(f32 / i64) +floor(f32 ^ 0.5) +floor(f32 ^ f64) +floor(f32 ^ i) +floor(f32) +floor(f32) != -i32 +floor(f32) * i32 +floor(f32) + f32 +floor(f32) / f32 +floor(f32) / f64 +floor(f32) == i64 +floor(f32) > i32 +floor(f32) >= f32 +floor(f32) >= i +floor(f32) ^ f32 +floor(f64 * f32) +floor(f64 ** 0.5) +floor(f64 ** 1) +floor(f64 ** i32) +floor(f64 + 0.5) +floor(f64 + 1) +floor(f64 + i32) +floor(f64 - 0.5) +floor(f64 - i32) +floor(f64 / 0.5) +floor(f64 / 1) +floor(f64 / f32) +floor(f64 / f64) +floor(f64 / i) +floor(f64 ^ 1) +floor(f64) +floor(f64) * i32 +floor(f64) ** f64 +floor(f64) / f32 +floor(f64) < i32 +floor(f64) <= f64 +floor(f64) <= i64 +floor(f64) == f64 ** i +floor(f64) == i +floor(f64) > i32 +floor(f64) >= 1 * 1 +floor(f64) >= f32 +floor(false ? div : 0.5) +floor(find(array, true)) +floor(findIndex(array, ok)) +floor(findLastIndex(array, ok)) +floor(float(0.5)) +floor(float(1)) +floor(float(f64)) +floor(float(i32)) +floor(floor(0.5)) +floor(floor(1)) +floor(floor(f32)) +floor(floor(f64)) +floor(floor(i)) +floor(floor(i32)) +floor(floor(i64)) +floor(get(array, 1)) +floor(get(array, i)) +floor(get(array, i64)) +floor(half(0.5)) +floor(half(1)) +floor(half(f64)) +floor(i % 1) +floor(i % i) +floor(i % i32) +floor(i % i64) +floor(i * 1) +floor(i * f64) +floor(i ** 0.5) +floor(i ** f32) +floor(i ** i32) +floor(i ** i64) +floor(i + 0.5) +floor(i + f64) +floor(i - 0.5) +floor(i - f32) +floor(i - i32) +floor(i / 0.5) +floor(i / 1) +floor(i / f64) +floor(i ^ i32) +floor(i) +floor(i) != i +floor(i) * f64 +floor(i) ^ i +floor(i32 % i32) +floor(i32 * 1) +floor(i32 * f32) +floor(i32 * f64) +floor(i32 * i32) +floor(i32 ** i) +floor(i32 ** i64) +floor(i32 + 0.5) +floor(i32 + f64) +floor(i32 - 1) +floor(i32 - f32) +floor(i32 - i) +floor(i32 - i32) +floor(i32 - i64) +floor(i32 ^ 0.5) +floor(i32 ^ 1) +floor(i32 ^ f64) +floor(i32 ^ i) +floor(i32 ^ i32) +floor(i32 ^ i64) +floor(i32) +floor(i32) != f32 +floor(i32) * f64 +floor(i32) * i +floor(i32) * i64 +floor(i32) > i32 +floor(i32) > i64 +floor(i32) >= i32 +floor(i32) ^ i32 +floor(i64 % i) +floor(i64 * 0.5) +floor(i64 * f32) +floor(i64 * i) +floor(i64 ** 0.5) +floor(i64 ** 1) +floor(i64 ** i) +floor(i64 ** i32) +floor(i64 + 0.5) +floor(i64 + f64) +floor(i64 + i64) +floor(i64 - f64) +floor(i64 - i) +floor(i64 / f32) +floor(i64 ^ 0.5) +floor(i64 ^ f32) +floor(i64 ^ i64) +floor(i64) +floor(i64) * i64 +floor(i64) / (i64 - i) +floor(i64) / f64 +floor(i64) / i32 +floor(i64) < f32 +floor(i64) <= i64 +floor(i64) ^ f32 +floor(int(0.5)) +floor(int(1)) +floor(int(i32)) +floor(int(i64)) +floor(len("foo")) +floor(len(array)) +floor(len(list)) +floor(max(0.5)) +floor(max(1)) +floor(max(f32)) +floor(max(f64)) +floor(max(i32)) +floor(min(0.5)) +floor(min(f64) ^ i64) +floor(min(i, i64)) +floor(min(i32)) +floor(ok ? 1 : 1) +floor(ok ? f32 : "foo") +floor(ok ? i64 : f64) +floor(reduce(array, #)) +floor(reduce(array, i)) +floor(reduce(array, i64)) +floor(reduce(list, 1)) +floor(reduce(list, f32)) +floor(reduce(list, i64)) +floor(round(0.5)) +floor(round(f32)) +floor(round(f64)) +floor(round(i)) +floor(round(i32)) +floor(score(1)) +floor(score(1, 1)) +floor(score(i)) +floor(true ? 0.5 : false) +floor(true ? 1 : true) +floor(true ? f64 : 0.5) +floor(true ? f64 : array) foo -foo != first(list) foo != foo -foo != foo ? 1 : 1 -foo != get(list, i) -foo != last(list) -foo != nil ? half : nil +foo != nil != nil +foo != reduce(list, #) foo == foo -foo == foo ? i : score -foo == last(list) -foo == nil == nil -foo == nil || ok +foo == foo and 0.5 != f64 +foo == get(list, 1) +foo == list[i] +foo == nil ? i : i32 +foo == nil ? i64 : i +foo == reduce(list, #) foo in filter(list, false) +foo in groupBy(array, #) +foo in groupBy(list, #) foo in list -foo in list ? nil : i32 -foo in map(list, #) +foo in list != ok +foo not in groupBy(array, #) +foo not in groupBy(array, f64).foo +foo not in groupBy(list, #).i +foo not in groupBy(list, f32) +foo not in groupBy(list, ok) foo not in list +foo not in list and ok +foo not in list or false +foo not in map(list, #) foo.Bar -foo.Bar != string(i64) -foo.Bar + type(greet) -foo.Bar < toJSON(0.5) -foo.Bar == type(0.5) -foo.Bar not matches string(half) -foo.Bar not startsWith foo.String() +foo.Bar <= foo.Bar +foo.Bar matches foo.Bar +foo.Bar matches trimPrefix("foo") foo.Qux -foo.Qux != add -foo.Qux != half -foo.Qux != score -foo.Qux == div -foo.Qux == foo?.Qux -foo.Qux(foo?.String()) -foo.Qux(greet("bar")) -foo.Qux(toJSON(0.5)) +foo.Qux("foo" + "foo") +foo.Qux(foo.Bar) +foo.Qux(foo.String()) +foo.Qux(greet("foo")) +foo.Qux(string("foo")) foo.Qux(toJSON(i)) -foo.Qux(toJSON(nil)) -foo.Qux(trimSuffix("foo")) foo.Qux(type("bar")) -foo.Qux(type(i)) +foo.Qux(type(f64)) +foo.Qux(type(half)) foo.String -foo.String != div -foo.String == add -foo.String == greet -foo.String == half -foo.String == score foo.String() +foo.String() != foo?.String() +foo.String() in foo +foo.String() not in foo foo?.Bar -foo?.Bar + type(score) +foo?.Bar != foo?.Bar foo?.Bar in foo -foo?.Bar not endsWith "bar" ? score : array +foo?.Bar matches toJSON(f64) +foo?.Bar not endsWith foo.Bar +foo?.Bar not endsWith toJSON(foo) foo?.Qux -foo?.Qux != div -foo?.Qux != greet -foo?.Qux != half -foo?.Qux != score -foo?.Qux == add -foo?.Qux == greet -foo?.Qux == half -foo?.Qux == score foo?.Qux(foo?.Bar) -foo?.Qux(string(0.5)) -foo?.Qux(type(0.5)) +foo?.Qux(string(i32)) +foo?.Qux(toJSON(1)) +foo?.Qux(toJSON(i32)) foo?.Qux(upper("bar")) foo?.String -foo?.String != div -foo?.String != greet -foo?.String != half -foo?.String != nil ? half : list -foo?.String != score -foo?.String == add -foo?.String == half foo?.String() -foo?.String() + type(list) -foo?.String() < string(i32) -foo?.String() < toJSON(nil) -foo?.String() matches toBase64("bar") +foo?.String() contains string("foo") fromBase64(string(ok)) -fromBase64(string(true)) -fromBase64(toBase64("foo")) -fromBase64(toBase64(toJSON(nil))) -fromBase64(toJSON(nil)) -fromBase64(toJSON(ok)) -fromBase64(toJSON(true)) +fromBase64(toBase64("bar")) +fromBase64(type(1 == 0.5)) fromBase64(type(add)) fromBase64(type(div)) fromBase64(type(false)) fromBase64(type(greet)) fromBase64(type(half)) -fromBase64(type(nil == score)) fromBase64(type(ok)) fromBase64(type(score)) fromBase64(type(true)) -fromJSON("foo") not in list && false -fromJSON(string(0.5)) fromJSON(string(1)) fromJSON(string(f32)) fromJSON(string(f64)) -fromJSON(string(false)) fromJSON(string(i)) fromJSON(string(i32)) fromJSON(string(i64)) -fromJSON(string(i64)) ** f64 fromJSON(string(ok)) fromJSON(string(true)) -fromJSON(toJSON("foo")) -fromJSON(toJSON(0.5 ** 0.5)) -fromJSON(toJSON(1)) -fromJSON(toJSON(abs(1))) +fromJSON(toJSON("bar")) +fromJSON(toJSON(0.5)) fromJSON(toJSON(array)) -fromJSON(toJSON(f32)) fromJSON(toJSON(f64)) +fromJSON(toJSON(false)) +fromJSON(toJSON(foo)) fromJSON(toJSON(i)) fromJSON(toJSON(i32)) -fromJSON(toJSON(i64)) fromJSON(toJSON(list)) fromJSON(toJSON(nil)) -fromJSON(toJSON(ok)) fromJSON(toJSON(true)) -get(1 .. i32, i) -get(1 .. i64, abs(1)) -get(1 .. i64, i) -get(1 .. i64, i32) -get(["bar"], i64) -get([array], i) -get([greet], i) -get([nil, half], i) -get([score, 0.5, score], i64) +fromPairs(filter(array, false)) +fromPairs(filter(list, false)) +fromPairs(groupBy(array, #).String) +get(["foo"], i32) get(array, -1) -get(array, -i) get(array, -i32) -get(array, 1 % 1) -get(array, 1 % i64) -get(array, 1 - 1) -get(array, 1 - i) -get(array, 1) * f64 +get(array, -i64) +get(array, -score(1)) +get(array, 1 * 1) +get(array, 1 * i) +get(array, 1) ** f32 get(array, 1) < f32 -get(array, 1) <= i32 -get(array, 1) > i -get(array, 1) ^ f64 -get(array, 1) ^ i -get(array, array[1]) -get(array, count(list, true)) -get(array, false ? div : false) -get(array, first(array)) -get(array, i % i64) -get(array, i * 1) +get(array, 1) > i32 +get(array, 1) > i64 +get(array, bitnot(1)) +get(array, count(array, ok)) +get(array, false ? "foo" : 0.5) get(array, i) -get(array, i) + i -get(array, i) > i32 -get(array, i) ^ f32 -get(array, i32 * i64) +get(array, i) != f32 +get(array, i) != i32 +get(array, i) * i32 +get(array, i) - i +get(array, i) / i64 +get(array, i) > f64 +get(array, i) >= f64 +get(array, i) >= i64 +get(array, i) ^ half(0.5) +get(array, i32 % i32) get(array, i32) -get(array, i32) ** f32 -get(array, i32) == i32 -get(array, i32) > f64 +get(array, i32) / f64 +get(array, i32) < i +get(array, i64 - 1) get(array, i64) -get(array, i64) ** i -get(array, i64) ** i64 -get(array, i64) .. i32 -get(array, i64) <= -i32 -get(array, i64) <= f64 / f32 -get(array, i64) <= i -get(array, i64) == i64 -get(array, int(1)) -get(array, int(f32)) -get(array, int(f64)) -get(array, int(i32)) -get(array, len(array)) -get(array, max(1)) +get(array, i64) > f64 +get(array, last(array)) get(array, min(i)) -get(array, min(i32)) +get(array, reduce(array, #)) +get(array, reduce(list, i64)) get(array, score(1)) -get(array, true ? i : 1) -get(false ? "bar" : f64, list) -get(false ? "bar" : i32, greet) -get(false ? "foo" : i, ok) -get(false ? 1 : greet, ok) -get(false ? greet : score, score) -get(false ? half : list, i32) -get(false ? list : 1, i32) -get(false ? list : i64, i >= f64) -get(false ? score : 0.5, add) -get(false ? score : 0.5, half) -get(false ? score : f64, half) -get(filter(list, ok), i32) -get(filter(list, ok), i64) -get(i .. i, i) -get(i32 .. 1, i) +get(array, score(abs(1))) +get(array, score(i)) +get(array, sum(array)) +get(false ? 0.5 : greet, list) +get(false ? add : array, f64) +get(false ? add : score, ok) +get(false ? f64 : 1, ok) +get(false ? f64 : score, add) +get(false ? false : f32, i) +get(false ? i32 : list, i64) +get(false ? i64 : true, f64) +get(false ? score : ok, trimSuffix("bar", "bar")) +get(filter(list, true), i) +get(groupBy(array, "bar"), add) +get(groupBy(array, "bar"), i) +get(groupBy(array, "bar"), ok) +get(groupBy(array, "foo"), half) +get(groupBy(array, #), add) +get(groupBy(array, #), array) +get(groupBy(array, #), f32) +get(groupBy(array, #), f64) +get(groupBy(array, #), foo) +get(groupBy(array, #), greet) +get(groupBy(array, #), half) +get(groupBy(array, #), i) +get(groupBy(array, #), i64 * 0.5) +get(groupBy(array, #), i64) +get(groupBy(array, #)?.String, i64) +get(groupBy(array, 0.5), add) +get(groupBy(array, 0.5), div) +get(groupBy(array, 0.5), ok) +get(groupBy(array, 1), add) +get(groupBy(array, 1), f32) +get(groupBy(array, f64), i64) +get(groupBy(array, false), findIndex(array, ok)) +get(groupBy(array, i), ok) +get(groupBy(array, i), score) +get(groupBy(array, i64), add) +get(groupBy(array, ok), add) +get(groupBy(array, true), i32) +get(groupBy(list, "bar"), i32) +get(groupBy(list, "foo"), greet) +get(groupBy(list, #), div) +get(groupBy(list, #), f32 <= f64) +get(groupBy(list, #), f32) +get(groupBy(list, #), foo) +get(groupBy(list, #), greet) +get(groupBy(list, #), half) +get(groupBy(list, #), i) +get(groupBy(list, #), i32) +get(groupBy(list, #), i64) +get(groupBy(list, #), int(f32)) +get(groupBy(list, #), list) +get(groupBy(list, #), reduce(array, foo)) +get(groupBy(list, #), score(1)) +get(groupBy(list, #), score) +get(groupBy(list, 0.5), array) +get(groupBy(list, 0.5), div) +get(groupBy(list, 0.5), ok) +get(groupBy(list, 1), i32) +get(groupBy(list, f32), greet) +get(groupBy(list, foo), add) +get(groupBy(list, foo), i32) +get(groupBy(list, ok), greet) +get(groupBy(list, ok), list) +get(i .. 1, 1 * 1) +get(i .. i32, i) +get(i32 .. i, i64) get(i64 .. 1, i32) +get(i64 .. i, i32) +get(i64 .. i64, i64) +get(list, -1) get(list, -i) -get(list, -i32) get(list, -i64) -get(list, 1 * i) +get(list, 1 * 1) +get(list, 1 - 1) +get(list, 1 - i) +get(list, 1) != foo get(list, 1).Bar get(list, 1).Qux get(list, 1).String @@ -6287,11 +7161,12 @@ get(list, 1)?.Bar get(list, 1)?.Qux get(list, 1)?.String get(list, 1)?.String() -get(list, abs(i)) -get(list, abs(i32)) +get(list, bitshr(i, i32)) +get(list, first(array)) +get(list, get(array, 1)) +get(list, get(array, i64)) +get(list, i % 1) get(list, i) -get(list, i) != foo -get(list, i) == foo get(list, i).Bar get(list, i).Qux get(list, i).String @@ -6299,122 +7174,104 @@ get(list, i)?.Bar get(list, i)?.Qux get(list, i)?.String get(list, i)?.String() +get(list, i32 * i32) +get(list, i32 - i32) get(list, i32) get(list, i32).Bar get(list, i32).Qux get(list, i32).String -get(list, i32).String() get(list, i32)?.Bar get(list, i32)?.Qux get(list, i32)?.String get(list, i32)?.String() -get(list, i64 * i32) +get(list, i64 * 1) +get(list, i64 * i) +get(list, i64 - 1) get(list, i64) get(list, i64).Bar get(list, i64).Qux get(list, i64).String -get(list, i64).String() get(list, i64)?.Bar get(list, i64)?.Qux get(list, i64)?.String get(list, i64)?.String() -get(list, int(1) > 0.5 ? div : 0.5) -get(list, int(i)) -get(list, int(i32)) -get(list, int(i64)) -get(list, last(array)) -get(list, max(1, i64, i64)) +get(list, int(1)) +get(list, max(i32)) get(list, min(i32)) get(list, min(i64)) +get(list, ok ? 0.5 : "foo") +get(list, ok ? array : "foo") +get(list, reduce(list, i64)) get(list, score(1)) -get(list[i32:i], i64) +get(list, score(i)) +get(list, true ? i : i32) +get(list, {"foo": i32}?.i) +get(list[i64:1], i) get(map(array, #), i) +get(map(array, #), i32) get(map(array, #), i64) -get(map(array, #), last(array)) -get(map(array, 0.5), i) -get(map(array, 1), i) -get(map(array, i32), i64) -get(map(array, ok), i) -get(map(array, ok), i64) +get(map(array, add), i32) +get(map(array, array), i) +get(map(array, greet), i64) +get(map(array, half), i64) +get(map(list, "foo"), i64) get(map(list, #), i) -get(map(list, #), i32) get(map(list, #), i64) -get(map(list, 0.5), i64) +get(map(list, 1), i32) get(map(list, array), i) -get(map(list, div), i32) get(map(list, i32), i64) -get(map(list, ok), i32) -get(map(list, true), i64) -get(ok ? 0.5 : add, f32) -get(ok ? add : 0.5, ok) -get(ok ? add : false, div) -get(ok ? array : i, add) -get(ok ? i : f64, greet)?.f64 -get(ok ? i32 : "foo", score) -get(ok ? i32 : add, div) -get(ok ? list : "foo", f32) -get(ok ? ok : half, array) -get(ok ? true : i32, f32) +get(map(list, i64), i64) +get(ok ? "bar" : false, array) +get(ok ? 1 : "bar", f32) +get(ok ? add : f32, array) +get(ok ? f64 : div, i64) +get(ok ? false : list, f32 > i) +get(ok ? foo : 0.5, div) +get(ok ? half : i32, i) +get(ok ? half : ok, f64) +get(ok ? i : 0.5, half) +get(ok ? i32 : half, f64) +get(ok ? i64 : foo, f32) +get(ok ? list : "foo", add) +get(ok ? list : i32, f32) +get(ok ? ok : div, greet) +get(ok ? score : f64, i) +get(ok ? score : i64, foo) +get(reduce(list, array), i32) get(sort(array), i32) -get(true ? 0.5 : score, foo) -get(true ? 1 : f64, foo) -get(true ? 1 : greet, greet)?.foo -get(true ? add : score, i) -get(true ? array : 1, half) -get(true ? array : i64, ok) -get(true ? div : foo, list) -get(true ? f32 : 1, greet) -get(true ? i : f64, add) -get(true ? i64 : score, i) -get(true ? list : ok, ok) -get({"bar": i32}.i32, ok) +get(take(list, i), i64) +get(true ? "bar" : ok, score(i)) +get(true ? "foo" : half, list) +get(true ? 0.5 : i32, array) +get(true ? f32 : 0.5, ok) +get(true ? false : foo, i64 > 0.5) +get(true ? greet : i32, score) +get(true ? half : f32, greet) +get(true ? half : list, add) +get(true ? i64 : greet, i32) +get(true ? score : true, half)?.half +get(true ? true : i, f64) +get({"foo": foo, "bar": false}, type(i)) greet -greet != add -greet != div -greet != div != nil -greet != foo.Qux -greet != foo.String -greet != foo?.Qux -greet != foo?.String greet != greet -greet != greet != nil -greet != greet or 0.5 == i -greet != half -greet != half ? 1 : ok -greet != half ? array : 0.5 -greet != half ? false : f64 -greet != half ? greet : greet -greet != nil ? i64 : 0.5 -greet != score -greet == add -greet == add == ok -greet == add ? div == greet : i64 -greet == div -greet == div ? add : i32 -greet == foo.Qux -greet == foo.String -greet == foo?.Qux -greet == foo?.String +greet != greet != ok +greet != nil ? "bar" : add +greet != nil ? 0.5 : false +greet != nil ? list : false greet == greet -greet == half -greet == nil != nil -greet == nil && ok +greet == greet ? 0.5 : "bar" +greet == greet and ok greet == nil == ok -greet == score -greet in [nil] +greet == nil ? i64 : ok +greet in groupBy(array, f64).f32 +greet in groupBy(list, #).score +greet not in sort(array) greet("bar" + "bar") -greet("bar" + "foo") -greet("bar") != foo.String() -greet("bar") != nil != false -greet("bar") in foo -greet("foo" + "bar") greet("foo" + "foo") -greet("foo") >= string(foo) -greet("foo") not contains "bar" ? array : half -greet("foo") startsWith greet("bar") -greet(false ? f32 : "foo") -greet(false ? i : "bar") +greet("foo") startsWith type(f64) +greet(false ? i64 : "bar") greet(foo.Bar) +greet(foo.Qux("foo")) greet(foo.String()) greet(foo?.Bar) greet(foo?.String()) @@ -6422,14 +7279,20 @@ greet(greet("bar")) greet(greet("foo")) greet(lower("bar")) greet(lower("foo")) -greet(ok ? "bar" : div) +greet(ok ? "bar" : 1) +greet(ok ? "bar" : i64) +greet(ok ? "foo" : 0.5) +greet(ok ? "foo" : div) +greet(ok ? "foo" : true) +greet(reduce(array, "bar")) +greet(reduce(array, "foo")) +greet(reduce(list, "foo")) +greet(repeat("bar", 1)) +greet(repeat(foo?.String(), i32)) greet(string("bar")) greet(string("foo")) -greet(string(-i64)) -greet(string(0.5 == 1)) greet(string(0.5)) greet(string(1)) -greet(string([0.5])) greet(string(add)) greet(string(array)) greet(string(div)) @@ -6437,20 +7300,18 @@ greet(string(f32)) greet(string(f64)) greet(string(false)) greet(string(foo)) -greet(string(foo?.Qux)) greet(string(greet)) greet(string(half)) greet(string(i)) greet(string(i32)) greet(string(i64)) greet(string(list)) -greet(string(nil != false)) greet(string(nil)) greet(string(ok)) greet(string(score)) greet(string(true)) greet(toBase64("bar")) -greet(toBase64("foo")) +greet(toBase64(trimPrefix("bar"))) greet(toJSON("bar")) greet(toJSON("foo")) greet(toJSON(0.5)) @@ -6466,27 +7327,26 @@ greet(toJSON(i64)) greet(toJSON(list)) greet(toJSON(nil)) greet(toJSON(ok)) -greet(toJSON(string(array))) greet(toJSON(true)) greet(trim("bar")) greet(trim("foo")) -greet(trim(string(array))) greet(trimPrefix("bar")) greet(trimPrefix("foo")) greet(trimSuffix("bar")) greet(trimSuffix("foo")) -greet(trimSuffix("foo", "foo")) -greet(true ? "foo" : 0.5) +greet(trimSuffix(foo.String())) +greet(trimSuffix(foo?.Bar)) +greet(true ? "bar" : i64) +greet(true ? "bar" : ok) +greet(true ? "foo" : foo) greet(type("bar")) greet(type("foo")) greet(type(0.5)) greet(type(1)) -greet(type(abs(f32))) greet(type(add)) greet(type(array)) greet(type(div)) greet(type(f32)) -greet(type(f64 / i)) greet(type(f64)) greet(type(false)) greet(type(foo)) @@ -6502,46 +7362,1543 @@ greet(type(score)) greet(type(true)) greet(upper("bar")) greet(upper("foo")) +groupBy(1 .. 1, #).f64 +groupBy(1 .. i, #) +groupBy(1 .. i, i32)?.score +groupBy(1 .. i32, #) +groupBy(1 .. i32, ok) +groupBy(1 .. i64, i32) +groupBy([0.5, f64], nil == "foo") +groupBy([1], # <= #) +groupBy([f32 ^ i64], #) +groupBy([f32], f64) +groupBy([f64], # >= f32) +groupBy([half], f32) +groupBy([i32], array[#]) +groupBy([nil], foo) +groupBy([true], #) +groupBy(array, !false) +groupBy(array, !true) +groupBy(array, "bar" in foo).String +groupBy(array, "bar").Bar +groupBy(array, "bar").Qux +groupBy(array, "bar").String +groupBy(array, "bar").add +groupBy(array, "bar").array +groupBy(array, "bar").div +groupBy(array, "bar").f32 +groupBy(array, "bar").f64 +groupBy(array, "bar").foo +groupBy(array, "bar").greet +groupBy(array, "bar").half +groupBy(array, "bar").i +groupBy(array, "bar").i32 +groupBy(array, "bar").i64 +groupBy(array, "bar").list +groupBy(array, "bar").ok +groupBy(array, "bar").score +groupBy(array, "bar")?.Bar +groupBy(array, "bar")?.Qux +groupBy(array, "bar")?.String +groupBy(array, "bar")?.add +groupBy(array, "bar")?.array +groupBy(array, "bar")?.div +groupBy(array, "bar")?.f32 +groupBy(array, "bar")?.f64 +groupBy(array, "bar")?.foo +groupBy(array, "bar")?.greet +groupBy(array, "bar")?.half +groupBy(array, "bar")?.i +groupBy(array, "bar")?.i64 +groupBy(array, "bar")?.list +groupBy(array, "bar")?.ok +groupBy(array, "bar")?.score +groupBy(array, "bar")[f32 > f32] +groupBy(array, "foo").Bar +groupBy(array, "foo").Qux +groupBy(array, "foo").String +groupBy(array, "foo").add +groupBy(array, "foo").array +groupBy(array, "foo").div +groupBy(array, "foo").f32 +groupBy(array, "foo").f64 +groupBy(array, "foo").foo +groupBy(array, "foo").greet +groupBy(array, "foo").half +groupBy(array, "foo").i +groupBy(array, "foo").i32 +groupBy(array, "foo").i64 +groupBy(array, "foo").list +groupBy(array, "foo").ok +groupBy(array, "foo").score +groupBy(array, "foo")?.Bar +groupBy(array, "foo")?.String +groupBy(array, "foo")?.add +groupBy(array, "foo")?.array +groupBy(array, "foo")?.div +groupBy(array, "foo")?.f32 +groupBy(array, "foo")?.f64 +groupBy(array, "foo")?.foo +groupBy(array, "foo")?.greet +groupBy(array, "foo")?.half +groupBy(array, "foo")?.i +groupBy(array, "foo")?.i32 +groupBy(array, "foo")?.i64 +groupBy(array, "foo")?.list +groupBy(array, "foo")?.ok +groupBy(array, "foo")?.score +groupBy(array, # != #) +groupBy(array, # != #).Qux +groupBy(array, # != #)?.array +groupBy(array, # != 0.5) +groupBy(array, # != 1) +groupBy(array, # != f32) +groupBy(array, # != f64) +groupBy(array, # != f64)?.String +groupBy(array, # != i64) +groupBy(array, # != nil) +groupBy(array, # % #) +groupBy(array, # % 1) +groupBy(array, # % i32) +groupBy(array, # * #) +groupBy(array, # * #)?.Qux +groupBy(array, # * 0.5) +groupBy(array, # * 1) +groupBy(array, # * i) +groupBy(array, # * i32) +groupBy(array, # * i64) +groupBy(array, # ** #) +groupBy(array, # ** #).add +groupBy(array, # ** 0.5) +groupBy(array, # ** 0.5)?.foo +groupBy(array, # ** 0.5)?.greet +groupBy(array, # ** 1) +groupBy(array, # ** f64) +groupBy(array, # ** i) +groupBy(array, # ** i32) +groupBy(array, # ** i64) +groupBy(array, # + #) +groupBy(array, # + 1) +groupBy(array, # + f32) +groupBy(array, # + i) +groupBy(array, # - #) +groupBy(array, # - 0.5) +groupBy(array, # - 1) +groupBy(array, # - f32) +groupBy(array, # - f64) +groupBy(array, # - i) +groupBy(array, # - i32) +groupBy(array, # / #) +groupBy(array, # / 0.5) +groupBy(array, # / 0.5)?.foo +groupBy(array, # / 1) +groupBy(array, # / i) +groupBy(array, # / i32) +groupBy(array, # / i64) +groupBy(array, # < # || 0.5 > f64) +groupBy(array, # < #) +groupBy(array, # < 0.5) +groupBy(array, # < 1) +groupBy(array, # < i32) +groupBy(array, # < i64) +groupBy(array, # <= #) +groupBy(array, # <= #)?.Bar +groupBy(array, # <= #)?.Qux +groupBy(array, # <= 0.5) +groupBy(array, # <= 1) +groupBy(array, # <= f32) +groupBy(array, # <= f64) +groupBy(array, # <= i) +groupBy(array, # <= i64) +groupBy(array, # == #) +groupBy(array, # == #).String +groupBy(array, # == #)?.half +groupBy(array, # == 0.5) +groupBy(array, # == 1) +groupBy(array, # == f32) +groupBy(array, # == f32).half +groupBy(array, # == f64) +groupBy(array, # == i) +groupBy(array, # == i64) +groupBy(array, # == nil) +groupBy(array, # > #) +groupBy(array, # > 0.5) +groupBy(array, # > 1) +groupBy(array, # > 1).Bar +groupBy(array, # > i)?.i64 +groupBy(array, # > i64) +groupBy(array, # >= #) +groupBy(array, # >= f64) +groupBy(array, # >= i) +groupBy(array, # >= i32) +groupBy(array, # >= i64) +groupBy(array, # ^ #) +groupBy(array, # ^ 0.5) +groupBy(array, # ^ f32) +groupBy(array, # ^ i) +groupBy(array, # ^ i32) +groupBy(array, # in array) +groupBy(array, #) +groupBy(array, #).Bar +groupBy(array, #).Qux +groupBy(array, #).String +groupBy(array, #).add +groupBy(array, #).array +groupBy(array, #).div +groupBy(array, #).f32 +groupBy(array, #).f64 +groupBy(array, #).foo +groupBy(array, #).greet +groupBy(array, #).half +groupBy(array, #).i +groupBy(array, #).i32 +groupBy(array, #).i64 +groupBy(array, #).list +groupBy(array, #).ok +groupBy(array, #).score +groupBy(array, #)?.Bar +groupBy(array, #)?.Qux +groupBy(array, #)?.String +groupBy(array, #)?.add +groupBy(array, #)?.array +groupBy(array, #)?.div +groupBy(array, #)?.f32 +groupBy(array, #)?.f64 +groupBy(array, #)?.foo +groupBy(array, #)?.greet +groupBy(array, #)?.half +groupBy(array, #)?.i +groupBy(array, #)?.i32 +groupBy(array, #)?.i64 +groupBy(array, #)?.list +groupBy(array, #)?.ok +groupBy(array, #)?.score +groupBy(array, #)[1 / i] +groupBy(array, #)[f32] +groupBy(array, #)[f64] +groupBy(array, #)[foo] +groupBy(array, #)[i32] +groupBy(array, #)[i64] +groupBy(array, #)[i] +groupBy(array, #)[ok] +groupBy(array, #)[reduce(list, #)] +groupBy(array, -# * # * 0.5) +groupBy(array, -#) +groupBy(array, -#).Qux +groupBy(array, -0.5) +groupBy(array, -1) +groupBy(array, -f32) +groupBy(array, -i)?.score +groupBy(array, -i32) +groupBy(array, -i64) +groupBy(array, 0.5 != #) +groupBy(array, 0.5 * #) +groupBy(array, 0.5 * 0.5) +groupBy(array, 0.5 * f64) +groupBy(array, 0.5 ** #) +groupBy(array, 0.5 ** 1) +groupBy(array, 0.5 ** i64) +groupBy(array, 0.5 + #)?.score +groupBy(array, 0.5 + f32) +groupBy(array, 0.5 - 1) +groupBy(array, 0.5 / #).array +groupBy(array, 0.5 / f64) +groupBy(array, 0.5 / i64) +groupBy(array, 0.5 < 0.5) +groupBy(array, 0.5 <= f32) +groupBy(array, 0.5 == #) +groupBy(array, 0.5 >= #) +groupBy(array, 0.5 >= i32) +groupBy(array, 0.5 >= i64) +groupBy(array, 0.5 ^ f32) +groupBy(array, 0.5 ^ i64) +groupBy(array, 0.5).Bar +groupBy(array, 0.5).Qux +groupBy(array, 0.5).String +groupBy(array, 0.5).add +groupBy(array, 0.5).array +groupBy(array, 0.5).div +groupBy(array, 0.5).f32 +groupBy(array, 0.5).f64 +groupBy(array, 0.5).foo +groupBy(array, 0.5).greet +groupBy(array, 0.5).half +groupBy(array, 0.5).i +groupBy(array, 0.5).i32 +groupBy(array, 0.5).i64 +groupBy(array, 0.5).list +groupBy(array, 0.5).ok +groupBy(array, 0.5).score +groupBy(array, 0.5)?.Bar +groupBy(array, 0.5)?.Qux +groupBy(array, 0.5)?.String +groupBy(array, 0.5)?.add +groupBy(array, 0.5)?.array +groupBy(array, 0.5)?.div +groupBy(array, 0.5)?.f32 +groupBy(array, 0.5)?.f64 +groupBy(array, 0.5)?.foo +groupBy(array, 0.5)?.greet +groupBy(array, 0.5)?.half +groupBy(array, 0.5)?.i +groupBy(array, 0.5)?.i32 +groupBy(array, 0.5)?.i64 +groupBy(array, 0.5)?.list +groupBy(array, 0.5)?.ok +groupBy(array, 0.5)?.score +groupBy(array, 1 != #)?.String +groupBy(array, 1 != 0.5) +groupBy(array, 1 != f32) +groupBy(array, 1 % #) +groupBy(array, 1 % i) +groupBy(array, 1 * 0.5) +groupBy(array, 1 * i) +groupBy(array, 1 + #) +groupBy(array, 1 + 1) +groupBy(array, 1 - #) +groupBy(array, 1 - 1) +groupBy(array, 1 / #) +groupBy(array, 1 < #) +groupBy(array, 1 < i32)?.array +groupBy(array, 1 < i64)?.ok +groupBy(array, 1 <= #) +groupBy(array, 1 == #) +groupBy(array, 1 == #).add +groupBy(array, 1 == i32) +groupBy(array, 1 == nil) +groupBy(array, 1 > i) +groupBy(array, 1 >= #) +groupBy(array, 1 ^ #) +groupBy(array, 1 not in array) +groupBy(array, 1).Bar +groupBy(array, 1).Qux +groupBy(array, 1).String +groupBy(array, 1).add +groupBy(array, 1).array +groupBy(array, 1).div +groupBy(array, 1).f64 +groupBy(array, 1).foo +groupBy(array, 1).greet +groupBy(array, 1).half +groupBy(array, 1).i +groupBy(array, 1).i32 +groupBy(array, 1).i64 +groupBy(array, 1).list +groupBy(array, 1).ok +groupBy(array, 1).score +groupBy(array, 1)?.Bar +groupBy(array, 1)?.Qux +groupBy(array, 1)?.String +groupBy(array, 1)?.add +groupBy(array, 1)?.array +groupBy(array, 1)?.div +groupBy(array, 1)?.f32 +groupBy(array, 1)?.f64 +groupBy(array, 1)?.foo +groupBy(array, 1)?.greet +groupBy(array, 1)?.half +groupBy(array, 1)?.i +groupBy(array, 1)?.i32 +groupBy(array, 1)?.i64 +groupBy(array, 1)?.list +groupBy(array, 1)?.ok +groupBy(array, 1)?.score +groupBy(array, abs(#)) +groupBy(array, abs(0.5)) +groupBy(array, abs(1)) +groupBy(array, abs(f32)) +groupBy(array, abs(f64)) +groupBy(array, abs(i)) +groupBy(array, abs(i64)) +groupBy(array, add(#, #)) +groupBy(array, add(#, 1))?.i64 +groupBy(array, bitnand(1, #)) +groupBy(array, bitnot(#)) +groupBy(array, bitnot(1)) +groupBy(array, bitor(#, #)) +groupBy(array, bitor(1, #)) +groupBy(array, bitor(i32, #)) +groupBy(array, bitshl(1, #)) +groupBy(array, bitshr(i, #)) +groupBy(array, bitushr(#, #)) +groupBy(array, ceil(#)) +groupBy(array, ceil(i)) +groupBy(array, ceil(i32)) +groupBy(array, div(#, #)) +groupBy(array, f32 != #) +groupBy(array, f32 ** 0.5) +groupBy(array, f32 - #) +groupBy(array, f32 - f64) +groupBy(array, f32 / #) +groupBy(array, f32 < #) +groupBy(array, f32 <= #) +groupBy(array, f32 == #) +groupBy(array, f32 > 0.5) +groupBy(array, f32 > i32) +groupBy(array, f32 ^ i) +groupBy(array, f32) +groupBy(array, f32).Bar +groupBy(array, f32).Qux +groupBy(array, f32).String +groupBy(array, f32).add +groupBy(array, f32).array +groupBy(array, f32).div +groupBy(array, f32).f64 +groupBy(array, f32).greet +groupBy(array, f32).half +groupBy(array, f32).i +groupBy(array, f32).i32 +groupBy(array, f32).i64 +groupBy(array, f32).list +groupBy(array, f32).ok +groupBy(array, f32).score +groupBy(array, f32)?.Bar +groupBy(array, f32)?.Qux +groupBy(array, f32)?.String +groupBy(array, f32)?.add +groupBy(array, f32)?.array +groupBy(array, f32)?.div +groupBy(array, f32)?.f32 +groupBy(array, f32)?.f64 +groupBy(array, f32)?.greet +groupBy(array, f32)?.half +groupBy(array, f32)?.i32 +groupBy(array, f32)?.i64 +groupBy(array, f32)?.list +groupBy(array, f32)?.ok +groupBy(array, f32)?.score +groupBy(array, f32)[foo] +groupBy(array, f64 != #) +groupBy(array, f64 != i64) +groupBy(array, f64 ** #) +groupBy(array, f64 - #) +groupBy(array, f64 - #).i32 +groupBy(array, f64 < #) +groupBy(array, f64 == #) +groupBy(array, f64 > #) +groupBy(array, f64 >= #) +groupBy(array, f64 >= 0.5) +groupBy(array, f64) +groupBy(array, f64).Bar +groupBy(array, f64).Qux +groupBy(array, f64).String +groupBy(array, f64).add +groupBy(array, f64).array +groupBy(array, f64).div +groupBy(array, f64).f32 +groupBy(array, f64).f64 +groupBy(array, f64).foo +groupBy(array, f64).greet +groupBy(array, f64).half +groupBy(array, f64).i +groupBy(array, f64).i32 +groupBy(array, f64).i64 +groupBy(array, f64).list +groupBy(array, f64).ok +groupBy(array, f64).score +groupBy(array, f64)?.Bar +groupBy(array, f64)?.Qux +groupBy(array, f64)?.String +groupBy(array, f64)?.add +groupBy(array, f64)?.array +groupBy(array, f64)?.div +groupBy(array, f64)?.f32 +groupBy(array, f64)?.f64 +groupBy(array, f64)?.foo +groupBy(array, f64)?.greet +groupBy(array, f64)?.half +groupBy(array, f64)?.i +groupBy(array, f64)?.i32 +groupBy(array, f64)?.i64 +groupBy(array, f64)?.list +groupBy(array, f64)?.ok +groupBy(array, f64)?.score +groupBy(array, f64)[i32] +groupBy(array, false ? # : #) +groupBy(array, false || ok) +groupBy(array, false).Bar +groupBy(array, false).Qux +groupBy(array, false).String +groupBy(array, false).add +groupBy(array, false).array +groupBy(array, false).div +groupBy(array, false).f32 +groupBy(array, false).f64 +groupBy(array, false).greet +groupBy(array, false).half +groupBy(array, false).i +groupBy(array, false).i32 +groupBy(array, false).i64 +groupBy(array, false).list +groupBy(array, false).ok +groupBy(array, false).score +groupBy(array, false)?.Bar +groupBy(array, false)?.Qux +groupBy(array, false)?.String +groupBy(array, false)?.add +groupBy(array, false)?.array +groupBy(array, false)?.div +groupBy(array, false)?.f32 +groupBy(array, false)?.f64 +groupBy(array, false)?.foo +groupBy(array, false)?.greet +groupBy(array, false)?.half +groupBy(array, false)?.i +groupBy(array, false)?.i32 +groupBy(array, false)?.i64 +groupBy(array, false)?.list +groupBy(array, false)?.ok +groupBy(array, false)?.score +groupBy(array, findLastIndex(list, true)) +groupBy(array, float(#)) +groupBy(array, floor(#)) +groupBy(array, floor(i32)) +groupBy(array, foo) +groupBy(array, foo).Bar +groupBy(array, foo).Qux +groupBy(array, foo).String +groupBy(array, foo).add +groupBy(array, foo).array +groupBy(array, foo).div +groupBy(array, foo).f32 +groupBy(array, foo).f64 +groupBy(array, foo).foo +groupBy(array, foo).greet +groupBy(array, foo).half +groupBy(array, foo).i +groupBy(array, foo).i32 +groupBy(array, foo).i64 +groupBy(array, foo).list +groupBy(array, foo).ok +groupBy(array, foo).score +groupBy(array, foo)?.Bar +groupBy(array, foo)?.Qux +groupBy(array, foo)?.String +groupBy(array, foo)?.add +groupBy(array, foo)?.array +groupBy(array, foo)?.div +groupBy(array, foo)?.f32 +groupBy(array, foo)?.f64 +groupBy(array, foo)?.foo +groupBy(array, foo)?.greet +groupBy(array, foo)?.half +groupBy(array, foo)?.i +groupBy(array, foo)?.i32 +groupBy(array, foo)?.i64 +groupBy(array, foo)?.list +groupBy(array, foo)?.ok +groupBy(array, foo)?.score +groupBy(array, foo.Bar) +groupBy(array, foo?.Bar) +groupBy(array, get(array, #)) +groupBy(array, get(list, #)) +groupBy(array, get(list, i32)) +groupBy(array, half(1)) +groupBy(array, half(f64)) +groupBy(array, half(f64))?.i64 +groupBy(array, i != #) +groupBy(array, i % #) +groupBy(array, i * #) +groupBy(array, i * #)?.f64 +groupBy(array, i ** #) +groupBy(array, i + #) +groupBy(array, i - f64).array +groupBy(array, i / #) +groupBy(array, i < #) +groupBy(array, i <= #) +groupBy(array, i <= f64) +groupBy(array, i > i) +groupBy(array, i ^ #) +groupBy(array, i ^ 0.5) +groupBy(array, i) +groupBy(array, i).Bar +groupBy(array, i).Qux +groupBy(array, i).String +groupBy(array, i).add +groupBy(array, i).array +groupBy(array, i).div +groupBy(array, i).f32 +groupBy(array, i).f64 +groupBy(array, i).foo +groupBy(array, i).greet +groupBy(array, i).half +groupBy(array, i).i +groupBy(array, i).i32 +groupBy(array, i).i64 +groupBy(array, i).list +groupBy(array, i).ok +groupBy(array, i).score +groupBy(array, i)?.Bar +groupBy(array, i)?.String +groupBy(array, i)?.add +groupBy(array, i)?.array +groupBy(array, i)?.div +groupBy(array, i)?.f32 +groupBy(array, i)?.f64 +groupBy(array, i)?.foo +groupBy(array, i)?.greet +groupBy(array, i)?.half +groupBy(array, i)?.i +groupBy(array, i)?.i32 +groupBy(array, i)?.i64 +groupBy(array, i)?.list +groupBy(array, i)?.ok +groupBy(array, i)?.score +groupBy(array, i)[f64] +groupBy(array, i)[false ? i32 : ok] +groupBy(array, i32 * f64) +groupBy(array, i32 ** # <= i32) +groupBy(array, i32 ** f64) +groupBy(array, i32 ** i) +groupBy(array, i32 ** i64) +groupBy(array, i32 + #) +groupBy(array, i32 - 1)?.foo +groupBy(array, i32 - i64) +groupBy(array, i32 / #) +groupBy(array, i32 / f32) +groupBy(array, i32 < #) +groupBy(array, i32 < f64) +groupBy(array, i32 <= 1) +groupBy(array, i32 == #) +groupBy(array, i32 == i) +groupBy(array, i32 > #) +groupBy(array, i32 >= #).Bar +groupBy(array, i32 ^ #) +groupBy(array, i32) +groupBy(array, i32).Bar +groupBy(array, i32).Qux +groupBy(array, i32).String +groupBy(array, i32).add +groupBy(array, i32).array +groupBy(array, i32).div +groupBy(array, i32).f32 +groupBy(array, i32).f64 +groupBy(array, i32).greet +groupBy(array, i32).half +groupBy(array, i32).i +groupBy(array, i32).i32 +groupBy(array, i32).i64 +groupBy(array, i32).list +groupBy(array, i32).ok +groupBy(array, i32).score +groupBy(array, i32)?.Bar +groupBy(array, i32)?.Qux +groupBy(array, i32)?.String +groupBy(array, i32)?.add +groupBy(array, i32)?.array +groupBy(array, i32)?.div +groupBy(array, i32)?.f32 +groupBy(array, i32)?.f64 +groupBy(array, i32)?.foo +groupBy(array, i32)?.greet +groupBy(array, i32)?.half +groupBy(array, i32)?.i +groupBy(array, i32)?.i32 +groupBy(array, i32)?.i64 +groupBy(array, i32)?.list +groupBy(array, i32)?.ok +groupBy(array, i32)?.score +groupBy(array, i32)[i] +groupBy(array, i64 != i) +groupBy(array, i64 % #) +groupBy(array, i64 * f32) +groupBy(array, i64 ** #) +groupBy(array, i64 ** i) +groupBy(array, i64 + #) +groupBy(array, i64 - #) +groupBy(array, i64 / #)?.Qux +groupBy(array, i64 / 0.5) +groupBy(array, i64 < #) +groupBy(array, i64 <= #).foo +groupBy(array, i64 >= #) +groupBy(array, i64 ^ #) +groupBy(array, i64) +groupBy(array, i64).Bar +groupBy(array, i64).Qux +groupBy(array, i64).String +groupBy(array, i64).add +groupBy(array, i64).array +groupBy(array, i64).div +groupBy(array, i64).f32 +groupBy(array, i64).f64 +groupBy(array, i64).foo +groupBy(array, i64).greet +groupBy(array, i64).half +groupBy(array, i64).i +groupBy(array, i64).i32 +groupBy(array, i64).i64 +groupBy(array, i64).list +groupBy(array, i64).ok +groupBy(array, i64).score +groupBy(array, i64)?.Bar +groupBy(array, i64)?.Qux +groupBy(array, i64)?.String +groupBy(array, i64)?.add +groupBy(array, i64)?.array +groupBy(array, i64)?.div +groupBy(array, i64)?.f32 +groupBy(array, i64)?.f64 +groupBy(array, i64)?.foo +groupBy(array, i64)?.greet +groupBy(array, i64)?.half +groupBy(array, i64)?.i +groupBy(array, i64)?.i32 +groupBy(array, i64)?.i64 +groupBy(array, i64)?.list +groupBy(array, i64)?.ok +groupBy(array, i64)?.score +groupBy(array, int(f64)).i32 +groupBy(array, max(#)) +groupBy(array, max(#, #, #)).ok +groupBy(array, max(0.5, #)) +groupBy(array, max(1)) +groupBy(array, max(f64)) +groupBy(array, min(#)) +groupBy(array, min(0.5)) +groupBy(array, min(f32)) +groupBy(array, min(i, #, i32)) +groupBy(array, nil != #) +groupBy(array, nil != f64) +groupBy(array, nil != foo) +groupBy(array, nil != half) +groupBy(array, nil == #) +groupBy(array, nil == 0.5) +groupBy(array, none(array, false)) +groupBy(array, none(array, ok)) +groupBy(array, not ok)?.Bar +groupBy(array, not true) +groupBy(array, ok == ok) +groupBy(array, ok ? # : #) +groupBy(array, ok) +groupBy(array, ok).Bar +groupBy(array, ok).Qux +groupBy(array, ok).String +groupBy(array, ok).add +groupBy(array, ok).array +groupBy(array, ok).div +groupBy(array, ok).f32 +groupBy(array, ok).f64 +groupBy(array, ok).foo +groupBy(array, ok).greet +groupBy(array, ok).half +groupBy(array, ok).i +groupBy(array, ok).i32 +groupBy(array, ok).i64 +groupBy(array, ok).list +groupBy(array, ok).ok +groupBy(array, ok).score +groupBy(array, ok)?.Bar +groupBy(array, ok)?.Qux +groupBy(array, ok)?.String +groupBy(array, ok)?.array +groupBy(array, ok)?.div +groupBy(array, ok)?.f32 +groupBy(array, ok)?.f64 +groupBy(array, ok)?.foo +groupBy(array, ok)?.greet +groupBy(array, ok)?.half +groupBy(array, ok)?.i32 +groupBy(array, ok)?.i64 +groupBy(array, ok)?.list +groupBy(array, ok)?.ok +groupBy(array, ok)?.score +groupBy(array, one(array, ok)) +groupBy(array, reduce(array, #)) +groupBy(array, reduce(array, foo)) +groupBy(array, reduce(list, #)) +groupBy(array, round(#)) +groupBy(array, score(#)) +groupBy(array, score(#, #)) +groupBy(array, score(#, #, #, 1)) +groupBy(array, score(#, 1)).list +groupBy(array, score(1)) +groupBy(array, score(i)) +groupBy(array, string(#)) +groupBy(array, string(div)) +groupBy(array, string(i32)) +groupBy(array, toJSON("bar")) +groupBy(array, toJSON(#)) +groupBy(array, toJSON(1 .. i)) +groupBy(array, toJSON(foo)) +groupBy(array, trimPrefix("foo")) +groupBy(array, true == nil) +groupBy(array, true ? # : #) +groupBy(array, true ? # : 1) +groupBy(array, true ? nil : "foo") +groupBy(array, true).Bar +groupBy(array, true).Qux +groupBy(array, true).add +groupBy(array, true).div +groupBy(array, true).f64 +groupBy(array, true).foo +groupBy(array, true).greet +groupBy(array, true).half +groupBy(array, true).i +groupBy(array, true).i32 +groupBy(array, true).i64 +groupBy(array, true).list +groupBy(array, true).ok +groupBy(array, true).score +groupBy(array, true)?.Bar +groupBy(array, true)?.Qux +groupBy(array, true)?.String +groupBy(array, true)?.add +groupBy(array, true)?.array +groupBy(array, true)?.div +groupBy(array, true)?.f32 +groupBy(array, true)?.f64 +groupBy(array, true)?.half +groupBy(array, true)?.i +groupBy(array, true)?.i32 +groupBy(array, true)?.i64 +groupBy(array, true)?.list +groupBy(array, true)?.ok +groupBy(array, true)?.score +groupBy(array, true)[i32] +groupBy(array, type(# <= #)) +groupBy(array, type(#)).i64 +groupBy(array, type(-f64)) +groupBy(array, type(f32)) +groupBy(false ? 0.5 : "bar", #) +groupBy(filter(array, false), #) +groupBy(filter(array, false), add) +groupBy(filter(array, false), f32) +groupBy(filter(array, false), nil == #) +groupBy(filter(array, ok), half(1)) +groupBy(filter(array, true), #) +groupBy(filter(array, true), f64) +groupBy(filter(list, ok), #) +groupBy(groupBy(array, "foo").list, #) +groupBy(groupBy(array, #).i32, add) +groupBy(groupBy(array, ok).Bar, #?.array not matches #) +groupBy(groupBy(array, true).f64, #[#]) +groupBy(i .. 1, !ok)?.f64 +groupBy(i .. 1, # % #) +groupBy(i .. i, i64) +groupBy(i .. i32, #) +groupBy(i .. i32, f64 * #) +groupBy(i .. i64, f64)?.score +groupBy(i .. i64, foo) +groupBy(i .. len(array), #) +groupBy(i32 .. 1, # - #) +groupBy(i32 .. 1, #)?.f32 +groupBy(i32 .. i, #) +groupBy(i32 .. i32, i) +groupBy(i32 .. i32, i32) +groupBy(i32 .. i32, i64) +groupBy(i32 .. i32, list[i]) +groupBy(i32 .. i32, ok) +groupBy(i32 .. i64, #) +groupBy(i32 .. i64, get(array, #)) +groupBy(i64 .. 1, -0.5) +groupBy(i64 .. 1, i) +groupBy(i64 .. i, -#) +groupBy(i64 .. i, i32) +groupBy(i64 .. i32, i) +groupBy(i64 .. i64, i32) +groupBy(list, !("foo" in #)) +groupBy(list, !false) +groupBy(list, !ok) +groupBy(list, !true) +groupBy(list, "bar" contains "foo")?.ok +groupBy(list, "bar" endsWith "bar") +groupBy(list, "bar" not in #) +groupBy(list, "bar").Bar +groupBy(list, "bar").Qux +groupBy(list, "bar").String +groupBy(list, "bar").add +groupBy(list, "bar").array +groupBy(list, "bar").div +groupBy(list, "bar").f32 +groupBy(list, "bar").f64 +groupBy(list, "bar").foo +groupBy(list, "bar").greet +groupBy(list, "bar").i +groupBy(list, "bar").i32 +groupBy(list, "bar").i64 +groupBy(list, "bar").list +groupBy(list, "bar").ok +groupBy(list, "bar").score +groupBy(list, "bar")?.Bar +groupBy(list, "bar")?.Qux +groupBy(list, "bar")?.String +groupBy(list, "bar")?.add +groupBy(list, "bar")?.array +groupBy(list, "bar")?.div +groupBy(list, "bar")?.f32 +groupBy(list, "bar")?.f64 +groupBy(list, "bar")?.foo +groupBy(list, "bar")?.greet +groupBy(list, "bar")?.half +groupBy(list, "bar")?.i +groupBy(list, "bar")?.i32 +groupBy(list, "bar")?.i64 +groupBy(list, "bar")?.list +groupBy(list, "bar")?.ok +groupBy(list, "bar")?.score +groupBy(list, "foo" not in #)?.foo +groupBy(list, "foo").Bar +groupBy(list, "foo").Qux +groupBy(list, "foo").String +groupBy(list, "foo").add +groupBy(list, "foo").array +groupBy(list, "foo").div +groupBy(list, "foo").f32 +groupBy(list, "foo").f64 +groupBy(list, "foo").foo +groupBy(list, "foo").greet +groupBy(list, "foo").half +groupBy(list, "foo").i +groupBy(list, "foo").i32 +groupBy(list, "foo").i64 +groupBy(list, "foo").list +groupBy(list, "foo").ok +groupBy(list, "foo").score +groupBy(list, "foo")?.Bar +groupBy(list, "foo")?.Qux +groupBy(list, "foo")?.String +groupBy(list, "foo")?.add +groupBy(list, "foo")?.array +groupBy(list, "foo")?.div +groupBy(list, "foo")?.f32 +groupBy(list, "foo")?.f64 +groupBy(list, "foo")?.foo +groupBy(list, "foo")?.greet +groupBy(list, "foo")?.half +groupBy(list, "foo")?.i +groupBy(list, "foo")?.i32 +groupBy(list, "foo")?.i64 +groupBy(list, "foo")?.list +groupBy(list, "foo")?.ok +groupBy(list, "foo")?.score +groupBy(list, # != #) +groupBy(list, # != foo) +groupBy(list, # != foo)?.i +groupBy(list, # != nil) +groupBy(list, # == #) +groupBy(list, # == #).div +groupBy(list, # in list) +groupBy(list, # not in list) +groupBy(list, #) +groupBy(list, #).Bar +groupBy(list, #).Qux +groupBy(list, #).String +groupBy(list, #).add +groupBy(list, #).array +groupBy(list, #).div +groupBy(list, #).f32 +groupBy(list, #).f64 +groupBy(list, #).foo +groupBy(list, #).greet +groupBy(list, #).half +groupBy(list, #).i +groupBy(list, #).i32 +groupBy(list, #).i64 +groupBy(list, #).list +groupBy(list, #).ok +groupBy(list, #).score +groupBy(list, #)?.Bar +groupBy(list, #)?.Qux +groupBy(list, #)?.String +groupBy(list, #)?.add +groupBy(list, #)?.array +groupBy(list, #)?.div +groupBy(list, #)?.f32 +groupBy(list, #)?.f64 +groupBy(list, #)?.foo +groupBy(list, #)?.greet +groupBy(list, #)?.half +groupBy(list, #)?.i +groupBy(list, #)?.i32 +groupBy(list, #)?.i64 +groupBy(list, #)?.list +groupBy(list, #)?.ok +groupBy(list, #)?.score +groupBy(list, #)[-i64] +groupBy(list, #)[1 == i32] +groupBy(list, #)[f32] +groupBy(list, #)[foo] +groupBy(list, #)[i == i64] +groupBy(list, #)[i32] +groupBy(list, #)[i64] +groupBy(list, #)[ok] +groupBy(list, #?.Bar) +groupBy(list, #?.String()) +groupBy(list, #?.String())?.score +groupBy(list, -0.5) +groupBy(list, -1) +groupBy(list, -f32) +groupBy(list, -i) +groupBy(list, .Bar) +groupBy(list, .Bar).f32 +groupBy(list, .String()) +groupBy(list, .String())?.score +groupBy(list, 0.5 != f32) +groupBy(list, 0.5 != f64) +groupBy(list, 0.5 * f32) +groupBy(list, 0.5 ** i64) +groupBy(list, 0.5 / i) +groupBy(list, 0.5).Bar +groupBy(list, 0.5).Qux +groupBy(list, 0.5).String +groupBy(list, 0.5).add +groupBy(list, 0.5).array +groupBy(list, 0.5).div +groupBy(list, 0.5).f32 +groupBy(list, 0.5).f64 +groupBy(list, 0.5).greet +groupBy(list, 0.5).half +groupBy(list, 0.5).i +groupBy(list, 0.5).i32 +groupBy(list, 0.5).i64 +groupBy(list, 0.5).list +groupBy(list, 0.5).ok +groupBy(list, 0.5).score +groupBy(list, 0.5)?.Bar +groupBy(list, 0.5)?.Qux +groupBy(list, 0.5)?.String +groupBy(list, 0.5)?.add +groupBy(list, 0.5)?.array +groupBy(list, 0.5)?.div +groupBy(list, 0.5)?.f32 +groupBy(list, 0.5)?.f64 +groupBy(list, 0.5)?.foo +groupBy(list, 0.5)?.greet +groupBy(list, 0.5)?.half +groupBy(list, 0.5)?.i +groupBy(list, 0.5)?.i32 +groupBy(list, 0.5)?.i64 +groupBy(list, 0.5)?.list +groupBy(list, 0.5)?.ok +groupBy(list, 0.5)?.score +groupBy(list, 1 * f64).f32 +groupBy(list, 1 + i) +groupBy(list, 1 - 0.5) +groupBy(list, 1 ^ 0.5) +groupBy(list, 1 ^ 1) +groupBy(list, 1 ^ i) +groupBy(list, 1).Bar +groupBy(list, 1).Qux +groupBy(list, 1).String +groupBy(list, 1).add +groupBy(list, 1).array +groupBy(list, 1).div +groupBy(list, 1).f32 +groupBy(list, 1).f64 +groupBy(list, 1).foo +groupBy(list, 1).greet +groupBy(list, 1).half +groupBy(list, 1).i +groupBy(list, 1).i32 +groupBy(list, 1).i64 +groupBy(list, 1).list +groupBy(list, 1).ok +groupBy(list, 1).score +groupBy(list, 1)?.Bar +groupBy(list, 1)?.Qux +groupBy(list, 1)?.String +groupBy(list, 1)?.add +groupBy(list, 1)?.array +groupBy(list, 1)?.div +groupBy(list, 1)?.f32 +groupBy(list, 1)?.f64 +groupBy(list, 1)?.foo +groupBy(list, 1)?.greet +groupBy(list, 1)?.half +groupBy(list, 1)?.i +groupBy(list, 1)?.i32 +groupBy(list, 1)?.i64 +groupBy(list, 1)?.list +groupBy(list, 1)?.ok +groupBy(list, 1)?.score +groupBy(list, 1)[i] +groupBy(list, 1)[reduce(list, "foo")] +groupBy(list, abs(1)) +groupBy(list, abs(i)) +groupBy(list, abs(i64)) +groupBy(list, all(list, ok)) +groupBy(list, ceil(0.5)) +groupBy(list, ceil(f64)) +groupBy(list, f32 ** 0.5) +groupBy(list, f32 ** 1) +groupBy(list, f32 < f32) +groupBy(list, f32 == i64) +groupBy(list, f32 >= 1) +groupBy(list, f32) +groupBy(list, f32).Bar +groupBy(list, f32).Qux +groupBy(list, f32).String +groupBy(list, f32).add +groupBy(list, f32).array +groupBy(list, f32).div +groupBy(list, f32).f32 +groupBy(list, f32).f64 +groupBy(list, f32).foo +groupBy(list, f32).half +groupBy(list, f32).i +groupBy(list, f32).i32 +groupBy(list, f32).i64 +groupBy(list, f32).list +groupBy(list, f32).ok +groupBy(list, f32)?.Bar +groupBy(list, f32)?.Qux +groupBy(list, f32)?.String +groupBy(list, f32)?.add +groupBy(list, f32)?.array +groupBy(list, f32)?.div +groupBy(list, f32)?.f32 +groupBy(list, f32)?.f64 +groupBy(list, f32)?.foo +groupBy(list, f32)?.greet +groupBy(list, f32)?.half +groupBy(list, f32)?.i +groupBy(list, f32)?.i32 +groupBy(list, f32)?.i64 +groupBy(list, f32)?.list +groupBy(list, f32)?.ok +groupBy(list, f32)?.score +groupBy(list, f32)[add == nil] +groupBy(list, f32)[toJSON(true)] +groupBy(list, f64 * 0.5) +groupBy(list, f64 * 1) +groupBy(list, f64 - 1) +groupBy(list, f64 < f64) +groupBy(list, f64) +groupBy(list, f64).Bar +groupBy(list, f64).Qux +groupBy(list, f64).String +groupBy(list, f64).add +groupBy(list, f64).array +groupBy(list, f64).div +groupBy(list, f64).f32 +groupBy(list, f64).f64 +groupBy(list, f64).foo +groupBy(list, f64).greet +groupBy(list, f64).half +groupBy(list, f64).i +groupBy(list, f64).i32 +groupBy(list, f64).i64 +groupBy(list, f64).list +groupBy(list, f64).ok +groupBy(list, f64).score +groupBy(list, f64)?.Bar +groupBy(list, f64)?.Qux +groupBy(list, f64)?.String +groupBy(list, f64)?.add +groupBy(list, f64)?.array +groupBy(list, f64)?.div +groupBy(list, f64)?.f32 +groupBy(list, f64)?.f64 +groupBy(list, f64)?.foo +groupBy(list, f64)?.greet +groupBy(list, f64)?.half +groupBy(list, f64)?.i +groupBy(list, f64)?.i32 +groupBy(list, f64)?.i64 +groupBy(list, f64)?.list +groupBy(list, f64)?.ok +groupBy(list, f64)?.score +groupBy(list, false == ok) +groupBy(list, false ? score : #) +groupBy(list, false).Bar +groupBy(list, false).add +groupBy(list, false).array +groupBy(list, false).div +groupBy(list, false).f32 +groupBy(list, false).foo +groupBy(list, false).greet +groupBy(list, false).half +groupBy(list, false).i +groupBy(list, false).i32 +groupBy(list, false).i64 +groupBy(list, false).list +groupBy(list, false).ok +groupBy(list, false)?.Bar +groupBy(list, false)?.Qux +groupBy(list, false)?.String +groupBy(list, false)?.add +groupBy(list, false)?.div +groupBy(list, false)?.f32 +groupBy(list, false)?.f64 +groupBy(list, false)?.greet +groupBy(list, false)?.half +groupBy(list, false)?.i +groupBy(list, false)?.i32 +groupBy(list, false)?.i64 +groupBy(list, false)?.list +groupBy(list, false)?.ok +groupBy(list, false)?.score +groupBy(list, findLastIndex(array, ok)) +groupBy(list, findLastIndex(list, false)) +groupBy(list, first(array)) +groupBy(list, float(-1)) +groupBy(list, float(0.5)) +groupBy(list, floor(i)) +groupBy(list, floor(i64)) +groupBy(list, foo != #) +groupBy(list, foo) +groupBy(list, foo).Bar +groupBy(list, foo).Qux +groupBy(list, foo).String +groupBy(list, foo).add +groupBy(list, foo).array +groupBy(list, foo).div +groupBy(list, foo).f32 +groupBy(list, foo).f64 +groupBy(list, foo).foo +groupBy(list, foo).greet +groupBy(list, foo).half +groupBy(list, foo).i +groupBy(list, foo).i32 +groupBy(list, foo).i64 +groupBy(list, foo).list +groupBy(list, foo).ok +groupBy(list, foo).score +groupBy(list, foo)?.Bar +groupBy(list, foo)?.Qux +groupBy(list, foo)?.String +groupBy(list, foo)?.add +groupBy(list, foo)?.array +groupBy(list, foo)?.div +groupBy(list, foo)?.f32 +groupBy(list, foo)?.f64 +groupBy(list, foo)?.foo +groupBy(list, foo)?.half +groupBy(list, foo)?.i +groupBy(list, foo)?.i32 +groupBy(list, foo)?.i64 +groupBy(list, foo)?.list +groupBy(list, foo)?.ok +groupBy(list, foo)?.score +groupBy(list, foo)[i32] +groupBy(list, foo.Bar) +groupBy(list, foo.String()) +groupBy(list, foo?.String()) +groupBy(list, greet != greet) +groupBy(list, greet("bar")) +groupBy(list, i * i) +groupBy(list, i / f64) +groupBy(list, i <= i) +groupBy(list, i ^ i) +groupBy(list, i) +groupBy(list, i).Bar +groupBy(list, i).Qux +groupBy(list, i).String +groupBy(list, i).add +groupBy(list, i).array +groupBy(list, i).div +groupBy(list, i).f32 +groupBy(list, i).f64 +groupBy(list, i).foo +groupBy(list, i).half +groupBy(list, i).i +groupBy(list, i).i32 +groupBy(list, i).i64 +groupBy(list, i).list +groupBy(list, i).ok +groupBy(list, i).score +groupBy(list, i)?.Bar +groupBy(list, i)?.Qux +groupBy(list, i)?.String +groupBy(list, i)?.add +groupBy(list, i)?.array +groupBy(list, i)?.div +groupBy(list, i)?.f32 +groupBy(list, i)?.f64 +groupBy(list, i)?.foo +groupBy(list, i)?.greet +groupBy(list, i)?.half +groupBy(list, i)?.i +groupBy(list, i)?.i32 +groupBy(list, i)?.i64 +groupBy(list, i)?.list +groupBy(list, i)?.ok +groupBy(list, i)?.score +groupBy(list, i32 != f32)?.foo +groupBy(list, i32 * 0.5) +groupBy(list, i32 ** 0.5) +groupBy(list, i32 ** f32) +groupBy(list, i32 > i) +groupBy(list, i32 ^ i) +groupBy(list, i32) +groupBy(list, i32).Bar +groupBy(list, i32).Qux +groupBy(list, i32).add +groupBy(list, i32).array +groupBy(list, i32).div +groupBy(list, i32).f32 +groupBy(list, i32).f64 +groupBy(list, i32).foo +groupBy(list, i32).greet +groupBy(list, i32).half +groupBy(list, i32).i +groupBy(list, i32).i32 +groupBy(list, i32).i64 +groupBy(list, i32).list +groupBy(list, i32).ok +groupBy(list, i32).score +groupBy(list, i32)?.Bar +groupBy(list, i32)?.Qux +groupBy(list, i32)?.String +groupBy(list, i32)?.add +groupBy(list, i32)?.array +groupBy(list, i32)?.div +groupBy(list, i32)?.f32 +groupBy(list, i32)?.f64 +groupBy(list, i32)?.foo +groupBy(list, i32)?.greet +groupBy(list, i32)?.half +groupBy(list, i32)?.i +groupBy(list, i32)?.i32 +groupBy(list, i32)?.i64 +groupBy(list, i32)?.list +groupBy(list, i32)?.ok +groupBy(list, i32)?.score +groupBy(list, i64 != i32) +groupBy(list, i64 != nil) +groupBy(list, i64 - 0.5) +groupBy(list, i64 < 1) +groupBy(list, i64 <= 1) +groupBy(list, i64 == 1) +groupBy(list, i64 == nil) +groupBy(list, i64) +groupBy(list, i64).Bar +groupBy(list, i64).Qux +groupBy(list, i64).String +groupBy(list, i64).add +groupBy(list, i64).array +groupBy(list, i64).div +groupBy(list, i64).f32 +groupBy(list, i64).f64 +groupBy(list, i64).foo +groupBy(list, i64).greet +groupBy(list, i64).half +groupBy(list, i64).i +groupBy(list, i64).i32 +groupBy(list, i64).list +groupBy(list, i64).ok +groupBy(list, i64).score +groupBy(list, i64)?.Bar +groupBy(list, i64)?.Qux +groupBy(list, i64)?.String +groupBy(list, i64)?.add +groupBy(list, i64)?.array +groupBy(list, i64)?.div +groupBy(list, i64)?.f32 +groupBy(list, i64)?.f64 +groupBy(list, i64)?.foo +groupBy(list, i64)?.greet +groupBy(list, i64)?.half +groupBy(list, i64)?.i +groupBy(list, i64)?.i32 +groupBy(list, i64)?.i64 +groupBy(list, i64)?.list +groupBy(list, i64)?.ok +groupBy(list, i64)?.score +groupBy(list, i64)[max(i)] +groupBy(list, i64)[ok] +groupBy(list, int(1)) +groupBy(list, list == array) +groupBy(list, lower("foo")) +groupBy(list, max(f64)) +groupBy(list, max(i)) +groupBy(list, nil != #) +groupBy(list, nil != div) +groupBy(list, nil != true) +groupBy(list, nil == #) +groupBy(list, nil == #).i +groupBy(list, nil in list) +groupBy(list, not false) +groupBy(list, not ok) +groupBy(list, ok != false) +groupBy(list, ok ? # : true) +groupBy(list, ok) +groupBy(list, ok).Bar +groupBy(list, ok).Qux +groupBy(list, ok).String +groupBy(list, ok).add +groupBy(list, ok).array +groupBy(list, ok).div +groupBy(list, ok).f32 +groupBy(list, ok).f64 +groupBy(list, ok).foo +groupBy(list, ok).greet +groupBy(list, ok).half +groupBy(list, ok).i +groupBy(list, ok).i32 +groupBy(list, ok).i64 +groupBy(list, ok).list +groupBy(list, ok).ok +groupBy(list, ok).score +groupBy(list, ok)?.Bar +groupBy(list, ok)?.Qux +groupBy(list, ok)?.String +groupBy(list, ok)?.add +groupBy(list, ok)?.array +groupBy(list, ok)?.div +groupBy(list, ok)?.f32 +groupBy(list, ok)?.f64 +groupBy(list, ok)?.foo +groupBy(list, ok)?.greet +groupBy(list, ok)?.half +groupBy(list, ok)?.i +groupBy(list, ok)?.i32 +groupBy(list, ok)?.i64 +groupBy(list, ok)?.list +groupBy(list, ok)?.ok +groupBy(list, ok)?.score +groupBy(list, reduce(array, #)) +groupBy(list, reduce(list, #)).i32 +groupBy(list, reduce(list, f64)) +groupBy(list, reduce(list, i32)) +groupBy(list, reduce(map(list, i64), #)) +groupBy(list, round(0.5)) +groupBy(list, round(1)) +groupBy(list, round(f64)) +groupBy(list, score(1)) +groupBy(list, score(i)) +groupBy(list, string(#)) +groupBy(list, string(add)) +groupBy(list, string(half)) +groupBy(list, string(i32)) +groupBy(list, string(true)) +groupBy(list, toBase64("foo")) +groupBy(list, toJSON(#)) +groupBy(list, toJSON(1)) +groupBy(list, toJSON(array)) +groupBy(list, toJSON(foo)) +groupBy(list, true && false) +groupBy(list, true ? # : 1) +groupBy(list, true ? 1 : #) +groupBy(list, true).Qux +groupBy(list, true).String +groupBy(list, true).add +groupBy(list, true).array +groupBy(list, true).div +groupBy(list, true).f32 +groupBy(list, true).f64 +groupBy(list, true).foo +groupBy(list, true).greet +groupBy(list, true).half +groupBy(list, true).i +groupBy(list, true).i32 +groupBy(list, true).i64 +groupBy(list, true).list +groupBy(list, true).ok +groupBy(list, true).score +groupBy(list, true)?.Bar +groupBy(list, true)?.Qux +groupBy(list, true)?.String +groupBy(list, true)?.add +groupBy(list, true)?.array +groupBy(list, true)?.div +groupBy(list, true)?.f32 +groupBy(list, true)?.f64 +groupBy(list, true)?.foo +groupBy(list, true)?.greet +groupBy(list, true)?.half +groupBy(list, true)?.i +groupBy(list, true)?.i32 +groupBy(list, true)?.i64 +groupBy(list, true)?.list +groupBy(list, true)?.ok +groupBy(list, true)?.score +groupBy(list, type("foo")) +groupBy(list, type(#)) +groupBy(list, type(false)) +groupBy(list[i32:1], i64) +groupBy(list[i32:i32], foo) +groupBy(list[i64:1], i32) +groupBy(list[i:1], f64) +groupBy(map(array, #), # <= #) +groupBy(map(array, #), # == #) +groupBy(map(array, #), # >= #) +groupBy(map(array, #), #) +groupBy(map(array, #), 0.5 < 0.5) +groupBy(map(array, #), foo) +groupBy(map(array, #), i) +groupBy(map(array, #), i64) +groupBy(map(array, #), min(1)) +groupBy(map(array, #), ok) +groupBy(map(array, 0.5), # != 0.5) +groupBy(map(array, 0.5), # / #) +groupBy(map(array, 0.5), #) +groupBy(map(array, 0.5), f64) +groupBy(map(array, 1), 0.5 / #) +groupBy(map(array, 1), f64) +groupBy(map(array, 1), max(#)) +groupBy(map(array, 1), ok) +groupBy(map(array, div), div != #) +groupBy(map(array, f32), # - 0.5) +groupBy(map(array, f32), min(#)) +groupBy(map(array, f64), #) +groupBy(map(array, false), f64) +groupBy(map(array, false), i) +groupBy(map(array, foo), #).add +groupBy(map(array, foo), i) +groupBy(map(array, foo), ok) +groupBy(map(array, i), #) +groupBy(map(array, i32), # % i) +groupBy(map(array, i32), #) +groupBy(map(array, ok), i64) +groupBy(map(list, "bar"), #) +groupBy(map(list, "foo"), #) +groupBy(map(list, #), "bar" == "bar") +groupBy(map(list, #), #) +groupBy(map(list, #), #)?.array +groupBy(map(list, #), f32) +groupBy(map(list, #), f64) +groupBy(map(list, #), i32) +groupBy(map(list, #), i64) +groupBy(map(list, #), ok) +groupBy(map(list, 0.5), # * i64) +groupBy(map(list, 0.5), # ** #) +groupBy(map(list, 0.5), #) +groupBy(map(list, 0.5), i32) +groupBy(map(list, 1), #) +groupBy(map(list, 1), get(list, #)).i64 +groupBy(map(list, 1), i64) +groupBy(map(list, f32), # ** #).array +groupBy(map(list, f64), #) +groupBy(map(list, f64), #).half +groupBy(map(list, f64), f32) +groupBy(map(list, f64), i) +groupBy(map(list, i), #) +groupBy(map(list, i32), # == #) +groupBy(map(list, i64), #)?.i32 +groupBy(map(list, i64), i) +groupBy(map(list, list), foo) +groupBy(map(list, ok), #) +groupBy(ok ? "foo" : greet, # <= #) +groupBy(reduce(array, # .. i64), add) +groupBy(reduce(array, array), foo) +groupBy(reduce(array, array), i) +groupBy(reduce(list, array), # / #) +groupBy(reduce(list, array), true ? true : nil) +groupBy(sort(array), #) +groupBy(sort(array), foo) +groupBy(true ? "foo" : 1, # > 0.5) +groupBy(true ? "foo" : 1, foo) +groupBy(true ? "foo" : false, # / #) +groupBy(true ? "foo" : score, #) half -half != add -half != add ? ok : half -half != div -half != div == true -half != foo.Qux -half != foo.String -half != foo?.Qux -half != foo?.String -half != greet half != half -half != score -half == add -half == add ? "bar" : half -half == div -half == div ? add : 0.5 -half == div and 1 >= 1 -half == foo.Qux -half == foo.String -half == foo?.Qux -half == foo?.String -half == greet -half == greet == nil -half == greet ? ok : foo -half == greet || ok +half != half != nil +half != half and "bar" in foo +half != nil == false +half != nil ? "bar" : div +half != nil ? "bar" : false +half != nil ? true : div +half != reduce(list, half) half == half -half == half && i >= 0.5 -half == half ? score : "bar" -half == half and ok -half == nil == true -half == nil ? 1 : 0.5 -half == nil ? 1 : score -half == score -half not in [list, i64, ok] -half not in {"bar": list, "foo": 0.5}.ok -half(-(f32 - 0.5)) -half(--1) +half == nil && ok +half == nil ? array : 0.5 +half == nil ? foo : false +half(-(0.5 + 1)) +half(-(f64 + 1)) +half(-(i64 - 0.5)) half(-0.5) half(-1) -half(-f32 ^ i) half(-f64) half(0.5 * 0.5) half(0.5 * 1) @@ -6557,9 +8914,11 @@ half(0.5 ** i) half(0.5 ** i32) half(0.5 ** i64) half(0.5 + 0.5) +half(0.5 + 1 + i64) half(0.5 + 1) half(0.5 + f32) half(0.5 + f64) +half(0.5 + i) half(0.5 + i32) half(0.5 + i64) half(0.5 - 0.5) @@ -6574,7 +8933,6 @@ half(0.5 / 1) half(0.5 / f32) half(0.5 / f64) half(0.5 / i) -half(0.5 / i32) half(0.5 / i64) half(0.5 ^ 0.5) half(0.5 ^ 1) @@ -6583,38 +8941,49 @@ half(0.5 ^ f64) half(0.5 ^ i) half(0.5 ^ i32) half(0.5 ^ i64) -half(0.5) != f32 +half(0.5) != -i64 +half(0.5) != 0.5 ^ i +half(0.5) != i32 half(0.5) != i64 half(0.5) * f32 +half(0.5) * i +half(0.5) * i32 +half(0.5) * i64 half(0.5) ** f32 -half(0.5) ** f64 -half(0.5) + 1 * f64 +half(0.5) ** i +half(0.5) ** i32 +half(0.5) ** i64 +half(0.5) ** max(1) +half(0.5) + 1 / 1 +half(0.5) + f32 half(0.5) + f64 half(0.5) + i32 half(0.5) + i64 -half(0.5) - f32 -half(0.5) - f64 -half(0.5) - i -half(0.5) - i32 +half(0.5) - i64 +half(0.5) / -0.5 +half(0.5) / f64 half(0.5) / i -half(0.5) / i32 half(0.5) / i64 -half(0.5) < i32 -half(0.5) <= i -half(0.5) == f32 != true -half(0.5) == i -half(0.5) == i32 +half(0.5) < f64 +half(0.5) <= f32 ? f64 : 1 +half(0.5) <= f64 +half(0.5) <= i32 +half(0.5) <= i64 + i32 +half(0.5) <= int(0.5) +half(0.5) == f32 +half(0.5) == i32 / i half(0.5) == i64 +half(0.5) > f32 +half(0.5) > f64 half(0.5) > i -half(0.5) > i32 half(0.5) > i64 -half(0.5) >= f32 -half(0.5) >= f64 -half(0.5) >= i half(0.5) >= i32 -half(0.5) >= i64 -half(0.5) ^ (i32 - 1) +half(0.5) ^ (1 * i32) +half(0.5) ^ f32 +half(0.5) ^ f64 +half(0.5) ^ i half(0.5) ^ i32 +half(0.5) ^ i64 half(1 * 0.5) half(1 * 1) half(1 * f32) @@ -6656,22 +9025,77 @@ half(1 ^ f32) half(1 ^ f64) half(1 ^ i) half(1 ^ i32) +half(1 ^ i64) +half(1) != f32 +half(1) != f64 +half(1) != f64 ** f32 +half(1) != f64 ^ 0.5 +half(1) != i32 +half(1) != i64 +half(1) * i32 * i64 +half(1) ** (i64 * f32) +half(1) ** f32 +half(1) ** i +half(1) ** i32 +half(1) ** i64 +half(1) + f32 +half(1) + f32 / 0.5 +half(1) + i +half(1) + i32 +half(1) + i64 + i32 +half(1) - f32 +half(1) - i < i64 +half(1) - i32 +half(1) - i64 +half(1) / -1 +half(1) / 0.5 / i +half(1) / i +half(1) / i32 +half(1) < f64 +half(1) < i +half(1) < i64 +half(1) <= f32 +half(1) <= i32 +half(1) <= i64 +half(1) == -1 +half(1) == 1 ^ i64 +half(1) == f32 +half(1) == i32 +half(1) > i +half(1) > i32 +half(1) > i64 +half(1) >= f32 +half(1) >= i +half(1) >= i32 +half(1) >= i64 +half(1) >= max(1) +half(1) >= mean(array) +half(1) ^ f32 +half(1) ^ findIndex(list, true) +half(1) ^ i64 +half(1) in array +half(1) not in array half(abs(0.5)) half(abs(f64)) -half(abs(f64)) - i +half(ceil(0.5)) +half(ceil(1)) +half(ceil(f32)) +half(ceil(f64)) +half(ceil(i)) +half(ceil(i32)) +half(ceil(i64)) half(f32 * 0.5) half(f32 * 1) half(f32 * f64) half(f32 * i) half(f32 * i32) -half(f32 * i64) half(f32 ** 0.5) half(f32 ** f32) half(f32 ** f64) +half(f32 ** i64) half(f32 + 0.5) half(f32 + 1) half(f32 + f64) -half(f32 + i) half(f32 + i32) half(f32 + i64) half(f32 - 0.5) @@ -6684,84 +9108,85 @@ half(f32 / 0.5) half(f32 / 1) half(f32 / f32) half(f32 / f64) +half(f32 / i) half(f32 / i32) half(f32 / i64) half(f32 ^ 0.5) +half(f32 ^ 1) half(f32 ^ f32) half(f32 ^ f64) +half(f32 ^ i) half(f32 ^ i32) half(f32 ^ i64) half(f64 * 0.5) -half(f64 * 1) half(f64 * f32) +half(f64 * f64) half(f64 * i) half(f64 * i32) +half(f64 * i64) half(f64 ** 0.5) half(f64 ** 1) half(f64 ** f32) -half(f64 ** f64) half(f64 ** i) half(f64 ** i32) +half(f64 + 0.5) half(f64 + 1) -half(f64 + f32) +half(f64 + f64) half(f64 + i) -half(f64 + i32) +half(f64 + i64) half(f64 - 0.5) half(f64 - 1) half(f64 - f32) half(f64 - f64) half(f64 - i) -half(f64 - i32) half(f64 - i64) +half(f64 / 0.5) half(f64 / 1) half(f64 / f32) half(f64 / f64) +half(f64 / i) half(f64 / i32) -half(f64 / i64) half(f64 ^ 0.5) half(f64 ^ 1) half(f64 ^ f32) -half(f64 ^ i) +half(f64 ^ f64) half(f64 ^ i32) -half(f64 ^ i64) half(f64) -half(f64) != f32 -half(f64) != f64 +half(f64) != f64 != false +half(f64) != i32 half(f64) != i64 -half(f64) * f32 -half(f64) * i64 -half(f64) ** (i32 * 0.5) -half(f64) ** 0.5 ** i half(f64) ** f64 -half(f64) ** i64 -half(f64) + 1 + f64 -half(f64) + f64 -half(f64) + i +half(f64) ** i +half(f64) ** i32 half(f64) + i32 half(f64) + i64 half(f64) - f64 half(f64) - i32 -half(f64) / f32 half(f64) / f64 half(f64) / i32 -half(f64) / i64 -half(f64) < f64 half(f64) < i half(f64) < i32 -half(f64) < i64 -half(f64) <= 0.5 + f64 -half(f64) <= f64 -half(f64) <= i64 +half(f64) <= f32 +half(f64) <= i32 +half(f64) == f32 +half(f64) == f64 +half(f64) == i +half(f64) == i32 half(f64) == i64 -half(f64) > abs(i) -half(f64) > f32 * 0.5 -half(f64) > max(i64) -half(f64) >= f32 +half(f64) > f32 +half(f64) > f64 +half(f64) > i +half(f64) > i32 +half(f64) > i64 half(f64) >= i half(f64) >= i64 -half(f64) ^ f32 -half(false ? 0.5 : 0.5) -half(float(-f64)) +half(f64) ^ i +half(f64) not in array +half(false ? f64 : 0.5) +half(false ? i32 : 0.5) +half(false ? ok : 0.5) +half(false ? score : 0.5) +half(false ? true : f64) half(float(0.5)) half(float(1)) half(float(f32)) @@ -6769,37 +9194,43 @@ half(float(f64)) half(float(i)) half(float(i32)) half(float(i64)) -half(greet == div ? "bar" : 0.5) +half(floor(0.5)) +half(floor(1)) +half(floor(f32)) +half(floor(f64)) +half(floor(i)) +half(floor(i32)) +half(floor(i64)) half(half(0.5)) +half(half(1)) +half(half(ceil(i))) +half(half(f64 - 0.5)) half(half(f64)) -half(half(i - 0.5)) half(i * 0.5) half(i * 1) -half(i * f32) half(i * f64) half(i ** 0.5) half(i ** 1) half(i ** f32) half(i ** f64) half(i ** i) +half(i ** i32) half(i ** i64) half(i + 0.5) half(i + 1) half(i + f32) half(i + f64) -half(i - 0.5) half(i - 1) +half(i - f32) half(i - f64) half(i / 0.5) half(i / 1) -half(i / f32) half(i / f64) half(i / i) half(i / i32) -half(i / i64) half(i ^ 0.5) half(i ^ 1) -half(i ^ f32) +half(i ^ i) half(i ^ i32) half(i ^ i64) half(i32 * 0.5) @@ -6808,2450 +9239,2668 @@ half(i32 * f32) half(i32 * f64) half(i32 ** 0.5) half(i32 ** 1) -half(i32 ** f32) half(i32 ** f64) half(i32 ** i) half(i32 ** i32) half(i32 ** i64) half(i32 + 0.5) half(i32 + 1) +half(i32 + f32) half(i32 + f64) half(i32 - 0.5) half(i32 - 1) half(i32 - f32) -half(i32 - f64) half(i32 / 0.5) half(i32 / 1) half(i32 / f32) half(i32 / f64) half(i32 / i) +half(i32 / i32 / f32 / f64) half(i32 / i32) half(i32 / i64) half(i32 ^ 0.5) half(i32 ^ 1) half(i32 ^ f32) +half(i32 ^ f64) half(i32 ^ i) half(i32 ^ i32) +half(i32 ^ i64 ^ i) half(i32 ^ i64) +half(i64 != i ? true : 0.5) half(i64 * 0.5) half(i64 * 1) half(i64 * f64) half(i64 ** 0.5) half(i64 ** 1) -half(i64 ** f32) half(i64 ** f64) +half(i64 ** i) +half(i64 ** i32) half(i64 ** i64) half(i64 + 0.5) -half(i64 + 1) half(i64 + f32) half(i64 + f64) half(i64 - 0.5) half(i64 - 1) half(i64 - f32) +half(i64 - f64) half(i64 / 0.5) half(i64 / 1) half(i64 / f32) half(i64 / f64) half(i64 / i) half(i64 / i32) -half(i64 / i64) half(i64 ^ 0.5) half(i64 ^ 1) half(i64 ^ f32) half(i64 ^ f64) +half(i64 ^ i) half(i64 ^ i32) -half(i64 ^ i64) half(max(0.5)) -half(max(0.5, f32)) +half(max(0.5)) ** i half(max(f64)) +half(mean(array)) +half(median(array)) half(min(0.5)) -half(min(0.5, 0.5)) -half(min(1, 0.5, 1)) +half(min(0.5, f32)) +half(min(0.5, i32)) half(min(f64)) -half(ok ? 0.5 : f32) -half(ok ? 0.5 : false) -half(ok ? 0.5 : foo) -half(true ? 0.5 : 0.5) -hasPrefix("bar", "foo") != ok -hasSuffix("foo", "foo") or 0.5 <= i +half(min(i, 0.5)) +half(reduce(array, 0.5)) +half(reduce(array, f64)) +half(reduce(list, 0.5)) +half(reduce(list, f64)) +half(round(0.5)) +half(round(1)) +half(round(f32)) +half(round(f64)) +half(round(i)) +half(round(i32)) +half(round(i64)) +half(score(1) ^ i64) +half(true ? 0.5 : i64) +half(true ? f64 : nil) i i != -0.5 i != -1 i != -f32 i != -f64 i != -i -i != -i64 -i != 0.5 / 0.5 -i != 0.5 == ok -i != 0.5 ? 1 : array -i != 0.5 ? i32 : 0.5 -i != 0.5 ? score : score -i != 1 % i64 -i != 1 * i -i != 1 + 1 -i != 1 - 0.5 -i != 1 - 1 -i != 1 - i64 -i != 1 == ok -i != 1 ? ok : i64 -i != 1 or i64 != 1 +i != -i32 +i != 0.5 + 0.5 +i != 0.5 - 1 +i != 0.5 / 1 +i != 0.5 ? 1 : div +i != 0.5 ? false : i32 +i != 0.5 ^ 0.5 +i != 0.5 ^ 1 +i != 0.5 ^ f32 +i != 1 != nil +i != 1 / 1 +i != 1 ? f64 : score +i != ceil(1) +i != ceil(f32) +i != ceil(i64) i != f32 -i != f32 + i -i != f32 / 1 -i != f32 ? div : list +i != f32 ** i64 +i != f32 + i64 +i != f32 == ok i != f64 -i != f64 * 0.5 -i != f64 + 1 -i != f64 / 0.5 -i != f64 ? 0.5 : nil -i != f64 ? array : div -i != f64 ? half : 1 -i != f64 || ok -i != first(array) -i != float(1) -i != float(f32) -i != float(f64) +i != f64 + i32 +i != f64 == true +i != f64 ^ f32 +i != f64 ^ i64 +i != float(0.5) +i != float(i) i != half(0.5) +i != half(f64) i != i -i != i != nil -i != i ^ f64 +i != i * 1 +i != i * i32 +i != i - i32 +i != i ? i : false i != i32 -i != i32 % i32 -i != i32 * f64 -i != i32 - i64 -i != i32 / i64 -i != i32 ? 1 : i -i != i32 ? list : i -i != i32 || half != nil +i != i32 != nil ? greet : score +i != i32 * 0.5 +i != i32 * f32 +i != i32 and ok i != i64 -i != i64 - f32 -i != i64 ? true : "foo" -i != i64 ^ f64 +i != i64 ** i +i != i64 ? add : i64 +i != i64 ? f32 : nil +i != i64 ^ 1 i != int(1) -i != max(i32) -i != min(1) -i != nil != true -i != nil ? ok : "bar" +i != min(i64) +i != nil != ok +i != nil ? ok : f64 +i != reduce(array, #) +i != reduce(array, 0.5) +i != reduce(list, 1) +i != round(f64) +i != score(1) i != score(i) +i != {"foo": score}?.f32 +i % (1 + i32) +i % (i32 + i32) +i % (i64 + 1) i % -1 i % -i i % -i32 -i % -i64 -i % 1 != i64 -i % 1 .. i32 -i % 1 / i +i % 1 % i32 +i % 1 % i64 +i % 1 * i32 +i % 1 + i64 +i % 1 .. i +i % 1 / 0.5 +i % 1 / f32 +i % 1 <= i64 i % 1 >= i -i % 1 >= i32 -i % array[i] -i % first(array) -i % get(array, i64) +i % abs(1) +i % abs(i) +i % array[1] +i % array[i64] i % i -i % i % i32 -i % i + i32 -i % i == i -i % i in array +i % i / i i % i32 +i % i32 != i32 +i % i32 * 1 +i % i32 * f64 i % i32 / i32 -i % i32 <= f32 +i % i32 <= f64 i % i64 -i % i64 != i -i % int(i64) -i % len(array) -i % score(1) +i % i64 != i ? f64 : list +i % i64 <= i +i % min(1) +i % min(i64) +i % reduce(array, #) i % score(i) -i * (0.5 + 0.5) -i * (f32 + f32) -i * (i32 + 0.5) -i * (i32 - f64) -i * (i64 + 1) -i * -1 -i * -f32 -i * -i +i * (1 + 1) +i * (f32 + 0.5) +i * (f32 + 1) +i * (f64 + i) +i * (f64 - i32) +i * -i32 i * -i64 i * 0.5 * f64 i * 0.5 + i -i * 0.5 - i -i * 0.5 < i -i * 0.5 <= i64 ** f64 -i * 1 % i -i * 1 ** i32 -i * 1 / f64 -i * 1 / i64 -i * 1 <= f32 -i * abs(0.5) -i * add(1, 1) -i * array[i32] +i * 0.5 / i +i * 0.5 < i32 +i * 0.5 > i32 * f32 +i * 0.5 ^ 1 +i * 1 % i64 +i * 1 ** 1 +i * 1 < f64 +i * 1 < i32 +i * 1 == i32 +i * bitnand(i64, i64) +i * bitnot(i64) +i * ceil(1) i * f32 -i * f32 != f32 -i * f32 ** 0.5 -i * f32 >= f32 +i * f32 <= f64 +i * f32 ^ 0.5 +i * f32 ^ 1 i * f32 ^ f32 i * f64 -i * f64 * 1 -i * float(f64) +i * f64 != i +i * f64 * f32 > i +i * f64 * i +i * f64 ** i32 +i * float(f32) +i * floor(f32) +i * floor(i) +i * floor(i32) +i * floor(i64) +i * half(0.5) +i * half(1) i * half(f64) i * i -i * i != i64 -i * i / f32 -i * i / f64 -i * i / i32 -i * i / i64 +i * i % i +i * i * 0.5 +i * i * f32 +i * i ** 0.5 +i * i - f32 +i * i .. i +i * i == f32 i * i32 -i * i32 ** f64 -i * i32 ** i32 -i * i32 - i -i * i32 / i32 -i * i32 <= i32 +i * i32 * i +i * i32 .. i32 +i * i32 / min(1) +i * i32 == f32 +i * i32 in array i * i64 -i * i64 % i32 -i * i64 * 0.5 -i * i64 + f32 -i * i64 >= i32 -i * i64 ^ i64 -i * int(f64) -i * int(i) -i * int(i64) -i * max(0.5) -i * min(i64) +i * i64 < f64 +i * int(1) +i * max(1) +i * max(f64, f32) +i * max(i) +i * min(f64, i) +i * reduce(array, #) i * score(1) -i ** (0.5 + f64) -i ** (0.5 + i64) -i ** (1 * 1) -i ** (1 - 0.5) -i ** (i32 % i64) -i ** (i32 - 1) +i * score(i) +i * sum(array) +i ** (0.5 * f64) +i ** (0.5 + 0.5) +i ** (0.5 - 1) +i ** (0.5 - f64) +i ** (0.5 / i32) +i ** (f32 + 0.5) +i ** (f32 + f32) +i ** (i * 0.5) +i ** (i * 1) +i ** (i + f64) +i ** (i - i32 + i32) +i ** (i32 - i64) +i ** (i32 / 1) +i ** (i64 - 0.5) i ** -0.5 -i ** -i +i ** -1 +i ** -f32 i ** -i32 i ** -i64 -i ** 0.5 ** 0.5 -i ** 0.5 ** 1 +i ** 0.5 ** f32 +i ** 0.5 ** reduce(array, #) +i ** 0.5 < bitnot(i64) i ** 0.5 < f32 -i ** 0.5 <= i64 ^ i32 -i ** 1 != f64 +i ** 0.5 < f64 +i ** 0.5 <= i64 +i ** 0.5 ^ i +i ** 0.5 ^ i64 i ** 1 ** 1 -i ** 1 ** f64 -i ** 1 ** i -i ** 1 == f32 +i ** 1 / i +i ** 1 < -f32 +i ** 1 >= f64 +i ** 1 ^ i +i ** 1 ^ i32 +i ** abs(0.5) +i ** array[i64] +i ** bitnand(i32, 1) +i ** bitshl(i64, i32) +i ** ceil(1) i ** f32 -i ** f32 ** 0.5 -i ** f32 ** f64 -i ** f32 + f64 -i ** f32 <= f32 -i ** f32 <= i32 ? 1 : f32 -i ** f32 >= float(i64) +i ** f32 * i32 +i ** f32 ** 1 +i ** f32 ^ f64 +i ** f32 ^ i64 i ** f64 -i ** f64 != f64 -i ** f64 < 1 / 0.5 -i ** float(0.5) -i ** float(f32) -i ** float(i32) +i ** f64 != i32 +i ** f64 ** f64 +i ** f64 > i64 ? 1 : ok +i ** f64 >= i +i ** first(array) +i ** floor(f64) +i ** half(1) i ** half(f64) +i ** half(i + f32) i ** i -i ** i + f64 -i ** i <= i -i ** i ^ i +i ** i != i == ok +i ** i ^ 0.5 i ** i32 -i ** i32 != i -i ** i32 != i32 -i ** i32 + i32 +i ** i32 == f32 +i ** i32 > i64 i ** i64 -i ** i64 ** 1 -i ** i64 ** f64 -i ** i64 ** i64 -i ** i64 - f64 +i ** i64 ** i +i ** i64 < i +i ** i64 == i32 i ** i64 >= i -i ** i64 >= i32 -i ** i64 ^ 1 -i ** int(1) -i ** max(f32) -i ** min(0.5, 1) -i ** min(f32) -i ** min(i) +i ** i64 ^ i64 +i ** i64 not in array +i ** len("foo") +i ** len(array) +i ** min(1) i ** min(i32) +i ** reduce(array, #) i ** score(1) +i ** score(i) +i + -0.5 i + -1 i + -f32 i + -f64 -i + -i -i + 0.5 != i -i + 0.5 ** i32 -i + 0.5 - i -i + 0.5 < 1 + f32 -i + 0.5 <= i32 -i + 0.5 > f32 -i + 1 / array[i32] +i + 0.5 ** 0.5 +i + 0.5 + i +i + 0.5 / 1 +i + 1 + f32 i + 1 / f32 -i + 1 <= f32 -i + 1 > i64 -i + 1 >= f64 -i + array[i32] -i + count(list, false) +i + 1 > f64 +i + 1 ^ 1 +i + 1 ^ f32 +i + abs(0.5) +i + array[i64] +i + array[i] +i + count(list, true) i + f32 -i + f32 != f64 -i + f32 * i i + f32 ** i +i + f32 / f64 +i + f32 / i32 +i + f32 < i64 i + f64 -i + f64 <= i64 -i + f64 == f64 +i + f64 - i32 +i + f64 < i64 +i + f64 == i32 +i + f64 > f64 i + float(0.5) -i + float(f32) -i + get(array, i64) -i + half(0.5) +i + float(i32) +i + get(array, i) +i + half(1) i + half(f64) i + i -i + i + f32 -i + i - i32 +i + i * i64 +i + i ^ 1 i + i32 -i + i32 != i64 -i + i32 - 0.5 +i + i32 .. -i64 i + i32 .. i -i + i32 > f32 +i + i32 <= f32 +i + i32 == i64 +i + i32 > min(i) +i + i32 >= i32 == nil +i + i32 in array i + i64 -i + i64 + f64 -i + i64 ^ 1 +i + i64 - f64 +i + i64 / 0.5 +i + i64 / f64 +i + i64 > f32 i + int(f32) -i + int(i64) -i + last(array) i + len("bar") -i + max(0.5) -i + max(f32) +i + reduce(array, #) +i + reduce(array, f32) +i + reduce(list, i32) +i + score(i) +i - -0.5 i - -1 i - -f32 -i - -i +i - -f64 i - -i64 -i - 0.5 * 0.5 -i - 0.5 * 1 -i - 0.5 / 1 -i - 1 * 1 -i - 1 * i32 -i - 1 - i +i - 0.5 + i64 +i - 0.5 - 1 +i - 0.5 < f64 +i - 0.5 > i +i - 0.5 not in array +i - 1 + i +i - 1 - i64 +i - 1 .. i64 +i - 1 < i32 +i - 1 <= f64 +i - 1 <= i +i - 1 > 0.5 - 0.5 i - 1 ^ 0.5 -i - 1 ^ i32 -i - abs(0.5) -i - abs(f32) -i - abs(i32) +i - bitxor(i, i) +i - ceil(f64) i - f32 -i - f32 * i32 -i - f32 ** 1 -i - f32 + f64 -i - f32 - 1 -i - f32 / 0.5 -i - f32 / f32 -i - f32 / i32 -i - f32 ^ i64 +i - f32 * f32 +i - f32 - i32 +i - f32 / i +i - f32 ^ 0.5 i - f64 -i - findIndex(list, ok) -i - half(0.5) +i - f64 + i32 +i - f64 + i32 - f64 +i - f64 / i32 +i - f64 ^ i64 +i - find(array, true) +i - float(0.5) +i - floor(1) +i - half(f64) i - i -i - i * 1 -i - i < i + f64 -i - i <= i -i - i <= i32 -i - i >= f32 -i - i not in array +i - i + f32 i - i32 -i - i32 > len(array) -i - i32 ^ 0.5 +i - i32 + 0.5 +i - i32 - f32 +i - i32 - i32 i - i64 -i - i64 ** 1 -i - i64 + i32 -i - i64 - 1 / 1 -i - i64 - f64 -i - int(1) -i - int(f32) -i - int(i) -i - last(array) -i - max(0.5) +i - i64 .. i32 +i - i64 / i +i - i64 <= i32 +i - i64 ^ f32 +i - i64 ^ f64 +i - int(i32) i - max(i64) -i - min(f32) +i - median(array) +i - round(i32) i - score(1) -i - score(i) +i .. -i i .. -i32 -i .. 1 % i32 -i .. 1 == array +i .. -i64 i .. abs(1) -i .. abs(i32) i .. i -i .. i % 1 i .. i32 -i .. i32 == array i .. i64 -i .. i64 + i -i .. i64 == list -i .. int(i64) -i .. last(array) -i .. len(list) -i .. min(1) +i .. i64 * 1 +i .. i64 + 1 +i .. int(0.5) +i .. max(1) +i .. max(i) +i .. min(i) +i .. reduce(list, i64) +i .. score(1) i .. score(i) -i / (f32 + f64) -i / (f64 + f32) -i / (i32 + f32) -i / -0.5 +i / (0.5 + 1) +i / (0.5 + f64) +i / (0.5 + i) +i / (0.5 - f32) +i / (i + f32) i / -1 +i / -f32 +i / -f64 i / -i32 -i / -i64 -i / 0.5 * f32 +i / 0.5 * 1 i / 0.5 * f64 -i / 0.5 ** f32 -i / 0.5 / i32 -i / 0.5 < i64 -i / 0.5 <= i64 -i / 0.5 == 0.5 - f64 -i / 0.5 >= i64 -i / 1 ** 1 -i / 1 / i64 -i / 1 == f64 -i / 1 ^ 1 -i / 1 ^ i64 -i / abs(i64) +i / 0.5 / f64 +i / 0.5 == nil != false +i / 0.5 >= f32 +i / 0.5 ^ i32 +i / 1 ** i32 +i / 1 <= i64 +i / 1 > i +i / abs(i) +i / bitnot(i64) +i / count(array, false) i / f32 -i / f32 != f32 -i / f32 ** i64 -i / f32 / i +i / f32 != i64 ? 1 : list +i / f32 >= len(array) i / f64 -i / f64 * f32 -i / f64 - f32 -i / float(i32) -i / half(0.5) -i / half(f64) +i / f64 * f64 +i / f64 ^ i32 +i / float(0.5) +i / float(1) +i / float(f64) +i / floor(1) +i / floor(i32) i / i -i / i != i64 -i / i > i32 -i / i > i64 +i / i ** 1 +i / i / i +i / i < i32 +i / i ^ 1 i / i32 -i / i32 - i -i / i32 / i -i / i32 / i64 -i / i32 ^ f32 +i / i32 / 1 i / i64 -i / i64 != i -i / i64 ** f32 -i / i64 < i % 1 -i / i64 >= i32 ? div : div -i / len("bar") -i / len(list) -i / max(1 / i) -i / min(0.5) -i / min(f64) -i / min(i32) +i / i64 * f32 +i / i64 / f64 +i / max(0.5) +i / mean(array) +i / min(f32) +i / min(i64) i / score(1) -i / score(i) -i < -(f32 - 1) -i < -1 -i < -f32 -i < -i +i < -(f32 * 1) +i < --f64 i < -i32 -i < 0.5 != false -i < 0.5 != ok -i < 0.5 * i -i < 0.5 + 0.5 +i < -i64 +i < 0.5 != nil +i < 0.5 + f64 i < 0.5 == ok -i < 0.5 ? "bar" : "bar" -i < 0.5 ? f32 : array -i < 0.5 ? f32 : half -i < 1 * 1 -i < 1 ** f32 -i < 1 == ok -i < 1 ? false : nil -i < abs(f64) +i < 1 / 0.5 +i < 1 == nil +i < 1 ? array : score +i < 1 ^ i64 +i < abs(i32) i < f32 -i < f32 * i -i < f32 ^ f32 +i < f32 && ok +i < f32 * 0.5 +i < f32 * i64 +i < f32 ** i +i < f32 ** i32 +i < f32 + 1 +i < f32 + array[i64] +i < f32 / 0.5 +i < f32 ? "bar" : div +i < f32 || ok i < f64 -i < f64 * f64 -i < findIndex(list, ok) -i < half(f32 ^ i64) +i < f64 - 1 +i < float(f64) +i < floor(f32) +i < half(0.5) +i < half(1) i < half(f64) i < i -i < i % 1 -i < i / 1 -i < i ? i32 : add -i < i ^ 0.5 -i < i ^ i32 +i < i != true +i < i ** 1 +i < i / i64 +i < i ? score : list i < i32 -i < i32 ** 0.5 -i < i32 - f32 -i < i32 == nil +i < i32 * f32 +i < i32 + 1 i < i64 -i < i64 && ok -i < i64 - f64 -i < i64 - i32 -i < i64 ? nil : "foo" -i < i64 ^ 0.5 -i < int(0.5) -i < int(i64) -i < len(array) -i < len(list) -i < min(i64) -i < score(1) -i < score(i) -i <= -f32 +i < i64 ^ f32 +i < max(0.5) +i < reduce(array, #) +i <= -0.5 +i <= -1 +i <= -f64 i <= -i +i <= -i32 i <= -i64 -i <= 0.5 ** 0.5 -i <= 0.5 ** f32 -i <= 0.5 == nil -i <= 0.5 ? score : array -i <= 1 != all(array, true) +i <= 0.5 * f32 +i <= 0.5 + 0.5 +i <= 0.5 / 1 +i <= 0.5 / f64 +i <= 0.5 == ok +i <= 0.5 ? i : ok +i <= 0.5 ? nil : i32 +i <= 0.5 ^ f32 i <= 1 != nil -i <= 1 % i -i <= 1 + 1 -i <= 1 - f64 -i <= 1 ? ok : 1 -i <= abs(1) -i <= abs(i32) -i <= add(1, 1) +i <= 1 && ok +i <= 1 * 0.5 +i <= 1 ** i +i <= 1 + f64 +i <= 1 - f32 +i <= 1 ? 0.5 : f32 +i <= 1 ? 0.5 : list +i <= 1 ? list : div +i <= 1 ^ f32 +i <= abs(0.5) +i <= ceil(1) i <= f32 -i <= f32 != nil -i <= f32 * 0.5 -i <= f32 / f32 -i <= f32 ? ok : 1 -i <= f32 or ok +i <= f32 - 0.5 +i <= f32 ? array : nil i <= f64 -i <= f64 * 1 -i <= f64 == nil -i <= f64 ? foo : div -i <= f64 or add == greet -i <= float(f64) -i <= float(i) -i <= float(i32) -i <= half(-1) -i <= half(0.5) +i <= float(0.5) +i <= float(f32) +i <= half(1) +i <= half(f64) i <= i -i <= i ** 1 -i <= i == true +i <= i != nil +i <= i * f32 +i <= i ** f64 +i <= i - 0.5 +i <= i - 1 +i <= i / i +i <= i ^ 1 i <= i32 -i <= i32 - f32 -i <= i32 - i64 +i <= i32 - f64 +i <= i32 - i +i <= i32 == ok +i <= i32 ? array : false +i <= i32 ? greet : foo +i <= i32 || false ? f32 : i32 i <= i64 -i <= i64 % i32 -i <= i64 / 1 -i <= i64 ? ok : 1 -i <= int(1) -i <= int(i32) -i <= len("bar") -i <= len(array) -i <= max(i) -i <= min(f32) -i <= min(f64) -i <= min(i) -i <= min(i64) -i == -0.5 -i == -1 +i <= i64 * i +i <= i64 + f64 +i <= len(list) +i <= max(0.5) +i <= max(f32, i32) +i <= round(f32) +i <= round(i32) +i <= score(1) i == -f32 i == -f64 i == -i i == -i32 i == -i64 -i == 0.5 + f32 -i == 0.5 - i32 +i == 0.5 ** f64 i == 0.5 == ok -i == 0.5 ? false : true -i == 0.5 ? list : i32 -i == 0.5 ^ 0.5 -i == 1 != true -i == 1 % i -i == 1 * f32 -i == 1 ** 1 -i == 1 ? foo : list -i == 1 || ok -i == abs(0.5) -i == abs(1) -i == div(1, i) +i == 0.5 ? "foo" : f64 +i == 1 * 0.5 +i == 1 ** i64 +i == 1 / 0.5 +i == 1 / f32 +i == 1 ? f32 : 1 +i == 1 ? f64 : f64 +i == 1 ? greet : score +i == abs(i64) +i == bitnot(1) i == f32 -i == f32 * i64 +i == f32 + i +i == f32 == nil +i == f32 ? foo : foo +i == f32 ^ i32 i == f64 -i == f64 != nil -i == f64 + i64 -i == f64 == ok +i == f64 + i32 +i == f64 - i +i == f64 ? i64 : div +i == f64 ? score : foo +i == f64 and ok +i == findIndex(list, true) +i == float(0.5) +i == floor(f32) +i == floor(i32) +i == half(0.5) +i == half(f64) i == i -i == i - f64 -i == i / i32 -i == i ? ok : score -i == i ^ i +i == i + 0.5 +i == i - i32 +i == i == true +i == i ? add : i32 +i == i ? i32 : add +i == i and ok i == i32 -i == i32 ** f32 -i == i32 ** i -i == i32 ? list : foo +i == i32 * 0.5 +i == i32 ** 0.5 +i == i32 + 0.5 +i == i32 + i64 +i == i32 ^ f32 i == i64 -i == i64 != ok -i == i64 + i32 -i == i64 ? array : 0.5 -i == i64 ? score : 1 -i == i64 ^ f64 -i == int(f64) -i == len(array) -i == max(0.5) -i == max(i64) -i == min(i) -i == nil ? false : 1 +i == i64 * 0.5 +i == i64 * f32 +i == i64 ** 0.5 +i == i64 == nil +i == i64 == ok +i == i64 ? list : div +i == len("bar") +i == nil ? 0.5 : div +i == nil ? div : i32 +i == nil and add != nil +i == reduce(array, #) +i == reduce(array, 0.5) i == score(1) -i > -i64 -i > 0.5 * f64 -i > 0.5 ** 0.5 -i > 0.5 / 0.5 -i > 0.5 / 1 -i > 0.5 == nil -i > 0.5 ^ 0.5 -i > 1 ? greet : "bar" -i > 1 ? greet : f64 -i > abs(i64) -i > array[i] +i == score(i) +i > -f32 +i > -f64 +i > -i +i > -i32 +i > 0.5 - 0.5 +i > 0.5 ^ i64 +i > 0.5 or ok +i > 0.5 || ok +i > 1 != ok +i > 1 % i64 +i > 1 ** i32 +i > 1 == ok +i > 1 ? greet : nil +i > 1 ? score : 0.5 +i > 1 ? true : greet +i > bitnot(1) +i > bitor(1, i32) +i > count(array, true) i > f32 +i > f32 ** i32 +i > f32 - f64 +i > f32 ^ 1 i > f64 -i > f64 + 0.5 -i > float(1) -i > half(f64) +i > f64 != ok +i > f64 * 1 +i > f64 * f32 +i > f64 ** i32 +i > f64 ? foo : array +i > f64 ? greet : "bar" +i > first(array) +i > floor(f64) i > i -i > i ** i32 -i > i ** i64 -i > i / i -i > i or ok +i > i % i32 +i > i ** i +i > i + i +i > i ? f32 : i32 i > i32 -i > i32 ? 1 : true -i > i32 ? foo : score -i > i32 ^ i +i > i32 * 1 +i > i32 * i32 +i > i32 + 1 +i > i32 == ok i > i64 -i > int(0.5) -i > int(i) -i > int(i32) -i > max(f32) -i > max(i) -i > min(0.5) -i > score(i) -i > score(len(array)) +i > i64 && f32 < 0.5 +i > i64 + 0.5 +i > i64 - 0.5 +i > i64 - i +i > int(f32) +i > len("bar") +i > reduce(list, i32) i >= -0.5 i >= -1 +i >= -f32 +i >= -i i >= -i32 i >= -i64 -i >= 0.5 ** f64 -i >= 0.5 + i32 -i >= 0.5 - 1 -i >= 0.5 == nil -i >= 0.5 ? div : i -i >= 0.5 ? score : f64 -i >= 1 / i -i >= 1 ? nil : 0.5 -i >= abs(0.5) -i >= abs(i64) +i >= 0.5 / 1 +i >= 0.5 ? i64 : array +i >= 0.5 ? nil : ok +i >= 0.5 ^ i +i >= 1 * i64 +i >= 1 + f32 +i >= 1 == nil +i >= 1 ? f32 : nil +i >= 1 ? ok : false +i >= 1 ^ f64 +i >= bitnot(i) i >= f32 -i >= f32 ** f64 -i >= f32 - i -i >= f32 ? "bar" : array -i >= f32 ? score : half +i >= f32 ? f32 : i +i >= f32 ? true : list i >= f64 -i >= f64 * i32 -i >= f64 + i32 -i >= f64 - i +i >= f64 * 0.5 +i >= f64 - 1 +i >= first(array) +i >= float(0.5) +i >= float(1) +i >= get(array, i64) +i >= half(f64) i >= i -i >= i ** 0.5 -i >= i / 1 -i >= i / i -i >= i == nil -i >= i == ok +i >= i * 1 +i >= i ** f32 +i >= i ? foo : div i >= i32 -i >= i32 ** 0.5 -i >= i32 - f64 -i >= i32 ? f64 : div +i >= i32 ** i64 +i >= i32 ? f32 : div +i >= i32 ^ 1 i >= i64 -i >= i64 * i -i >= i64 ^ 0.5 -i >= int(i32) -i >= len("foo") -i >= min(f32 ^ i64) +i >= int(0.5) +i >= min(0.5) +i >= reduce(array, f64) +i >= reduce(array, i) +i >= reduce(list, 1) +i >= round(1) +i >= score(1) i >= score(i) -i ^ (0.5 * 1) -i ^ (0.5 - 0.5) -i ^ (f32 * 1) -i ^ (f32 * f32) -i ^ (f32 * f64) -i ^ (f32 / f64) -i ^ (i * 1) -i ^ (i - i64) -i ^ (i32 % 1) -i ^ (i32 + i) -i ^ (i32 / 0.5) -i ^ (i64 / 0.5) -i ^ (i64 / 1) -i ^ --f32 +i ^ (1 % i) +i ^ (1 * f64) +i ^ (1 - 0.5) +i ^ (f32 - f64) +i ^ (f64 - 1) +i ^ (i + 0.5) +i ^ (i + i64) +i ^ (i - f32) +i ^ (i32 * i32) +i ^ (i32 + 1) +i ^ (i32 / f32) +i ^ (i32 / i) +i ^ (i64 * 1) i ^ -1 +i ^ -f32 +i ^ -f64 i ^ -i -i ^ -i32 -i ^ -i64 -i ^ 0.5 != 1 + i -i ^ 0.5 * f32 -i ^ 0.5 - i -i ^ 0.5 / f64 -i ^ 0.5 <= f32 -i ^ 0.5 > i64 +i ^ 0.5 ** 0.5 +i ^ 0.5 + i32 +i ^ 0.5 < f64 +i ^ 0.5 < i +i ^ 0.5 <= i64 +i ^ 0.5 > f64 +i ^ 0.5 >= f32 +i ^ 0.5 >= reduce(array, #) i ^ 0.5 ^ f32 -i ^ 1 != f32 -i ^ 1 * f32 -i ^ 1 ** i -i ^ 1 - f32 -i ^ 1 / i32 -i ^ 1 ^ i64 -i ^ abs(1) -i ^ abs(f32) -i ^ abs(i64) -i ^ add(1, 1) -i ^ array[i] +i ^ 0.5 ^ i64 +i ^ 1 * f64 +i ^ 1 / i +i ^ 1 >= f32 +i ^ 1 ^ i +i ^ 1 not in array +i ^ bitnot(i64 + 1) +i ^ bitnot(min(i)) +i ^ ceil(0.5) i ^ f32 -i ^ f32 != 1 - i -i ^ f32 != i64 ? list : i32 -i ^ f32 + f64 -i ^ f32 / i +i ^ f32 ** 1 i ^ f32 < i -i ^ f32 >= i32 +i ^ f32 <= -f32 i ^ f64 -i ^ f64 * i -i ^ f64 >= f64 -i ^ find(array, true) -i ^ float(f64) +i ^ f64 ** 0.5 +i ^ f64 - f64 +i ^ f64 / i32 +i ^ f64 <= f32 +i ^ f64 == i +i ^ f64 > f32 +i ^ find(array, ok) +i ^ floor(i32) +i ^ half(0.5) +i ^ half(1) +i ^ half(f64) i ^ i -i ^ i ** f64 -i ^ i + i32 -i ^ i >= f64 +i ^ i * i +i ^ i * i64 +i ^ i ** i +i ^ i / i i ^ i32 -i ^ i32 - f32 -i ^ i32 == i64 * i -i ^ i32 >= f64 -i ^ i32 >= max(i64) +i ^ i32 / f64 +i ^ i32 in array i ^ i64 -i ^ i64 * i64 -i ^ i64 ** i -i ^ i64 == f32 -i ^ i64 >= i64 ^ f32 -i ^ i64 ^ f64 -i ^ int(f32) -i ^ max(1) -i ^ min(i32) +i ^ i64 != f32 + 1 +i ^ i64 ** f32 +i ^ last(array) +i ^ median(array) +i ^ min(i32, 1) +i ^ reduce(array, #) +i ^ round(i32) i ^ score(1) +i in 1 .. i i in array -i in array == ok -i in array ? f32 : greet -i in array ? foo : false -i in array || ok +i in array != nil +i in array ? nil : 1 +i in groupBy(list, #) +i in groupBy(list, foo) +i in map(array, #) +i in map(array, i64) +i not in 1 .. 1 i not in array -i not in array ? foo : list -i not in array and true +i not in groupBy(array, #) +i not in groupBy(list, #) i not in i64 .. 1 +i not in i64 .. i64 i not in map(array, #) -i not in {"foo": 1}.div +i not in map(list, i32) i32 i32 != -0.5 i32 != -1 i32 != -f32 i32 != -i -i32 != 0.5 && nil == i64 +i32 != -i32 +i32 != -i64 +i32 != 0.5 - 0.5 +i32 != 0.5 - i32 +i32 != 0.5 / f32 +i32 != 0.5 ^ 0.5 +i32 != 0.5 ^ i64 +i32 != 0.5 || ok +i32 != 1 % i64 i32 != 1 && ok -i32 != 1 * i64 -i32 != 1 + 1 -i32 != 1 / 1 -i32 != 1 ? 0.5 : greet -i32 != 1 ? false : i64 -i32 != 1 ? greet : half -i32 != 1 ? greet : ok -i32 != abs(i64) -i32 != array[i] -i32 != count(array, ok) +i32 != 1 * f32 +i32 != 1 ? "foo" : array +i32 != 1 ? greet : "foo" +i32 != array[i64] +i32 != bitnot(i) +i32 != bitnot(i64) +i32 != ceil(1) +i32 != ceil(f64) +i32 != count(array, false) i32 != f32 -i32 != f32 && ok -i32 != f32 / f64 -i32 != f32 ? f64 : i32 -i32 != f32 and ok +i32 != f32 == true +i32 != f32 ? false : 0.5 +i32 != f32 ? i : 0.5 i32 != f64 -i32 != f64 == true -i32 != findIndex(list, false) -i32 != first(array) -i32 != float(i) -i32 != get(array, i64) -i32 != half(f64) +i32 != f64 ** i +i32 != f64 - 1 +i32 != f64 ? 1 : add +i32 != findLastIndex(array, false) +i32 != get(array, 1) +i32 != half(1) i32 != i -i32 != i ** 1 -i32 != i ** f64 +i32 != i + 1 i32 != i32 -i32 != i32 * 1 -i32 != i32 - 0.5 -i32 != i32 ? array : add +i32 != i32 ** 0.5 +i32 != i32 + 0.5 +i32 != i32 ^ i64 i32 != i64 -i32 != i64 % i32 -i32 != i64 * 0.5 -i32 != i64 ? div : nil -i32 != i64 ? true : nil -i32 != int(f32) -i32 != max(1) -i32 != max(f64, 0.5) -i32 != min(1, 0.5, f64) -i32 != min(i) -i32 != nil ? half : 1 -i32 % -i +i32 != i64 * i64 +i32 != i64 / 0.5 +i32 != i64 / f32 +i32 != len(list) +i32 != max(f64) +i32 != min(1) +i32 != min(i32) +i32 != nil != false +i32 != nil ? f64 : "foo" +i32 != reduce(array, #) +i32 != reduce(array, i) +i32 != reduce(list, f32) +i32 != round(1) +i32 % -1 i32 % -i32 -i32 % 1 != i64 -i32 % 1 % (i64 + i64) -i32 % 1 % i64 -i32 % 1 * f64 -i32 % 1 + f64 +i32 % 1 % i32 +i32 % 1 * f32 +i32 % 1 * i +i32 % 1 * i32 +i32 % 1 .. i +i32 % 1 / 0.5 +i32 % 1 / i32 i32 % 1 > i -i32 % add(1, 1) -i32 % count(list, ok) +i32 % array[i64] +i32 % get(array, 1) i32 % i -i32 % i != f32 +i32 % i != i +i32 % i < i i32 % i32 -i32 % i32 != i -i32 % i32 * f32 -i32 % i32 * i +i32 % i32 != f64 +i32 % i32 * i64 +i32 % i32 == i32 +i32 % i32 >= i64 i32 % i64 -i32 % i64 != f32 -i32 % i64 / i32 -i32 % i64 == i -i32 % i64 >= i64 -i32 % min(1, i64) -i32 % min(i) +i32 % i64 % i +i32 % i64 * i64 +i32 % i64 + i +i32 % i64 .. i +i32 % i64 / i +i32 % i64 == f64 +i32 % max(i32) +i32 % reduce(array, #) +i32 % score(1) +i32 * (1 + f32) +i32 * (1 + f64) i32 * (f32 + 1) -i32 * (f32 + f32) -i32 * (f32 + i) -i32 * (f64 - f32) -i32 * (i32 - 0.5) +i32 * (f32 - i) +i32 * (f64 + 0.5) +i32 * (f64 + i) +i32 * (i - f32) +i32 * (i32 + i64) +i32 * (i32 - 1) i32 * (i32 - f64) -i32 * (i32 - i64) +i32 * -0.5 +i32 * -1 i32 * -f32 -i32 * -f64 -i32 * -i -i32 * 0.5 ** 0.5 -i32 * 0.5 + f64 -i32 * 0.5 <= f32 -i32 * 1 % i64 -i32 * 1 * f32 -i32 * 1 * i32 -i32 * 1 < i -i32 * array[i32] -i32 * count(array, true) +i32 * -i32 +i32 * -i64 +i32 * 0.5 * 0.5 +i32 * 0.5 / 0.5 +i32 * 0.5 / 1 +i32 * 0.5 / i32 +i32 * 0.5 == f64 +i32 * 0.5 == i64 +i32 * 0.5 ^ f64 +i32 * 0.5 ^ i32 +i32 * 1 * i +i32 * 1 ** i64 +i32 * 1 + f64 +i32 * 1 - i64 +i32 * 1 > half(0.5) +i32 * 1 ^ 1 +i32 * abs(i32) +i32 * bitnot(i32) +i32 * ceil(1) i32 * f32 -i32 * f32 != i +i32 * f32 + f32 +i32 * f32 / i +i32 * f32 <= f64 +i32 * f32 <= i32 +i32 * f32 ^ f32 i32 * f64 -i32 * f64 * i -i32 * f64 + f32 -i32 * f64 / i -i32 * f64 > i32 +i32 * f64 * 1 +i32 * f64 >= f32 +i32 * first(array) +i32 * float(f32) +i32 * float(f64) +i32 * floor(f64) +i32 * half(0.5) +i32 * half(1) i32 * i -i32 * i != i32 -i32 * i * 0.5 -i32 * i .. i -i32 * i / array[i32] -i32 * i / i32 +i32 * i / -i +i32 * i / f32 i32 * i / i64 +i32 * i < f32 i32 * i32 -i32 * i32 % i32 -i32 * i32 * 0.5 -i32 * i32 ** 1 -i32 * i32 - f32 -i32 * i32 == i32 +i32 * i32 != f64 +i32 * i32 % i64 / i +i32 * i32 / i64 +i32 * i32 < i64 +i32 * i32 >= f32 i32 * i64 i32 * i64 % 1 -i32 * i64 .. i -i32 * i64 / 1 -i32 * i64 / i32 -i32 * int(f32) -i32 * max(f64) +i32 * i64 % 1 % 1 +i32 * i64 ** i64 +i32 * i64 / f32 +i32 * i64 < i +i32 * len("foo") +i32 * max(i32) i32 * max(i64) -i32 * min(1) -i32 ** (0.5 * 0.5) -i32 ** (0.5 + 0.5) -i32 ** (0.5 + i32) -i32 ** (0.5 / f64) -i32 ** (f32 / i) -i32 ** (f64 + 0.5) -i32 ** (i + 1) -i32 ** (i64 - i) -i32 ** -1 ^ i32 -i32 ** -f32 -i32 ** -i32 +i32 * median(array) +i32 * min(0.5) +i32 * min(i) +i32 * reduce(array, #) +i32 * round(i) +i32 * score(1) +i32 * score(i) +i32 ** (0.5 - i32) +i32 ** (1 * i64) +i32 ** (1 / 0.5) +i32 ** (f32 * i64) +i32 ** (i % i32) +i32 ** (i - i) +i32 ** (i - i32) +i32 ** (i / 0.5) +i32 ** (i32 / i64) +i32 ** (i64 + 0.5) +i32 ** (i64 - 1) +i32 ** -1 +i32 ** -f64 +i32 ** -i i32 ** -i64 -i32 ** 0.5 / f32 -i32 ** 0.5 <= i32 +i32 ** 0.5 * i64 +i32 ** 0.5 - f64 +i32 ** 0.5 / reduce(array, #) i32 ** 0.5 ^ i i32 ** 1 ** i64 -i32 ** 1 + f64 -i32 ** 1 + i64 -i32 ** 1 - f32 -i32 ** 1 >= i64 * 0.5 -i32 ** 1 ^ f64 -i32 ** array[i] +i32 ** 1 + f32 +i32 ** 1 / i64 +i32 ** 1 <= i +i32 ** 1 ^ i64 +i32 ** 1 in array +i32 ** array[1] +i32 ** array[i64] +i32 ** bitnot(i64) +i32 ** ceil(1) +i32 ** ceil(f64) i32 ** f32 -i32 ** f32 ** i -i32 ** f32 == i64 +i32 ** f32 / score(1) +i32 ** f32 < f32 +i32 ** f32 <= i +i32 ** f32 == f32 i32 ** f64 -i32 ** f64 != i64 ? i : half -i32 ** f64 + f64 -i32 ** f64 >= i -i32 ** f64 ^ f32 -i32 ** float(1) -i32 ** float(f64) +i32 ** f64 == f32 +i32 ** f64 > i +i32 ** find(array, ok) +i32 ** float(i32) i32 ** half(0.5) +i32 ** half(1) +i32 ** half(f64) i32 ** i -i32 ** i ** 0.5 -i32 ** i ^ 0.5 +i32 ** i * f64 +i32 ** i ** i +i32 ** i ^ i i32 ** i32 +i32 ** i32 ^ i64 i32 ** i64 -i32 ** i64 != 0.5 == true -i32 ** i64 - f64 -i32 ** i64 / f64 -i32 ** i64 / i -i32 ** i64 > i -i32 ** i64 ^ 1 -i32 ** i64 ^ i -i32 ** int(0.5) -i32 ** int(f64) -i32 ** len(array) -i32 ** min(f64) -i32 ** min(i32) -i32 ** score(1) -i32 ** score(i) +i32 ** int(1) +i32 ** int(i32) +i32 ** len("foo") +i32 ** len(list) +i32 ** max(f32, i32) +i32 ** min(0.5) +i32 ** min(i64) +i32 ** reduce(array, 1) +i32 ** reduce(array, i64) +i32 ** reduce(list, i64) +i32 ** round(i64) +i32 ** sum(array) i32 + -0.5 i32 + -1 -i32 + -f32 -i32 + -f64 i32 + -i i32 + -i32 -i32 + 0.5 * 0.5 -i32 + 0.5 * i32 +i32 + -i64 +i32 + 0.5 != f32 +i32 + 0.5 != i32 +i32 + 0.5 * i +i32 + 0.5 + 0.5 i32 + 0.5 + 1 +i32 + 0.5 + f32 +i32 + 0.5 + f64 +i32 + 0.5 + i i32 + 0.5 + i64 -i32 + 0.5 - 0.5 -i32 + 0.5 - f32 -i32 + 0.5 <= i -i32 + 0.5 > i % 1 -i32 + 0.5 >= i -i32 + 1 / f64 -i32 + 1 < i32 -i32 + 1 ^ i -i32 + 1 ^ i32 -i32 + abs(i32) -i32 + count(array, false) +i32 + 0.5 / i64 +i32 + 0.5 <= -f32 +i32 + 1 % 1 +i32 + 1 + i64 +i32 + 1 - f32 +i32 + 1 - i +i32 + 1 - i64 +i32 + 1 / i +i32 + 1 ^ f32 +i32 + abs(f32) +i32 + array[i64] +i32 + bitnot(i32) +i32 + ceil(i) i32 + f32 +i32 + f32 / i +i32 + f32 < i32 +i32 + f32 <= i64 i32 + f64 i32 + f64 * 1 -i32 + f64 * f64 -i32 + f64 ** 0.5 -i32 + f64 - f32 * 0.5 -i32 + f64 == i32 -i32 + f64 >= i +i32 + f64 * i32 +i32 + f64 > i32 +i32 + f64 ^ 0.5 i32 + f64 ^ i32 -i32 + find(array, ok) +i32 + findIndex(list, true) +i32 + floor(0.5) +i32 + floor(f64) i32 + i -i32 + i * 1 -i32 + i - f32 -i32 + i > half(f64) -i32 + i >= -1 +i32 + i + f64 +i32 + i + i64 +i32 + i - 0.5 +i32 + i - i64 +i32 + i <= i32 +i32 + i > i64 i32 + i32 -i32 + i32 ** 0.5 -i32 + i32 >= f32 -i32 + i32 ^ i64 +i32 + i32 + f64 +i32 + i32 <= i + i64 +i32 + i32 > i +i32 + i32 > i32 i32 + i64 -i32 + i64 + i64 -i32 + i64 / f64 -i32 + i64 <= f32 -i32 + i64 ^ f32 -i32 + i64 not in array -i32 + int(f64) -i32 + last(array) -i32 + len("foo") -i32 + len(list) -i32 + min(0.5, i32) -i32 + min(1, i) -i32 + min(i) -i32 + min(i, i32) +i32 + i64 % i32 +i32 + i64 ** 1 +i32 + i64 - 0.5 +i32 + i64 - f32 +i32 + i64 / 0.5 +i32 + i64 ^ 1 +i32 + int(i64) +i32 + len("bar") +i32 + min(i32) +i32 + reduce(array, #) +i32 + round(f32) +i32 + round(i32) i32 + score(i) i32 - -0.5 i32 - -1 i32 - -f32 -i32 - -i32 -i32 - -i64 -i32 - 0.5 * 0.5 -i32 - 0.5 * i64 -i32 - 0.5 + i -i32 - 0.5 + i32 -i32 - 0.5 - f32 -i32 - 0.5 < i32 -i32 - 0.5 <= f64 -i32 - 1 != f32 -i32 - 1 * f32 -i32 - 1 ** i32 -i32 - 1 / 0.5 -i32 - 1 <= i64 -i32 - 1 not in array -i32 - array[1] +i32 - -i +i32 - 0.5 * f32 +i32 - 0.5 + half(0.5) +i32 - 0.5 - i32 +i32 - 0.5 <= f32 +i32 - 0.5 ^ 0.5 +i32 - 1 ** i +i32 - 1 + 0.5 +i32 - 1 > -i64 +i32 - abs(i32) +i32 - abs(i64) +i32 - array[i] +i32 - bitushr(i32, i64) +i32 - div(1, i) +i32 - div(i, i) i32 - f32 -i32 - f32 * f32 -i32 - f32 ** f64 -i32 - f32 + 0.5 -i32 - f32 / f64 +i32 - f32 * 0.5 +i32 - f32 + i32 +i32 - f32 - int(f64) +i32 - f32 / i32 +i32 - f32 < i64 +i32 - f32 <= f32 +i32 - f32 <= i32 +i32 - f32 > i +i32 - f32 >= f32 i32 - f64 -i32 - f64 ** f64 -i32 - f64 + 0.5 -i32 - f64 - i64 -i32 - f64 / i64 -i32 - f64 < i64 -i32 - first(array) -i32 - float(i) -i32 - get(array, i64) +i32 - f64 + f32 +i32 - float(0.5) +i32 - float(1) +i32 - float(f64) +i32 - floor(1) +i32 - floor(f64) +i32 - get(array, i) +i32 - half(0.5) +i32 - half(f64) i32 - i -i32 - i % i -i32 - i + f32 -i32 - i - 1 -i32 - i / i -i32 - i <= i64 -i32 - i == i +i32 - i ** i64 +i32 - i + i32 +i32 - i / 0.5 +i32 - i == f32 i32 - i > f64 -i32 - i >= f64 +i32 - i > i +i32 - i >= i64 i32 - i32 -i32 - i32 ** 0.5 -i32 - i32 <= i32 + i64 -i32 - i32 ^ 1 +i32 - i32 != i64 +i32 - i32 * 1 +i32 - i32 * i32 +i32 - i32 + 1 +i32 - i32 < i32 +i32 - i32 > i64 +i32 - i32 > i64 / i i32 - i64 -i32 - i64 % i -i32 - i64 % i64 -i32 - i64 .. i -i32 - i64 <= i -i32 - i64 ^ 0.5 -i32 - i64 ^ f64 -i32 - int(1) -i32 - int(f64) -i32 - max(i64) -i32 - max(i64, i) -i32 - min(0.5) -i32 - score(i) -i32 .. -1 -i32 .. -i -i32 .. -i32 +i32 - i64 != -f32 +i32 - i64 / 1 +i32 - i64 == f64 +i32 - len(array) +i32 - len(list) +i32 - max(f32) +i32 - score(1) i32 .. -i64 -i32 .. 1 - 1 -i32 .. abs(i) -i32 .. array[i32] -i32 .. count(array, ok) +i32 .. abs(i64) +i32 .. bitnot(i64) +i32 .. bitushr(i, 1) +i32 .. count(array, true) +i32 .. div(i, 1) i32 .. i -i32 .. i - 1 i32 .. i32 -i32 .. i32 != list i32 .. i64 -i32 .. i64 - i32 -i32 .. int(0.5) -i32 .. len(list) -i32 .. min(1) -i32 .. min(1, 0.5) -i32 .. min(i32) -i32 .. min(i64) +i32 .. int(f32) +i32 .. len("foo") +i32 .. max(1) +i32 .. max(i32) +i32 .. max(i32, 0.5) i32 .. score(i) -i32 / (0.5 + i32) -i32 / (1 + f32) -i32 / (1 - f32) -i32 / (1 - i) -i32 / (f32 + i) -i32 / (f32 - f64) -i32 / (f64 + 0.5) -i32 / (f64 - 1) -i32 / (i32 - 1) +i32 / (1 + 1) +i32 / (1 + i64) +i32 / (f64 - i64) +i32 / (i32 + i64) +i32 / (i64 + 0.5) i32 / -0.5 -i32 / -1 i32 / -f32 i32 / -i i32 / -i32 +i32 / -i64 i32 / 0.5 * i +i32 / 0.5 * i / 1 +i32 / 0.5 + i64 +i32 / 0.5 - i32 +i32 / 0.5 / i32 i32 / 0.5 / i64 -i32 / 0.5 >= f64 -i32 / 1 != f64 -i32 / 1 < i32 +i32 / 0.5 >= i64 +i32 / 0.5 ^ 1 +i32 / 0.5 ^ f64 +i32 / 1 != i +i32 / 1 * i64 +i32 / 1 ** 1 +i32 / 1 ^ 0.5 i32 / abs(0.5) +i32 / abs(1) +i32 / abs(f64) +i32 / abs(i32) +i32 / array[1] +i32 / ceil(i32) i32 / f32 +i32 / f32 ** 1 +i32 / f32 / i64 +i32 / f32 <= i32 +i32 / f32 <= i64 +i32 / f32 >= i32 == false i32 / f64 -i32 / f64 * i32 +i32 / f64 != f64 +i32 / f64 != i64 +i32 / f64 * 1 +i32 / f64 - i32 +i32 / f64 == i64 i32 / f64 >= f32 -i32 / half(f64) +i32 / find(array, ok) +i32 / float(f32) +i32 / floor(1) +i32 / floor(f64) +i32 / half(0.5) i32 / i -i32 / i <= i +i32 / i * i32 +i32 / i ^ i32 i32 / i32 -i32 / i32 * 1 -i32 / i32 / f32 / f64 +i32 / i32 * f64 i32 / i32 / i64 +i32 / i32 <= i64 i32 / i64 -i32 / i64 != i64 -i32 / i64 * i -i32 / i64 / i -i32 / i64 == f32 -i32 / i64 == f64 -i32 / int(i) -i32 / len("bar") +i32 / i64 ** f32 +i32 / i64 ^ 0.5 +i32 / int(1) i32 / len("foo") -i32 / max(i32) +i32 / max(1) +i32 / max(i) i32 / min(f32) -i32 / min(f64) -i32 / min(i) -i32 / min(i32) -i32 < -(i - f32) -i32 < -0.5 +i32 / reduce(array, #) +i32 / score(i) i32 < -f32 +i32 < -f64 i32 < -i32 i32 < 0.5 ** i32 +i32 < 0.5 - 1 i32 < 0.5 - f32 -i32 < 0.5 ^ 1 -i32 < 1 % 1 -i32 < 1 ** 1 -i32 < 1 + 0.5 -i32 < 1 + 1 -i32 < 1 ? "foo" : i32 -i32 < 1 ? 1 : 0.5 -i32 < 1 ^ i32 -i32 < abs(i64) -i32 < div(1, 1) +i32 < 0.5 / 1 +i32 < 0.5 == nil +i32 < 0.5 ? "foo" : half +i32 < 0.5 ? foo : 1 +i32 < 0.5 or ok +i32 < 0.5 || ok +i32 < 1 * f32 +i32 < 1 + i64 +i32 < 1 / f32 +i32 < 1 ^ i +i32 < abs(f64) i32 < f32 -i32 < f32 == nil -i32 < f32 ? div : true -i32 < f32 || i64 != f32 +i32 < f32 * i +i32 < f32 - 0.5 +i32 < f32 - 1 i32 < f64 -i32 < f64 != nil -i32 < f64 != true -i32 < f64 * f32 -i32 < f64 == nil -i32 < f64 ? f32 : half -i32 < f64 ? greet : false -i32 < f64 ? list : i32 -i32 < f64 ^ f32 -i32 < f64 || 1 < 1 -i32 < float(i) -i32 < float(i32) -i32 < half(0.5) +i32 < f64 * i64 +i32 < float(reduce(array, f32)) +i32 < get(array, i32) +i32 < get(array, i64) +i32 < half(1) +i32 < half(f64) i32 < i -i32 < i != true -i32 < i ^ 0.5 +i32 < i ** i64 +i32 < i + 0.5 +i32 < i / i32 +i32 < i ? score : score i32 < i32 -i32 < i32 != ok -i32 < i32 * f32 -i32 < i32 / i32 -i32 < i32 ? ok : 1 +i32 < i32 % i +i32 < i32 ** 1 +i32 < i32 - f32 +i32 < i32 ^ i64 i32 < i64 -i32 < i64 - 0.5 -i32 < i64 ^ f64 +i32 < i64 ** 0.5 +i32 < i64 + f32 +i32 < i64 / f64 i32 < int(0.5) -i32 < int(i32) -i32 < int(i64) -i32 < max(0.5) -i32 < max(1) -i32 < min(1, i32) +i32 < last(array) +i32 < min(1) i32 < min(f64) -i32 < min(i) -i32 < min(i64) +i32 < min(i32) i32 < score(1) +i32 < score(i) i32 <= -0.5 i32 <= -f32 i32 <= -i i32 <= -i32 -i32 <= 0.5 != nil -i32 <= 0.5 != ok -i32 <= 0.5 * 0.5 -i32 <= 0.5 * i -i32 <= 0.5 + i64 -i32 <= 1 ? i : f32 -i32 <= 1 ? true : true -i32 <= 1 or 0.5 == 0.5 -i32 <= abs(i32) -i32 <= count(list, ok) +i32 <= -i64 +i32 <= 0.5 - f64 +i32 <= 0.5 == nil +i32 <= 0.5 ? i32 : greet +i32 <= 0.5 ? i32 : half +i32 <= 0.5 ^ i64 +i32 <= 0.5 and ok +i32 <= 1 + i32 +i32 <= 1 + i64 +i32 <= 1 ^ 0.5 +i32 <= 1 and ok +i32 <= 1 || i32 >= i32 +i32 <= abs(1) i32 <= f32 -i32 <= f32 * i64 -i32 <= f32 / 0.5 -i32 <= f32 ^ i64 +i32 <= f32 != ok i32 <= f64 +i32 <= f64 != ok i32 <= f64 * i -i32 <= f64 ^ 1 -i32 <= float(i) +i32 <= f64 == ok +i32 <= f64 ^ f64 +i32 <= findIndex(array, true) +i32 <= float(i32) +i32 <= floor(0.5) i32 <= half(0.5) +i32 <= half(1) +i32 <= half(f64) i32 <= i -i32 <= i % i64 +i32 <= i * 1 +i32 <= i * i64 +i32 <= i - 0.5 i32 <= i32 -i32 <= i32 != nil -i32 <= i32 % 1 -i32 <= i32 ** f64 +i32 <= i32 != true i32 <= i64 -i32 <= i64 != false -i32 <= i64 != ok -i32 <= i64 + f32 -i32 <= i64 ? div : nil -i32 <= last(array) -i32 <= len(array) -i32 <= len(list) -i32 <= max(f64) -i32 <= min(i) +i32 <= i64 / 1 +i32 <= len("foo") +i32 <= max(i64) +i32 <= mean(array) +i32 <= round(0.5) i32 <= score(1) i32 <= score(i) i32 == -0.5 i32 == -1 +i32 == -f32 i32 == -f64 i32 == -i -i32 == -i64 -i32 == 0.5 / f64 -i32 == 0.5 ? half : array -i32 == 0.5 ^ i -i32 == 0.5 ^ i64 -i32 == 1 ** 1 -i32 == 1 ** i -i32 == 1 || f32 < f64 +i32 == 0.5 != false +i32 == 0.5 * f32 +i32 == 0.5 / 0.5 +i32 == 1 % 1 +i32 == 1 + f32 +i32 == 1 - i +i32 == 1 ? div : div +i32 == 1 ^ 0.5 +i32 == 1 ^ f64 +i32 == abs(f64) +i32 == abs(i) +i32 == bitnot(1) +i32 == bitnot(i) +i32 == ceil(1) +i32 == count(list, ok) i32 == f32 -i32 == f32 ? f32 : nil -i32 == f32 ? half : "bar" -i32 == f32 ? score : false -i32 == f32 or ok +i32 == f32 * i32 +i32 == f32 ** 1 +i32 == f32 - f32 +i32 == f32 ? f64 : list +i32 == f32 ? i64 : true +i32 == f32 ? score : "bar" i32 == f64 -i32 == f64 != ok -i32 == f64 * 0.5 -i32 == f64 ** f32 -i32 == f64 ** i64 -i32 == f64 ? add : half -i32 == findLastIndex(array, ok) -i32 == float(i) -i32 == half(0.5) +i32 == f64 ** 0.5 +i32 == find(array, 0.5 == i64) +i32 == first(array) +i32 == floor(f64) +i32 == half(f64) i32 == i -i32 == i % i64 -i32 == i ? "foo" : greet -i32 == i ? type(false) : array -i32 == i ^ f64 -i32 == i and ok -i32 == i || ok +i32 == i ** f64 +i32 == i ? half : 1 +i32 == i ? i : "bar" i32 == i32 -i32 == i32 ? add : add -i32 == i32 ? f32 : f64 -i32 == i32 ^ 1 +i32 == i32 && i == i +i32 == i32 - 1 +i32 == i32 - i64 i32 == i64 -i32 == i64 + f32 -i32 == i64 ? foo : list -i32 == len(list) -i32 == max(0.5) -i32 == min(f32) -i32 == min(i32) -i32 == nil ? f32 : add -i32 == nil and ok -i32 == {"foo": f32, "foo": list}?.String?.Qux +i32 == i64 * f32 +i32 == i64 ? "foo" : 1 +i32 == i64 or ok +i32 == int(f64) +i32 == int(i) +i32 == nil ? f32 : 0.5 +i32 == reduce(array, #) +i32 == round(i32) +i32 == round(i64) +i32 == score(1) i32 > -0.5 -i32 > -1 -i32 > -f32 i32 > -f64 -i32 > -i i32 > -i32 -i32 > -i64 -i32 > 0.5 != ok i32 > 0.5 != true i32 > 0.5 * f64 -i32 > 0.5 ** f32 +i32 > 0.5 ** 0.5 +i32 > 0.5 ** 1 i32 > 0.5 ** i -i32 > 0.5 + 0.5 -i32 > 0.5 + 1 -i32 > 0.5 - 1 -i32 > 0.5 / i64 -i32 > 0.5 == nil -i32 > 0.5 ? greet : f32 -i32 > 0.5 ? ok : false -i32 > 0.5 ^ f32 -i32 > 1 ** f64 -i32 > 1 - i -i32 > 1 / 1 -i32 > 1 ? i : add -i32 > 1 || ok -i32 > abs(1) -i32 > abs(f64) -i32 > array[1] -i32 > array[i32] +i32 > 0.5 - i +i32 > 0.5 / 1 +i32 > 0.5 == ok +i32 > 0.5 ^ 1 +i32 > 0.5 || ok +i32 > 1 * f64 +i32 > 1 * i32 +i32 > 1 + i64 +i32 > 1 ? f32 : f64 +i32 > 1 ? i : "bar" +i32 > 1 ? i64 : div +i32 > ceil(0.5) +i32 > ceil(1) +i32 > count(array, ok) i32 > f32 -i32 > f32 != ok -i32 > f32 && "bar" == nil i32 > f32 * i64 -i32 > f32 ? "bar" : half +i32 > f32 + 0.5 +i32 > f32 + 1 +i32 > f32 - f32 +i32 > f32 - i32 +i32 > f32 ^ 0.5 i32 > f64 -i32 > f64 * 0.5 -i32 > f64 - 1 -i32 > f64 / 1 -i32 > f64 / i32 -i32 > f64 == nil -i32 > f64 == ok -i32 > f64 == true -i32 > f64 ? 0.5 : add -i32 > f64 ^ i64 -i32 > float(i) -i32 > float(i32) -i32 > half(0.5) -i32 > half(f64) +i32 > f64 ** i32 +i32 > f64 + f64 +i32 > get(array, i32) +i32 > half(1) +i32 > half(half(1)) i32 > i +i32 > i != ok i32 > i + f32 -i32 > i / f32 +i32 > i ? i : i i32 > i ^ i32 i32 > i32 -i32 > i32 - 0.5 -i32 > i32 ? "bar" : div -i32 > i32 ? array : 0.5 -i32 > i32 ? foo : 1 +i32 > i32 - i +i32 > i32 == nil ? score : i +i32 > i32 ? score : 1 +i32 > i32 ^ 1 +i32 > i32 ^ i32 i32 > i64 +i32 > i64 != false i32 > i64 ** f32 -i32 > i64 + f64 -i32 > i64 - i -i32 > i64 ? list : list -i32 > int(i) +i32 > i64 / 1 +i32 > i64 == ok +i32 > i64 || ok +i32 > int(1) i32 > int(i64) -i32 > max(i) -i32 > min(0.5) -i32 > score(1) -i32 >= -0.5 +i32 > min(i32) +i32 > reduce(array, #) +i32 > round(i64) +i32 > score(i) i32 >= -1 +i32 >= -f32 +i32 >= -f64 i32 >= -i -i32 >= 0.5 ** 0.5 -i32 >= 0.5 ^ f32 -i32 >= 0.5 || ok -i32 >= 1 && ok -i32 >= abs(i) -i32 >= abs(i64) -i32 >= array[i] +i32 >= -i64 +i32 >= 0.5 != not true +i32 >= 0.5 == true +i32 >= 0.5 ? 0.5 : half +i32 >= 0.5 ^ 0.5 +i32 >= 0.5 ^ i32 +i32 >= 1 % i +i32 >= 1 * 0.5 +i32 >= 1 * i32 +i32 >= 1 + i64 +i32 >= 1 - 1 +i32 >= 1 == ok +i32 >= 1 ? 1 : false +i32 >= 1 ? add : 1 +i32 >= abs(0.5) +i32 >= abs(f32) +i32 >= bitnot(1 + i) +i32 >= bitnot(i64) +i32 >= ceil(1) +i32 >= ceil(f32) +i32 >= count(list, true) i32 >= f32 -i32 >= f32 != true -i32 >= f32 - 0.5 -i32 >= f32 ^ 0.5 +i32 >= f32 ** f32 +i32 >= f32 ^ 1 i32 >= f64 -i32 >= f64 && nil == 0.5 -i32 >= f64 - f64 -i32 >= f64 / 1 -i32 >= f64 ? f32 : list -i32 >= f64 ^ 1 -i32 >= float(1) +i32 >= f64 != false +i32 >= f64 ** f64 +i32 >= f64 / i64 +i32 >= f64 ? half : f64 +i32 >= f64 ^ f64 +i32 >= float(0.5) +i32 >= floor(1) +i32 >= floor(f32) i32 >= half(0.5) -i32 >= half(f64) i32 >= i +i32 >= i % 1 i32 >= i % i64 -i32 >= i ** i32 -i32 >= i / i -i32 >= i ? div : list -i32 >= i ? foo : 0.5 +i32 >= i / i32 +i32 >= i / i64 +i32 >= i == ok i32 >= i32 +i32 >= i32 ** i32 i32 >= i64 -i32 >= i64 != ok -i32 >= i64 ** i64 -i32 >= i64 / i64 -i32 >= i64 ? list : greet -i32 >= i64 ^ i32 +i32 >= i64 != false +i32 >= i64 - i64 +i32 >= i64 / i32 +i32 >= i64 ? 0.5 : 0.5 +i32 >= i64 ? div : half +i32 >= i64 ? half : i64 +i32 >= i64 and ok i32 >= int(i64) i32 >= last(array) -i32 >= len(array) i32 >= min(i32) +i32 >= reduce(array, #) +i32 >= reduce(array, i64) +i32 >= reduce(list, i32) +i32 >= round(f32) i32 >= score(1) -i32 >= score(i) -i32 ^ (f32 + i64) -i32 ^ (f64 + 0.5) -i32 ^ (i - f64) -i32 ^ (i32 + f32) -i32 ^ (i64 % i) -i32 ^ (i64 * 0.5) -i32 ^ (i64 + f32) -i32 ^ (i64 - f64) -i32 ^ --0.5 +i32 ^ (0.5 + 1) +i32 ^ (1 - i) +i32 ^ (i + 1) +i32 ^ (i / f64) +i32 ^ (i32 + 0.5) +i32 ^ (i32 - f32) +i32 ^ (i64 + i) i32 ^ -0.5 +i32 ^ -1 i32 ^ -f64 +i32 ^ -i i32 ^ -i32 -i32 ^ 0.5 ** i -i32 ^ 0.5 + i32 -i32 ^ 0.5 - i -i32 ^ 0.5 < i +i32 ^ -i64 +i32 ^ 0.5 != f32 +i32 ^ 0.5 != f64 +i32 ^ 0.5 * i +i32 ^ 0.5 ** i64 +i32 ^ 0.5 - f32 +i32 ^ 0.5 / i32 i32 ^ 0.5 == i64 -i32 ^ abs(1) +i32 ^ 0.5 >= f64 +i32 ^ 1 ** i32 +i32 ^ 1 + i32 +i32 ^ 1 - f64 +i32 ^ 1 < f64 +i32 ^ 1 ^ (1 + i64) +i32 ^ 1 ^ f32 +i32 ^ array[i64] i32 ^ f32 -i32 ^ f32 * i64 -i32 ^ f32 ** 0.5 -i32 ^ f32 ** i -i32 ^ f32 < 0.5 * i -i32 ^ f32 ^ i +i32 ^ f32 / bitnot(1) +i32 ^ f32 >= max(f64) i32 ^ f64 -i32 ^ f64 ^ 1 -i32 ^ float(f32) -i32 ^ half(0.5) -i32 ^ half(f64) +i32 ^ f64 + i +i32 ^ find(array, true) +i32 ^ first(array) +i32 ^ float(i64) i32 ^ i -i32 ^ i + i32 -i32 ^ i - f32 +i32 ^ i * f64 +i32 ^ i + i64 i32 ^ i <= f32 -i32 ^ i ^ 1 i32 ^ i32 -i32 ^ i32 ** f32 -i32 ^ i32 ** f64 -i32 ^ i32 + i32 -i32 ^ i32 + i64 -i32 ^ i32 <= i64 +i32 ^ i32 * f64 +i32 ^ i32 ** i i32 ^ i64 -i32 ^ i64 - f32 -i32 ^ max(0.5) -i32 ^ max(1) -i32 ^ max(i) -i32 ^ min(f32) -i32 ^ score(1) +i32 ^ i64 == f64 +i32 ^ i64 > -f64 +i32 ^ len(list) +i32 ^ mean(array) +i32 ^ min(i) +i32 ^ reduce(array, #) +i32 ^ reduce(list, 1) +i32 in [0.5] i32 in array +i32 in array || ok +i32 in groupBy(array, #) +i32 in groupBy(array, f32) +i32 in groupBy(list, #) +i32 in groupBy(list, #?.Bar) +i32 in groupBy(list, foo).i +i32 in i32 .. 1 +i32 in i32 .. i64 i32 in map(array, #) +i32 in map(list, 0.5) +i32 in map(list, i32) +i32 not in 1 .. i i32 not in array -i32 not in array ? score : score -i32 not in map(array, #) -i32 not in map(array, 1) +i32 not in array ? array : array +i32 not in filter(array, ok) +i32 not in groupBy(list, #) i64 -i64 != -0.5 i64 != -1 -i64 != -f32 -i64 != -f64 i64 != -i -i64 != 0.5 != nil -i64 != 0.5 != ok -i64 != 0.5 != true -i64 != 0.5 * 1 -i64 != 0.5 ? false : i64 -i64 != 0.5 ^ 1 -i64 != 0.5 and f64 == 1 -i64 != 1 || f64 < i -i64 != 1 || ok +i64 != -i64 +i64 != 0.5 && ok +i64 != 0.5 * 0.5 +i64 != 0.5 * i +i64 != 0.5 + 0.5 +i64 != 0.5 + i +i64 != 0.5 - 0.5 +i64 != 0.5 / i64 +i64 != 0.5 ? i : 1 +i64 != 0.5 ^ i32 +i64 != 1 * f64 +i64 != 1 - 1 i64 != abs(f64) +i64 != array[i64] +i64 != bitnot(i32) i64 != f32 -i64 != f32 + f32 -i64 != f32 / f32 -i64 != f32 ? div : 1 -i64 != f32 ? f64 : i64 -i64 != f32 ^ i +i64 != f32 + i64 i64 != f64 -i64 != f64 != false -i64 != f64 - i32 -i64 != f64 / i32 -i64 != f64 / i64 -i64 != f64 ? 0.5 : score -i64 != f64 ? i64 : true -i64 != findLast(array, false) -i64 != first(array) -i64 != float(i32) -i64 != get(array, i64) +i64 != f64 * 1 +i64 != f64 == true +i64 != f64 or i64 <= f32 +i64 != findIndex(array, ok) +i64 != float(1) +i64 != floor(i) +i64 != get(array, i) i64 != half(0.5) -i64 != half(f64) +i64 != half(1) i64 != i -i64 != i == nil -i64 != i ? array : f32 -i64 != i and ok +i64 != i % 1 +i64 != i + 1 +i64 != i / 0.5 +i64 != i ? f32 : true i64 != i32 -i64 != i32 ? 1 : f32 +i64 != i32 ? 0.5 : nil +i64 != i32 ? f64 : greet +i64 != i32 ^ i +i64 != i32 || ok i64 != i64 -i64 != i64 ? true : score -i64 != last(array) -i64 != len("foo") -i64 != min(0.5) +i64 != i64 - 0.5 +i64 != len("bar") +i64 != len(list) +i64 != max(0.5) +i64 != min(1) +i64 != min(1, f32) i64 != min(f32) -i64 != min(f64) -i64 != min(i64) -i64 != nil && ok +i64 != min(i) +i64 != nil != ok +i64 != nil ? div : 1 +i64 != nil ? greet : i +i64 != nil ? i : i +i64 != nil ? i64 : false i64 != score(1) -i64 % -1 +i64 != score(i) i64 % -i -i64 % -i32 -i64 % 1 * i32 -i64 % 1 .. i -i64 % 1 / 0.5 -i64 % 1 / f64 +i64 % 1 % 1 +i64 % 1 * i i64 % 1 < i32 -i64 % 1 <= -i32 -i64 % 1 == 0.5 + 0.5 -i64 % 1 not in array -i64 % abs(i64) -i64 % array[1] -i64 % find(array, true) -i64 % first(array) +i64 % 1 >= f64 +i64 % 1 >= i32 +i64 % abs(i32) +i64 % array[i32] i64 % i -i64 % i .. i32 -i64 % i not in array +i64 % i * i +i64 % i >= i i64 % i32 -i64 % i32 != f64 -i64 % i32 * f32 -i64 % i32 == i -i64 % i32 > f64 ^ i32 +i64 % i32 / f64 +i64 % i32 <= f64 i64 % i64 -i64 % i64 * 1 -i64 % i64 * f32 -i64 % i64 + -i64 -i64 % max(i32) -i64 % min(i) +i64 % i64 % 1 +i64 % i64 .. i64 +i64 % i64 == i64 +i64 % int(i32) +i64 % len("bar") +i64 % max(i) +i64 % min(1) i64 % score(1) -i64 * (0.5 + i64) -i64 * (0.5 - 1) -i64 * (1 + 1) +i64 * (0.5 + f64) +i64 * (1 - i64) +i64 * (f32 - f32) i64 * (f64 + f32) -i64 * (f64 - i) -i64 * (i - 1) -i64 * (i64 + 0.5) -i64 * --f64 +i64 * (i + 0.5) +i64 * (i + f64) +i64 * (i32 + f64) i64 * -0.5 i64 * -1 i64 * -f32 -i64 * -f64 -i64 * 0.5 != f64 +i64 * -i32 i64 * 0.5 * i32 +i64 * 0.5 ** 0.5 i64 * 0.5 - f32 -i64 * 0.5 < f32 -i64 * 0.5 == min(i64) +i64 * 0.5 / 1 i64 * 0.5 >= f32 -i64 * 0.5 ^ i -i64 * 1 * 1 +i64 * 1 % 1 +i64 * 1 * 0.5 +i64 * 1 * f64 +i64 * 1 ** 1 +i64 * 1 - i64 i64 * 1 .. i32 -i64 * 1 <= i64 -i64 * 1 == i32 -i64 * 1 >= i32 -i64 * array[i32] +i64 * 1 / i64 +i64 * 1 <= f64 +i64 * 1 == 0.5 != true +i64 * 1 == f32 +i64 * 1 > 1 - i64 +i64 * 1 > f64 +i64 * 1 ^ i32 +i64 * add(1, 1) +i64 * ceil(1) +i64 * ceil(i) +i64 * ceil(i64) +i64 * count(array, false) i64 * f32 -i64 * f32 - f32 -i64 * f32 / f64 -i64 * f32 >= i64 -i64 * f32 ^ i -i64 * f32 ^ i32 +i64 * f32 * f32 +i64 * f32 ** 1 +i64 * f32 / f32 +i64 * f32 / i +i64 * f32 / i32 +i64 * f32 not in array i64 * f64 -i64 * f64 * i32 -i64 * f64 ^ f64 +i64 * f64 + i32 +i64 * f64 - f64 +i64 * f64 / f64 +i64 * f64 < f64 +i64 * f64 > f64 +i64 * f64 ^ i32 +i64 * findIndex(array, ok) +i64 * float(i) i64 * float(i64) -i64 * get(array, i64) -i64 * half(f64) +i64 * half(0.5) i64 * i -i64 * i * i64 -i64 * i == i32 -i64 * i ^ i64 +i64 * i - -f64 +i64 * i <= f64 i64 * i32 -i64 * i32 ** f32 -i64 * i32 >= f64 -i64 * i32 >= i64 -i64 * i32 ^ 1 +i64 * i32 != i32 +i64 * i32 * 1 +i64 * i32 * i +i64 * i32 / 0.5 +i64 * i32 ^ i i64 * i64 -i64 * i64 ** 1 -i64 * i64 ** f32 -i64 * i64 - f64 -i64 * i64 in array +i64 * i64 % i64 +i64 * i64 * i64 +i64 * i64 ** i +i64 * i64 / f32 +i64 * i64 > i32 i64 * int(1) -i64 * min(f32, 0.5) +i64 * int(i) +i64 * max(1) +i64 * max(i64) +i64 * min(1) +i64 * min(i32) +i64 * reduce(array, #) +i64 * reduce(list, 0.5) +i64 * reduce(list, 1) +i64 * round(i) i64 * score(1) -i64 ** (0.5 * i64) -i64 ** (0.5 + 1) -i64 ** (1 % i) -i64 ** (f64 / i) -i64 ** (i * 0.5) -i64 ** (i - i) -i64 ** (i32 + i) +i64 ** (0.5 + 0.5) +i64 ** (0.5 / 1) +i64 ** (1 % 1) +i64 ** (1 * 1) +i64 ** (1 - f32) +i64 ** (f32 + 1) +i64 ** (f32 / 0.5) +i64 ** (f64 - 0.5) +i64 ** (i * i64) +i64 ** (i / 1) +i64 ** (i64 % i) +i64 ** (i64 / i) +i64 ** -0.5 i64 ** -1 -i64 ** -i -i64 ** -i32 -i64 ** 0.5 * f64 -i64 ** 0.5 + f32 -i64 ** 0.5 + f32 - 1 -i64 ** 0.5 - i -i64 ** 0.5 ^ 1 -i64 ** 0.5 ^ f32 -i64 ** 1 != i -i64 ** 1 ** f32 -i64 ** 1 ** float(1) -i64 ** 1 / f64 -i64 ** 1 / i -i64 ** 1 == i64 -i64 ** 1 ^ i64 -i64 ** abs(f32) -i64 ** abs(i64) +i64 ** -f32 +i64 ** 0.5 != i32 +i64 ** 0.5 <= f32 +i64 ** 0.5 <= i +i64 ** 1 + i32 +i64 ** 1 - f32 +i64 ** 1 / i64 +i64 ** 1 >= f32 +i64 ** bitnot(i32) +i64 ** ceil(i32) +i64 ** count(array, false) i64 ** f32 -i64 ** f32 != f64 -i64 ** f32 != i64 -i64 ** f32 ** i32 -i64 ** f32 / i64 / 1 -i64 ** f32 <= i64 -i64 ** f32 > f32 +i64 ** f32 * min(0.5) i64 ** f64 -i64 ** f64 / i -i64 ** f64 <= f32 -i64 ** f64 > f64 -i64 ** f64 >= f64 -i64 ** f64 >= i32 -i64 ** float(1) -i64 ** half(0.5) +i64 ** f64 ** f64 +i64 ** f64 not in array +i64 ** f64 not in array ? f32 : greet +i64 ** floor(f32) +i64 ** half(1) i64 ** i +i64 ** i != f32 +i64 ** i * f32 +i64 ** i <= -i +i64 ** i == f64 +i64 ** i ^ f32 i64 ** i32 -i64 ** i32 != f32 -i64 ** i32 <= f64 -i64 ** i32 <= min(0.5) +i64 ** i32 != i64 +i64 ** i32 * i ^ i +i64 ** i32 not in array i64 ** i64 -i64 ** i64 / f64 -i64 ** i64 >= f64 -i64 ** int(0.5) -i64 ** int(f64) -i64 ** len("foo") +i64 ** i64 - i64 +i64 ** i64 in array +i64 ** max(1) i64 ** min(0.5) -i64 ** score(1) -i64 + -(f32 / i) -i64 + -0.5 -i64 + -f32 -i64 + -f64 +i64 ** min(1) +i64 ** min(i32, 1) +i64 ** reduce(array, #) +i64 + -1 i64 + -i i64 + -i64 -i64 + 0.5 * i -i64 + 0.5 ** 1 -i64 + 0.5 + 1 +i64 + 0.5 ** f32 i64 + 0.5 + i32 -i64 + 1 % i -i64 + 1 ** i -i64 + 1 + i32 -i64 + 1 - f64 -i64 + 1 - i32 -i64 + 1 .. i -i64 + 1 < i32 -i64 + 1 < i64 -i64 + 1 <= i -i64 + 1 == i -i64 + abs(1) +i64 + 0.5 + i64 +i64 + 0.5 - f64 +i64 + 0.5 <= bitnand(1, 1) +i64 + 0.5 <= f64 +i64 + 0.5 == f32 +i64 + 1 != f64 +i64 + 1 % i64 +i64 + 1 + f64 +i64 + 1 <= f32 +i64 + array[i64] +i64 + array[i] i64 + f32 -i64 + f32 ** 1 -i64 + f32 >= f64 +i64 + f32 * f64 +i64 + f32 / i64 i64 + f64 -i64 + f64 != f32 -i64 + f64 + i -i64 + f64 <= f32 -i64 + f64 == i32 -i64 + findIndex(list, ok) -i64 + first(array) -i64 + get(array, i32) +i64 + f64 * 0.5 +i64 + f64 ** 0.5 +i64 + f64 > f32 +i64 + float(f32) +i64 + float(i32) i64 + half(0.5) -i64 + half(f64) i64 + i -i64 + i + i -i64 + i - f64 -i64 + i / 1 +i64 + i % 1 +i64 + i * 0.5 +i64 + i + f32 +i64 + i - i32 +i64 + i / i32 +i64 + i == 0.5 - i32 +i64 + i ^ f32 +i64 + i ^ f64 i64 + i32 -i64 + i32 * 1 -i64 + i32 * i -i64 + i32 < f64 -i64 + i32 >= f32 -i64 + i32 in array +i64 + i32 % i64 +i64 + i32 - 0.5 +i64 + i32 == f64 i64 + i64 -i64 + i64 % i64 -i64 + i64 ** f32 -i64 + i64 + 0.5 -i64 + i64 - int(f64) -i64 + i64 ^ i -i64 + max(f32) -i64 + min(0.5) -i64 + min(1) -i64 + min(f32) -i64 + min(i32) +i64 + i64 - 0.5 +i64 + reduce(array, #) i64 + score(i) i64 - -1 i64 - -f32 i64 - -i32 i64 - -i64 -i64 - 0.5 != i32 -i64 - 0.5 * 1 i64 - 0.5 + f32 -i64 - 0.5 + f64 -i64 - 0.5 / f64 -i64 - 0.5 == -0.5 -i64 - 0.5 ^ i32 -i64 - 1 - 0.5 -i64 - 1 - f32 -i64 - 1 - i32 +i64 - 0.5 / i64 +i64 - 0.5 <= i +i64 - 0.5 ^ f32 +i64 - 1 ** 1 +i64 - 1 < i i64 - 1 == i32 -i64 - 1 >= f64 +i64 - 1 > f32 i64 - 1 >= i -i64 - abs(1) -i64 - abs(i32) -i64 - array[i64] +i64 - 1 not in array +i64 - ceil(1) i64 - f32 -i64 - f32 != score(i) -i64 - f32 * i32 +i64 - f32 != f32 i64 - f32 - 1 -i64 - f32 <= f64 -i64 - f32 ^ f32 +i64 - f32 - i +i64 - f32 / 1 +i64 - f32 < i64 +i64 - f32 >= f64 i64 - f64 -i64 - f64 ** 0.5 +i64 - f64 != i +i64 - f64 ** f32 +i64 - f64 ** i32 +i64 - f64 + f32 +i64 - f64 + i32 +i64 - f64 >= f64 i64 - float(0.5) -i64 - float(f32) -i64 - float(i) +i64 - half(1) +i64 - half(f64) i64 - i -i64 - i != i32 -i64 - i * i64 -i64 - i + i32 -i64 - i - i64 -i64 - i > f64 - 0.5 -i64 - i >= i +i64 - i * 1 +i64 - i + i64 +i64 - i - 1 +i64 - i .. i64 +i64 - i < i32 +i64 - i > 1 - 0.5 +i64 - i >= f64 i64 - i ^ i64 +i64 - i not in array i64 - i32 -i64 - i32 % i32 -i64 - i32 + i32 -i64 - i32 <= i +i64 - i32 - i64 +i64 - i32 .. i64 +i64 - i32 > i +i64 - i32 >= i i64 - i64 -i64 - i64 + i32 -i64 - i64 .. i64 -i64 - i64 / i32 -i64 - max(f64) -i64 - min(1, 0.5) +i64 - i64 > f32 +i64 - int(i) +i64 - len("foo") +i64 - max(0.5) +i64 - min(f32) +i64 - min(f64) +i64 - min(i) +i64 - reduce(array, #) +i64 - reduce(array, i64) +i64 - round(1) i64 - score(1) +i64 - score(i) i64 .. -1 +i64 .. -i +i64 .. -i32 i64 .. -i64 -i64 .. 1 == list -i64 .. findIndex(list, ok) +i64 .. 1 * i64 +i64 .. 1 - 1 +i64 .. 1 - i +i64 .. 1 - i64 +i64 .. abs(i) +i64 .. bitnot(i32) +i64 .. count(array, false) i64 .. get(array, 1) i64 .. i +i64 .. i * i +i64 .. i + 1 +i64 .. i == list i64 .. i32 -i64 .. i32 * i +i64 .. i32 * 1 i64 .. i64 -i64 .. i64 + 1 +i64 .. i64 * i32 +i64 .. i64 + i +i64 .. i64 - i +i64 .. int(0.5) i64 .. int(f32) -i64 .. int(i32) -i64 .. last(array) -i64 .. len(list) +i64 .. int(i64) +i64 .. min(i32) +i64 .. min(i64, 0.5) +i64 .. reduce(array, #) i64 .. score(1) -i64 / (0.5 + f64) -i64 / (1 - 0.5) -i64 / (i32 - 1) +i64 / (f32 + i64) +i64 / (f32 - i) +i64 / (i + 1) +i64 / (i32 + 0.5) +i64 / (i64 - i) i64 / -0.5 i64 / -1 i64 / -f32 i64 / -f64 i64 / -i -i64 / -i64 -i64 / 0.5 < f64 -i64 / 0.5 == f32 -i64 / 0.5 ^ f64 -i64 / 1 ** 1 -i64 / 1 - f32 -i64 / 1 - min(0.5) -i64 / 1 / 0.5 -i64 / abs(i64) -i64 / array[i] +i64 / 0.5 * f64 +i64 / 0.5 - i64 +i64 / 0.5 / i +i64 / 0.5 == i +i64 / 1 ** i64 +i64 / 1 / i32 +i64 / 1 / i64 +i64 / 1 < i +i64 / 1 == f32 +i64 / ceil(i) i64 / f32 -i64 / f32 ** i -i64 / f32 <= i +i64 / f32 - i +i64 / f32 / i64 +i64 / f32 > i +i64 / f32 ^ 1 +i64 / f32 ^ i i64 / f64 -i64 / f64 * 1 -i64 / f64 ** 0.5 -i64 / f64 ** f64 -i64 / f64 + i32 -i64 / f64 <= f32 -i64 / f64 <= i64 -i64 / float(f32) -i64 / float(f64) -i64 / float(i) -i64 / float(i64) -i64 / half(0.5) -i64 / half(f64) +i64 / f64 * i64 +i64 / f64 - min(i64) +i64 / f64 / f32 +i64 / f64 / i * 0.5 +i64 / f64 / i32 +i64 / f64 in array +i64 / float(1) +i64 / get(array, i32) +i64 / half(1) i64 / i -i64 / i != i64 -i64 / i * 0.5 -i64 / i * f32 -i64 / i - i32 -i64 / i ^ i64 +i64 / i * i64 +i64 / i - f64 i64 / i32 -i64 / i32 * i +i64 / i32 != f32 +i64 / i32 * f64 +i64 / i32 == f64 +i64 / i32 > 1 + 1 +i64 / i32 >= f32 +i64 / i32 >= f64 +i64 / i32 ^ f32 i64 / i64 -i64 / i64 ** f32 -i64 / i64 - f64 -i64 / i64 / i64 -i64 / i64 < f32 -i64 / int(0.5) -i64 / min(f32) +i64 / i64 + f64 +i64 / i64 < i32 +i64 / i64 <= f32 +i64 / i64 == i32 +i64 / int(1) +i64 / len(list) +i64 / max(1) +i64 / reduce(array, #) +i64 / reduce(array, 1) +i64 / round(0.5) +i64 / round(i) i64 / score(1) +i64 / score(i) +i64 < -0.5 i64 < -1 +i64 < -f32 +i64 < -f64 +i64 < -i i64 < -i32 i64 < -i64 -i64 < 1 != true -i64 < 1 * f64 +i64 < 0.5 * 0.5 +i64 < 0.5 + i +i64 < 0.5 - 1 +i64 < 0.5 / 0.5 +i64 < 0.5 / 1 +i64 < 0.5 == ok +i64 < 0.5 || false ? 1 : nil +i64 < 1 * i32 +i64 < 1 ** 0.5 +i64 < 1 + 0.5 i64 < 1 + i64 -i64 < 1 / i32 -i64 < 1 ? half : ok -i64 < 1 ^ f64 -i64 < abs(f32) -i64 < array[1] +i64 < 1 / f32 +i64 < ceil(i64) i64 < f32 -i64 < f32 * i32 -i64 < f32 ? "bar" : ok -i64 < f32 ^ 0.5 +i64 < f32 * 0.5 +i64 < f32 - i64 +i64 < f32 ^ f32 i64 < f64 -i64 < f64 + f64 -i64 < f64 - f32 -i64 < f64 - i -i64 < f64 ? i64 : score -i64 < f64 or ok -i64 < float(f64) -i64 < half(0.5) +i64 < f64 && ok +i64 < f64 - f64 +i64 < f64 ? score : add +i64 < float(0.5) +i64 < float(i32) +i64 < floor(0.5) +i64 < floor(i32) +i64 < half(1) i64 < i -i64 < i != false +i64 < i % i64 +i64 < i ^ 0.5 +i64 < i || ok i64 < i32 -i64 < i32 * 1 -i64 < i32 + i64 -i64 < i32 - 0.5 -i64 < i32 - f32 -i64 < i32 ? greet : 1 -i64 < i32 ? nil : array -i64 < i32 ? true : "bar" +i64 < i32 + 1 +i64 < i32 + i32 +i64 < i32 / f32 +i64 < i32 ? foo : i i64 < i64 -i64 < i64 + 1 -i64 < i64 ? f32 : foo -i64 < i64 ? half : i -i64 < int(i64) -i64 < max(0.5) -i64 < min(0.5) -i64 < min(i) -i64 < score(1) -i64 < score(1) * i64 +i64 < i64 != nil +i64 < i64 * 1 +i64 < i64 * i64 +i64 < i64 / f32 +i64 < i64 / i +i64 < i64 ^ 1 +i64 < i64 ^ i +i64 < int(f64) +i64 < len("bar") +i64 < len("foo") +i64 <= -0.5 i64 <= -1 i64 <= -f32 -i64 <= -i -i64 <= -i32 +i64 <= -f64 i64 <= -i64 -i64 <= 0.5 != true -i64 <= 0.5 + i -i64 <= 0.5 - 1 -i64 <= 0.5 == nil -i64 <= 0.5 ? 0.5 : "foo" -i64 <= 1 != true -i64 <= 1 ** f64 +i64 <= 0.5 && ok +i64 <= 0.5 * 0.5 +i64 <= 0.5 + 1 +i64 <= 0.5 ? i : i32 +i64 <= 1 ** i32 +i64 <= 1 + 1 +i64 <= 1 - 0.5 +i64 <= 1 - 1 +i64 <= 1 / 1 i64 <= 1 == ok -i64 <= 1 ? array : ok -i64 <= 1 and ok -i64 <= array[i32] +i64 <= 1 ? add : div +i64 <= 1 ? f32 : greet +i64 <= 1 ? i64 : true +i64 <= 1 ^ 1 +i64 <= array[i64] +i64 <= array[i] +i64 <= bitnot(1) i64 <= f32 -i64 <= f32 && ok -i64 <= f32 + 1 -i64 <= f32 / f32 -i64 <= f32 ^ i32 +i64 <= f32 ** i +i64 <= f32 ** i64 +i64 <= f32 == ok i64 <= f64 i64 <= f64 + 1 -i64 <= f64 - f32 -i64 <= half(0.5) +i64 <= f64 + f32 +i64 <= f64 / 1 +i64 <= f64 ? nil : i32 +i64 <= float(1) +i64 <= floor(i) +i64 <= floor(i32) +i64 <= half(min(0.5, 1, i64)) i64 <= i -i64 <= i != true i64 <= i * 1 -i64 <= i + 1 -i64 <= i / i64 -i64 <= i ? i32 : list -i64 <= i ^ 0.5 +i64 <= i * f32 +i64 <= i ** i32 +i64 <= i ? greet : add i64 <= i32 -i64 <= i32 && ok -i64 <= i32 ? f64 : i < 1 +i64 <= i32 ** i32 +i64 <= i32 ? list : half +i64 <= i32 ^ -1 i64 <= i64 -i64 <= i64 - 0.5 -i64 <= i64 ? greet : div -i64 <= int(i64) -i64 <= last(array) +i64 <= i64 * i +i64 <= len(list) +i64 <= max(f32) i64 <= min(0.5) -i64 <= min(f64) -i64 <= score(1) -i64 <= score(i) -i64 == -0.5 +i64 <= min(i32) +i64 <= reduce(array, i32) +i64 <= reduce(list, i64) +i64 <= round(0.5) i64 == -1 +i64 == -f32 i64 == -f64 i64 == -i +i64 == -i32 +i64 == 0.5 * 1 +i64 == 0.5 - f64 i64 == 0.5 == ok -i64 == 0.5 ? 1 : list -i64 == 0.5 ? div : i64 -i64 == 0.5 ? foo : f32 -i64 == 0.5 ^ 0.5 -i64 == 0.5 ^ i -i64 == 1 % i64 -i64 == 1 && ok +i64 == 0.5 ? 0.5 : f64 i64 == 1 ** f64 -i64 == 1 + f32 -i64 == 1 - f64 -i64 == abs(0.5) -i64 == abs(i32) -i64 == count(array, true) -i64 == count(list, true) +i64 == 1 + 0.5 +i64 == 1 / i +i64 == 1 == ok +i64 == 1 ? "foo" : i +i64 == array[1] +i64 == bitnot(i64) +i64 == ceil(i64) i64 == f32 +i64 == f32 != true +i64 == f32 + i +i64 == f32 - f32 +i64 == f32 == ok i64 == f64 -i64 == f64 != ok -i64 == f64 != true -i64 == f64 - i -i64 == f64 ? f64 : add -i64 == findIndex(array, false) +i64 == f64 * f64 +i64 == f64 ? 1 : nil +i64 == f64 ^ 0.5 +i64 == f64 ^ f32 +i64 == f64 and not true +i64 == findIndex(list, f64 <= f64) +i64 == floor(0.5) +i64 == get(array, 1) +i64 == half(1) i64 == i -i64 == i * f32 -i64 == i == false -i64 == i == ok -i64 == i ^ 1 +i64 == i != nil +i64 == i + i32 +i64 == i ? i64 : foo i64 == i32 -i64 == i32 ** 0.5 -i64 == i32 / f64 i64 == i64 -i64 == i64 ^ 0.5 +i64 == i64 * f32 +i64 == i64 / i64 +i64 == i64 ? add : 0.5 +i64 == i64 ? add : greet +i64 == int(0.5) i64 == int(1) -i64 == int(f32) -i64 == last(array) -i64 == max(0.5) -i64 == nil ? true : ok +i64 == int(i) +i64 == len("foo") +i64 == nil != nil +i64 == reduce(array, #) i64 == score(1) -i64 == score(i) i64 > -0.5 -i64 > -1 i64 > -f32 i64 > -f64 -i64 > -i -i64 > -i32 -i64 > -i64 -i64 > 0.5 * 1 -i64 > 0.5 ** 0.5 -i64 > 0.5 == true -i64 > 0.5 ? f64 : greet -i64 > 0.5 ? foo : add -i64 > 1 ** 0.5 -i64 > 1 - 0.5 -i64 > 1 ? false : array -i64 > 1 ? half : i64 -i64 > abs(1) -i64 > abs(f64) -i64 > array[i64] +i64 > 0.5 + f32 +i64 > 0.5 - f64 +i64 > 0.5 - i32 +i64 > 0.5 ? array : 1 +i64 > 0.5 ? f32 : nil +i64 > 0.5 ? ok : nil +i64 > 0.5 ? score : foo +i64 > 0.5 or ok +i64 > 1 != true +i64 > 1 ** 1 +i64 > 1 == false +i64 > 1 ? nil : 1 +i64 > 1 ^ f32 +i64 > 1 ^ i32 i64 > f32 -i64 > f32 - 1 -i64 > f32 ? div : false +i64 > f32 * 0.5 +i64 > f32 + f64 +i64 > f32 / f32 +i64 > f32 ? "foo" : greet +i64 > f32 ? 1 : i32 i64 > f64 -i64 > f64 == nil -i64 > f64 and 1 > i64 +i64 > f64 * i +i64 > f64 - 0.5 +i64 > f64 - f32 i64 > first(array) -i64 > float(f32) -i64 > half(f64) +i64 > half(0.5) i64 > i -i64 > i % i32 -i64 > i * f64 -i64 > i ** 1 -i64 > i + i -i64 > i + i32 -i64 > i ^ i32 +i64 > i != nil +i64 > i == true i64 > i32 -i64 > i32 && ok -i64 > i32 ** 0.5 -i64 > i32 ** i +i64 > i32 ? div : f32 +i64 > i32 ^ f32 i64 > i64 -i64 > i64 % i32 -i64 > i64 - i64 -i64 > int(f32) -i64 > int(i32) -i64 > int(i64) +i64 > i64 - i +i64 > i64 - i32 +i64 > i64 / f64 +i64 > i64 == false +i64 > len(list) +i64 > max(0.5) +i64 > min(1) +i64 > min(i32) +i64 > reduce(array, #) +i64 > reduce(array, 1) +i64 > round(0.5) +i64 > round(i32) i64 > score(i) i64 >= -0.5 i64 >= -1 -i64 >= -f64 i64 >= -i -i64 >= 0.5 * f64 -i64 >= 0.5 ** f32 -i64 >= 0.5 + f32 +i64 >= -i64 +i64 >= 0.5 / i i64 >= 0.5 == nil -i64 >= 0.5 == true -i64 >= 0.5 ? array : array -i64 >= 0.5 ? i32 : nil -i64 >= 0.5 ^ 0.5 -i64 >= 0.5 and f32 != nil -i64 >= 1 + f64 -i64 >= 1 + i32 -i64 >= 1 ? i : false -i64 >= 1 ? i : string(array) -i64 >= 1 ? true : i +i64 >= 0.5 ? 0.5 : f64 +i64 >= 0.5 ^ i +i64 >= 1 % i64 +i64 >= 1 * f64 +i64 >= 1 * i64 +i64 >= abs(i64) +i64 >= array[i32] +i64 >= bitnot(1) i64 >= f32 -i64 >= f32 * f32 -i64 >= f32 ** f64 -i64 >= f32 ** i32 -i64 >= f32 / f64 +i64 >= f32 + f32 +i64 >= f32 - f32 +i64 >= f32 ? array : i +i64 >= f32 ? f32 : i32 +i64 >= f32 ? list : f32 i64 >= f64 -i64 >= f64 + i -i64 >= f64 / i64 -i64 >= f64 == ok -i64 >= f64 and ok -i64 >= find(array, ok) +i64 >= f64 + 0.5 +i64 >= first(array) +i64 >= float(0.5) i64 >= float(f32) -i64 >= float(i) -i64 >= float(i32) +i64 >= floor(1) +i64 >= floor(i64) i64 >= half(0.5) +i64 >= half(half(f64)) i64 >= i -i64 >= i and ok +i64 >= i / 0.5 +i64 >= i ? true : i32 i64 >= i32 -i64 >= i32 % i64 +i64 >= i32 * i +i64 >= i32 / f32 +i64 >= i32 == false +i64 >= i32 || f64 == 1 i64 >= i64 -i64 >= i64 % i -i64 >= i64 && i64 > f32 -i64 >= i64 / i32 -i64 >= i64 == nil -i64 >= i64 in {"foo": f64}.half -i64 >= max(f64) +i64 >= i64 + 1 +i64 >= i64 ? foo : foo +i64 >= i64 or ok +i64 >= int(f64) +i64 >= last(array) i64 >= max(i64) -i64 >= min(f32) +i64 >= min(1) +i64 >= min(f64) +i64 >= round(1) +i64 >= round(i) i64 >= score(1) -i64 ^ (0.5 + 1) -i64 ^ (0.5 / i32) -i64 ^ (1 * f32) -i64 ^ (1 / i) -i64 ^ (1 / i64) -i64 ^ (f32 + f32) -i64 ^ (f32 - f32) -i64 ^ (f64 * f32) -i64 ^ (i % i32) -i64 ^ (i - 0.5) -i64 ^ (i32 - f32) -i64 ^ (i64 + i32) -i64 ^ (i64 / f64) +i64 ^ (0.5 * i32) +i64 ^ (0.5 / i64) +i64 ^ (1 * f64) +i64 ^ (1 - i) +i64 ^ (f32 / 1) +i64 ^ (i % i) +i64 ^ (i32 * f64) +i64 ^ (i32 - f64) +i64 ^ (i64 + 0.5) +i64 ^ (i64 + 1) +i64 ^ (i64 - f32) i64 ^ -0.5 -i64 ^ -i32 -i64 ^ 0.5 ** f32 -i64 ^ 0.5 <= i -i64 ^ 0.5 >= f32 -i64 ^ 0.5 >= f64 -i64 ^ 0.5 >= i64 -i64 ^ 0.5 ^ 0.5 -i64 ^ 1 != i -i64 ^ 1 != i32 +i64 ^ -1 +i64 ^ -f32 +i64 ^ -i64 +i64 ^ 0.5 != i64 +i64 ^ 0.5 ** 0.5 +i64 ^ 0.5 / f32 +i64 ^ 0.5 <= i64 +i64 ^ 0.5 == i +i64 ^ 0.5 ^ f32 +i64 ^ 0.5 ^ i64 +i64 ^ 1 * i64 +i64 ^ 1 * round(0.5) +i64 ^ 1 ** f64 i64 ^ 1 ** i32 -i64 ^ 1 + f32 -i64 ^ 1 < f32 -i64 ^ 1 <= i +i64 ^ 1 - f32 +i64 ^ 1 < f64 +i64 ^ 1 >= f32 +i64 ^ 1 >= half(1) +i64 ^ 1 ^ f32 +i64 ^ 1 ^ i32 i64 ^ abs(1) -i64 ^ abs(i) -i64 ^ array[i64] +i64 ^ array[i] i64 ^ f32 -i64 ^ f32 - f32 +i64 ^ f32 * i32 +i64 ^ f32 ** f64 +i64 ^ f32 - f64 +i64 ^ f32 / i - i32 +i64 ^ f32 < f32 +i64 ^ f32 <= i64 +i64 ^ f32 ^ 1 i64 ^ f64 -i64 ^ f64 * i32 -i64 ^ f64 ** i -i64 ^ f64 + f32 -i64 ^ f64 < f32 -i64 ^ f64 == i64 -i64 ^ f64 > 1 + i64 +i64 ^ f64 * i +i64 ^ f64 ** 1 +i64 ^ f64 > i64 i64 ^ f64 ^ f32 -i64 ^ get(array, i) -i64 ^ half(f64) +i64 ^ float(i32) +i64 ^ floor(i32) +i64 ^ floor(i64) +i64 ^ half(0.5) +i64 ^ half(1) i64 ^ i -i64 ^ i ** f32 -i64 ^ i ** i64 +i64 ^ i * i +i64 ^ i ** i32 +i64 ^ i + i % 1 +i64 ^ i + i64 +i64 ^ i - f32 ^ 1 +i64 ^ i - f64 +i64 ^ i / i +i64 ^ i < f32 +i64 ^ i ^ i32 i64 ^ i32 -i64 ^ i32 != f32 -i64 ^ i32 != i32 -i64 ^ i32 ** i -i64 ^ i32 + f32 -i64 ^ i32 + f64 -i64 ^ i32 / f32 +i64 ^ i32 * i +i64 ^ i32 + i32 +i64 ^ i32 + i64 i64 ^ i64 -i64 ^ i64 * f64 i64 ^ i64 * i64 -i64 ^ i64 ** f64 -i64 ^ i64 ^ f32 -i64 ^ i64 ^ f64 -i64 ^ i64 ^ i -i64 ^ int(i64) -i64 ^ last(array) -i64 ^ len(array) +i64 ^ i64 + i +i64 ^ i64 == i64 +i64 ^ i64 ^ 1 +i64 ^ i64 in array +i64 ^ int(1) i64 ^ max(0.5) -i64 ^ max(1) -i64 ^ max(f32) +i64 ^ reduce(array, #) +i64 ^ round(i64) i64 ^ score(1) -i64 ^ score(1, 1) -i64 ^ score(i) i64 in array -i64 in array == nil -i64 in array ? false : greet +i64 in array == ok +i64 in groupBy(array, 0.5) +i64 in groupBy(array, foo) +i64 in groupBy(list, "bar") +i64 in groupBy(list, i) +i64 in i64 .. i32 i64 in map(array, #) +i64 in map(list, 1) +i64 in map(list, i) +i64 not in 1 .. i i64 not in array -indexOf("bar", "bar") + i64 -indexOf(foo.Bar, string(i32)) -int(-(i * 0.5)) +i64 not in array ? f32 : i32 +i64 not in array ? ok : f32 +i64 not in map(array, #) +i64 not in map(list, 0.5) int(-0.5) int(-1) -int(-abs(f64)) int(-f32) int(-f64) int(-i) int(-i32) -int(-i32) != i int(-i64) int(0.5 * 0.5) -int(0.5 * 1) int(0.5 * f32) -int(0.5 * i) +int(0.5 * f64) int(0.5 * i32) -int(0.5 * i64) int(0.5 ** 0.5) int(0.5 ** 1) int(0.5 ** f32) int(0.5 ** f64) -int(0.5 ** i64) -int(0.5 + f32) +int(0.5 ** i32) +int(0.5 + 0.5) +int(0.5 + 1) int(0.5 + f64) -int(0.5 + i) int(0.5 + i32) -int(0.5 - 0.5) +int(0.5 + i64) int(0.5 - f32) +int(0.5 - i) int(0.5 - i32) -int(0.5 / 0.5) -int(0.5 / 1) -int(0.5 / f32) -int(0.5 / f64) -int(0.5 / i32) +int(0.5 - i64) +int(0.5 / i) int(0.5 / i64) -int(0.5 ^ 0.5) -int(0.5 ^ 1) -int(0.5 ^ f32) int(0.5 ^ i) -int(0.5) ** i64 -int(0.5) ** int(i64) -int(0.5) + f32 -int(0.5) + f64 -int(0.5) + i64 -int(0.5) - i -int(0.5) - i64 -int(0.5) .. i32 -int(0.5) < int(f64) +int(0.5 ^ i64) +int(0.5) * -i +int(0.5) ** f64 +int(0.5) ** i32 +int(0.5) + i +int(0.5) / i32 +int(0.5) < 0.5 * f64 +int(0.5) <= i +int(0.5) <= i32 int(0.5) == f32 -int(0.5) == i -int(0.5) > -1 -int(0.5) >= i - i64 +int(0.5) > -i64 +int(0.5) > i +int(0.5) >= f32 +int(0.5) >= i32 +int(0.5) >= max(0.5) int(0.5) ^ i32 -int(0.5) ^ i64 -int(0.5) in array -int(0.5) not in array -int(1 % 1) int(1 % i) -int(1 % i32) -int(1 * 0.5) int(1 * f32) -int(1 * f64) int(1 * i) -int(1 * i64) -int(1 ** 0.5) -int(1 ** 1) -int(1 ** f32) -int(1 ** i32) -int(1 ** i64) -int(1 + 0.5) +int(1 * i32) +int(1 ** i) int(1 + 1) +int(1 + f32) int(1 + f64) -int(1 + i) +int(1 + i32) int(1 - 0.5) -int(1 - 1) +int(1 - f32) +int(1 - f64) +int(1 - i32) int(1 - i64) +int(1 / 0.5) int(1 / 1) -int(1 / f64) -int(1 / i32) -int(1 / i64) int(1 ^ 0.5) -int(1 ^ 1) -int(1 ^ i32) int(1 ^ i64) -int(1) * f64 -int(1) * i +int(1) != i64 int(1) ** f32 -int(1) ** i64 -int(1) + 0.5 + 1 +int(1) ** i32 +int(1) + f32 int(1) + i64 -int(1) - f64 -int(1) - i64 -int(1) .. i -int(1) / f32 -int(1) / i +int(1) + reduce(array, #) +int(1) - i int(1) < f64 -int(1) <= f32 -int(1) <= f64 -int(1) == i -int(1) == i64 -int(1) > f64 -int(1) > float(1) -int(1) > i32 -int(1) >= f32 -int(1) >= f64 -int(1) >= half(0.5) -int(1) ^ f32 +int(1) < i64 * 0.5 +int(1) == i32 int(1) ^ f64 -int(1) ^ i -int(1) ^ i32 -int(1) in array int(abs(0.5)) -int(abs(f32)) +int(abs(1)) int(abs(f64)) int(abs(i)) int(abs(i32)) int(abs(i64)) -int(array[1]) -int(array[i32]) +int(add(1, 1)) int(array[i64]) -int(count(list, ok)) -int(div(1, i)) -int(f32 * f32) -int(f32 * i64) +int(bitnot(1)) +int(bitnot(i32)) +int(bitnot(i64)) +int(bitshl(1, i)) +int(bitxor(1, i32) + i) +int(bitxor(i32, i)) +int(ceil(0.5)) +int(ceil(1)) +int(ceil(f32)) +int(ceil(half(1))) +int(ceil(i)) +int(ceil(i32)) +int(count(array, ok)) +int(count(list, false)) +int(f32 * 1) +int(f32 * i) int(f32 ** 0.5) -int(f32 ** f64) -int(f32 ** i32) +int(f32 ** i64) int(f32 + f32) -int(f32 + i64) int(f32 - 0.5) -int(f32 - f32) -int(f32 - i) +int(f32 - i64) +int(f32 / 0.5) +int(f32 / 1) int(f32 / f64) -int(f32 ^ 1) +int(f32 / i32) +int(f32 / i64) int(f32 ^ f32) -int(f32 ^ i) -int(f32 ^ i64) +int(f32 ^ i32) int(f32) -int(f32) != f32 -int(f32) % i -int(f32) * f64 -int(f32) .. i32 -int(f32) / f32 -int(f32) / i -int(f32) == 0.5 != nil -int(f32) == i -int(f32) > i -int(f32) >= i32 -int(f32) ^ i64 -int(f32) in array +int(f32) != i +int(f32) != i64 +int(f32) ** f64 +int(f32) + i32 +int(f32) - f32 +int(f32) < i +int(f32) <= i32 +int(f32) == i ? list : add int(f64 * 0.5) -int(f64 * 1) -int(f64 * f32) -int(f64 * f64) -int(f64 * i32) -int(f64 * i64) -int(f64 ** 0.5) int(f64 ** 1) -int(f64 ** f32) int(f64 ** i) int(f64 ** i32) -int(f64 ** i64) -int(f64 + f32) -int(f64 + i64) +int(f64 + 0.5) +int(f64 + 1) +int(f64 + i) int(f64 - 0.5) -int(f64 - 1) -int(f64 - f64) -int(f64 / 1) -int(f64 / i) +int(f64 - f32) +int(f64 / 0.5) +int(f64 / i64) int(f64 ^ 0.5) int(f64 ^ 1) -int(f64 ^ f32) +int(f64 ^ f64) +int(f64 ^ i64) int(f64) -int(f64) != i32 -int(f64) * i32 -int(f64) ** i64 -int(f64) - i +int(f64) % i64 +int(f64) * f64 +int(f64) + f64 int(f64) < i32 -int(f64) <= i32 -int(f64) == float(i32) -int(f64) ^ i32 -int(f64) ^ i64 -int(f64) not in array -int(false ? add : 0.5) -int(false ? f32 : 0.5) -int(false ? f64 : i32) -int(find(array, true)) -int(findIndex(array, ok)) -int(findIndex(array, true)) -int(findIndex(list, # == foo)) +int(f64) == f32 +int(f64) == f64 +int(f64) > i +int(f64) > i64 +int(false ? 0.5 : 0.5) +int(false ? i : 0.5) int(findIndex(list, ok)) -int(findLastIndex(array, ok)) -int(findLastIndex(array, true)) -int(findLastIndex(list, true)) +int(findLastIndex(list, ok)) int(first(array)) int(float(0.5)) int(float(1)) int(float(f32)) -int(float(f64) ** i64) int(float(f64)) -int(float(i)) +int(float(i32 ** i)) int(float(i32)) -int(float(i64)) -int(get(array, 1)) +int(floor(f64)) +int(floor(i)) +int(floor(i32)) int(get(array, i64)) int(half(0.5)) -int(half(1 / f32)) +int(half(1)) int(half(f64)) int(i % 1) +int(i % i32) int(i % i64) int(i * 0.5) int(i * 1) -int(i * f32) int(i * f64) -int(i ** 0.5) int(i ** f32) int(i ** f64) int(i ** i64) -int(i + 0.5) int(i + f32) -int(i + i32) -int(i + i64) -int(i - f64) +int(i + f64) +int(i + i) +int(i - 0.5) +int(i - f32) +int(i - i32) int(i - i64) -int(i / 1) <= i32 -int(i / f64) +int(i / 0.5) +int(i / 1) int(i / i) -int(i ^ f32) -int(i ^ f64) -int(i ^ i) +int(i / i32) +int(i ^ 0.5) +int(i ^ 1) int(i ^ i32) int(i) -int(i) != i -int(i) + f32 -int(i) + i32 -int(i) - i32 +int(i) != i32 +int(i) * f64 +int(i) * i64 +int(i) - i int(i) .. i64 -int(i) / i -int(i) < f32 -int(i) < f64 -int(i) <= f64 -int(i) == f32 -int(i) > i32 -int(i) > i64 -int(i) > int(i) -int(i) >= i -int(i) ^ i64 -int(i32 % i64) int(i32 * 0.5) int(i32 * 1) -int(i32 * f64) -int(i32 ** i) +int(i32 * i64) +int(i32 ** 0.5) +int(i32 ** 1) int(i32 + 0.5) int(i32 + 1) -int(i32 + f32) -int(i32 - 0.5) +int(i32 + f64) +int(i32 + i64) int(i32 - 1) -int(i32 - f64) int(i32 - i) -int(i32 - i64) int(i32 / 0.5) +int(i32 / 1) int(i32 / f64) int(i32 ^ 0.5) -int(i32 ^ f32) int(i32 ^ f64) -int(i32 ^ i) -int(i32 ^ i64) +int(i32 ^ i32) int(i32) int(i32) != f32 -int(i32) % i64 -int(i32) ** -0.5 -int(i32) + i -int(i32) - f32 -int(i32) .. i32 +int(i32) - i +int(i32) / f32 int(i32) / i -int(i32) / i32 +int(i32) / i64 int(i32) < i64 -int(i32) <= f32 -int(i32) == -i32 -int(i32) == f64 -int(i32) > f64 -int(i64 % i32) -int(i64 * f32) -int(i64 * f64) -int(i64 * i) -int(i64 ** i) -int(i64 + 1) +int(i32) > half(0.5) +int(i64 * 1) +int(i64 ** 0.5) +int(i64 ** f64) +int(i64 ** i64) int(i64 + i) -int(i64 + i64) +int(i64 + i32) +int(i64 - 0.5) int(i64 - f32) -int(i64 - f64) -int(i64 - i32) -int(i64 / f32) -int(i64 / f64) -int(i64 / i) -int(i64 / i64) -int(i64 ^ 0.5) +int(i64 - i) +int(i64 - i64) +int(i64 / 1) int(i64 ^ f64) int(i64 ^ i32) int(i64 ^ i64) int(i64) -int(i64) != f64 -int(i64) != i -int(i64) != nil ? 1 : half -int(i64) % i -int(i64) % i32 -int(i64) ** f64 -int(i64) - i32 +int(i64) != i64 +int(i64) - i64 int(i64) .. i32 +int(i64) / i int(i64) <= i -int(i64) <= i64 -int(i64) == min(i) -int(i64) > f64 -int(i64) > i32 -int(i64) >= f64 -int(i64) ^ f32 -int(i64) ^ i32 -int(i64) in array -int(i64) not in array +int(i64) == f32 +int(i64) > i64 +int(i64) ^ i int(int(0.5)) int(int(1)) -int(int(f32)) int(int(f64)) -int(int(i32)) -int(int(i64)) -int(last(array)) int(len("bar")) int(len(array)) -int(len(list)) int(max(0.5)) +int(max(0.5, i64)) int(max(1)) +int(max(f32)) int(max(f64)) int(max(i)) int(max(i64)) +int(mean(array)) int(min(0.5)) int(min(1)) +int(min(1, i64)) int(min(f32)) -int(min(f32, i32)) -int(min(f64)) -int(min(f64, 1)) int(min(i)) int(min(i32)) int(min(i64)) -int(min(i64, 1)) -int(ok ? 0.5 : i64) -int(ok ? 1 : div) -int(ok ? i32 : add) +int(ok ? i : div) +int(ok ? i : i64) +int(ok ? i64 : list) +int(reduce(array, #)) +int(reduce(array, f32)) +int(reduce(array, i32)) +int(reduce(list, 0.5)) +int(reduce(list, 1)) +int(reduce(list, i64)) +int(round(0.5)) +int(round(1)) +int(round(f32)) +int(round(f64)) +int(round(i)) int(score(1)) +int(score(1, i)) int(score(i)) int(string(1)) int(string(i)) int(string(i32)) int(string(i64)) -int(toJSON(1)) +int(sum(array)) int(toJSON(i)) int(toJSON(i32)) int(toJSON(i64)) -int(true ? f64 : 0.5) -int(true ? f64 : 1) -join(["bar"]) -join(map(array, "bar")) +int(true ? 1 : foo) +int(true ? f64 : greet) join(map(array, "foo")) -join(map(list, "bar")) -keys({"bar": i64}) -keys({"foo": 0.5}) -keys({"foo": f32}) -keys({"foo": i}) -last(1 .. i32) +join(map(list, "foo")) +keys(groupBy(array, "foo")) +keys(groupBy(array, # ** 0.5)) +keys(groupBy(array, #)) +keys(groupBy(array, f32 != f64)) +keys(groupBy(array, foo)) +keys(groupBy(array, i32)) +keys(groupBy(array, ok)) +keys(groupBy(list, "bar")) +keys(groupBy(list, #)) +keys(groupBy(list, false)) +keys(groupBy(list, i32)) +keys({"bar": 1}) +keys({"bar": array, "foo": "bar"}) +keys({"bar": f32}) +keys({"foo": array, "bar": f64}) +keys({"foo": array}) +last(1 .. 1) +last(1 .. i) last([0.5]) -last([array]) -last([f64]) -last([half, i32]) +last([f32, list]) +last([list, list]) last(array) -last(array) != f32 -last(array) != i32 -last(array) % i32 -last(array) * i32 -last(array) + f32 -last(array) + i +last(array) != int(i64) +last(array) + f64 last(array) - f32 last(array) - i64 -last(array) - score(i) -last(array) .. max(i) -last(array) / f64 -last(array) > f64 -last(array) > max(1) -last(array) >= f32 +last(array) .. i32 +last(array) / f32 +last(array) <= i32 +last(array) == f32 +last(array) > f32 * i64 last(array) >= f64 -last(false ? 0.5 : greet) -last(false ? div : 1) -last(false ? f32 : 1) -last(false ? list : 1)?.add -last(false ? list : add) +last(false ? "foo" : true) +last(false ? 0.5 : "bar") +last(false ? 1 : foo)?.div +last(false ? div : score) +last(false ? f64 : false) last(filter(array, false)) last(filter(array, ok)) last(filter(list, true)) -last(i .. i32) -last(i32 .. i32) +last(groupBy(array, foo).Qux) +last(groupBy(array, i32).Qux) +last(groupBy(list, #).list) +last(groupBy(list, #)?.Qux) +last(groupBy(list, #)?.ok) +last(i32 .. 1) last(i32 .. i64) -last(i64 .. i) +last(i64 .. 1) last(list) -last(list) == foo -last(list) not in list last(list).Bar last(list).Qux last(list).String @@ -9260,181 +11909,155 @@ last(list)?.Bar last(list)?.Qux last(list)?.String last(list)?.String() -last(map(array, "bar")) +last(list[1:i64]) last(map(array, #)) +last(map(array, 1)) last(map(array, array)) -last(map(array, i64)) -last(map(list, "bar")) +last(map(array, foo)) +last(map(array, i)) last(map(list, "foo")) last(map(list, #)) -last(map(list, 0.5)) -last(map(list, add)) -last(map(list, f32)) -last(map(list, foo)) -last(map(list, i)) +last(map(list, 1)) +last(map(list, false)) +last(map(list, half)) last(map(list, i32)) -last(map(list, true)) -last(ok ? 0.5 : score) -last(ok ? array : false) -last(ok ? foo : add != half) -last(ok ? nil : list) -last(ok ? ok : i32) -last(true ? 1 : list)?.String -last(true ? foo : half) -last(true ? half : 1) -last(true ? i32 : ok) -last(true ? i64 : 1) -last(true ? ok : f64) -lastIndexOf("bar", "foo") < f32 ^ f64 -len("bar" + "foo") -len("bar") != f32 -len("bar") % score(i) -len("bar") * i32 -len("bar") ** f64 -len("bar") ** i32 -len("bar") <= i64 -len("bar") > i32 -len("bar") >= 0.5 ^ 0.5 -len("bar") >= f32 -len("bar") >= f64 -len("foo" + foo.Bar) -len("foo") * i32 -len("foo") * i64 +last(map(list, i64)) +last(map(list, ok)) +last(ok ? "bar" : true) +last(ok ? "foo" : f64) +last(ok ? 0.5 : "foo") +last(ok ? 0.5 : list) +last(ok ? 1 : add) +last(ok ? 1 : half) +last(ok ? array : array) +last(ok ? array : ok) +last(ok ? f32 : 0.5) +last(ok ? greet : 1) +last(ok ? i32 : array) +last(ok ? i64 : add) +last(ok ? ok : 0.5) +last(reduce(array, list)) +last(reduce(list, array)) +last(sort(array)) +last(true ? "bar" : half) +last(true ? add : list) +last(true ? foo : 1) +last(true ? greet : true) +last(true ? ok : 1) +len("bar") ** i64 +len("bar") + i64 - i64 +len("bar") / i64 +len("bar") >= i +len("bar") in array +len("foo") ** i32 +len("foo") ** i64 len("foo") - i -len("foo") .. i -len("foo") < f32 -len("foo") <= f32 -len("foo") <= f64 -len("foo") == i -len("foo") == i32 -len("foo") == i64 -len("foo") > f64 -len("foo") not in array -len([f64]) -len([false, add, half]) -len([false, foo, false]) -len([false]) +len("foo") - i32 +len("foo") >= i +len(1 .. 1) +len([f32]) +len([foo]) +len([half]) len(array) -len(array) != i -len(array) != i32 -len(array) * i -len(array) ** i -len(array) .. 1 - 1 -len(array) / f32 -len(array) < f32 -len(array) <= i -len(array) >= f32 +len(array) != f32 +len(array) + i64 +len(array) < f64 +len(array) <= i32 +len(array) == f32 len(array) >= f64 -len(array) >= i64 -len(false ? 1 : list) -len(false ? nil : "foo") +len(array) ^ i32 +len(array) not in array +len(filter(list, false)) +len(filter(list, ok)) len(foo.Bar) len(foo.String()) len(foo?.Bar) +len(foo?.Qux("bar")) len(foo?.String()) len(greet("bar")) len(greet("foo")) -len(i .. 1) -len(i32 .. 1) -len(i32 .. i) -len(i32 .. i32) -len(i32 .. i64) +len(groupBy(array, #)) +len(groupBy(array, 0.5)) +len(groupBy(array, f32)) +len(groupBy(array, false)) +len(groupBy(array, i64)) +len(groupBy(array, true)) +len(groupBy(list, #)) +len(groupBy(list, #).ok) +len(groupBy(list, 0.5)) +len(groupBy(list, false)) +len(groupBy(list, foo).list) +len(groupBy(list, i32)) +len(groupBy(list, i64)) len(i64 .. 1) len(i64 .. i) len(list) -len(list) != i64 -len(list) * f32 -len(list) ** i -len(list) / f64 -len(list) <= f64 -len(list) == f32 -len(list) == i +len(list) % i32 +len(list) % i64 +len(list) .. i64 +len(list) / i32 +len(list) <= i len(list) > i -len(list) > i64 - i -len(list) >= i -len(list) not in map(array, #) +len(list) ^ f64 +len(list[1:i]) +len(lower("bar")) len(lower("foo")) -len(lower(toBase64("foo"))) -len(lower(type(list))) len(map(array, "bar")) len(map(array, #)) -len(map(array, 0.5)) -len(map(array, array)) -len(map(array, f64)) -len(map(array, foo)) -len(map(array, half)) +len(map(array, add)) +len(map(array, f32)) +len(map(array, greet)) len(map(array, i)) -len(map(array, i64)) -len(map(array, list)) -len(map(array, ok)) +len(map(array, list)[i64]) len(map(array, score)) -len(map(list, "bar")) -len(map(list, "foo")) len(map(list, #)) -len(map(list, 0.5)) len(map(list, 1)) +len(map(list, f32)) len(map(list, f64)) -len(map(list, false)) -len(map(list, greet)) -len(map(list, half)) -len(map(list, i)) -len(map(list, score)) +len(map(list, foo)) +len(map(list, i64)) +len(map(list, ok)) len(map(list, true)) +len(ok ? list : score) len(sort(array)) len(string("bar")) len(string("foo")) len(string(0.5)) len(string(1)) len(string(add)) -len(string(array)) -len(string(div)) -len(string(f32)) len(string(f64)) len(string(foo)) -len(string(greet)) len(string(half)) +len(string(i)) len(string(i32)) len(string(i64)) len(string(list)) len(string(nil)) -len(string(ok)) len(string(score)) -len(string(true)) +len(string(string(list))) len(toJSON("bar")) len(toJSON("foo")) len(toJSON(0.5)) -len(toJSON(1 <= i32)) len(toJSON(1)) len(toJSON(array)) len(toJSON(f32)) -len(toJSON(f64)) len(toJSON(false)) -len(toJSON(foo)) -len(toJSON(foo.Bar)) len(toJSON(i)) len(toJSON(i32)) -len(toJSON(i64)) len(toJSON(list)) len(toJSON(nil)) len(toJSON(ok)) len(toJSON(true)) -len(trim("bar")) len(trim("foo")) -len(trimPrefix("bar")) len(trimPrefix("foo")) len(trimSuffix("bar")) -len(trimSuffix("foo")) +len(type("foo")) len(type(0.5)) len(type(1)) +len(type(add)) len(type(array)) len(type(div)) -len(type(f32)) -len(type(f64)) -len(type(false)) -len(type(foo)) -len(type(greet)) len(type(half)) -len(type(half)) > f32 len(type(i)) len(type(i32)) len(type(i64)) @@ -9444,46 +12067,48 @@ len(type(ok)) len(type(score)) len(upper("bar")) len(upper("foo")) -len({"bar": 1}) -len({"bar": add}) -len({"bar": f64, "bar": i}) -len({"bar": greet, "bar": greet}) -len({"foo": "foo"}) +len({"bar": array}) +len({"bar": f64}) +len({"bar": score}) +len({"foo": 1}) +len({"foo": add, "foo": "foo"}) +len({"foo": i64}) list +list != 1 .. 1 +list != ["foo"] +list != [i, 0.5] +list != [i] list != array -list != array == ok -list != array ? 0.5 : "bar" -list != filter(list, true) +list != filter(array, ok) +list != filter(array, true) list != list +list != list ? 0.5 : div +list != list ? half : div list != map(array, #) -list != map(array, 1) -list != map(array, div) -list != map(list, #) -list != map(list, div) -list != map(list, list) -list == [add] +list != map(list, 1) +list != map(list, i64) +list != nil && i32 <= 1 +list != nil ? false : 1 +list != nil ? i : 1 +list != sort(array) +list == [div, nil] +list == [i] list == array -list == array ? div : i +list == array == nil list == list -list == list == nil -list == list ? f64 : array -list == list or add != nil -list == map(list, f32) -list == map(list, i64) -list == nil == nil -list == nil == ok -list == nil or i == 0.5 -list == sort(array) -list == {"bar": half, "foo": "foo"}?.i32 +list == list != false +list == list ? i32 : i +list == map(list, #) +list == nil && ok +list == nil ? nil : "foo" +list == nil or f64 == f64 +list not in groupBy(list, #).i list[-1] list[-i32] list[-i64] -list[-i64].String list[-i] -list[-i].String -list[1 % i32] -list[1 * i64] -list[1:i] == list +list[1 - 1] +list[1] not in list list[1].Bar list[1].Qux list[1].String @@ -9492,35 +12117,35 @@ list[1]?.Bar list[1]?.Qux list[1]?.String list[1]?.String() -list[false ? add : 1] -list[false ? nil : i] -list[false ? true : f64] -list[findIndex(list, ok)] -list[i * i32] +list[bitnot(i)] +list[bitshr(i32, i32)] +list[findIndex(array, true)] +list[first(array)] +list[i * i64] list[i32:i32] -list[i32:i64] list[i32:i] list[i32] +list[i32] in list list[i32].Bar list[i32].Qux list[i32].String -list[i32].String() list[i32]?.Bar list[i32]?.Qux list[i32]?.String -list[i64 % 1] -list[i64:i32] +list[i32]?.String() +list[i64:i32 - i] list[i64:i64] -list[i64:i] list[i64] +list[i64] in list list[i64].Bar list[i64].Qux list[i64].String -list[i64].String() list[i64]?.Bar list[i64]?.Qux list[i64]?.String -list[i:false ? false : i64] +list[i:i32] +list[i:i64] +list[i:i64] == nil != nil list[i:i] list[i] list[i].Bar @@ -9529,17 +12154,22 @@ list[i].String list[i].String() list[i]?.Bar list[i]?.Qux +list[i]?.String list[i]?.String() -list[int(0.5)] +list[int(f32)] list[int(f64)] list[int(i)] -list[max(i)] +list[int(i64)] +list[max(i64, 1)] list[min(i)] -list[ok ? f32 : add] +list[min(i32)] +list[ok ? 1 : half] list[score(1)] list[score(i)] -list[true ? f64 : true] lower("bar" + "bar") +lower("bar") == trimSuffix("bar") +lower("foo" + "bar") +lower(false ? foo : "bar") lower(foo.Bar) lower(foo.String()) lower(foo?.Bar) @@ -9547,106 +12177,87 @@ lower(foo?.String()) lower(greet("bar")) lower(greet("foo")) lower(lower("bar")) -lower(lower(trimSuffix("bar"))) -lower(string("bar")) +lower(lower("foo")) +lower(reduce(array, "bar")) +lower(reduce(list, "bar")) lower(string("foo")) lower(string(0.5)) lower(string(add)) -lower(string(array)) -lower(string(div)) lower(string(f32)) lower(string(f64)) -lower(string(false)) lower(string(foo)) lower(string(greet)) -lower(string(half)) lower(string(i)) lower(string(i32)) lower(string(i64)) lower(string(list)) lower(string(nil)) -lower(string(ok)) lower(string(score)) -lower(string(true)) -lower(toBase64("bar" + "bar")) -lower(toBase64("bar")) lower(toBase64("foo")) +lower(toBase64(string(i))) lower(toJSON("bar")) lower(toJSON("foo")) lower(toJSON(0.5)) lower(toJSON(1)) -lower(toJSON(array)) -lower(toJSON(f32)) lower(toJSON(f64)) -lower(toJSON(false)) lower(toJSON(foo)) -lower(toJSON(i)) -lower(toJSON(i32)) -lower(toJSON(i64)) lower(toJSON(list)) lower(toJSON(nil)) lower(toJSON(ok)) lower(toJSON(true)) +lower(trim("bar")) lower(trim("foo")) lower(trimPrefix("bar")) +lower(trimPrefix("foo")) lower(trimSuffix("bar")) -lower(trimSuffix("foo")) -lower(trimSuffix(foo?.String())) lower(type("bar")) lower(type("foo")) -lower(type(0.5 * i64)) lower(type(0.5)) lower(type(1)) -lower(type(array)) +lower(type(add)) lower(type(div)) lower(type(f32)) -lower(type(f64)) -lower(type(false)) -lower(type(foo)) -lower(type(greet)) lower(type(half)) lower(type(i)) +lower(type(i32)) lower(type(i64)) -lower(type(nil)) +lower(type(list)) lower(type(ok)) -lower(type(score)) lower(type(true)) lower(upper("bar")) lower(upper("foo")) -map(1 .. 1, # .. #) -map(1 .. 1, # == f64) -map(1 .. i, #) +map(1 .. 1, f32) +map(1 .. 1, foo) +map(1 .. 1, score) map(1 .. i, foo) -map(1 .. i, greet) map(1 .. i32, #) -map(1 .. i32, ok) -map(1 .. i64, f64 ^ 1) -map(1 .. i64, foo) -map(1 .. i64, list) -map(["bar"], # == #) -map(["foo"], #) -map([1, i], #) -map([add], foo) -map([f32], f64) -map([false], score) -map([greet, i32], #) -map([greet], #) +map(1 .. i32, 0.5 / f64) +map(1 .. i32, div) +map(1 .. i32, reduce(array, #)) +map(1 .. i64, # ^ #) +map(1 .. i64, #) +map(1 .. i64, half) +map(1 .. i64, i32) +map([f64], half) +map([false], ok) map([half], #) +map([i * i32], score) +map([i32, foo, score], #) map([i32], foo) -map([i64], #) -map([i], max(#)) -map([list, nil], i64) -map([list], #) -map([score, "bar"], #) -map([score], #) -map([score], array) -map(array, !false) -map(array, !true) -map(array, "bar" != "foo") -map(array, "bar" contains "foo") -map(array, "bar")[i64] -map(array, # != # ? # : array) +map([i32], greet) +map([i32], half) +map([list, 1, foo], i32) +map([nil], foo) +map([score, "bar"], f32) +map([true, i32, 1], #) +map(array, !(# == #)) +map(array, !(nil in list)) +map(array, !ok) +map(array, "bar" in foo) +map(array, "foo" not endsWith "bar") +map(array, "foo") == array map(array, # != #) +map(array, # != 0.5) map(array, # != 1) map(array, # != f64) map(array, # != i32) @@ -9654,1222 +12265,1146 @@ map(array, # != nil) map(array, # % #) map(array, # % 1) map(array, # % i) -map(array, # % i32) map(array, # % i64) map(array, # * #) map(array, # * 0.5) +map(array, # * 1) +map(array, # * f32) map(array, # * f64) -map(array, # * i32) -map(array, # * i64) +map(array, # * i) map(array, # ** #) -map(array, # ** 0.5) +map(array, # ** 1) +map(array, # ** f32) map(array, # ** i) -map(array, # ** i32) map(array, # ** i64) map(array, # + #) map(array, # + 0.5) map(array, # + 1) -map(array, # + f64) +map(array, # + f32) map(array, # + i) map(array, # + i32) -map(array, # + i64) map(array, # - #) map(array, # - 0.5) map(array, # - 1) map(array, # - f32) +map(array, # - f64) map(array, # - i) map(array, # - i32) map(array, # .. #) map(array, # .. 1) -map(array, # .. i) -map(array, # .. i32) -map(array, # .. i64) map(array, # / #) map(array, # / 0.5) +map(array, # / 1) +map(array, # / f32) map(array, # / f64) map(array, # / i) -map(array, # / i32) map(array, # / i64) map(array, # < #) -map(array, # < 0.5) map(array, # < 1) map(array, # < f32) -map(array, # < f64) +map(array, # < i32) +map(array, # < i64) map(array, # <= #) -map(array, # <= 1) -map(array, # <= i64) +map(array, # <= f32) +map(array, # <= i) +map(array, # <= i32) map(array, # == #) -map(array, # == 1) -map(array, # == i64) +map(array, # == f32) +map(array, # == f64) +map(array, # == nil) map(array, # > #) +map(array, # > 0.5) map(array, # > 1) map(array, # > f32) -map(array, # > i32) -map(array, # > i64) +map(array, # > f64) map(array, # >= #) -map(array, # >= 0.5) map(array, # >= 1) -map(array, # >= f64) -map(array, # >= i) +map(array, # >= f32) map(array, # >= i32) +map(array, # >= i64) map(array, # ^ #) map(array, # ^ 0.5) +map(array, # ^ 1) map(array, # ^ i) map(array, # ^ i32) -map(array, # ^ i64) -map(array, # in array) +map(array, # not in array) map(array, #) map(array, #) != array map(array, #) != list -map(array, #) != nil == nil +map(array, #) == array +map(array, #) == list map(array, #)[i64] map(array, #)[i] map(array, -#) -map(array, -(# ** f64)) +map(array, --#) map(array, -0.5) map(array, -1) map(array, -f64) map(array, -i) +map(array, -i32) map(array, -i64) map(array, 0.5 != #) map(array, 0.5 != 0.5) -map(array, 0.5 != i32) map(array, 0.5 * #) -map(array, 0.5 ** #) +map(array, 0.5 * f64) +map(array, 0.5 ** f32) +map(array, 0.5 ** i64) map(array, 0.5 + #) +map(array, 0.5 + 1) map(array, 0.5 - #) -map(array, 0.5 / #) +map(array, 0.5 - 0.5) +map(array, 0.5 / i) map(array, 0.5 < #) -map(array, 0.5 < 1) -map(array, 0.5 <= f32) -map(array, 0.5 == #) -map(array, 0.5 == i32) +map(array, 0.5 < i32) map(array, 0.5 > #) +map(array, 0.5 > i64) +map(array, 0.5 >= #) map(array, 0.5 ^ #) +map(array, 0.5)[i] map(array, 1 != #) -map(array, 1 != 1) map(array, 1 != f32) map(array, 1 % #) -map(array, 1 % i) -map(array, 1 * #) -map(array, 1 * f32) map(array, 1 ** #) -map(array, 1 ** 1) -map(array, 1 ** i32) +map(array, 1 ** i) +map(array, 1 ** i64) map(array, 1 + #) +map(array, 1 + f64) +map(array, 1 - #) map(array, 1 .. #) map(array, 1 / #) -map(array, 1 / 1) -map(array, 1 < 0.5) +map(array, 1 / i32) +map(array, 1 < #) map(array, 1 <= #) +map(array, 1 <= 1) +map(array, 1 <= f32) map(array, 1 == #) -map(array, 1 == nil) -map(array, 1 >= #) -map(array, 1 >= f64) map(array, 1 ^ #) -map(array, 1 ^ 1) -map(array, 1 in array) -map(array, 1)[i64] -map(array, 1)[i] -map(array, [array]) -map(array, [i32, foo]) map(array, abs(#)) -map(array, abs(0.5)) +map(array, abs(i64)) +map(array, add == nil) map(array, add(#, #)) map(array, add(#, i)) -map(array, add(1, #)) map(array, add) -map(array, add) != list -map(array, all(array, true)) -map(array, array != nil) map(array, array) -map(array, array) == array +map(array, array)[bitnot(i32)] +map(array, array)[i64] map(array, array[#:#]) -map(array, array[1]) +map(array, bitand(#, 1)) +map(array, bitnand(#, 1)) +map(array, bitnot(#)) +map(array, bitnot(1)) +map(array, bitshl(#, #)) +map(array, bitshr(#, #)) +map(array, bitshr(#, i64)) +map(array, bitushr(1, #)) +map(array, ceil(#)) +map(array, ceil(0.5)) +map(array, ceil(f32)) map(array, div(#, #)) map(array, div) +map(array, f32 * #) +map(array, f32 * f64) map(array, f32 ** #) -map(array, f32 ** f64) map(array, f32 + #) -map(array, f32 - f64) map(array, f32 / #) map(array, f32 < #) -map(array, f32 <= #) -map(array, f32 <= 1) map(array, f32 == #) map(array, f32 > #) +map(array, f32 >= #) +map(array, f32 >= i) +map(array, f32 ^ #) map(array, f32) +map(array, f32)[min(i32)] map(array, f64 != #) map(array, f64 != 0.5) -map(array, f64 * 1) +map(array, f64 * #) map(array, f64 ** #) -map(array, f64 - #) -map(array, f64 / 1) -map(array, f64 <= f64) -map(array, f64 > #) +map(array, f64 ** 0.5) +map(array, f64 / #) +map(array, f64 < #) +map(array, f64 < f64) +map(array, f64 <= #) +map(array, f64 == #) +map(array, f64 >= #) +map(array, f64 >= i32) +map(array, f64 ^ #) map(array, f64) -map(array, f64) != list -map(array, f64) == i .. 1 -map(array, false ? "foo" : #) -map(array, false ? 0.5 : #) -map(array, false)[i] -map(array, findLast(array, true)) -map(array, float(# * f64)) +map(array, false && false) +map(array, false ? # : f64) +map(array, false ? greet : i) +map(array, false)[i32] +map(array, find(array, true)) +map(array, findIndex(list, ok)) +map(array, float(# + #)) map(array, float(#)) -map(array, float(1)) -map(array, float(i64)) +map(array, floor(#)) +map(array, foo == foo) map(array, foo) map(array, foo.Bar) map(array, foo.Qux) map(array, foo.String()) map(array, foo.String) -map(array, foo?.Qux) +map(array, foo?.Bar) map(array, foo?.String) map(array, get(array, #)) -map(array, get(list, #)) -map(array, greet != half) map(array, greet("bar")) map(array, greet("foo")) map(array, greet) -map(array, greet) == list +map(array, groupBy(array, #)) +map(array, groupBy(array, f32)) +map(array, groupBy(list, #)) +map(array, groupBy(list, f64)) +map(array, groupBy(list, i)) +map(array, half != half) +map(array, half != nil) map(array, half(0.5)) +map(array, half(1)) +map(array, half(f64)) +map(array, half(i - 0.5)) map(array, half) -map(array, i != #) -map(array, i != f64) -map(array, i % i) -map(array, i * 0.5) -map(array, i ** #) -map(array, i ** 0.5) -map(array, i .. #) -map(array, i / #) +map(array, i % #) +map(array, i + #) +map(array, i - i32) +map(array, i / 0.5) +map(array, i <= #) +map(array, i <= f32) +map(array, i <= f64) map(array, i == #) -map(array, i > #) -map(array, i >= f64) -map(array, i ^ #) +map(array, i == f64) +map(array, i > i32) +map(array, i >= #) map(array, i) -map(array, i)[i64] -map(array, i32 % #) -map(array, i32 % i) +map(array, i)[i] map(array, i32 * #) -map(array, i32 + 0.5) -map(array, i32 + i64) -map(array, i32 - #) -map(array, i32 / #) -map(array, i32 < 0.5) +map(array, i32 ** #) +map(array, i32 ** f64) +map(array, i32 / f32) +map(array, i32 < #) +map(array, i32 < f64) map(array, i32 == #) -map(array, i32 == 0.5) -map(array, i32 == nil) +map(array, i32 == 1) map(array, i32 > #) -map(array, i32 >= f32) map(array, i32 ^ #) +map(array, i32 not in array) map(array, i32) +map(array, i32) == array +map(array, i32) == list map(array, i64 != #) +map(array, i64 % #) map(array, i64 * #) -map(array, i64 ** #) -map(array, i64 + #) +map(array, i64 * 0.5) +map(array, i64 + 0.5) map(array, i64 - #) map(array, i64 .. #) -map(array, i64 / #) -map(array, i64 <= 1) -map(array, i64 == #) -map(array, i64 == f64) +map(array, i64 < #) +map(array, i64 <= #) +map(array, i64 <= f64) +map(array, i64 <= i64) map(array, i64 > #) -map(array, i64 >= i64) -map(array, i64 ^ #) -map(array, i64 ^ i32) map(array, i64) -map(array, i64)[i32] map(array, int(#)) map(array, int(0.5)) -map(array, int(f64)) -map(array, last(array)) -map(array, len(array)) +map(array, len("foo")) +map(array, list != array) map(array, list) -map(array, map(array, #)) -map(array, map(array, true)) -map(array, map(list, #)) -map(array, map(list, f64)) +map(array, map(array, f64)) +map(array, map(list, greet)) map(array, max(#)) -map(array, max(#, #, #)) -map(array, max(0.5)) -map(array, max(0.5, #)) -map(array, max(i64, #, i)) -map(array, min(# ^ #)) -map(array, min(#)) -map(array, min(#, #, #, #)) -map(array, min(#, 1)) -map(array, min(#, 1, #)) -map(array, min(#, 1, f64)) -map(array, min(#, f32)) -map(array, min(#, f64)) -map(array, nil != #) +map(array, max(f32, 1)) +map(array, max(f64)) +map(array, mean(array)) +map(array, min(#, #)) map(array, nil == #) -map(array, nil == half) -map(array, not (# < 1)) -map(array, not false) +map(array, nil == ok) +map(array, nil not in list) +map(array, not ok) map(array, not true) -map(array, ok ? # : i64) -map(array, ok ? f32 : div) map(array, ok || ok) map(array, ok) -map(array, one(array, ok)) -map(array, one(array, true)) -map(array, score != nil) +map(array, ok)[i64] +map(array, reduce(array, "bar")) +map(array, reduce(array, #)) +map(array, reduce(list, add)) +map(array, reduce(list, half)) +map(array, round(#)) map(array, score(#)) map(array, score(#, #)) -map(array, score(#, #, 1)) map(array, score(1)) map(array, score) -map(array, sort(array)) -map(array, string("bar")) -map(array, string(# ** f64)) -map(array, string(#)) -map(array, string(array)) +map(array, string(add)) map(array, string(foo)) -map(array, string(list)) -map(array, string(score)) +map(array, string(i64)) +map(array, take(array, #)) +map(array, toBase64("foo")) map(array, toJSON(#)) -map(array, toJSON(array)) -map(array, toJSON(ok)) -map(array, true ? # : #) -map(array, true ? f32 : i) -map(array, true ? nil : #) -map(array, true)[i] +map(array, toJSON(foo)) +map(array, toJSON(list)) +map(array, true != nil) +map(array, true ? 0.5 : #) +map(array, true ? 0.5 : 1) +map(array, true ? f32 : div) +map(array, true ? i : true) map(array, type(#)) -map(array, type(half)) -map(array, type(i)) -map(array, upper("foo")) -map(array[i64:1], array) -map(array[i64:i64], #) -map(array[i:1], i > #) -map(false ? 0.5 : "bar", greet) -map(false ? 1 : list, half) -map(false ? array : "foo", i64 / 1) -map(false ? true : array, #) +map(array, type(f32)) +map(array[1:i32], list) +map(false ? i32 : list, ok) map(filter(array, false), foo) -map(filter(array, ok), # <= #) -map(filter(array, ok), #) -map(filter(array, ok), i32 + #) -map(filter(array, ok), score) -map(filter(array, true), f64) -map(filter(array, true), i) +map(filter(array, ok), 1 * #) +map(filter(list, # != #), #) map(filter(list, false), #) -map(filter(list, true), score) -map(i .. 1, # > #) -map(i .. 1, -i64) -map(i .. 1, f64) -map(i .. i32, #) -map(i .. i32, score) -map(i .. i64, #) -map(i .. i64, f64) -map(i .. i64, score) -map(i32 .. 1, #) -map(i32 .. 1, list) -map(i32 .. i, add) -map(i32 .. i, half) -map(i32 .. i32, #) -map(i32 .. i32, greet) -map(i32 .. i64, abs(#)) -map(i32 .. i64, f64) -map(i64 .. i, #) -map(i64 .. i, i) +map(filter(list, ok), #) +map(filter(list, ok), i) +map(filter(list, true), i64) +map(groupBy(array, #).String, i32) +map(groupBy(array, #).greet, foo.Qux(.f32)) +map(groupBy(array, #).greet, score) +map(groupBy(array, #).score, #?.list()) +map(groupBy(list, i32).i, #) +map(i .. 1, -#) +map(i .. 1, 0.5 ^ #) +map(i .. 1, f32) +map(i .. 1, i) +map(i .. i, add(#, #)) +map(i .. i, div) +map(i .. i, i32) +map(i .. i32, half) +map(i .. i64, min(#, #, #)) +map(i32 .. 1, half) +map(i32 .. i, f32) +map(i32 .. i32, array) +map(i32 .. i64, div) +map(i32 .. i64, list) +map(i64 .. 1, #) +map(i64 .. 1, 1 ^ #) +map(i64 .. 1, array) +map(i64 .. 1, f32) +map(i64 .. 1, f64) map(i64 .. i32, #) +map(i64 .. i64, # - #) +map(i64 .. i64, #) map(list, !false) -map(list, !true) -map(list, "bar" in #) -map(list, "bar" not in #) +map(list, !ok) +map(list, "bar" not matches "foo") map(list, "bar") != list -map(list, "foo" + "foo") -map(list, "foo" in #) -map(list, "foo" not matches "bar") -map(list, "foo") == list +map(list, "bar")[i64] +map(list, "foo" not in foo) +map(list, "foo" not matches #.Bar) map(list, # != #) -map(list, # != foo) map(list, # != nil) map(list, # == #) -map(list, # == foo) -map(list, # not in list) +map(list, # in list) map(list, #) -map(list, #) == array +map(list, #) != array map(list, #) == list -map(list, #)[i32] map(list, #)[i64] map(list, #)[i] map(list, #?.Bar) -map(list, #?.Qux("bar")) map(list, #?.Qux) map(list, #?.String()) map(list, #?.String) map(list, -0.5) -map(list, -1) -map(list, -f64) +map(list, -f32) map(list, -i) -map(list, .Bar not in # != true) +map(list, -i32) map(list, .Bar) map(list, .Qux) map(list, .String()) map(list, .String) -map(list, 0.5 - i64) -map(list, 0.5 < f32) -map(list, 0.5 <= f32) -map(list, 0.5 <= i64) -map(list, 0.5 >= 1) -map(list, 0.5 ^ 1) -map(list, 1 + i) -map(list, 1 - f64) -map(list, 1 .. 1) -map(list, 1 .. i64) -map(list, 1 / 1) -map(list, 1 / f32) -map(list, 1 < i32) -map(list, 1 > i32) -map(list, 1 >= f64) -map(list, [1]) -map(list, [false]) -map(list, abs(0.5)) -map(list, abs(1)) +map(list, 0.5 != 0.5) +map(list, 0.5 != i64) +map(list, 0.5 + i64) +map(list, 0.5 - 0.5) +map(list, 0.5 <= 0.5) +map(list, 0.5 == i32) +map(list, 0.5 in array) +map(list, 0.5) != array +map(list, 0.5) == array +map(list, 1 % i) +map(list, 1 ** 0.5) +map(list, 1 ** f32) +map(list, 1 + 1) +map(list, 1 / f64) +map(list, 1 / i64) +map(list, 1 < 0.5) +map(list, 1 <= i32) +map(list, 1 ^ i32) +map(list, [#]) +map(list, [foo, 0.5, #]) +map(list, [score]) +map(list, abs(f32)) map(list, add) map(list, array) -map(list, div != greet) -map(list, div == div) +map(list, ceil(0.5)) +map(list, count(array, true)) map(list, div) -map(list, div) != list -map(list, f32 != f32) -map(list, f32 ** f32) -map(list, f32 / i32) -map(list, f32 < 0.5) -map(list, f32 <= 1) +map(list, f32 != i32) +map(list, f32 ** 1) +map(list, f32 + i64) +map(list, f32 < f32) +map(list, f32 == 0.5) +map(list, f32 > i64) +map(list, f32 >= i) +map(list, f32 >= i32) +map(list, f32 ^ i) map(list, f32) -map(list, f64 * 0.5) -map(list, f64 * f32) -map(list, f64 ** i32) -map(list, f64 + 1) -map(list, f64 + i32) -map(list, f64 - 0.5) -map(list, f64 < f64) -map(list, f64 ^ i64) +map(list, f64 < 0.5) +map(list, f64 < f32) +map(list, f64 <= 1) +map(list, f64 > 1) +map(list, f64 >= 0.5) +map(list, f64 >= f32) map(list, f64) -map(list, f64) != list -map(list, false ? # : nil) -map(list, false ? f32 : #) -map(list, false ? f32 : foo) -map(list, false and true) -map(list, filter(list, false)) -map(list, first(list)) -map(list, float(0.5)) -map(list, float(1)) -map(list, float(f32)) -map(list, float(i64)) +map(list, f64)[i] +map(list, false ? # : list) +map(list, false) != array +map(list, float(f64)) +map(list, float(i)) +map(list, float(i32)) map(list, foo == #) map(list, foo) -map(list, foo.Bar) -map(list, foo.String) -map(list, foo?.String()) +map(list, foo.Qux) +map(list, foo.String()) map(list, foo?.String) -map(list, greet == greet) -map(list, greet("foo")) map(list, greet) -map(list, greet) != array ? 0.5 : 1 -map(list, half != score) +map(list, groupBy(array, #)) +map(list, groupBy(array, i)) +map(list, groupBy(list, #)) map(list, half(0.5)) +map(list, half(f64)) map(list, half) -map(list, i * 1) -map(list, i * i64) -map(list, i + i) -map(list, i >= f64) -map(list, i >= i64) -map(list, i ^ f32) -map(list, i ^ i64) +map(list, i ** 1) +map(list, i + i64) +map(list, i .. i) +map(list, i < 0.5) +map(list, i == 1) map(list, i) -map(list, i32 * f32) -map(list, i32 == i64) -map(list, i32 == nil) -map(list, i32 > i) -map(list, i32 ^ 0.5) +map(list, i)[i64] +map(list, i32 % i64) +map(list, i32 ** 0.5) +map(list, i32 + f32) +map(list, i32 - i32) +map(list, i32 / f64) +map(list, i32 < 1) +map(list, i32 < i32) +map(list, i32 <= 1) +map(list, i32 >= 1) map(list, i32) -map(list, i64 == 1) -map(list, i64 == f32) -map(list, i64 ^ (i + i32)) +map(list, i64 * i) +map(list, i64 + i64) +map(list, i64 <= i64) +map(list, i64 == nil) map(list, i64) -map(list, int(1)) -map(list, len(array)) +map(list, i64)[i64] +map(list, i64)[i] +map(list, last(array)) map(list, list) -map(list, map(array, score)) -map(list, map(list, #)) -map(list, min(i64)) +map(list, list)[i] +map(list, map(array, #)) +map(list, map(array, 1)) +map(list, map(array, div)) +map(list, map(array, i64)) +map(list, map(list, "foo")) +map(list, max(f32)) +map(list, min(0.5)) +map(list, min(f64)) map(list, nil != #) -map(list, nil != 1) -map(list, nil != array) -map(list, nil != i) -map(list, nil != nil) +map(list, nil != i64) map(list, nil == #) -map(list, nil == div) -map(list, nil == foo) -map(list, nil == i32) -map(list, nil not in array) -map(list, not false) +map(list, nil == ok) +map(list, nil not in list) +map(list, none(array, true)) map(list, not ok) -map(list, not true) -map(list, ok ? i64 : i64) +map(list, ok ? # : #) +map(list, ok || ok) map(list, ok) -map(list, ok) != array -map(list, score != greet) -map(list, score(i)) +map(list, reduce(array, half)) +map(list, reduce(list, foo)) +map(list, reduce(list, half)) +map(list, score(1)) map(list, score) +map(list, score)[i64] map(list, string(#)) -map(list, string(foo)) -map(list, string(nil)) -map(list, toBase64("foo")) +map(list, string(1)) +map(list, string(add)) +map(list, string(i32)) map(list, toJSON(#)) -map(list, toJSON(1)) -map(list, toJSON(foo)) -map(list, toJSON(i)) -map(list, trimPrefix("bar")) -map(list, trimSuffix("foo")) -map(list, true ? false : score) -map(list, true ? nil : #) +map(list, toJSON([#])) +map(list, toJSON(false)) +map(list, toJSON(ok)) +map(list, true ? i : f32) +map(list, true ? i32 : #) +map(list, true ? list : div) map(list, true)[i32] +map(list, type("bar")) map(list, type(#)) -map(list, type(greet)) -map(list, type(half)) -map(list, type(i)) -map(list, type(i64)) -map(list[i:i], i) -map(map(array, "bar"), #) -map(map(array, # >= #), add) -map(map(array, #), # < #) -map(map(array, #), # ^ i32) +map(list, type(i32)) +map(list, type(true)) +map(list[i64:i32], greet) +map(map(array, #), # - i32) +map(map(array, #), # == #) +map(map(array, #), # >= #) map(map(array, #), #) map(map(array, #), add) -map(map(array, #), div) -map(map(array, #), f32) -map(map(array, #), f64) +map(map(array, #), bitand(#, #)) map(map(array, #), foo) -map(map(array, #), foo.Qux) map(map(array, #), greet) map(map(array, #), half) +map(map(array, #), i % i64) map(map(array, #), i) +map(map(array, #), i32) map(map(array, #), i64) -map(map(array, #), int(#)) -map(map(array, #), nil != half) -map(map(array, #), score(i)) -map(map(array, #), score) -map(map(array, 0.5), # != #) +map(map(array, #), list) map(map(array, 0.5), #) -map(map(array, 0.5), -1) -map(map(array, 0.5), list) -map(map(array, 1), #) -map(map(array, 1), ok) -map(map(array, 1), score) -map(map(array, add), #) -map(map(array, add), list) -map(map(array, array), add) -map(map(array, array), f64) +map(map(array, 0.5), ok) +map(map(array, 1), greet) +map(map(array, array), i32 ^ i32) +map(map(array, array), i64) +map(map(array, array), reduce(#, array)) +map(map(array, div), i) +map(map(array, div), list) map(map(array, f32), #) -map(map(array, f64), add) -map(map(array, f64), nil == nil) -map(map(array, foo), #) -map(map(array, foo), f64) -map(map(array, foo), greet) -map(map(array, half), div) +map(map(array, f32), array) +map(map(array, f32), f64) +map(map(array, f64), # > #) +map(map(array, f64), f64) +map(map(array, f64), greet) +map(map(array, foo), div) +map(map(array, greet), foo) +map(map(array, greet), list) +map(map(array, half), array) +map(map(array, i), #) +map(map(array, i32), #) +map(map(array, i64), array) map(map(array, i64), f64) -map(map(array, list), #) -map(map(array, true), #) -map(map(array, true), div) -map(map(array, true), foo) -map(map(list, "foo"), add) -map(map(list, "foo"), div) -map(map(list, "foo"), i32) -map(map(list, #), "bar" + "foo") +map(map(array, list), foo) +map(map(array, ok), !#) +map(map(array, ok), -f32) +map(map(array, true), # != nil) +map(map(array, true), i64) map(map(list, #), # != #) map(map(list, #), #) -map(map(list, #), array) +map(map(list, #), #?.Qux) +map(map(list, #), .Bar) map(map(list, #), div) map(map(list, #), f32) map(map(list, #), f64) map(map(list, #), greet) -map(map(list, #), i) -map(map(list, #), i32) -map(map(list, #), i64 < i32) -map(map(list, #), i64) -map(map(list, #), nil != i) +map(map(list, #), half) +map(map(list, #), list) map(map(list, #), ok) map(map(list, #), score) -map(map(list, 0.5), # / #) map(map(list, 0.5), #) -map(map(list, 0.5), greet) -map(map(list, 0.5), list) -map(map(list, 0.5), score) -map(map(list, 1), # <= #) -map(map(list, 1), foo) -map(map(list, add), [#, #]) -map(map(list, add), f64) -map(map(list, f32), #) -map(map(list, f32), greet) -map(map(list, f32), true ? "foo" : "foo") -map(map(list, f64), #) -map(map(list, false), array) -map(map(list, false), f64) -map(map(list, false), i32) -map(map(list, false), list) +map(map(list, 0.5), div) +map(map(list, 1), # * #) +map(map(list, 1), f32) +map(map(list, add), #) +map(map(list, add), i) +map(map(list, array), f64) +map(map(list, array), findIndex(#, ok)) +map(map(list, f64), f32) +map(map(list, f64), i32) +map(map(list, false), 0.5 / f64) map(map(list, foo), #) -map(map(list, foo), ok) -map(map(list, greet), "bar" != "foo") -map(map(list, greet), # == #) -map(map(list, greet), #) -map(map(list, greet), ["foo", 1]) -map(map(list, greet), half) -map(map(list, half), #) -map(map(list, i), i32) -map(map(list, i32), half) -map(map(list, i32), list) +map(map(list, foo), list) +map(map(list, greet), "bar" <= "foo") +map(map(list, i64), # >= f64) map(map(list, i64), #) -map(map(list, i64), array) -map(map(list, i64), div) -map(map(list, i64), f64) -map(map(list, i64), list) +map(map(list, i64), i64) map(map(list, list), #) -map(map(list, list), div) -map(map(list, list), i) -map(map(list, ok), #) -map(map(list, score), #) -map(map(list, score), ok) -map(map(list, true), #) -map(ok ? "foo" : 0.5, #) -map(ok ? "foo" : greet, f32) -map(ok ? array : "bar", ok) -map(ok ? array : foo, # / 1) -map(sort(array), # > #) -map(sort(array), i32 > #) -map(true ? "bar" : true, #) -map(true ? "foo" : add, i64) -map(true ? array : f64, #) -map(true ? array : true, #) -max(--1) +map(map(list, ok), f64 > i64) +map(map(list, ok), foo) +map(map(list, true), f64) +map(map(list, true), list) +map(ok ? "bar" : i64, ok) +map(ok ? "bar" : ok, i64) +map(ok ? "bar" : score, 1 .. #) +map(ok ? array : foo, foo) +map(ok ? array : i64, list) +map(ok ? list : i64, #) +map(ok ? list : list, add) +map(reduce(array, array), # <= #) +map(reduce(array, array), #) +map(reduce(list, array), -i32) +map(reduce(list, array), foo) +map(reduce(list, array), half) +map(reduce(list, list), #) +map(sort(array), # / 0.5) +map(sort(array), #) +map(sort(array), greet) +map(split("foo", "bar"), #) +map(true ? "foo" : 0.5, # * #) +map(true ? array : "foo", f32 + #) +map(true ? list : greet, greet) +map(true ? list : list, #) max(-0.5) max(-1) -max(-1, i) -max(-count(list, false), i64) max(-f32) max(-f64) +max(-findIndex(array, ok)) max(-i) -max(-i, i32, i) +max(-i, f32) max(-i32) max(-i64) -max(-i64, 0.5 / f64) -max(0.5 * 0.5) -max(0.5 * f64) +max(-reduce(array, #)) +max(0.5 * f32) max(0.5 * i) -max(0.5 * i, i32) -max(0.5 * i32) +max(0.5 * i64) max(0.5 ** 0.5) max(0.5 ** 1) max(0.5 ** f32) -max(0.5 ** f64) +max(0.5 ** f64 ^ reduce(array, f64)) max(0.5 ** i) -max(0.5 ** i64) -max(0.5 + 0.5) +max(0.5 ** i32) max(0.5 + 1) -max(0.5 + i) -max(0.5 + i32) -max(0.5 + i64) max(0.5 - 0.5) -max(0.5 - 1) -max(0.5 - i) -max(0.5 - i32) -max(0.5 - i64) +max(0.5 - f32) +max(0.5 - f64) max(0.5 / 0.5) -max(0.5 / f32) +max(0.5 / 1) max(0.5 / f64) -max(0.5 / f64, f64) -max(0.5 / i) +max(0.5 / i32) max(0.5 / i64) max(0.5 ^ 0.5) max(0.5 ^ 1) -max(0.5 ^ f32) max(0.5 ^ i) max(0.5 ^ i32) max(0.5 ^ i64) -max(0.5) != i == ok -max(0.5) * f32 -max(0.5) * f64 +max(0.5) != f32 +max(0.5) != i +max(0.5) + f64 max(0.5) + i -max(0.5) - f32 -max(0.5) - f64 -max(0.5) < f64 -max(0.5) <= 0.5 - 0.5 -max(0.5) <= f64 -max(0.5) == f32 -max(0.5) == i64 -max(0.5) > f32 -max(0.5) >= i32 -max(0.5) ^ i32 -max(0.5, 1) <= i32 +max(0.5) - i32 +max(0.5) / i64 +max(0.5) <= i +max(0.5) > f64 +max(0.5) > i +max(0.5) > i64 +max(0.5) >= i64 +max(0.5, 0.5) != i +max(0.5, i) ** i32 max(1 % 1) -max(1 % i) -max(1 % i32) max(1 % i64) max(1 * 0.5) max(1 * 1) +max(1 * f64) +max(1 * i32) max(1 ** 0.5) max(1 ** 1) -max(1 ** f64) +max(1 ** f32) max(1 ** i64) -max(1 + f32, f64) +max(1 + f32) max(1 + i64) -max(1 - 1) -max(1 - i32) -max(1 - i64) -max(1 / 0.5) +max(1 - f32) +max(1 - f64) max(1 / 1) max(1 / f32) +max(1 / f32, i64) max(1 / f64) +max(1 / i) +max(1 / i32) +max(1 / i64) +max(1 ^ 0.5) max(1 ^ 1) +max(1 ^ f32) +max(1 ^ f64) max(1 ^ i32) -max(1) != i -max(1) * i +max(1 ^ i64) +max(1) != 1 ? foo : "bar" +max(1) + f32 max(1) - f64 -max(1) - i64 -max(1) .. i32 +max(1) .. i max(1) / i -max(1) / i64 -max(1) <= f32 -max(1) <= i -max(1) <= i32 -max(1) <= i64 -max(1) == f32 -max(1) > f32 +max(1) == i64 max(1) > f64 -max(1) > i -max(1) > i64 -max(1, i32, f32) != i64 +max(1) > i32 +max(1, i) not in array max(abs(0.5)) max(abs(1)) max(abs(f32)) max(abs(f64)) max(abs(i)) max(abs(i32)) -max(abs(i64)) +max(add(1, i)) max(array[1]) max(array[i64]) -max(array[i]) -max(count(array, false)) -max(count(list, false)) -max(div(1, 1)) -max(f32 * 0.5) +max(bitnand(i32, 1)) +max(bitnot(1)) +max(bitnot(i)) +max(bitnot(i64)) +max(bitshr(1, i32)) +max(bitxor(1, 1)) +max(ceil(0.5), f64 / i64) +max(ceil(f32)) +max(ceil(i32)) max(f32 * 1) -max(f32 * f32) -max(f32 * i32) -max(f32 ** 0.5) +max(f32 * f64) +max(f32 * i64) max(f32 ** 1) -max(f32 ** i32) -max(f32 ** i64) +max(f32 ** f64) max(f32 + 1) max(f32 + f64) +max(f32 + i) max(f32 + i64) -max(f32 - f64) -max(f32 - i) -max(f32 - i32) +max(f32 - 1) +max(f32 - i64) max(f32 / 0.5) max(f32 / f32) -max(f32 ^ 0.5) max(f32 ^ 1) max(f32 ^ f32) -max(f32 ^ i32) +max(f32 ^ f64) max(f32 ^ i64) max(f32) -max(f32) != -i32 -max(f32) != i32 -max(f32) + i64 -max(f32) - f32 -max(f32) <= i -max(f32) <= max(f64) -max(f32) >= i64 +max(f32) * i64 +max(f32) ** i +max(f32) + f32 +max(f32) + f64 +max(f32) - f64 +max(f32) / i32 +max(f32) < i +max(f32) == i max(f32) ^ f32 -max(f32) ^ i32 -max(f32, -f32) -max(f32, 1) > i32 max(f32, f32) max(f32, f64) +max(f32, f64) in array max(f32, i) max(f32, i32) +max(f32, i32) ** i64 max(f32, i64) -max(f32, min(i)) -max(f64 * 0.5) +max(f64 * 1) max(f64 * f64) -max(f64 * i, f32) -max(f64 * i32) -max(f64 ** 1) +max(f64 ** 0.5) +max(f64 ** f64) max(f64 ** i) -max(f64 ** i64) -max(f64 + 0.5) -max(f64 - i32) -max(f64 - i64) -max(f64 / 0.5) -max(f64 / f32) -max(f64 / i32) +max(f64 + 1) +max(f64 + f32) +max(f64 + f64) +max(f64 - 0.5) +max(f64 - i) max(f64 ^ 0.5) -max(f64 ^ i32) -max(f64 ^ i64) +max(f64 ^ 1) +max(f64 ^ f32) +max(f64 ^ f64) max(f64) -max(f64) != i -max(f64) + f32 -max(f64) + i64 -max(f64) - f32 -max(f64) / f32 -max(f64) / i32 -max(f64) == f64 -max(f64) == i32 -max(f64) > f32 -max(f64) > f64 -max(f64) > i64 -max(f64) ^ 1 ^ i64 -max(f64) ^ i -max(f64) ^ min(i32, 1) -max(f64, -1) -max(f64, 0.5 ** i64) -max(f64, 1) <= f64 -max(f64, 1) == i32 +max(f64) != f64 +max(f64) < i32 +max(f64) <= f32 +max(f64) == f32 +max(f64) == i +max(f64) == round(i) +max(f64) ^ f32 +max(f64) ^ i64 max(f64, f32) -max(f64, f32, i32) -max(f64, f32, i64) +max(f64, f32) <= int(f64) max(f64, f64) -max(f64, f64, score(1)) -max(f64, float(i)) -max(f64, half(f64)) max(f64, i) +max(f64, i) - 1 ^ i +max(f64, i) < i +max(f64, i) > f64 max(f64, i32) max(f64, i64) -max(false ? 1 : 0.5) -max(false ? 1 : nil) -max(false ? add : ok) -max(false ? i : nil) -max(false ? i32 : score) -max(false ? true : 1) -max(find(array, ok)) -max(find(array, true)) -max(findIndex(array, ok)) -max(findIndex(array, true)) +max(f64, i64) ^ f32 +max(false ? 0.5 : array) +max(false ? add : f64) +max(false ? div : half) +max(false ? div : i64) +max(false ? ok : 0.5) +max(find(array, false)) +max(findIndex(list, false)) max(findIndex(list, ok)) -max(findIndex(list, true)) max(findLast(array, false)) -max(findLast(array, true)) -max(findLastIndex(array, false)) -max(findLastIndex(list, true)) -max(first(array)) max(float(0.5)) max(float(1)) -max(float(f32)) -max(float(f64)) -max(float(i)) +max(float(1), i) +max(float(i32)) max(float(i64)) -max(float(i64), f64) +max(float(score(i))) +max(floor(0.5)) +max(floor(1)) +max(floor(f32)) +max(floor(i)) +max(floor(i32)) +max(floor(len(array))) max(get(array, 1)) max(get(array, i)) max(get(array, i32)) max(get(array, i64)) -max(half(-0.5)) max(half(0.5)) +max(half(1)) +max(half(1), i64) max(half(f64)) -max(i % i) -max(i % i32) -max(i % i64) +max(i % 1) max(i * 0.5) -max(i * 1) max(i * f32) -max(i * i32) -max(i ** 0.5) -max(i ** 1) +max(i * i) +max(i * i64) max(i ** f64) -max(i ** i) -max(i ** i64) -max(i + 0.5) +max(i ** score(1)) max(i + 1) -max(i + f32) -max(i + f64) -max(i + i) max(i - 1) -max(i - i32) -max(i - i32, f32) +max(i - i) max(i - i64) -max(i / 0.5) -max(i / f32) -max(i / i32, f64) -max(i ^ 0.5) -max(i ^ 1) -max(i ^ f32) max(i ^ f64) max(i) -max(i) != f64 -max(i) ** f64 -max(i) + f32 -max(i) + i64 -max(i) - f32 -max(i) - f64 -max(i) - i32 -max(i) - i64 -max(i) / f64 -max(i) >= i64 -max(i) ^ (i * i) -max(i) ^ f32 -max(i, -f32) +max(i) != i32 +max(i) != i64 +max(i) % (i64 + i) +max(i) % array[i32] +max(i) ** (1 / i32) +max(i) + f64 +max(i) - i +max(i) / f32 +max(i) / i +max(i) < 0.5 - f64 +max(i) < f32 +max(i) < i32 +max(i) <= f64 +max(i) == f64 +max(i) >= i max(i, f32) -max(i, f32, f32) max(i, f64) max(i, i) max(i, i32) max(i, i64) -max(i, i64, i64) +max(i, i64, i32) max(i32 % 1) -max(i32 % i32) max(i32 * 0.5) max(i32 * 1) max(i32 * f32) +max(i32 * i) max(i32 * i64) -max(i32 + 0.5, f64) -max(i32 + f64) -max(i32 + i) -max(i32 + i32) +max(i32 ** f32) +max(i32 ** i) +max(i32 ** i32) +max(i32 + 0.5) +max(i32 + i64) +max(i32 - 0.5) +max(i32 - 1) +max(i32 - f64) max(i32 - i) -max(i32 - i64) -max(i32 / f32) -max(i32 / f64) -max(i32 / i64) -max(i32 ^ 0.5) -max(i32 ^ 1) -max(i32 ^ f32) +max(i32 / 1) max(i32 ^ i) -max(i32 ^ i32) +max(i32 ^ i, f32) max(i32) -max(i32) != min(i64) -max(i32) - f32 -max(i32) - i64 +max(i32) * i32 max(i32) / f32 -max(i32) >= i32 -max(i32) ^ i64 -max(i32, 1) == i32 -max(i32, abs(f64)) +max(i32) / i +max(i32) <= f32 +max(i32) ^ f32 +max(i32) in array max(i32, f32) -max(i32, f32) != i32 max(i32, f64) -max(i32, f64) - f32 max(i32, i) -max(i32, i, i) max(i32, i32) -max(i32, i32, i) max(i32, i64) max(i64 % i) -max(i64 % i32) max(i64 * 0.5) -max(i64 * 1) -max(i64 * f32) -max(i64 * i32) -max(i64 ** 1) +max(i64 * i64) +max(i64 ** 0.5) +max(i64 ** f32) max(i64 ** i64) -max(i64 + 0.5) -max(i64 + f32) -max(i64 + i32) +max(i64 + i) +max(i64 + i64) max(i64 - 0.5) max(i64 - 1) -max(i64 - f32) max(i64 - f64) -max(i64 - i) -max(i64 / 1) max(i64 / f64) -max(i64 / i) +max(i64 / i32) max(i64 / i64) max(i64 ^ 0.5) max(i64 ^ 1) max(i64 ^ i) -max(i64 ^ i64) max(i64) -max(i64) != f32 -max(i64) != i32 -max(i64) * i32 -max(i64) * i64 -max(i64) ** i64 -max(i64) + f32 -max(i64) + i64 -max(i64) / f32 -max(i64) / i -max(i64) / i64 +max(i64) ** (1 + 1) +max(i64) ** f32 +max(i64) + i32 +max(i64) - i32 +max(i64) - i64 +max(i64) .. i32 max(i64) < f32 -max(i64) < i64 -max(i64) <= i -max(i64) == f32 -max(i64) == f64 -max(i64) >= i32 -max(i64) ^ (i64 / f32) -max(i64) in array -max(i64, 1) * i32 +max(i64) >= f32 +max(i64) ^ i +max(i64, 0.5 + 1) +max(i64, 0.5, i64) ** i32 max(i64, f32) max(i64, f64) +max(i64, half(1)) max(i64, i) +max(i64, i) + i32 max(i64, i32) +max(i64, i32) == f64 max(i64, i64) max(int(0.5)) -max(int(1)) max(int(f32)) -max(int(f64)) -max(int(i)) max(int(i32)) max(int(i64)) -max(last(array)) -max(len("bar")) max(len("foo")) max(len(array)) max(len(list)) -max(len(list), 0.5 - i) max(max(0.5)) -max(max(0.5, 0.5)) +max(max(0.5, f64)) max(max(1)) -max(max(f32)) -max(max(f64)) max(max(i)) max(max(i32)) max(max(i64)) -max(min(0.5)) -max(min(0.5, i)) +max(mean(array)) +max(median(array)) +max(min(0.5, 0.5)) max(min(1)) -max(min(1, i64, 1)) -max(min(f32)) -max(min(f64)) -max(min(f64, i64)) +max(min(1, f64)) +max(min(f32, i64, i32)) max(min(i)) max(min(i32)) -max(min(i32, i)) -max(ok ? 1 : foo) +max(ok ? "foo" : f64) +max(ok ? 0.5 : i64) max(ok ? 1 : i) -max(ok ? 1 : i32) -max(ok ? div : foo) -max(ok ? div : i64) -max(ok ? i : true) -max(ok ? ok : i64) -max(ok ? true : 0.5) +max(ok ? array : true) +max(ok ? foo : greet) +max(ok ? half : f32) +max(ok ? half : list) +max(ok ? i : 1) +max(ok ? i : nil) +max(reduce(array, # % #)) +max(reduce(array, #)) +max(reduce(array, 1)) +max(reduce(array, f32)) +max(reduce(array, f64)) +max(reduce(list, 0.5)) +max(reduce(list, f32), i64) +max(reduce(list, i64)) +max(round(1)) +max(round(f32)) +max(round(f64)) +max(round(i)) +max(round(i32)) max(score(1)) -max(score(1), i64) -max(score(i)) -max(score(i, i)) -max(true ? 0.5 : half) -max(true ? 1 : i64) -max(true ? add : list) -max(true ? foo : add) -max(true ? foo : f32) -max(true ? i : ok) -max(true ? i64 : "bar") -min(-(0.5 + i)) -min(-(f32 + i64)) +max(score(i), i) +max(true ? f32 : f32) +max(true ? foo : array) +max(true ? greet : 1) +max({"bar": list}.String) +max({"foo": array}?.f32) +max({"foo": half}?.f32) +mean(1 .. 1) +mean(1 .. i) +mean([f64, 0.5]) +mean([i]) +mean(array) +mean(array) * i +mean(array) + i +mean(array) - min(i) +mean(array) / i +mean(array) / i64 +mean(array) < f32 +mean(array) < f64 +mean(array) <= i64 +mean(array) > f32 +mean(array) >= f32 +mean(array) >= i64 +mean(array) ^ i +mean(array) ^ i32 +mean(filter(array, true)) +mean(groupBy(array, i64).score) +mean(i .. 1) +mean(i .. i) +mean(map(array, #)) +mean(map(array, -#)) +mean(map(array, f32)) +mean(map(array, i)) +mean(map(array, i32)) +mean(map(list, 1)) +mean(map(list, f32)) +mean(map(list, i)) +mean(map(list, i32)) +mean(sort(array)) +median(1 .. i) +median(array) +median(array) != f32 +median(array) * 1 * f32 +median(array) * i32 +median(array) ** i64 +median(array) + f32 +median(array) >= i32 +median(array) ^ i32 +median(array) ^ i64 +median(array) not in array +median(array[1:1]) +median(filter(array, ok)) +median(groupBy(list, #).i32) +median(i .. i) +median(i .. i64) +median(i64 .. i64) +median(map(array, #)) +median(map(array, 1)) +median(map(list, 0.5)) +median(map(list, f32)) +median(map(list, i32)) +median(reduce(array, array)) +median(reduce(list, array)) +median(sort(array)) min(-0.5) min(-0.5, i) min(-1) -min(-1, i) -min(-1, i64) min(-f32) -min(-f32, i64) min(-f64) -min(-f64, i32) +min(-half(0.5)) min(-i) min(-i32) min(-i64) min(0.5 * 0.5) min(0.5 * 1) +min(0.5 * f32, i32 ** i32) min(0.5 * f64) min(0.5 * i32) -min(0.5 ** 0.5) -min(0.5 ** f64) +min(0.5 * i64) +min(0.5 ** i) min(0.5 ** i64) -min(0.5 + 1) -min(0.5 + f32) min(0.5 + f64) min(0.5 + i) +min(0.5 + i32) min(0.5 - 0.5) min(0.5 - 1) +min(0.5 - f32) min(0.5 - f64) min(0.5 - i) min(0.5 / 0.5) -min(0.5 / f64) -min(0.5 ^ 1) +min(0.5 / i64) +min(0.5 / i64, i64) +min(0.5 ^ 0.5) min(0.5 ^ f32) min(0.5 ^ i) -min(0.5) != i32 -min(0.5) * 0.5 ** i64 +min(0.5 ^ i32) +min(0.5) != i64 +min(0.5) * i32 +min(0.5) ** f64 min(0.5) ** i -min(0.5) + i -min(0.5) + i32 -min(0.5) + i64 -min(0.5) < f32 -min(0.5) <= i ? f32 : 1 -min(0.5) <= i64 -min(0.5) == i - 0.5 -min(0.5) > i64 -min(0.5) >= i -min(0.5, 0.5) == f32 -min(0.5, 1) >= i64 -min(0.5, i) == i64 -min(0.5, i32, f32) + f32 +min(0.5) + f64 ^ i64 +min(0.5) - f32 +min(0.5) - f64 +min(0.5) / i32 +min(0.5) < i32 +min(0.5) == f32 / f32 +min(0.5) == i +min(0.5) >= i64 +min(0.5) ^ (f32 - i64) +min(0.5, 0.5) < f32 + f64 +min(1 % 1) +min(1 % i) min(1 % i32) min(1 % i64) min(1 * 0.5) min(1 * 1) +min(1 * f32) min(1 * i) min(1 * i32) -min(1 * i64) -min(1 ** 0.5) -min(1 ** f32) -min(1 ** f64) -min(1 ** i32) +min(1 ** i) min(1 + 0.5) min(1 + 1) min(1 + f32) -min(1 + i32) min(1 + i64) min(1 - 1) min(1 - f64) min(1 - i) min(1 - i32) -min(1 / 1) +min(1 - i64) +min(1 / 0.5) +min(1 / f32) min(1 / i) min(1 / i32) -min(1 / i32, f64) min(1 / i64) +min(1 ^ 0.5) min(1 ^ 1) min(1 ^ f32) -min(1 ^ f64) -min(1) != 1 ? list : f64 +min(1 ^ i) +min(1 ^ i32) +min(1 ^ i64) min(1) != i -min(1) % i64 -min(1) * -0.5 -min(1) * 1 ** 1 -min(1) - i64 ^ 0.5 -min(1) .. i -min(1) .. i64 -min(1) / f64 -min(1) / i -min(1) < i -min(1) == f64 -min(1) == i32 +min(1) - i +min(1) .. i32 +min(1) <= f32 +min(1) <= f64 +min(1) > i64 +min(1) >= i min(1) >= i64 -min(1) ^ f32 +min(1) ^ f64 min(abs(0.5)) min(abs(1)) min(abs(f32)) min(abs(f64)) -min(abs(i * 1)) min(abs(i)) min(abs(i32)) -min(abs(i64)) -min(abs(i64), f64) -min(add(1, i)) -min(add(i, i)) min(array[1]) +min(array[i32]) min(array[i]) +min(bitnand(1, i32)) +min(bitnot(1)) +min(bitnot(i)) +min(bitnot(i32)) +min(bitnot(i32), i64) +min(bitnot(i64)) +min(ceil(0.5)) +min(ceil(1)) +min(ceil(f32)) +min(ceil(f64)) +min(ceil(i)) min(count(array, false)) -min(count(array, ok)) -min(count(array, true)) min(count(list, ok)) min(f32 * 1) -min(f32 * f32) -min(f32 * i32) -min(f32 ** i32) -min(f32 ** i64) -min(f32 ** i64, f32) -min(f32 + f64) -min(f32 + i) -min(f32 + i32) -min(f32 + i64) -min(f32 - f32) +min(f32 * i64) +min(f32 ** 0.5) +min(f32 - 0.5) +min(f32 - 1) +min(f32 - f64) min(f32 - i) -min(f32 - i32) min(f32 - i64) -min(f32 / 0.5) -min(f32 / f64) -min(f32 / i) -min(f32 / i32) +min(f32 / 1) min(f32 / i64) -min(f32 ^ 1) -min(f32 ^ f32) -min(f32 ^ i) min(f32 ^ i32) min(f32) -min(f32) * f32 -min(f32) * f64 -min(f32) + i -min(f32) + i32 -min(f32) + i64 -min(f32) - f32 -min(f32) < i64 +min(f32) * i64 +min(f32) / f64 +min(f32) / i32 min(f32) == i -min(f32) == i32 * i32 -min(f32) == i64 -min(f32) > i32 -min(f32) ^ f64 -min(f32, 0.5 ^ 0.5) -min(f32, 0.5) <= i64 +min(f32) >= f64 +min(f32, -0.5) +min(f32, ceil(1)) min(f32, f32) min(f32, f64) -min(f32, f64) >= i -min(f32, get(array, i64)) min(f32, i) min(f32, i32) min(f32, i64) -min(f32, len(array)) -min(f32, len(list)) -min(f64 * 0.5) min(f64 * 1) min(f64 * f64) -min(f64 * i) -min(f64 * i32) -min(f64 ** 1) +min(f64 ** f32) min(f64 ** f64) -min(f64 ** i) -min(f64 ** i32) -min(f64 ** i64) -min(f64 + 1) -min(f64 + i) +min(f64 + 0.5) +min(f64 + f32) min(f64 + i64) -min(f64 - 0.5) +min(f64 - 1) min(f64 - i) min(f64 - i32) -min(f64 - i64) -min(f64 / 1) +min(f64 / 0.5) min(f64 / f32) min(f64 / i) -min(f64 / i32) min(f64 / i64) -min(f64 ^ 0.5) -min(f64 ^ f64) -min(f64 ^ i32) +min(f64 ^ 1) min(f64) -min(f64) + f64 -min(f64) + i32 -min(f64) + i64 -min(f64) / f32 -min(f64) ^ 1 ^ 1 -min(f64) ^ i32 -min(f64) ^ i64 -min(f64, 0.5 ** 1) -min(f64, 0.5, i) <= f64 -min(f64, 1 ** i) -min(f64, 1) < i64 +min(f64) * f64 +min(f64) * i32 +min(f64) / i +min(f64) >= f64 +min(f64, 0.5 ** i64) +min(f64, 0.5) == f64 min(f64, f32) min(f64, f64) -min(f64, f64, i64) min(f64, i) min(f64, i32) min(f64, i64) -min(false ? 1 : add) -min(false ? f64 : false) -min(false ? f64 : score) -min(false ? foo : 1) -min(false ? greet : i) -min(false ? i32 : "foo") -min(false ? i32 : i64) -min(false ? true : 0.5) +min(false ? foo : i32) +min(false ? greet : f32) min(find(array, false)) min(find(array, ok)) -min(findIndex(list, ok)) -min(findLast(array, true)) -min(findLastIndex(array, false)) +min(findIndex(array, false)) +min(findLastIndex(array, i32 > #)) min(findLastIndex(array, ok)) min(findLastIndex(array, true)) min(findLastIndex(list, ok)) @@ -10879,220 +13414,188 @@ min(float(1)) min(float(f32)) min(float(f64)) min(float(i)) -min(float(i32)) -min(float(i64)) -min(get(array, i)) -min(get(array, i64)) -min(half(0.5 ^ i32)) +min(float(i64), i) +min(floor(0.5)) +min(floor(1)) +min(floor(f32)) +min(floor(i)) +min(floor(i32)) +min(floor(i64)) min(half(0.5)) -min(half(0.5), f32) +min(half(1)) +min(half(1), -1) +min(half(f64 - 0.5)) min(half(f64)) min(i % 1) -min(i % i32) min(i % i64) -min(i * 0.5) -min(i * 1) min(i * i) -min(i * i64) min(i ** 0.5) -min(i ** f32) -min(i ** f64) min(i ** i) -min(i ** i64) -min(i + 0.5) -min(i + f32) -min(i + f64) -min(i + i) +min(i + 1) min(i - 0.5) -min(i - 1) -min(i - i) -min(i / 0.5) -min(i / i64) -min(i / i64, i) -min(i ^ 0.5) -min(i ^ i, i32) +min(i - f64) +min(i - i32) +min(i / 1) + f64 +min(i / f64) +min(i ^ f32) +min(i ^ f64) +min(i ^ i) min(i) -min(i) != i32 -min(i) % i min(i) * f32 -min(i) ** i -min(i) .. i +min(i) ** i64 min(i) / f64 -min(i) < f32 -min(i) <= i64 +min(i) / i +min(i) < f64 +min(i) < i32 +min(i) >= i32 +min(i) ^ f32 min(i, f32) +min(i, f32, i) + i32 min(i, f64) min(i, i) -min(i, i32 - i) min(i, i32) -min(i, i64 * f32) min(i, i64) -min(i32 % i) -min(i32 * 1) -min(i32 * f64) -min(i32 * i32) -min(i32 ** 1 ^ i64) -min(i32 ** f32) -min(i32 ** i) -min(i32 ** i64) -min(i32 + 0.5) -min(i32 + 1) -min(i32 + f32) +min(i, last(array)) +min(i32 % 1) +min(i32 * f32) +min(i32 * i) +min(i32 ** 0.5) +min(i32 ** i32) +min(i32 + i32) +min(i32 + i64) min(i32 - 0.5) -min(i32 - 1) -min(i32 - i32) -min(i32 / 1) -min(i32 / i) -min(i32 / i64) -min(i32 / i64, score(1)) -min(i32 ^ 1) +min(i32 - i64) +min(i32 / 0.5) +min(i32 / f64) +min(i32 ^ 0.5) +min(i32 ^ f32) min(i32 ^ f64) -min(i32 ^ i) min(i32 ^ i64) min(i32) -min(i32) != i64 -min(i32) + f32 -min(i32) - i64 -min(i32) / f32 -min(i32) < i32 -min(i32) == f32 -min(i32) == i32 -min(i32) >= i32 -min(i32) ^ f64 -min(i32, 0.5) .. i32 +min(i32) - i +min(i32) .. i32 +min(i32) / i +min(i32) < i +min(i32) <= f32 +min(i32) <= i +min(i32) > f32 +min(i32) > i64 + f64 +min(i32) >= i +min(i32) ^ f32 +min(i32) ^ i64 min(i32, f32) +min(i32, f64 * 0.5) min(i32, f64) min(i32, i) min(i32, i32) -min(i32, i32, i) min(i32, i64) -min(i32, i64) .. i -min(i32, i64) <= f64 -min(i32, min(i)) -min(i64 % i32) -min(i64 * 1, f32) -min(i64 * f64) +min(i64 % 1) +min(i64 * 0.5) +min(i64 * 1) +min(i64 * bitnot(i64)) +min(i64 * i) min(i64 * i32) +min(i64 * i64) min(i64 ** 0.5) -min(i64 ** 1) +min(i64 ** f64) min(i64 ** i) -min(i64 + 0.5) -min(i64 + 1) +min(i64 ** i32) min(i64 + f32) -min(i64 + i) -min(i64 + i32) -min(i64 - 0.5) -min(i64 - f32) min(i64 - f64) -min(i64 - i) -min(i64 - i64) -min(i64 / 0.5) -min(i64 / f64) +min(i64 - i32) +min(i64 / 1) +min(i64 / f32) min(i64 / i) +min(i64 / i32) min(i64 / i64) +min(i64 ^ 0.5) min(i64 ^ 1) +min(i64 ^ f64) min(i64 ^ i32) -min(i64 ^ i64) min(i64) -min(i64) != i64 -min(i64) % i32 -min(i64) ** -1 -min(i64) ** -f64 -min(i64) ** i -min(i64) + i32 -min(i64) .. i -min(i64) .. i64 -min(i64) <= f32 -min(i64) == i -min(i64) ^ f32 -min(i64) ^ f64 -min(i64) in array -min(i64, 1 ** 0.5) -min(i64, 1) <= f64 +min(i64) / f32 +min(i64) < i32 +min(i64) >= f64 +min(i64) not in array min(i64, f32) min(i64, f64) -min(i64, f64) != f64 -min(i64, f64) * i32 -min(i64, f64, i32) min(i64, i) min(i64, i32) -min(i64, i32, i) min(i64, i64) -min(i64, i64, f32) +min(i64, i64) < i64 min(int(0.5)) min(int(1)) min(int(f32)) min(int(f64)) min(int(i)) +min(int(i32)) min(int(i64)) +min(last(1 .. 1)) min(last(array)) -min(len("bar")) -min(len("foo")) min(len(array)) min(len(list)) -min(len(list), f64) min(max(0.5)) -min(max(1)) min(max(1, 0.5)) -min(max(1, f32)) -min(max(1, i32)) min(max(f32)) min(max(f64)) -min(max(i), i64) -min(max(i32)) -min(min(0.5)) -min(min(0.5, 1)) +min(max(i)) +min(max(i64, 1)) +min(mean(array)) min(min(1)) -min(min(f32)) -min(min(f32, i, i32)) -min(min(f64)) +min(min(1, 1, 1)) +min(min(1, i, f32)) min(min(i)) min(min(i32)) -min(min(i64)) -min(ok ? add : 0.5) -min(ok ? f32 : "foo") -min(ok ? f64 : true) -min(ok ? foo : 1) -min(ok ? true : 1) +min(min(reduce(list, f32))) +min(ok ? array : false) +min(ok ? f64 : i) +min(ok ? half : ok) +min(ok ? i : f32) +min(ok ? array : score) +min(ok ? true : div) +min(reduce(array, #)) +min(reduce(array, 0.5)) +min(reduce(array, 1)) +min(reduce(list, 1)) +min(round(0.5)) +min(round(1)) +min(round(f32)) +min(round(i32)) +min(round(i64)) min(score(1)) min(score(i)) -min(true ? 0.5 : ok) -min(true ? 1 : greet) -min(true ? add : greet) -min(true ? f32 : i) -min(true ? foo : 0.5) -min(true ? foo : half) -min(true ? i : 1) -min(true ? i32 : score) -nil != "bar" ? i64 : 0.5 - i -nil != 0.5 && 0.5 != f32 -nil != 1 && ok -nil != 1 or any(list, false) -nil != 1 || ok -nil != f32 || ok -nil != f64 && ok -nil != f64 or ok -nil != f64 || array != array -nil != false and not true -nil != false and ok -nil != false || ok -nil != foo == ok -nil != foo || ok +min(sum(array)) +min(true ? i : "foo") +min(true ? i : i32) +min(true ? i64 : "foo") +nil != array != nil ? add : half +nil != array && ok +nil != div == reduce(array, ok) +nil != f64 || ok || false +nil != false && ok +nil != false or i == nil +nil != foo and ok nil != foo.Bar nil != foo.Qux nil != foo.String +nil != foo.String() nil != foo?.Bar nil != foo?.Qux nil != foo?.String -nil != greet ? half : half -nil != greet or f32 < i -nil != i32 or f32 >= 1 -nil != i64 or i >= 1 -nil != ok == not true -nil != true == ok -nil == 1 != nil ? "bar" : i32 -nil == add == ("bar" not endsWith "foo") -nil == f32 && i64 < f64 +nil != foo?.String() +nil != nil ? score : div +nil != true || i < 1 +nil == "foo" != ok +nil == "foo" && 0.5 < f64 +nil == 0.5 and reduce(list, true) +nil == add && 0.5 >= 0.5 +nil == add || f32 >= i64 +nil == array and ok +nil == array or ok +nil == array[i64] +nil == div ? f64 : ok +nil == false && nil != true +nil == false ? i64 : toBase64("bar") nil == foo.Bar nil == foo.Qux nil == foo.String @@ -11100,28 +13603,30 @@ nil == foo.String() nil == foo?.Bar nil == foo?.Qux nil == foo?.String -nil == foo?.String() -nil == i64 ? add : add -nil == nil == ok -nil == true ? i64 ^ f32 : foo -nil == true || ok -nil in array || ok -nil in array[i32:i64] -nil in list and ok -none(array, !ok) +nil == greet ? i : greet("bar") +nil == list || f32 == i +nil == list[i32] +nil == nil and ok +nil in array || score == nil +nil in list != not false +none(1 .. i, # < #) +none(1 .. i32, # <= #) +none([foo, list, 1 >= i], ok) +none([greet], ok) +none([true], #) +none(array, !(i32 != i32)) +none(array, !false) none(array, !true) -none(array, "bar" == "bar") +none(array, "bar" endsWith "foo") none(array, # != #) +none(array, # != 0.5) none(array, # != 1) none(array, # != f32) none(array, # != f64) -none(array, # != i32) -none(array, # != i64) +none(array, # != i) none(array, # < #) none(array, # < 0.5) -none(array, # < 1) none(array, # < f32) -none(array, # < i) none(array, # < i32) none(array, # < i64) none(array, # <= #) @@ -11130,155 +13635,164 @@ none(array, # <= 1) none(array, # <= f32) none(array, # <= i) none(array, # <= i32) +none(array, # <= i64) none(array, # == #) none(array, # == 0.5) -none(array, # == 1) -none(array, # == i) +none(array, # == f32) +none(array, # == i32) +none(array, # == i64) none(array, # == nil) none(array, # > #) none(array, # > 0.5) -none(array, # > f32) -none(array, # > f64) none(array, # > i) -none(array, # > i32) none(array, # >= #) none(array, # >= 0.5) none(array, # >= 1) none(array, # >= f32) none(array, # >= f64) +none(array, # >= i32) +none(array, # >= i64) none(array, # in array) -none(array, # not in array) none(array, 0.5 != #) -none(array, 0.5 != f32) +none(array, 0.5 != 1) none(array, 0.5 < #) -none(array, 0.5 <= 0.5) +none(array, 0.5 < i64) +none(array, 0.5 <= #) none(array, 0.5 <= 1) -none(array, 0.5 <= i) -none(array, 0.5 > #) +none(array, 0.5 <= f64) +none(array, 0.5 == #) +none(array, 0.5 > 0.5) +none(array, 0.5 > 1) +none(array, 0.5 > f32) none(array, 0.5 >= #) -none(array, 1 != #) +none(array, 0.5 >= 1) none(array, 1 < #) -none(array, 1 < 0.5) -none(array, 1 < i) -none(array, 1 < i64) -none(array, 1 <= 1) -none(array, 1 == #) -none(array, 1 == f64) +none(array, 1 <= #) +none(array, 1 == 1) none(array, 1 > #) -none(array, 1 > f64) -none(array, 1 >= i) -none(array, add != greet) -none(array, all(array, true)) -none(array, div == greet) +none(array, any(array, true)) none(array, f32 != #) -none(array, f32 != nil) -none(array, f32 <= #) +none(array, f32 < 0.5) +none(array, f32 < 1) +none(array, f32 == 1) +none(array, f32 > #) none(array, f32 >= #) -none(array, f64 != #) +none(array, f32 >= 1) +none(array, f32 >= f32) +none(array, f64 != 1) none(array, f64 == #) -none(array, f64 >= 0.5) -none(array, half != nil) +none(array, f64 > #) +none(array, f64 >= #) +none(array, i != #) none(array, i < #) -none(array, i < 1) +none(array, i < f64) none(array, i <= #) -none(array, i == i64) -none(array, i not in array) +none(array, i > #) +none(array, i >= #) +none(array, i >= 0.5) +none(array, i >= i32) none(array, i32 != #) -none(array, i32 != f64) +none(array, i32 != i) none(array, i32 != nil) none(array, i32 < #) none(array, i32 > #) -none(array, i32 >= #) -none(array, i64 < #) -none(array, i64 < f64) +none(array, i64 != #) +none(array, i64 != 0.5) +none(array, i64 > i64) none(array, i64 >= #) -none(array, nil != 0.5) -none(array, nil != div) +none(array, nil != "bar") +none(array, nil != #) +none(array, nil != false) +none(array, nil != greet) none(array, nil == #) none(array, nil == 1) -none(array, nil == div) -none(array, none(array, !true)) -none(array, not ok) -none(array, ok == nil) +none(array, nil == f32) +none(array, nil == greet) +none(array, nil == half) +none(array, not (# == #)) +none(array, not (# >= 1)) +none(array, not false) none(array, ok) -none(array, ok) != ok -none(array, ok) ? f32 : !ok -none(array, score == nil) -none(array, score == score) -none(array, true ? ok : f64) -none(array, true or true) -none(i64 .. i32, # > #) -none(list, "bar" not in #) +none(array, reduce(array, true)) +none(filter(array, # >= f64), ok) +none(groupBy(array, #).f64, # or #.Bar) +none(groupBy(list, #).div, ok) +none(groupBy(list, #).greet, #) +none(groupBy(list, 0.5).i, ok) +none(i .. i, ok) +none(i .. i32, # <= #) +none(list, !false) +none(list, !ok) +none(list, "bar" contains "bar") none(list, # != #) none(list, # != foo) none(list, # != nil) none(list, # == #) -none(list, # == nil) -none(list, 0.5 != i) -none(list, 0.5 <= 1) -none(list, 0.5 <= f64) -none(list, 0.5 == nil) -none(list, 1 < i32) +none(list, # == foo) +none(list, # in list) +none(list, # not in list) +none(list, (0.5 not in array) || ok) +none(list, 0.5 != i32) +none(list, 0.5 > f64) +none(list, 0.5 > i) +none(list, 1 != i64) +none(list, 1 != nil) none(list, 1 == f32) -none(list, any(list, ok)) -none(list, array == nil) -none(list, f32 > i) -none(list, f64 == i32) -none(list, false && false) -none(list, false) or f64 >= i64 +none(list, 1 > 0.5) +none(list, all(array, ok)) +none(list, f32 != 1 ** f64) +none(list, f32 >= 0.5) +none(list, f32 in array) +none(list, f32 not in array) +none(list, f64 <= i32) +none(list, f64 >= 1) +none(list, false) ? ok : half +none(list, false) || ok none(list, foo != #) -none(list, foo == #) -none(list, greet != add) -none(list, greet != half) -none(list, i <= i64) -none(list, i >= 1) -none(list, i >= f64) -none(list, i not in array) -none(list, i32 != nil) -none(list, i32 == f64) -none(list, i32 == nil) -none(list, i32 >= 1) -none(list, i32 >= f32) -none(list, i64 < f64) -none(list, i64 <= f64) -none(list, i64 > f64) +none(list, foo == foo) +none(list, i != i) +none(list, i != i64) +none(list, i >= f32) +none(list, i32 == f32) +none(list, i32 > 1) +none(list, i32 > i64) +none(list, i32 not in array) +none(list, i64 != 0.5) none(list, i64 > i64) -none(list, nil != array) -none(list, nil != true) -none(list, nil == foo) +none(list, nil != #) +none(list, nil != greet) +none(list, nil != i64) +none(list, nil == #) +none(list, nil == list) none(list, not false) -none(list, not ok) none(list, ok) -none(list, one(array, false)) -none(list, score != nil) -none(list, score == add) +none(list, one(array, true)) none(list, true && ok) -none(list, true == ok) -none(list, true) ? div : array -none(map(array, "bar"), # not endsWith #) -none(map(array, "foo"), # not endsWith #) +none(list, true) and ok none(map(array, #), ok) -none(map(array, 0.5), # == #) -none(map(array, 1), # >= #) -none(map(array, half), # == #) -none(map(array, ok), #) -none(map(list, "bar"), # not startsWith #) -none(map(list, "bar"), # startsWith #) -none(map(list, #), # != #) +none(map(array, div), # != #) +none(map(array, f64 == #), ok) +none(map(list, "bar"), # endsWith #) +none(map(list, #), nil == list) none(map(list, #), ok) -none(map(list, i32), f64 > #) -none(map(list, true), # != #) -none(ok ? "bar" : ok, # >= f64) -not !("foo" not matches "foo") -not !(0.5 > 1) -not !(f64 >= i32) -not !(false && ok) -not !(i >= i32) +none(map(list, 1), i > #) +none(map(list, ok), # ? true : #) +none(map(list, ok), #) +none(map(list, score), ok) +none(sort(filter(array, false)), #?.div > greet(#)) +not !(0.5 != i64) +not !(i < 1) +not !(i >= 0.5) +not !(i32 != i32) +not !(nil != false) not !false +not !not false not !ok not !true +not ("bar" != "bar") not ("bar" != "foo") not ("bar" != nil) +not ("bar" < "bar") not ("bar" < "foo") not ("bar" <= "bar") not ("bar" <= "foo") @@ -11295,6 +13809,7 @@ not ("bar" endsWith "bar") not ("bar" endsWith "foo") not ("bar" in foo) not ("bar" matches "bar") +not ("bar" matches "foo") not ("bar" not contains "bar") not ("bar" not contains "foo") not ("bar" not endsWith "bar") @@ -11302,6 +13817,8 @@ not ("bar" not endsWith "foo") not ("bar" not in foo) not ("bar" not matches "bar") not ("bar" not matches "foo") +not ("bar" not startsWith "bar") +not ("bar" not startsWith "foo") not ("bar" startsWith "bar") not ("bar" startsWith "foo") not ("foo" != "bar") @@ -11316,7 +13833,9 @@ not ("foo" == "foo") not ("foo" == nil) not ("foo" > "bar") not ("foo" > "foo") +not ("foo" >= "bar") not ("foo" >= "foo") +not ("foo" contains "bar") not ("foo" contains "foo") not ("foo" endsWith "bar") not ("foo" endsWith "foo") @@ -11328,13 +13847,13 @@ not ("foo" not contains "foo") not ("foo" not endsWith "bar") not ("foo" not endsWith "foo") not ("foo" not in foo) -not ("foo" not matches "bar") not ("foo" not matches "foo") -not ("foo" not startsWith "bar") not ("foo" not startsWith "foo") +not ("foo" startsWith "bar") not ("foo" startsWith "foo") not (0.5 != 0.5) not (0.5 != 1) +not (0.5 != f32) not (0.5 != f64) not (0.5 != i) not (0.5 != i32) @@ -11358,6 +13877,7 @@ not (0.5 == 0.5) not (0.5 == 1) not (0.5 == f32) not (0.5 == f64) +not (0.5 == i && i32 != i32) not (0.5 == i) not (0.5 == i32) not (0.5 == i64) @@ -11376,6 +13896,8 @@ not (0.5 >= f64) not (0.5 >= i) not (0.5 >= i32) not (0.5 >= i64) +not (0.5 in array) +not (0.5 not in array) not (1 != 0.5) not (1 != 1) not (1 != f32) @@ -11384,7 +13906,6 @@ not (1 != i) not (1 != i32) not (1 != i64) not (1 != nil) -not (1 + i > 0.5 ** i32) not (1 < 0.5) not (1 < 1) not (1 < f32) @@ -11404,6 +13925,7 @@ not (1 == 1) not (1 == f32) not (1 == f64) not (1 == i) +not (1 == i32) not (1 == i64) not (1 == nil) not (1 > 0.5) @@ -11420,40 +13942,25 @@ not (1 >= f64) not (1 >= i) not (1 >= i32) not (1 >= i64) -not (1 ^ f32 != i64) not (1 in array) not (1 not in array) -not (abs(i) <= i) not (add != add) -not (add != div) -not (add != greet) -not (add != half) not (add != nil) -not (add != score) -not (add == add) not (add == div) -not (add == greet) -not (add == half) not (add == nil) -not (add == score) not (array != array) not (array != list) not (array != nil) not (array == array) not (array == list) not (array == nil) +not (array[i32] > i64) not (div != add) not (div != div) -not (div != greet) -not (div != half) not (div != nil) -not (div != score) not (div == add) not (div == div) -not (div == greet) -not (div == half) not (div == nil) -not (div == score) not (f32 != 0.5) not (f32 != 1) not (f32 != f32) @@ -11464,7 +13971,6 @@ not (f32 != i64) not (f32 != nil) not (f32 < 0.5) not (f32 < 1) -not (f32 < abs(0.5)) not (f32 < f32) not (f32 < f64) not (f32 < i) @@ -11472,7 +13978,6 @@ not (f32 < i32) not (f32 < i64) not (f32 <= 0.5) not (f32 <= 1) -not (f32 <= f32) not (f32 <= f64) not (f32 <= i) not (f32 <= i32) @@ -11481,6 +13986,7 @@ not (f32 == 0.5) not (f32 == 1) not (f32 == f32) not (f32 == f64) +not (f32 == i) not (f32 == i32) not (f32 == i64) not (f32 == nil) @@ -11488,15 +13994,19 @@ not (f32 > 0.5) not (f32 > 1) not (f32 > f32) not (f32 > f64) +not (f32 > i) not (f32 > i32) +not (f32 > i64) not (f32 >= 0.5) not (f32 >= 1) not (f32 >= f32) not (f32 >= f64) not (f32 >= i) +not (f32 >= i32) not (f32 >= i64) +not (f32 in array) +not (f32 not in array) not (f64 != 0.5) -not (f64 != 1 * 0.5) not (f64 != 1) not (f64 != f32) not (f64 != f64) @@ -11508,28 +14018,29 @@ not (f64 < 0.5) not (f64 < 1) not (f64 < f32) not (f64 < f64) -not (f64 < i) not (f64 < i32) not (f64 < i64) +not (f64 <= -0.5) not (f64 <= 0.5) not (f64 <= 1) not (f64 <= f32) not (f64 <= f64) +not (f64 <= i) not (f64 <= i32) not (f64 <= i64) not (f64 == 0.5) not (f64 == 1) -not (f64 == f32) not (f64 == f64) not (f64 == i) not (f64 == i32) -not (f64 == i64 - f32) +not (f64 == i64) not (f64 == nil) not (f64 > 0.5) not (f64 > 1) not (f64 > f32) not (f64 > f64) not (f64 > i) +not (f64 > i32) not (f64 > i64) not (f64 >= 0.5) not (f64 >= 1) @@ -11538,16 +14049,18 @@ not (f64 >= f64) not (f64 >= i) not (f64 >= i32) not (f64 >= i64) +not (f64 in array) +not (f64 not in array) not (false != false) not (false != nil) not (false != ok) not (false != true) +not (false && false) not (false && ok) -not (false && true) -not (false == false) not (false == nil) -not (false == true) +not (false == ok) not (false and false) +not (false and ok) not (false and true) not (false or false) not (false or ok) @@ -11555,35 +14068,21 @@ not (false or true) not (false || false) not (false || ok) not (false || true) +not (findIndex(list, ok) != i ^ f64) not (foo != foo) not (foo != nil) not (foo == foo) not (foo == nil) not (foo in list) not (foo not in list) -not (greet != add) -not (greet != div) not (greet != greet) -not (greet != half) not (greet != nil) -not (greet != score) -not (greet == add) -not (greet == div) not (greet == greet) -not (greet == half) not (greet == nil) -not (greet == score) -not (half != add) -not (half != div) -not (half != greet) +not (half != half) not (half != nil) -not (half != score) -not (half == add) -not (half == div) -not (half == greet) not (half == half) not (half == nil) -not (half == score) not (i != 0.5) not (i != 1) not (i != f32) @@ -11603,27 +14102,31 @@ not (i <= 0.5) not (i <= 1) not (i <= f32) not (i <= f64) +not (i <= i) not (i <= i32) not (i <= i64) not (i == 0.5) not (i == 1) +not (i == ceil(f64)) not (i == f32) not (i == f64) not (i == i) not (i == i32) +not (i == i64) not (i == nil) not (i > 0.5) not (i > 1) not (i > f32) not (i > f64) not (i > i) +not (i > i32) not (i > i64) not (i >= 0.5) not (i >= 1) -not (i >= div(1, 1)) not (i >= f32) not (i >= f64) not (i >= i) +not (i >= i32) not (i >= i64) not (i in array) not (i not in array) @@ -11632,10 +14135,13 @@ not (i32 != 1) not (i32 != f32) not (i32 != f64) not (i32 != i) +not (i32 != i32) not (i32 != i64) not (i32 != nil) not (i32 < 0.5) not (i32 < 1) +not (i32 < f32 ** 0.5) +not (i32 < f32) not (i32 < f64) not (i32 < i) not (i32 < i32) @@ -11647,6 +14153,7 @@ not (i32 <= f64) not (i32 <= i) not (i32 <= i32) not (i32 <= i64) +not (i32 == -i) not (i32 == 0.5) not (i32 == 1) not (i32 == f32) @@ -11670,6 +14177,7 @@ not (i32 >= i) not (i32 >= i32) not (i32 >= i64) not (i32 in array) +not (i32 not in array) not (i64 != 0.5) not (i64 != 1) not (i64 != f32) @@ -11685,12 +14193,12 @@ not (i64 < f64) not (i64 < i) not (i64 < i32) not (i64 < i64) -not (i64 < int(f64)) not (i64 <= 0.5) not (i64 <= 1) not (i64 <= f32) not (i64 <= f64) not (i64 <= i) +not (i64 <= i32) not (i64 <= i64) not (i64 == 0.5) not (i64 == 1) @@ -11702,6 +14210,7 @@ not (i64 == i64) not (i64 == nil) not (i64 > 0.5) not (i64 > 1) +not (i64 > f32) not (i64 > f64) not (i64 > i) not (i64 > i32) @@ -11712,8 +14221,7 @@ not (i64 >= f32) not (i64 >= f64) not (i64 >= i) not (i64 >= i32) -not (i64 >= max(i)) -not (i64 in array) +not (i64 >= i64) not (i64 not in array) not (list != array) not (list != list) @@ -11732,7 +14240,6 @@ not (nil != f32) not (nil != f64) not (nil != false) not (nil != foo) -not (nil != greet) not (nil != half) not (nil != i) not (nil != i32) @@ -11767,7 +14274,6 @@ not (nil in array) not (nil in list) not (nil not in array) not (nil not in list) -not (ok != false) not (ok != nil) not (ok != ok) not (ok != true) @@ -11786,24 +14292,17 @@ not (ok or ok) not (ok or true) not (ok || ok) not (ok || true) -not (score != add) -not (score != div) -not (score != greet) -not (score != half) not (score != nil) not (score != score) -not (score == add) -not (score == div) -not (score == greet) -not (score == half) not (score == nil) not (score == score) not (true != false) not (true != nil) not (true != ok) not (true != true) -not (true && ok) +not (true && false) not (true && true) +not (true == false) not (true == nil) not (true == ok) not (true == true) @@ -11812,707 +14311,1729 @@ not (true and ok) not (true and true) not (true or false) not (true or ok) +not (true or true) not (true || false) +not (true || ok) +not (true || true) +not all(array, false) not all(array, ok) not all(array, true) -not all(list, false) +not all(list, nil == #) not all(list, ok) not all(list, true) not any(array, false) not any(array, ok) not any(array, true) -not any(list, # != #) not any(list, false) not any(list, ok) not any(list, true) +not false && nil == f64 not false && ok -not false && ok ? list : array -not false ? "bar" : 0.5 -not false ? "bar" : foo -not false ? "foo" : 0.5 -not false ? 0.5 : greet -not false ? 1 : div -not false ? 1 : i32 -not false ? add : i -not false ? array : "foo" -not false ? array : array -not false ? array : greet -not false ? array : ok -not false ? div : greet -not false ? foo : 1 -not false ? foo : array -not false ? greet : ok -not false ? half : 0.5 -not false ? half : i32 -not false ? i : i64 -not false ? i : score -not false ? i32 : 0.5 -not false ? i32 : add -not false ? i32 : f32 -not false ? i32 : true +not false == ok +not false ? "foo" : "foo" +not false ? 0.5 : "foo" +not false ? 0.5 : array +not false ? 0.5 : div +not false ? 0.5 : foo +not false ? 0.5 : i64 +not false ? 0.5 : nil +not false ? 1 : 0.5 +not false ? add : array +not false ? array : 0.5 +not false ? array : 1 +not false ? array : f64 +not false ? array : i +not false ? array : true +not false ? div : 0.5 +not false ? div : f64 +not false ? f32 : 0.5 +not false ? f32 : 1 +not false ? f32 : i +not false ? f32 : nil +not false ? f32 : score +not false ? f64 : "foo" +not false ? f64 : f64 +not false ? false : half +not false ? false : list +not false ? foo : f64 +not false ? greet : 1 +not false ? i : "bar" +not false ? i : 1 +not false ? i : array +not false ? i : i +not false ? i32 : greet not false ? i64 : list -not false ? list : i32 -not false ? nil : greet -not false ? nil : i32 -not false ? nil : nil -not false ? ok : "bar" +not false ? list : i +not false ? list : true +not false ? nil : f32 +not false ? nil : half +not false ? nil : ok not false ? ok : 1 -not false ? ok : list -not false ? score : "foo" -not false ? score : array -not false ? score : score -not false ? score : true -not false ? true : 0.5 -not false ? true : 1 +not false ? score : ok +not false ? true : f64 not false ? true : nil -not false or "foo" > "bar" -not none(array, # == #) +not false or false == false +not false or ok +not false || ok +not none(array, # > f32) not none(array, false) not none(array, ok) not none(array, true) not none(list, false) not none(list, ok) not none(list, true) -not not ("bar" >= "foo") -not not (1 < i) -not not (add == nil) -not not (half == nil) +not not (f64 <= 1) +not not (i32 < i64) +not not (i64 >= f64) +not not (nil != greet) +not not (ok or ok) not not false not not ok not not true not ok +not ok != ok +not ok && 1 > 0.5 not ok && ok -not ok == ok -not ok ? "bar" : 1 -not ok ? "bar" : f32 -not ok ? 0.5 + f64 : half -not ok ? 0.5 : "foo" +not ok ? "bar" : list +not ok ? "foo" : 0.5 +not ok ? "foo" : 1 +not ok ? 0.5 : "bar" not ok ? 0.5 : 0.5 -not ok ? 0.5 : div -not ok ? 0.5 : f32 -not ok ? 0.5 : greet -not ok ? 1 : 1 -not ok ? add : 0.5 -not ok ? array : f64 -not ok ? array : true -not ok ? div : 1 -not ok ? div : add -not ok ? f32 : div -not ok ? f64 : 1 +not ok ? 0.5 : i +not ok ? 1 : f64 +not ok ? 1 : nil +not ok ? add : array +not ok ? add : groupBy(array, #) +not ok ? array : 1 +not ok ? array : f32 +not ok ? div : f64 +not ok ? f32 : f32 +not ok ? f64 : f64 not ok ? f64 : half -not ok ? false : f32 -not ok ? false : i -not ok ? false : true -not ok ? foo : add -not ok ? foo : false -not ok ? foo : i64 -not ok ? greet : add -not ok ? half : true -not ok ? i : div -not ok ? i : true -not ok ? i32 : nil -not ok ? i64 : add +not ok ? foo : foo +not ok ? greet : 0.5 +not ok ? half : half +not ok ? i : 1 +not ok ? i : add +not ok ? i32 : 1 +not ok ? i32 : i +not ok ? i64 : f32 +not ok ? i64 : f64 +not ok ? nil : "bar" not ok ? nil : 0.5 -not ok ? nil : div not ok ? nil : foo -not ok ? nil : half +not ok ? nil : greet not ok ? nil : i -not ok ? score : div -not ok ? score : i -not ok ? score : true -not ok ? true : f32 -not ok ? true : false -not ok ? true : score -not ok and not ok +not ok ? ok : false +not ok ? ok : list +not ok ? score : "foo" +not ok ? score : score +not ok ? true : 1 +not ok ? true : div +not ok ? true : half +not ok ? true : i64 +not ok ? true : nil +not ok and "foo" == "foo" +not ok and i32 > 0.5 +not ok and ok +not ok or 1 != i not ok or ok -not ok or one(array, true) +not ok || array == list not ok || ok -not ok || true ? 0.5 : 1 -not one(array, # > f32) not one(array, false) not one(array, ok) not one(array, true) not one(list, false) not one(list, ok) not one(list, true) -not true && i32 <= i32 -not true ? "foo" : i -not true ? 1 : i64 -not true ? add : add -not true ? add : foo -not true ? array : 1 -not true ? array : add -not true ? array : array -not true ? array : i32 -not true ? array : i64 -not true ? div : nil -not true ? f64 : i64 -not true ? foo : foo -not true ? greet : "bar" -not true ? greet : add -not true ? greet : foo -not true ? greet : i32 +not reduce(array, false) +not reduce(array, ok) +not reduce(array, true) +not reduce(list, false) +not reduce(list, ok) +not reduce(list, true) +not true != ok +not true && ok +not true == ok +not true ? "bar" : array +not true ? "bar" : i32 +not true ? "foo" : f32 +not true ? "foo" : f64 +not true ? 0.5 : foo +not true ? 0.5 : greet +not true ? 0.5 : i +not true ? 0.5 : i64 +not true ? 1 : f32 +not true ? add : i32 +not true ? add : ok +not true ? array : nil +not true ? f32 : 0.5 +not true ? f32 : div +not true ? f64 : 1 +not true ? f64 : array +not true ? foo : greet +not true ? foo : ok +not true ? greet : 1 +not true ? greet : i64 +not true ? greet : list +not true ? greet : true not true ? half : half -not true ? i : 1 -not true ? i : i -not true ? i32 : 0.5 -not true ? i64 : 1 +not true ? i : f64 +not true ? i64 : "foo" +not true ? i64 : array +not true ? i64 : i64 not true ? list : "bar" -not true ? list : 0.5 -not true ? list : 1 -not true ? list : array -not true ? list : type(add) -not true ? nil : list -not true ? score : 1 -not true ? score : list -not true ? score : true +not true ? list : f64 +not true ? list : foo +not true ? nil : div +not true ? ok : nil +not true ? score : f32 +not true ? score : score +not true ? true : 1 +not true and ok ? i : half not true || ok ok ok != !ok -ok != !true +ok != (0.5 not in array) ok != false != ok -ok != false ? 1 : i +ok != false ? f32 : list ok != nil == nil -ok != none(list, ok) -ok != not !ok +ok != nil ? f32 : greet +ok != nil ? nil : array ok != not ok ok != ok -ok != ok || ok -ok && !ok ? f32 : 0.5 -ok && !true -ok && "bar" >= "bar" -ok && "foo" <= "bar" -ok && 0.5 != nil -ok && 0.5 == 0.5 -ok && 0.5 >= f32 -ok && 1 != f64 +ok != ok ? false : "bar" +ok && !false +ok && !ok +ok && "foo" matches "bar" +ok && ("bar" not endsWith "bar") +ok && (false || ok) +ok && (ok or false) +ok && (true || true) +ok && 0.5 < 1 +ok && 0.5 < f64 +ok && 0.5 <= 1 +ok && 0.5 == nil +ok && 0.5 > i64 +ok && 1 != 0.5 ok && 1 != i32 -ok && 1 < 1 -ok && 1 <= 0.5 -ok && 1 == f64 -ok && 1 >= f32 -ok && div == half -ok && f32 != 0.5 -ok && f32 < 0.5 -ok && f32 == f32 -ok && f32 == i64 -ok && f64 < 1 -ok && f64 < i32 -ok && f64 == i32 -ok && f64 >= i32 -ok && false == false -ok && i != i -ok && i32 != 0.5 -ok && i32 < f32 -ok && i32 <= i64 -ok && i32 == 1 -ok && i32 >= 1 -ok && i64 < i32 -ok && i64 <= i32 -ok && i64 > 1 -ok && list != array -ok && nil != f64 -ok && nil == add -ok && nil == i32 -ok && nil == true +ok && 1 <= 1 +ok && 1 <= f64 +ok && 1 == 0.5 +ok && 1 == nil +ok && 1 >= f64 +ok && f32 != i +ok && f32 >= i64 +ok && f64 <= 0.5 +ok && false != ok +ok && false ? i : list +ok && false ? ok : ok +ok && i < 0.5 +ok && i < i64 +ok && i == 0.5 +ok && i > f64 +ok && i32 > 0.5 +ok && i32 >= i64 +ok && i64 != i +ok && i64 == 0.5 +ok && nil != 0.5 +ok && nil != 1 +ok && nil == ok +ok && not false +ok && not true ok && ok -ok && score != add -ok && true != ok -ok && true == nil +ok && ok ? nil : div +ok && ok and false +ok && true != false +ok && true && 1 >= i64 ok == !false -ok == !ok -ok == (false or true) -ok == (ok and ok) -ok == any(list, ok) -ok == false == nil -ok == nil ? false : add -ok == nil ? score : array +ok == !true +ok == ("bar" not endsWith "foo") +ok == (0.5 not in array) +ok == (false and ok) +ok == (i32 not in array) +ok == (nil not in list) +ok == false ? f64 : 1 +ok == false ? score : 1 +ok == nil ? i64 : add +ok == nil ? nil : f64 +ok == none(array, true) ok == not false -ok == not true ok == ok -ok ? "bar" : i == f32 -ok ? "bar" : i32 < i32 -ok ? "foo" : foo.String -ok ? -0.5 : foo -ok ? -f32 : i64 + 1 -ok ? -f64 : score -ok ? -i64 : ok -ok ? 0.5 * array[i64] : greet -ok ? 0.5 : f64 < i64 -ok ? 0.5 : half != add -ok ? 0.5 : i .. i -ok ? 0.5 < i32 : score -ok ? 0.5 == 0.5 : half -ok ? 1 : 1 + i64 + i32 +ok == ok != false +ok == true && ok +ok ? "bar" : f64 <= f32 +ok ? "foo" : foo.Bar +ok ? -0.5 : add +ok ? -f64 : list +ok ? -i32 : i +ok ? 0.5 / 0.5 : f64 +ok ? 0.5 : i32 >= i64 +ok ? 0.5 > 1 : 0.5 * i64 +ok ? 1 + i : i32 +ok ? 1 / i64 : greet ok ? 1 : foo.Bar -ok ? 1 : foo.String +ok ? 1 : foo?.Qux +ok ? abs(i64) : i64 +ok ? add : abs(f32) ok ? add : add ok ? add : array -ok ? add : div -ok ? add : f32 +ok ? add : f64 +ok ? add : foo +ok ? add : foo?.String ok ? add : greet +ok ? add : half ok ? add : i -ok ? add : i32 ok ? add : i64 ok ? add : list ok ? add : ok -ok ? array : div -ok ? array : f64 -ok ? array : float(i32) +ok ? array : array +ok ? array : f32 +ok ? array : f64 + f64 ok ? array : foo -ok ? array : foo?.Bar +ok ? array : foo.String +ok ? array : foo?.String +ok ? array : greet +ok ? array : i ok ? array : i32 -ok ? array : i64 ok ? array : list -ok ? array : ok in map(array, ok) +ok ? array : ok +ok ? array : score +ok ? div : add +ok ? div : array ok ? div : div -ok ? div : f32 ok ? div : f64 -ok ? div : foo?.String +ok ? div : foo +ok ? div : foo.Bar ok ? div : greet ok ? div : half -ok ? div : half(1) -ok ? div : i32 -ok ? div : i64 -ok ? div : list -ok ? div : list == array +ok ? div : i32 > reduce(array, #) +ok ? div : nil == true +ok ? div : ok ok ? div : score -ok ? div : score(i) +ok ? f32 != i32 : f32 +ok ? f32 ** i64 : score +ok ? f32 : -0.5 ok ? f32 : add ok ? f32 : array ok ? f32 : div ok ? f32 : f32 ok ? f32 : f64 ok ? f32 : foo -ok ? f32 : foo?.Bar ok ? f32 : half -ok ? f32 : i != i64 ok ? f32 : i32 +ok ? f32 : i64 +ok ? f32 : ok +ok ? f32 : score +ok ? f64 : add ok ? f64 : array +ok ? f64 : div +ok ? f64 : f64 - f64 +ok ? f64 : false != true +ok ? f64 : foo +ok ? f64 : foo.String ok ? f64 : greet -ok ? f64 : half -ok ? f64 : i64 +ok ? f64 : i32 +ok ? f64 : i32 % i32 +ok ? f64 : i32 >= -i64 +ok ? f64 : ok ok ? f64 : score -ok ? false : foo?.String() -ok ? foo : add +ok ? false : foo.Bar +ok ? foo : div +ok ? foo : f32 ok ? foo : foo -ok ? foo : foo?.Bar ok ? foo : greet -ok ? foo : i -ok ? foo : i == i32 +ok ? foo : half ok ? foo : i32 +ok ? foo : i32 > i32 ok ? foo : i64 -ok ? foo : i64 ^ f32 ok ? foo : list -ok ? get(array, i32) : ok +ok ? foo : ok +ok ? foo : score +ok ? foo.Qux : ok +ok ? greet : 0.5 > i +ok ? greet : 1 <= 0.5 ok ? greet : add ok ? greet : div -ok ? greet : f64 == i64 -ok ? greet : greet +ok ? greet : f32 +ok ? greet : f64 +ok ? greet : foo ok ? greet : half -ok ? greet : i / i32 -ok ? greet : i32 -ok ? greet : i64 % i64 +ok ? greet : i64 ok ? greet : list -ok ? greet : type(f64) -ok ? half : 0.5 ^ i32 +ok ? greet : map(list, i) +ok ? greet : ok +ok ? greet : score ok ? half : add -ok ? half : array -ok ? half : div -ok ? half : f32 == f64 +ok ? half : f32 ok ? half : f64 -ok ? half : f64 <= i ok ? half : foo -ok ? half : foo?.Bar +ok ? half : foo?.Qux ok ? half : greet ok ? half : half -ok ? half : i -ok ? half : i32 ok ? half : list +ok ? half : nil in list ok ? half : ok -ok ? half : type(add) -ok ? i : -i32 -ok ? i : 0.5 * i64 -ok ? i : 1 ** f64 +ok ? half : reduce(list, "bar") +ok ? half : string(array) +ok ? half(1) : add +ok ? i : 1 / i64 +ok ? i : add ok ? i : array -ok ? i : div -ok ? i : f32 -ok ? i : f64 -ok ? i : foo.Bar +ok ? i : f32 <= 0.5 +ok ? i : foo +ok ? i : half ok ? i : i ok ? i : i32 +ok ? i : i64 +ok ? i : list ok ? i : ok ok ? i : score -ok ? i32 + f32 : half -ok ? i32 : -i32 -ok ? i32 : 1 not in array +ok ? i32 : 1 - f64 ok ? i32 : add -ok ? i32 : array +ok ? i32 : div ok ? i32 : f32 +ok ? i32 : f32 + 0.5 +ok ? i32 : f64 +ok ? i32 : foo ok ? i32 : foo.Qux -ok ? i32 : foo?.Qux -ok ? i32 : half +ok ? i32 : greet ok ? i32 : i ok ? i32 : i32 +ok ? i32 : i32 + i32 ok ? i32 : list ok ? i32 : ok -ok ? i32 >= f64 : f32 -ok ? i64 : array +ok ? i32 : score +ok ? i64 : (ok ? list : half) ok ? i64 : div ok ? i64 : f32 -ok ? i64 : f64 +ok ? i64 : foo +ok ? i64 : foo.String ok ? i64 : half +ok ? i64 : i ok ? i64 : i32 ok ? i64 : i64 +ok ? i64 : list ok ? i64 : ok -ok ? int(1) : div -ok ? list : -1 +ok ? i64 ^ f32 : foo +ok ? list : 0.5 * f64 ok ? list : add ok ? list : array ok ? list : div +ok ? list : div(i64, 1) ok ? list : f32 -ok ? list : i32 +ok ? list : foo.String +ok ? list : greet +ok ? list : half +ok ? list : i +ok ? list : i - f32 ok ? list : i64 ok ? list : list -ok ? list : nil in array -ok ? list : ok +ok ? list : list != array +ok ? list : not ok ok ? list : score -ok ? lower("foo") : f32 -ok ? map(array, #) : duration("foo") -ok ? map(list, #) : score -ok ? min(f32) : score -ok ? min(i) : score +ok ? map(list, #) : add +ok ? nil : 0.5 <= f64 +ok ? nil : foo.Qux ok ? nil : foo?.Bar -ok ? ok : -f32 -ok ? ok : 0.5 + i +ok ? not false : i32 +ok ? ok : 0.5 ** i32 +ok ? ok : add ok ? ok : array -ok ? ok : f64 +ok ? ok : div +ok ? ok : f32 +ok ? ok : f64 ** int(f64) ok ? ok : foo +ok ? ok : foo.String ok ? ok : greet +ok ? ok : half +ok ? ok : i32 ok ? ok : i64 ok ? ok : list -ok ? ok : score -ok ? score : add -ok ? score : array +ok ? ok : ok +ok ? reduce(array, false) : score +ok ? reduce(list, #) : list +ok ? score : 1 == i32 +ok ? score : div ok ? score : f32 -ok ? score : foo.String -ok ? score : foo?.String +ok ? score : f64 ok ? score : greet ok ? score : half ok ? score : i ok ? score : i32 -ok ? score : list -ok ? score : nil != div -ok ? score : ok +ok ? score : min(i64) ok ? score : score -ok ? string(half) : array -ok ? toJSON("foo") : i32 -ok ? true : foo?.Qux +ok ? score : true == nil +ok ? toJSON(i64) : div ok and !ok -ok and "bar" not endsWith foo?.Bar -ok and "foo" endsWith "foo" -ok and 0.5 <= f32 -ok and 0.5 > f64 -ok and 0.5 >= f64 -ok and 1 != 1 -ok and 1 != nil +ok and "bar" < "foo" +ok and ("foo" not contains "bar") ok and 1 < i64 ok and 1 == 1 -ok and add == add -ok and any(list, false) +ok and 1 == i64 +ok and add == nil +ok and f32 != 1 ok and f32 >= 1 -ok and f64 != i -ok and f64 != nil -ok and f64 > 1 -ok and false != true -ok and i > i32 -ok and i >= f64 -ok and i >= i64 -ok and i32 != nil -ok and i32 == 0.5 -ok and i32 >= f64 -ok and i64 != nil -ok and i64 <= i +ok and greet == greet +ok and i == 0.5 +ok and i32 < f32 +ok and i32 <= i64 +ok and i32 > i32 +ok and i64 < i32 +ok and i64 <= i64 ok and i64 > 1 -ok and list == list -ok and nil != i -ok and nil != true -ok and none(list, ok) +ok and i64 >= i +ok and i64 in array +ok and list != nil +ok and nil == array +ok and nil == nil +ok and nil in array +ok and nil in list +ok and nil not in array ok and not ok ok and not true ok and ok -ok not in sort(array) -ok or !false +ok and ok && ok +ok and true ? f64 : add +ok and true ? greet : i +ok in groupBy(array, "bar") +ok in groupBy(list, #) +ok in groupBy(list, i32) +ok in {"bar": true}?.greet +ok not in groupBy(array, # != i32) +ok not in groupBy(array, 0.5) +ok not in groupBy(array, f64) +ok not in groupBy(list, #)?.f64 +ok not in groupBy(list, f64)?.Bar ok or !ok ok or !true -ok or "bar" < "bar" -ok or "foo" != nil -ok or 0.5 != i32 -ok or 0.5 != i64 -ok or 0.5 <= 0.5 -ok or 0.5 == 1 -ok or 0.5 >= i -ok or 1 != i32 -ok or 1 >= 0.5 -ok or f64 < f32 -ok or f64 < i64 -ok or fromJSON("bar") -ok or greet != add -ok or half == nil -ok or half == score -ok or i != 0.5 +ok or "bar" endsWith "foo" +ok or 0.5 != f32 +ok or 0.5 != nil +ok or 0.5 == i +ok or 1 != f32 +ok or 1 <= 1 +ok or 1 <= i +ok or div != nil +ok or f32 != f32 +ok or f32 == 0.5 +ok or f32 == f32 +ok or f64 <= 1 +ok or false ? ok : 1 +ok or false and false +ok or foo != foo ok or i < 1 -ok or i32 < 0.5 -ok or i32 == f64 -ok or i32 > 0.5 -ok or i64 != f32 -ok or i64 == 1 -ok or list == array -ok or nil != 0.5 +ok or i == 0.5 +ok or i == f32 +ok or i32 < 1 +ok or i32 > f64 +ok or i64 != i32 +ok or i64 > i64 +ok or i64 >= 0.5 +ok or i64 not in array +ok or nil != "foo" +ok or nil != f64 +ok or nil != foo +ok or nil != greet +ok or nil != ok +ok or nil == div ok or not false ok or not ok -ok or not true ok or ok -ok or ok || false -ok or one(array, true) -ok || "bar" not contains string(true) -ok || 0.5 < i32 -ok || 0.5 <= 0.5 -ok || 0.5 == i64 -ok || 1 != 0.5 -ok || 1 != 1 +ok or ok == true +ok or true || true +ok or {"foo": false}.String +ok || !ok +ok || (nil not in list) +ok || 0.5 < f32 +ok || 0.5 > 0.5 +ok || 0.5 > 1 +ok || 0.5 >= f64 ok || 1 != nil -ok || 1 < 0.5 -ok || 1 <= 1 -ok || add != score -ok || all(array, ok) -ok || div == nil -ok || f32 <= 0.5 -ok || f32 <= 1 -ok || f32 > i64 -ok || f32 >= f64 -ok || false && ok -ok || i != f64 -ok || i <= 0.5 -ok || i32 != 0.5 -ok || i32 < 0.5 -ok || i32 > 1 -ok || i64 > 0.5 +ok || 1 < i32 +ok || 1 == i +ok || f32 >= 1 +ok || f64 < 1 +ok || f64 == i +ok || f64 > f64 +ok || f64 >= i64 +ok || false ? half : i64 +ok || foo == foo +ok || i == i +ok || i32 < f32 +ok || i32 <= 0.5 +ok || i32 == i +ok || i32 > 0.5 +ok || i32 >= i32 +ok || i64 != i32 +ok || i64 == 0.5 +ok || list == list +ok || nil == 0.5 +ok || nil == array +ok || nil == nil +ok || nil not in array +ok || not false +ok || not ok ok || ok -ok || score != score -ok || toJSON(f64) > trimSuffix("bar") -one([1], ok) -one([i32], i32 >= #) -one([score, greet], # == #) -one([score], ok) -one(array, "bar" matches "foo") -one(array, "bar" not in foo) -one(array, "foo" != "foo") -one(array, "foo" > "foo") +ok || ok ? f64 : i64 +ok || ok ? ok : score +ok || ok or ok +ok || reduce(array, false) +ok || true ? add : ok +one(1 .. i64, ok) +one([div], nil == i32) +one([false], i64 != i32) +one(array, !(# <= 0.5)) +one(array, !false) +one(array, !ok) +one(array, !true) +one(array, "bar" matches "bar") one(array, # != #) one(array, # != 0.5) +one(array, # != 1) +one(array, # != f32) one(array, # != f64) +one(array, # != i) one(array, # != i32) one(array, # != nil) -one(array, # % # <= #) +one(array, # / i >= f64) one(array, # < #) one(array, # < 0.5) one(array, # < 1) one(array, # < f32) -one(array, # < f64) -one(array, # < i) -one(array, # < i32) +one(array, # < i64) one(array, # <= #) +one(array, # <= 0.5) +one(array, # <= 1) one(array, # <= f32) one(array, # <= f64) -one(array, # <= i) one(array, # <= i32) one(array, # == #) one(array, # == 0.5) one(array, # == 1) -one(array, # == f64) -one(array, # == i) -one(array, # == i32) -one(array, # == i64) +one(array, # == nil) one(array, # > #) +one(array, # > f32) one(array, # > f64) one(array, # > i32) -one(array, # > i64) one(array, # >= #) one(array, # >= 0.5) one(array, # >= 1) -one(array, # >= f32) -one(array, # >= i) -one(array, # >= i32) -one(array, # in array) +one(array, # >= f64) one(array, 0.5 != #) +one(array, 0.5 != i64) one(array, 0.5 < #) +one(array, 0.5 < 0.5) one(array, 0.5 <= #) one(array, 0.5 == #) +one(array, 0.5 == 0.5) one(array, 0.5 > #) -one(array, 0.5 > f32) +one(array, 0.5 > 1) one(array, 0.5 >= #) one(array, 1 != #) -one(array, 1 < 0.5) -one(array, 1 < i) +one(array, 1 != i64) +one(array, 1 != nil) +one(array, 1 < #) +one(array, 1 < f64) one(array, 1 <= #) -one(array, 1 <= 0.5) -one(array, 1 == #) -one(array, 1 == i32) -one(array, 1 > #) +one(array, 1 > 0.5) one(array, 1 >= #) -one(array, 1 >= f32) -one(array, f32 < 1) +one(array, add == div) +one(array, all(array, true)) one(array, f32 <= #) -one(array, f32 <= i64) -one(array, f32 == #) -one(array, f32 == 0.5) -one(array, f32 == 1) +one(array, f32 <= 0.5) one(array, f32 >= #) -one(array, f64 != #) -one(array, f64 != 1) -one(array, f64 != i) -one(array, f64 != nil) +one(array, f64 < #) one(array, f64 == #) -one(array, f64 > #) -one(array, false == nil) -one(array, greet == score) -one(array, i != 0.5) -one(array, i < i32) -one(array, i <= #) -one(array, i == #) +one(array, f64 >= #) +one(array, f64 >= 1) +one(array, f64 >= i32) +one(array, f64 in array) +one(array, false || true) +one(array, i < #) +one(array, i > 0.5) one(array, i > f64) -one(array, i >= #) -one(array, i >= f32) one(array, i32 != #) +one(array, i32 < #) one(array, i32 <= #) -one(array, i32 == #) -one(array, i32 == i) one(array, i32 > #) -one(array, i64 <= #) +one(array, i32 >= #) +one(array, i64 != #) +one(array, i64 < #) one(array, i64 == #) -one(array, i64 > #) -one(array, i64 > 1) +one(array, i64 == f32) +one(array, i64 >= #) +one(array, i64 >= f64) +one(array, list != array) one(array, nil != #) -one(array, nil != foo) -one(array, nil == i64) +one(array, nil != i64) one(array, not ok) -one(array, not true) -one(array, ok && true) one(array, ok) -one(array, one(array, false)) -one(array, score != greet) -one(array, score == div) -one(array, true || ok) -one(array, true || true) -one(filter(list, true), ok) -one(i32 .. i32, ok) -one(i32 .. i64, # >= #) +one(array, one(list, false)) +one(array, true != false) +one(array, true == nil) +one(array, true) ? greet : add +one(array, true) or 1 != nil +one(false ? greet : "bar", f64 != #) +one(groupBy(array, f64).array, .i(nil).ok) +one(groupBy(list, ok).foo, .add?.array) +one(i32 .. 1, # == #) +one(i32 .. i32, not ok) +one(i64 .. 1, # >= 1) +one(i64 .. i32, # != #) +one(i64 .. i32, # >= #) +one(list, !(i64 != 1)) +one(list, !false) one(list, !ok) -one(list, !true) -one(list, "bar" not in #) -one(list, "foo" != "bar") -one(list, "foo" < "foo") +one(list, "foo" < "bar") +one(list, "foo" not endsWith "bar") one(list, "foo" not in #) +one(list, "foo" startsWith "bar") one(list, # != #) -one(list, # != nil) +one(list, # != foo) one(list, # == #) -one(list, # == foo) -one(list, # == nil) one(list, # in list) -one(list, 0.5 != f32) -one(list, 0.5 > 0.5) -one(list, 1 < 1) -one(list, any(array, true)) -one(list, any(list, ok)) +one(list, # not in list) +one(list, 0.5 < 1) +one(list, 0.5 <= 0.5) +one(list, 0.5 == f64) +one(list, 1 > i) +one(list, add != nil) +one(list, all(array, true)) one(list, any(list, true)) -one(list, f32 == 0.5) -one(list, f32 == f64) -one(list, f32 > f32) -one(list, f64 != nil) -one(list, f64 == f32) -one(list, f64 >= 0.5) +one(list, div != nil) +one(list, f32 == nil) +one(list, f32 > i) +one(list, f32 >= 1) one(list, f64 >= 1) +one(list, false == nil) +one(list, foo != #) +one(list, foo != nil) one(list, foo == #) -one(list, greet != nil) -one(list, greet == score) -one(list, half != add) -one(list, i != nil) -one(list, i == i64) -one(list, i64 != f32) -one(list, i64 < 1) -one(list, i64 <= 0.5) -one(list, i64 > 0.5) -one(list, i64 > 1) -one(list, list != nil) -one(list, nil != nil) -one(list, nil != score) +one(list, greet == nil) +one(list, half == nil) +one(list, i <= i64) +one(list, i > f64) +one(list, i > i32) +one(list, i32 != f32) +one(list, i64 == 1) +one(list, nil != #) +one(list, nil != half) one(list, nil == #) -one(list, none(array, ok)) -one(list, none(list, ok)) -one(list, not false) -one(list, not ok) -one(list, not true) +one(list, nil == f64) +one(list, ok or true) one(list, ok) -one(list, ok) and ok -one(list, one(list, ok)) -one(list, score == half) -one(list, true) && ok ? i : i64 -one(map(array, "foo"), # matches #) +one(list, ok) or 0.5 == nil +one(list, score != nil) +one(list, true == nil) +one(list[i64:i32], i != i) +one(map(array, "bar"), not false) one(map(array, #), # != #) -one(map(array, #), # < #) -one(map(array, #), # <= #) -one(map(array, #), # > #) -one(map(array, #), # > 1) -one(map(array, #), f64 <= 0.5) -one(map(array, #), ok) -one(map(array, div), # == nil) -one(map(array, i64), ok) +one(map(array, #), # >= #) +one(map(array, #), i32 == #) +one(map(array, 1), ok) +one(map(array, div), # == #) +one(map(array, f64), # < 0.5) +one(map(array, false), #) +one(map(array, i), ok) +one(map(array, list), ok) one(map(array, true), #) -one(map(list, "bar"), ok) -one(map(list, #), nil != #) -one(map(list, 1), # < 0.5) -one(map(list, f64), # <= #) -one(map(list, false), #) -one(map(list, i), ok) -one(map(list, list), ok) one(map(list, ok), #) -repeat(toJSON(nil), i) +one(map(list, score), # != #) +one(ok ? "foo" : false, # > #) +one(reduce(array, array), ok) +one(true ? array : 1, # <= #) +reduce(1 .. 1, #) +reduce(1 .. 1, f32 >= i) +reduce(1 .. i64, array) +reduce(1 .. i64, greet) +reduce(1 .. i64, half) +reduce(["foo"], f32) +reduce([0.5], f64) +reduce([div, "foo"], i32) +reduce([f32, f64], f32) +reduce([foo], ok) +reduce([i32], list) +reduce([i64, half], "bar" not startsWith "foo") +reduce([i], # < #) +reduce([i], ok) +reduce([list], f64) +reduce([nil], # in array) +reduce(array, !false) +reduce(array, "foo" endsWith "foo") +reduce(array, "foo") not in foo +reduce(array, # != #) +reduce(array, # != 1) +reduce(array, # != i32) +reduce(array, # != nil) +reduce(array, # % #) +reduce(array, # % i64) +reduce(array, # * #) +reduce(array, # * 0.5) +reduce(array, # * 1) +reduce(array, # * f32) +reduce(array, # * i) +reduce(array, # * i32) +reduce(array, # * i64) +reduce(array, # ** #) +reduce(array, # ** f32) +reduce(array, # ** i32) +reduce(array, # + #) +reduce(array, # + 0.5) +reduce(array, # + 1) +reduce(array, # + i) +reduce(array, # + i64) +reduce(array, # - #) +reduce(array, # - 0.5) +reduce(array, # - 1) +reduce(array, # - i) +reduce(array, # - i32) +reduce(array, # - i64) +reduce(array, # .. #) +reduce(array, # .. i32) +reduce(array, # / #) +reduce(array, # / 0.5) +reduce(array, # / 1) +reduce(array, # / f32) +reduce(array, # / i32) +reduce(array, # < #) +reduce(array, # < 0.5) +reduce(array, # < 1) +reduce(array, # < i32) +reduce(array, # <= #) +reduce(array, # <= 0.5) +reduce(array, # <= f32) +reduce(array, # <= i32) +reduce(array, # == #) +reduce(array, # == 0.5) +reduce(array, # == 1) +reduce(array, # == f32) +reduce(array, # == i32) +reduce(array, # == i64) +reduce(array, # == nil) +reduce(array, # > #) +reduce(array, # > 1) +reduce(array, # > f64) +reduce(array, # > i) +reduce(array, # >= #) +reduce(array, # >= f32) +reduce(array, # >= f64) +reduce(array, # >= i32) +reduce(array, # >= i64) +reduce(array, # ^ #) +reduce(array, # ^ 0.5) +reduce(array, # ^ f32) +reduce(array, # ^ f64) +reduce(array, # ^ i64) +reduce(array, # in array) +reduce(array, # not in array) +reduce(array, #) +reduce(array, #) != 0.5 == true +reduce(array, #) != 0.5 ? ok : nil +reduce(array, #) != f32 +reduce(array, #) != i32 +reduce(array, #) != i64 +reduce(array, #) % i +reduce(array, #) % i32 +reduce(array, #) % i64 +reduce(array, #) * i +reduce(array, #) * i32 +reduce(array, #) * len("foo") +reduce(array, #) ** f64 +reduce(array, #) ** min(1, i32) +reduce(array, #) + i +reduce(array, #) + i64 +reduce(array, #) + reduce(array, #) +reduce(array, #) - f64 +reduce(array, #) - i +reduce(array, #) - max(f32) +reduce(array, #) .. i +reduce(array, #) .. i32 +reduce(array, #) .. i64 +reduce(array, #) / f32 +reduce(array, #) / f64 +reduce(array, #) / i32 +reduce(array, #) / i64 +reduce(array, #) < f32 +reduce(array, #) < f32 / 0.5 +reduce(array, #) < f64 +reduce(array, #) < i +reduce(array, #) <= -1 +reduce(array, #) <= f32 +reduce(array, #) <= f64 +reduce(array, #) <= f64 * 0.5 +reduce(array, #) <= i +reduce(array, #) == f64 +reduce(array, #) == i64 +reduce(array, #) > i32 +reduce(array, #) >= f32 +reduce(array, #) >= f64 +reduce(array, #) >= i32 +reduce(array, #) >= i64 +reduce(array, #) ^ f32 ** 0.5 +reduce(array, #) ^ i32 +reduce(array, #) not in array +reduce(array, #) not in map(array, #) +reduce(array, (0.5 + #) * f32) +reduce(array, -#) +reduce(array, -(# - #)) +reduce(array, -0.5) +reduce(array, -1) +reduce(array, -f32) +reduce(array, -f64) +reduce(array, -i) +reduce(array, -i32) +reduce(array, -i64) +reduce(array, 0.5 != #) +reduce(array, 0.5 != 0.5) +reduce(array, 0.5 * #) +reduce(array, 0.5 ** #) +reduce(array, 0.5 ** 1) +reduce(array, 0.5 + #) +reduce(array, 0.5 - #) +reduce(array, 0.5 - i64) +reduce(array, 0.5 / #) +reduce(array, 0.5 / f32) +reduce(array, 0.5 < #) +reduce(array, 0.5 < 1) +reduce(array, 0.5 <= #) +reduce(array, 0.5 <= 1) +reduce(array, 0.5 == #) +reduce(array, 0.5 == f64) +reduce(array, 0.5 == i64) +reduce(array, 0.5 > #) +reduce(array, 0.5 > 0.5) +reduce(array, 0.5 >= 0.5) +reduce(array, 0.5 >= 1) +reduce(array, 0.5 ^ #) +reduce(array, 0.5 ^ 0.5) +reduce(array, 0.5) * f32 +reduce(array, 0.5) - i +reduce(array, 0.5) > i64 ? 1 : 0.5 +reduce(array, 1 != #) +reduce(array, 1 * f64) +reduce(array, 1 ** #) +reduce(array, 1 + #) +reduce(array, 1 - #) +reduce(array, 1 - 1) +reduce(array, 1 / i32) +reduce(array, 1 < #) +reduce(array, 1 >= #) +reduce(array, 1 ^ #) +reduce(array, 1 ^ 0.5) +reduce(array, 1 ^ i32) +reduce(array, 1) % i32 +reduce(array, 1) ** f32 +reduce(array, 1) + f64 +reduce(array, 1) / f64 +reduce(array, 1) / i32 +reduce(array, 1) <= i32 +reduce(array, 1) ^ i +reduce(array, 1) not in array +reduce(array, [#]) +reduce(array, abs(#)) +reduce(array, abs(f64)) +reduce(array, abs(i64)) +reduce(array, add(#, #)) +reduce(array, add) +reduce(array, all(list, ok)) +reduce(array, array) +reduce(array, array)[i32] +reduce(array, array[#:#]) +reduce(array, array[i64:#]) +reduce(array, bitand(i32, i32)) +reduce(array, bitnot(#)) +reduce(array, bitor(#, #)) +reduce(array, bitshr(#, #)) +reduce(array, bitushr(#, #)) +reduce(array, ceil(#)) +reduce(array, div(#, #)) +reduce(array, div) +reduce(array, f32 ** #) +reduce(array, f32 + #) +reduce(array, f32 / #) +reduce(array, f32 <= #) +reduce(array, f32 == #) +reduce(array, f32 == i) +reduce(array, f32 >= #) +reduce(array, f32 >= 0.5) +reduce(array, f32 ^ #) +reduce(array, f32 ^ f32) +reduce(array, f32 ^ i32) +reduce(array, f32) +reduce(array, f32) ** (0.5 * f64) +reduce(array, f32) <= f32 +reduce(array, f32) not in array +reduce(array, f64 ** #) +reduce(array, f64 + #) +reduce(array, f64 + i32) +reduce(array, f64 - #) +reduce(array, f64 / 1) +reduce(array, f64 < #) +reduce(array, f64 == #) +reduce(array, f64 ^ 1) +reduce(array, f64) +reduce(array, f64) != i32 +reduce(array, f64) * i +reduce(array, f64) / f64 +reduce(array, f64) <= f32 +reduce(array, f64) <= first(array) +reduce(array, f64) == i +reduce(array, f64) >= i +reduce(array, f64) ^ f64 +reduce(array, false ? f64 : #) +reduce(array, false ? score : #) +reduce(array, false) ? i64 : f32 +reduce(array, false) || ok +reduce(array, findLastIndex(list, false)) +reduce(array, findLastIndex(list, reduce(array, true))) +reduce(array, float(#)) +reduce(array, floor(i64)) +reduce(array, foo) +reduce(array, foo).Bar +reduce(array, foo).Qux +reduce(array, foo).String +reduce(array, foo).String() +reduce(array, foo)?.Bar +reduce(array, foo)?.Qux +reduce(array, foo)?.String +reduce(array, foo)?.String() +reduce(array, foo.Bar) +reduce(array, foo.String) +reduce(array, foo?.String()) +reduce(array, foo?.String) +reduce(array, get(array, 1)) +reduce(array, get(list, #)) +reduce(array, greet("bar")) +reduce(array, greet) +reduce(array, groupBy(array, #)) +reduce(array, groupBy(list, #)) +reduce(array, groupBy(list, #)?.f32) +reduce(array, half(1)) +reduce(array, half) +reduce(array, i != #) +reduce(array, i % #) +reduce(array, i * #) +reduce(array, i ** f64) +reduce(array, i + 0.5) +reduce(array, i - #) +reduce(array, i / #) +reduce(array, i <= #) +reduce(array, i <= i64) +reduce(array, i > i32) +reduce(array, i ^ #) +reduce(array, i) +reduce(array, i) % i32 +reduce(array, i) + i32 +reduce(array, i) - f32 +reduce(array, i) == 0.5 ** 1 +reduce(array, i32 != #) +reduce(array, i32 != i32) +reduce(array, i32 + 0.5) +reduce(array, i32 - #) +reduce(array, i32 .. #) +reduce(array, i32 < #) +reduce(array, i32 < 1) +reduce(array, i32 > #) +reduce(array, i32 >= #) +reduce(array, i32) +reduce(array, i32) * 1 * 0.5 +reduce(array, i64 != #) +reduce(array, i64 % i) +reduce(array, i64 % i32) +reduce(array, i64 * #) +reduce(array, i64 + i32) +reduce(array, i64 - #) +reduce(array, i64 .. #) +reduce(array, i64 .. 1) +reduce(array, i64 / f64) +reduce(array, i64 <= #) +reduce(array, i64 == 1) +reduce(array, i64 == nil) +reduce(array, i64 ^ #) +reduce(array, i64 ^ f64) +reduce(array, i64) +reduce(array, i64) + i +reduce(array, i64) / f64 +reduce(array, i64) < i +reduce(array, i64) == f32 +reduce(array, int(f64)) +reduce(array, len(array)) +reduce(array, list) +reduce(array, list) != map(list, half) +reduce(array, map(array, div)) +reduce(array, map(array, score)) +reduce(array, map(list, 1)) +reduce(array, max(#, #, #)) +reduce(array, max(0.5)) +reduce(array, min(#)) +reduce(array, min(#, #, 0.5)) +reduce(array, min(0.5)) +reduce(array, min(1, 1)) +reduce(array, nil != "bar") +reduce(array, nil != #) +reduce(array, nil != 1) +reduce(array, not ok) +reduce(array, ok ? "foo" : "bar") +reduce(array, ok ? # : array) +reduce(array, ok ? # : i) +reduce(array, ok || true) +reduce(array, ok) +reduce(array, ok) and ok +reduce(array, reduce(array, 1)) +reduce(array, reduce(list, 0.5)) +reduce(array, round(0.5)) +reduce(array, score(#)) +reduce(array, score(1, #)) +reduce(array, score) +reduce(array, string(0.5)) +reduce(array, string(1)) +reduce(array, string(foo)) +reduce(array, string(i32)) +reduce(array, toJSON(i)) +reduce(array, trimPrefix("bar")) +reduce(array, true && true) +reduce(array, true ? add : #) +reduce(array, true) != ok +reduce(array, true) and ok +reduce(array, type(#)) +reduce(array, type(1)) +reduce(array, type(add)) +reduce(array, type(greet)) +reduce(array, type(score)) +reduce(array, upper("bar")) +reduce(false ? 0.5 : "bar", # and false) +reduce(false ? i32 : array, toJSON(#)) +reduce(false ? nil : list, #) +reduce(filter(array, ok), foo) +reduce(filter(list, ok), foo.Bar) +reduce(filter(list, true), i) +reduce(i .. 1, f64) +reduce(i .. 1, score) +reduce(i .. i, #) +reduce(i .. i, foo) +reduce(i .. i32, add) +reduce(i32 .. 1, #) +reduce(i32 .. 1, foo) +reduce(i32 .. i, 0.5 - #) +reduce(i32 .. i32, i64) +reduce(i32 .. i64, abs(f64)) +reduce(i64 .. 1, -#) +reduce(i64 .. i, #) +reduce(i64 .. i, -0.5) +reduce(i64 .. i, false ? "bar" : #) +reduce(i64 .. i, i) +reduce(i64 .. i, ok) +reduce(i64 .. i, round(i32)) +reduce(i64 .. i64, i64) +reduce(list, !true) +reduce(list, "bar" <= "bar") +reduce(list, "bar" in #) +reduce(list, "foo" not in #) +reduce(list, # != #) +reduce(list, # != foo) +reduce(list, # != nil) +reduce(list, # == #) +reduce(list, # == foo) +reduce(list, # == nil) +reduce(list, # in list) +reduce(list, # not in list) +reduce(list, #) +reduce(list, #) != foo +reduce(list, #) not in groupBy(array, i) +reduce(list, #) not in list +reduce(list, #).Bar +reduce(list, #).Qux +reduce(list, #).String +reduce(list, #).String() +reduce(list, #)?.Bar +reduce(list, #)?.Qux +reduce(list, #)?.String +reduce(list, #)?.String() +reduce(list, #?.Bar not in # ? # : #) +reduce(list, #?.Bar) +reduce(list, #?.Qux("foo")) +reduce(list, #?.Qux) +reduce(list, #?.String()) +reduce(list, #?.String) +reduce(list, -0.5) +reduce(list, -f64) +reduce(list, -i) +reduce(list, -i32) +reduce(list, .Bar) +reduce(list, .Qux) +reduce(list, .String()) +reduce(list, .String) +reduce(list, 0.5 != f64) +reduce(list, 0.5 != nil) +reduce(list, 0.5 == i64) +reduce(list, 0.5 >= 0.5) +reduce(list, 0.5) != i +reduce(list, 0.5) / i64 +reduce(list, 0.5) < f32 +reduce(list, 0.5) < i +reduce(list, 0.5) < i32 +reduce(list, 0.5) < i64 +reduce(list, 0.5) <= f32 +reduce(list, 0.5) >= f64 +reduce(list, 0.5) >= i64 +reduce(list, 1 != nil) +reduce(list, 1 + f64) +reduce(list, 1 - 0.5) +reduce(list, 1 / 0.5) +reduce(list, 1 < f64) +reduce(list, 1 <= 1) +reduce(list, 1 == 0.5) +reduce(list, 1 == nil) +reduce(list, 1 ^ 1) +reduce(list, 1) * f64 +reduce(list, 1) + f32 +reduce(list, 1) - i +reduce(list, add) +reduce(list, add) != div +reduce(list, array != array) +reduce(list, array) +reduce(list, div) +reduce(list, f32 / 0.5) +reduce(list, f32 < i32) +reduce(list, f32 <= f32) +reduce(list, f32) +reduce(list, f32) == f32 +reduce(list, f64 != nil) +reduce(list, f64 + 0.5) +reduce(list, f64 + 1) +reduce(list, f64 / i32) +reduce(list, f64 <= i32) +reduce(list, f64 == f32) +reduce(list, f64 > f32) +reduce(list, f64 >= 0.5) +reduce(list, f64) +reduce(list, f64) * i64 +reduce(list, false == false) +reduce(list, false ? "foo" : list) +reduce(list, false ? # : #) +reduce(list, false || true) +reduce(list, filter(list, ok)) +reduce(list, findIndex(array, true)) +reduce(list, findLastIndex(list, false)) +reduce(list, float(i)) +reduce(list, floor(0.5)) +reduce(list, foo != #) +reduce(list, foo) +reduce(list, foo) == foo +reduce(list, foo).Bar +reduce(list, foo).Qux +reduce(list, foo).String +reduce(list, foo).String() +reduce(list, foo)?.Bar +reduce(list, foo)?.Qux +reduce(list, foo)?.String +reduce(list, foo)?.String() +reduce(list, foo.Bar) +reduce(list, foo.String) +reduce(list, foo?.Bar) +reduce(list, foo?.Qux) +reduce(list, foo?.String) +reduce(list, get(list, i)) +reduce(list, greet != nil) +reduce(list, greet("bar")) +reduce(list, greet) +reduce(list, groupBy(array, 1)) +reduce(list, groupBy(list, "bar")) +reduce(list, groupBy(list, #)) +reduce(list, half(1)) +reduce(list, half) +reduce(list, i * i64) +reduce(list, i + 1) +reduce(list, i - f64) +reduce(list, i .. 1) +reduce(list, i == 0.5) +reduce(list, i > i64) +reduce(list, i >= 0.5) +reduce(list, i) +reduce(list, i) * i64 +reduce(list, i) .. 1 % 1 +reduce(list, i) .. i +reduce(list, i) / f64 +reduce(list, i) / i32 +reduce(list, i) < f32 +reduce(list, i) == f32 +reduce(list, i) > f32 +reduce(list, i) ^ f32 +reduce(list, i32 != nil) +reduce(list, i32 - i32) +reduce(list, i32 .. 1) +reduce(list, i32 / 0.5) +reduce(list, i32 < i) +reduce(list, i32 <= i) +reduce(list, i32 == f64) +reduce(list, i32 >= f32) +reduce(list, i32) +reduce(list, i32) != f64 +reduce(list, i32) % i +reduce(list, i32) - f32 +reduce(list, i32) >= i +reduce(list, i64 .. 1) +reduce(list, i64 < i64) +reduce(list, i64 > i64) +reduce(list, i64 >= 0.5) +reduce(list, i64) +reduce(list, i64) * f64 +reduce(list, i64) ** i32 +reduce(list, i64) <= i64 +reduce(list, int(i64)) +reduce(list, len(array)) +reduce(list, list != nil) +reduce(list, list == nil) +reduce(list, list) +reduce(list, map(array, "bar")) +reduce(list, map(array, #)) +reduce(list, map(list, 1)) +reduce(list, max(0.5)) +reduce(list, max(f32)) +reduce(list, min(0.5)) +reduce(list, min(1)) +reduce(list, min(f32)) +reduce(list, nil != #) +reduce(list, nil != add) +reduce(list, nil != half) +reduce(list, nil == #) +reduce(list, not false) +reduce(list, not ok) +reduce(list, not true) +reduce(list, ok ? # : #) +reduce(list, ok ? # : score) +reduce(list, ok ? greet : add) +reduce(list, ok ? score : #) +reduce(list, ok) +reduce(list, reduce(array, ok)) +reduce(list, reduce(array, score)) +reduce(list, reduce(list, #)) +reduce(list, reduce(list, 1)) +reduce(list, reduce(list, add)) +reduce(list, reduce(list, i32)) +reduce(list, score(i)) +reduce(list, score) +reduce(list, string(greet)) +reduce(list, toBase64("bar")) +reduce(list, toBase64("foo")) +reduce(list, toJSON(array)) +reduce(list, toJSON(list)) +reduce(list, toJSON(nil)) +reduce(list, true == nil) +reduce(list, true ? foo : f64) +reduce(list, type(#)) +reduce(map(array, "bar"), # not endsWith #) +reduce(map(array, "bar"), add) +reduce(map(array, "foo"), half(f64)) +reduce(map(array, #), # != i) +reduce(map(array, #), # .. #) +reduce(map(array, #), #) +reduce(map(array, #), abs(#)) +reduce(map(array, #), i) +reduce(map(array, #), i32 * #) +reduce(map(array, #), not ok) +reduce(map(array, 0.5), add) +reduce(map(array, 0.5), div) +reduce(map(array, 0.5), f32) +reduce(map(array, 1), # ^ 0.5) +reduce(map(array, 1), #) +reduce(map(array, 1), foo) +reduce(map(array, add), #) +reduce(map(array, add), f32) +reduce(map(array, add), list) +reduce(map(array, array), f64) +reduce(map(array, div), #) +reduce(map(array, div), div) +reduce(map(array, div), i32 * i) +reduce(map(array, f32), f32) +reduce(map(array, f32), i) +reduce(map(array, f32), i32) +reduce(map(array, f64), #) +reduce(map(array, f64), f32 < #) +reduce(map(array, false), # and true) +reduce(map(array, false), f32) +reduce(map(array, foo), # == nil) +reduce(map(array, i), # / 1) +reduce(map(array, i), #) +reduce(map(array, i), add) +reduce(map(array, i), f64 + 1) +reduce(map(array, i32), array) +reduce(map(array, i32), list) +reduce(map(array, i64), # <= #) +reduce(map(array, i64), #) +reduce(map(array, list), filter(#, false)) +reduce(map(array, ok), i) +reduce(map(array, score), i32) +reduce(map(list, "bar"), #) +reduce(map(list, "foo"), #) +reduce(map(list, #), #) +reduce(map(list, #), .Qux) +reduce(map(list, #), add) +reduce(map(list, #), array) +reduce(map(list, #), f32) +reduce(map(list, #), f64) +reduce(map(list, #), half) +reduce(map(list, #), i64) +reduce(map(list, #), ok) +reduce(map(list, 0.5), #) +reduce(map(list, 0.5), foo) +reduce(map(list, 1), # > #) +reduce(map(list, 1), #) +reduce(map(list, 1), list) +reduce(map(list, array), div) +reduce(map(list, div), add) +reduce(map(list, f64), #) +reduce(map(list, f64), ok) +reduce(map(list, false), div) +reduce(map(list, greet), #) +reduce(map(list, i), #) +reduce(map(list, i), [i32]) +reduce(map(list, i), f32) +reduce(map(list, i), score(#)) +reduce(map(list, i32), #) +reduce(map(list, i32), foo) +reduce(map(list, i64), #) +reduce(map(list, i64), i32) +reduce(map(list, list), ok) +reduce(map(list, score), #) +reduce(map(list, score), f64) +reduce(map(list, true), #) +reduce(map(list, true), add) +reduce(map(list, true), half) +reduce(ok ? "bar" : i32, #) +reduce(ok ? "foo" : list, #) +reduce(ok ? array : half, f32) +reduce(ok ? list : i, #) +reduce(reduce(array, array), f64 != #) +reduce(reduce(array, list), get(array, i32)) +reduce(reduce(list, array), f64) +reduce(sort(array), #) +reduce(sort(array), foo) +reduce(sort(array), greet) +reduce(sort(array), ok) +reduce(true ? array : 1, array) +reduce(true ? array : array, #) +repeat(type(ok), i) +round(-0.5) +round(-1) +round(-f32) +round(-f64) +round(-i) +round(-i32) +round(-i64) +round(0.5 * 1) +round(0.5 * f64) +round(0.5 * i32) +round(0.5 ** 0.5) +round(0.5 ** 1) +round(0.5 ** i) +round(0.5 ** i32) +round(0.5 ** i64) +round(0.5 + 1) +round(0.5 + f64) +round(0.5 + i) +round(0.5 + i32) +round(0.5 - 0.5) +round(0.5 - 1) +round(0.5 - i32) +round(0.5 / 0.5) +round(0.5 / 1) +round(0.5 / f64) +round(0.5 / i32) +round(0.5 ^ f64) +round(0.5 ^ i) +round(0.5 ^ i64) +round(0.5) * f32 +round(0.5) ** i32 +round(0.5) + -f32 +round(0.5) - i64 ^ i +round(0.5) < f64 +round(0.5) <= i64 +round(0.5) == i32 +round(0.5) == i64 +round(0.5) == max(i, i64) +round(0.5) > -1 +round(0.5) > i +round(0.5) >= i +round(0.5) in array +round(1 % i) +round(1 % i64) +round(1 * 0.5) +round(1 * f32) +round(1 * i64) +round(1 ** 0.5) +round(1 ** 1) +round(1 ** f32) +round(1 ** f64) +round(1 ** i) +round(1 + 0.5) +round(1 + 1) +round(1 + i64) +round(1 - 0.5) +round(1 - 1) +round(1 - i) +round(1 - i32) +round(1 - i64) +round(1 / 0.5) +round(1 / 1) +round(1 / f32) +round(1 / i) +round(1 / i64) +round(1 ^ 0.5) +round(1 ^ 1) +round(1 ^ f32) +round(1 ^ i) +round(1 ^ i64) +round(1) != ceil(i32) +round(1) * i32 +round(1) + i64 +round(1) - i64 +round(1) / i32 +round(1) / i64 +round(1) < i64 +round(1) <= i +round(1) == i +round(1) >= f64 +round(1) >= i32 +round(1) >= i64 +round(1) ^ f64 +round(1) not in array +round(abs(0.5)) +round(abs(1)) +round(abs(f64)) +round(abs(i)) +round(abs(i64)) +round(add(1, i)) +round(array[1]) +round(array[i32]) +round(array[i64]) +round(bitnot(i)) +round(bitnot(i32)) +round(bitnot(i64)) +round(ceil(1)) +round(ceil(f64)) +round(ceil(i32)) +round(ceil(i64)) +round(count(list, true)) +round(div(1, 1)) +round(f32 * 0.5) +round(f32 * 1) +round(f32 * f64) +round(f32 * i32 ^ f32) +round(f32 * i64) +round(f32 ** 0.5) +round(f32 ** 1) +round(f32 + f64) +round(f32 + i32) +round(f32 - 0.5) +round(f32 - i) +round(f32 / i32) +round(f32 ^ 0.5) +round(f32 ^ f32) +round(f32 ^ i) +round(f32 ^ i64) +round(f32) +round(f32) * i32 +round(f32) - i32 +round(f32) / f32 +round(f32) == i32 +round(f64 * 0.5) +round(f64 * i) +round(f64 ** 0.5) +round(f64 ** 1) +round(f64 ** f32) +round(f64 ** i) +round(f64 + f64) +round(f64 + i) +round(f64 + i32) +round(f64 - 0.5) +round(f64 - 1) +round(f64 - i32) +round(f64 / f64) +round(f64 / i) +round(f64 / i32) +round(f64 / i64) +round(f64 ^ 1) +round(f64 ^ f64) +round(f64) +round(f64) * f32 +round(f64) ** i32 +round(f64) + f64 +round(f64) <= f64 +round(f64) > i +round(f64) > i32 +round(f64) >= i64 +round(f64) not in array +round(false ? f32 : f64) +round(false ? f64 : 1) +round(false ? nil : 1) +round(findIndex(array, # <= #)) +round(findIndex(list, ok)) +round(findLast(array, ok)) +round(findLast(array, true)) +round(findLastIndex(array, ok)) +round(findLastIndex(list, ok)) +round(float(0.5)) +round(float(1)) +round(float(f32)) +round(float(i)) +round(floor(0.5)) +round(floor(1)) +round(floor(f64)) +round(floor(i32)) +round(floor(i64)) +round(get(array, i)) +round(get(array, i32)) +round(get(array, i64)) +round(half(-1)) +round(half(0.5)) +round(half(1)) +round(half(f64)) +round(i % i32) +round(i % i64) +round(i * 1) +round(i * f64) +round(i * i32) +round(i ** 1) +round(i ** i64) +round(i + 0.5) +round(i + 1) +round(i + f64) +round(i + i) +round(i + i32) +round(i + i64) +round(i - i) +round(i - i32) +round(i / 1) +round(i / i) +round(i / i64) +round(i ^ 0.5) > f32 +round(i ^ 1) +round(i ^ f32) +round(i) +round(i) * f32 +round(i) * i +round(i) / f64 +round(i) < i +round(i) < i32 +round(i) > i +round(i) > i64 != ok +round(i) >= f32 +round(i) >= i64 +round(i) ^ i32 +round(i32 % 1) +round(i32 * 1) +round(i32 ** 1) +round(i32 ** f32) +round(i32 ** f64) +round(i32 + 0.5) +round(i32 + 1) +round(i32 + i32) +round(i32 - 1) +round(i32 - f32) +round(i32 - f64) +round(i32 / 0.5) +round(i32 / 1) +round(i32 ^ f64) +round(i32) +round(i32) != i +round(i32) * f32 +round(i32) ** f64 +round(i32) - i +round(i32) < i32 +round(i32) <= ceil(1) +round(i32) <= f64 +round(i32) <= i64 +round(i32) >= f64 +round(i32) >= i32 +round(i32) ^ f64 +round(i64 % i) +round(i64 % i32) +round(i64 * 0.5) +round(i64 * i) +round(i64 ** 1) +round(i64 ** f64) +round(i64 ** i64) +round(i64 + f32) +round(i64 - 0.5) +round(i64 - 1) +round(i64 - i) +round(i64 / 0.5) +round(i64 / 1) +round(i64 ^ 1) +round(i64 ^ i32) +round(i64 ^ i64) +round(i64) +round(i64) != f64 +round(i64) * i64 +round(i64) ** i32 +round(i64) - bitnot(1) +round(i64) - f32 +round(i64) < f64 +round(i64) ^ f64 +round(int(0.5)) +round(int(1)) +round(int(f32)) +round(int(f64)) +round(int(i)) +round(int(i32)) +round(int(i64)) +round(last(array)) +round(len("bar")) +round(len("foo")) +round(len(array)) +round(len(list)) +round(max(0.5)) +round(max(1)) +round(max(i)) +round(max(i32)) +round(max(i64)) +round(max(i64, f32)) +round(mean(array)) +round(median(array)) +round(min(0.5)) +round(min(1)) +round(min(f32)) +round(min(f64)) +round(min(i32)) +round(min(i64)) +round(reduce(array, #)) +round(reduce(array, 0.5)) +round(reduce(array, 1)) +round(reduce(array, i64)) +round(reduce(list, 0.5)) +round(reduce(list, f32)) +round(round(0.5)) +round(round(1)) +round(round(f32)) +round(round(f64)) +round(round(i)) +round(round(i32)) +round(round(i64)) +round(score(1)) +round(score(i)) +round(sum(array)) +round(true ? i : ok) score -score != add -score != add != true -score != add ? i64 : "foo" -score != div -score != div ? i : f32 -score != div and ok -score != foo.Qux -score != foo.String -score != foo?.Qux -score != foo?.String -score != greet -score != greet ? score : array -score != half +score != nil != ok +score != nil ? half : f64 +score != nil or i32 > 0.5 +score != nil || ok score != score -score != score ? 1 : i -score == add -score == add == false -score == add ? f64 : not false -score == div -score == div || foo == foo -score == foo.Qux -score == foo.String -score == foo?.Qux -score == foo?.String -score == greet -score == greet ? half : f64 -score == greet and ok -score == half +score != score != ok +score != score ? i32 : i32 +score == nil != nil +score == nil && ok +score == nil ? 0.5 : "bar" score == score -score == score ? 0.5 : foo -score == score ? nil : i32 -score == score or ok -score == {"bar": 0.5}.f32 +score == score == true +score == score ? 0.5 : score +score in groupBy(list, #)?.array +score in sort(array) score(-1) +score(-1, i) +score(-get(array, i)) score(-i) score(-i, i) score(1 % 1) @@ -12520,7 +16041,6 @@ score(1 % i) score(1 % i32) score(1 % i64) score(1 * 1) -score(1 * 1, i) score(1 * i) score(1 * i32) score(1 * i64) @@ -12531,73 +16051,81 @@ score(1 + i64) score(1 - 1) score(1 - i) score(1 - i32) -score(1 - i64) -score(1) != -0.5 -score(1) != f32 -score(1) != float(f64) +score(1) != -f32 score(1) != i -score(1) % i32 +score(1) != i32 +score(1) % -1 +score(1) % i +score(1) % i64 score(1) * f32 -score(1) * f64 +score(1) * i score(1) * i64 -score(1) ** -1 -score(1) ** f32 -score(1) ** i64 -score(1) + f32 +score(1) ** i32 score(1) + f64 +score(1) + i32 score(1) - f32 score(1) - i +score(1) - i32 +score(1) - int(0.5) +score(1) .. i +score(1) .. i32 score(1) .. i64 -score(1) / f64 -score(1) / i +score(1) .. score(1) +score(1) / f32 score(1) / i32 -score(1) / i64 +score(1) < i score(1) < i32 score(1) < i64 -score(1) <= i32 +score(1) < i64 - 0.5 +score(1) <= 0.5 * 1 +score(1) <= i score(1) <= i64 -score(1) == 1 ^ 1 -score(1) == f64 -score(1) == i ** f64 score(1) == i32 score(1) == i64 +score(1) > bitshr(i64, 1) +score(1) > f32 score(1) > i64 +score(1) >= 0.5 + f64 score(1) >= f32 -score(1) >= f64 score(1) >= i -score(1) >= i32 -score(1) >= i64 -score(1) ^ f32 +score(1) >= sum(array) score(1) ^ f64 score(1) ^ i +score(1) ^ i32 score(1) in array -score(1, i) > f32 +score(1) not in groupBy(list, false) +score(1, 1) < i +score(1, i) < f64 +score(1, i) ^ f32 score(abs(1)) score(abs(i)) -score(add(1, 1)) score(add(1, i)) score(array[1]) -score(array[i32]) score(array[i64]) score(array[i]) -score(count(array, f64 < 1)) +score(bitnand(1, i64)) +score(bitnand(i64, i32)) +score(bitnot(1)) +score(bitnot(i)) +score(bitnot(i32)) +score(bitnot(i64)) +score(bitshl(i32, i)) +score(bitshr(1, i64)) +score(bitshr(i32, i64)) +score(bitushr(1, i)) score(count(array, false)) score(count(array, ok)) score(count(array, true)) -score(count(list, false)) score(count(list, ok)) -score(count(list, true)) -score(div(1, 1)) -score(div(i, 1)) -score(false ? true : i) +score(false ? f64 : 1) +score(false ? foo : 1) +score(find(array, i != #)) score(find(array, ok)) +score(find(array, true)) score(findIndex(array, ok)) score(findIndex(array, true)) -score(findIndex(list, ok)) score(findIndex(list, true)) -score(findLast(array, 0.5 != #)) -score(findLast(array, ok)) -score(findLastIndex(array, ok)) +score(findLast(array, true)) score(findLastIndex(array, true)) score(findLastIndex(list, ok)) score(findLastIndex(list, true)) @@ -12606,76 +16134,95 @@ score(get(array, 1)) score(get(array, i)) score(get(array, i32)) score(get(array, i64)) +score(i % 1) score(i % i) -score(i % i32) +score(i % i64) +score(i * 1 * i) score(i * 1) +score(i * i) score(i * i32) score(i * i64) score(i + 1) score(i + i) score(i + i32) -score(i + i64) score(i - 1) score(i - i) score(i - i32) -score(i - i64) score(i) -score(i) != 1 == true -score(i) != float(i32) -score(i) != i -score(i) != i32 -score(i) % i32 % i64 -score(i) % i64 -score(i) * f64 +score(i) != f32 +score(i) != f64 +score(i) % i +score(i) % i * f64 +score(i) * f32 score(i) * i32 -score(i) * i64 -score(i) ** f64 +score(i) ** (0.5 / 0.5) +score(i) ** -0.5 score(i) ** i32 -score(i) + f32 -score(i) + i -score(i) + i32 -score(i) + i64 -score(i) - f32 -score(i) - i +score(i) ** i64 +score(i) + f64 +score(i) - f64 score(i) - i32 -score(i) / f32 -score(i) / i +score(i) / i64 +score(i) < 1 != ok score(i) < f32 +score(i) < f64 / 0.5 score(i) < i32 -score(i) <= f32 - f32 +score(i) < i64 +score(i) <= 0.5 / f32 +score(i) <= f32 +score(i) <= f64 +score(i) <= i +score(i) <= i32 score(i) == f32 -score(i) == i32 -score(i) == i64 +score(i) > f32 +score(i) > i +score(i) > i64 score(i) >= f32 -score(i) ^ f64 -score(i) ^ i -score(i, i + i) +score(i) >= f64 +score(i) >= i +score(i) >= i32 +score(i) >= i64 +score(i) ^ f32 +score(i) ^ i32 +score(i) ^ i64 +score(i) ^ score(1) +score(i, 1) + -1 +score(i, 1) .. i64 +score(i, 1) <= f32 score(i, i) -score(i, i) >= i -score(i, int(i64)) -score(i, score(i)) - i32 +score(i, i) ** f32 +score(i32 % 1) score(i32 % i) -score(i32 % i64) +score(i32 % i32) score(i32 * 1) score(i32 * i) +score(i32 * i32) +score(i32 * i64) +score(i32 + 1) score(i32 + i) +score(i32 + i32) score(i32 + i64) score(i32 - 1) score(i32 - i) +score(i32 - i32) +score(i32 - i64) score(i64 % 1) score(i64 % i) +score(i64 % i32) +score(i64 % i64) score(i64 * 1) -score(i64 * i) score(i64 * i32) +score(i64 * i64) score(i64 + 1) +score(i64 + i) +score(i64 + i32) score(i64 - 1) -score(i64 - i) -score(i64 - i32) +score(i64 - i64) score(int(0.5)) score(int(1)) -score(int(f32 * i)) score(int(f32)) score(int(f64)) +score(int(float(0.5))) score(int(i)) score(int(i32)) score(int(i64)) @@ -12683,72 +16230,74 @@ score(last(array)) score(len("bar")) score(len("foo")) score(len(array)) -score(len(i32 .. i64)) score(len(list)) score(max(1)) -score(max(1, 1)) +score(max(1, i32, 0.5)) score(max(i)) -score(max(i, 1)) +score(max(i, i32)) score(min(1)) -score(min(1, i64)) score(min(i)) +score(min(i, i32)) +score(ok ? 1 : "bar") +score(ok ? 1 : list) +score(reduce(array, #)) +score(reduce(array, i)) +score(reduce(list, 1)) +score(reduce(list, i)) score(score(1)) -score(score(1, 1)) score(score(i)) -score(score(i32 % 1)) -score(true ? 1 : true) -score(true ? i : i64) +score(score(i32 + i)) +score(sum(array)) sort(1 .. 1) -sort(1 .. i64) -sort([0.5]) -sort([1]) -sort([i32]) +sort(1 .. i) +sort([add]) +sort([greet]) +sort([half]) sort([i64]) -sort([nil]) +sort([list]) sort(array) -sort(array) != list -sort(false ? i64 : array) -sort(filter(array, false)) -sort(filter(array, true)) -sort(filter(list, false)) -sort(i .. 1) +sort(array) == array +sort(false ? greet : array) +sort(groupBy(list, #)?.foo) +sort(groupBy(list, i32).half) +sort(i .. i32) sort(i .. i64) sort(i32 .. 1) -sort(i32 .. i32) +sort(i64 .. 1) sort(map(array, "bar")) sort(map(array, "foo")) sort(map(array, #)) sort(map(array, 1)) -sort(map(array, i32)) -sort(map(list, "foo")) != list -sort(map(list, i)) -sort(sort(array)) -string(!(i <= f32)) +sort(map(array, f64)) +sort(map(array, i)) +sort(map(array, i64)) +sort(reduce(array, array)) +sortBy(array, string(true)) +string(!!false) string(!false) string(!ok) string(!true) -string("bar" != "bar") -string("bar" < "bar") +string("bar" != nil) +string("bar" <= "bar") string("bar" == "bar") -string("bar" > "bar") -string("bar" contains "foo") -string("bar" endsWith "bar") +string("bar" > "foo") +string("bar" >= "bar") string("bar" not endsWith "bar") -string("bar" not matches "foo") +string("bar" not matches "bar") string("bar" not startsWith "foo") -string("bar" startsWith "bar") -string("bar") >= type(score) -string("bar") endsWith "foo" + "foo" -string("bar") in foo +string("bar" startsWith "foo") +string("bar") > type(i64) +string("bar") >= toJSON("bar") string("foo" != nil) -string("foo" <= "foo") -string("foo" >= "bar") -string("foo" matches "foo") -string("foo" not endsWith "foo") +string("foo" == "foo") +string("foo" == nil) +string("foo" > "bar") +string("foo" in foo) +string("foo" matches "bar") +string("foo" not contains "bar") +string("foo" not contains "foo") string("foo" not in foo) -string("foo" not matches "foo") -string("foo" startsWith "bar") -string(-(0.5 + f64)) +string(--i) string(-0.5) string(-1) string(-f32) @@ -12757,292 +16306,245 @@ string(-i) string(-i32) string(-i64) string(0.5 != 0.5) -string(0.5 != 1) -string(0.5 != f32) string(0.5 != f64) string(0.5 != i) -string(0.5 != nil) +string(0.5 != i32) string(0.5 * 0.5) -string(0.5 * f32) string(0.5 * i) string(0.5 * i32) -string(0.5 ** 0.5) -string(0.5 ** 1) +string(0.5 ** f32) string(0.5 ** i32) -string(0.5 ** i64) -string(0.5 + 0.5) -string(0.5 + 1) -string(0.5 + f32) string(0.5 + f64) +string(0.5 + i) string(0.5 + i64) -string(0.5 - 0.5) -string(0.5 - 1) +string(0.5 - f32) +string(0.5 - f64) string(0.5 / 0.5) -string(0.5 / f64) +string(0.5 / 1) +string(0.5 / f32) string(0.5 / i) +string(0.5 < 0.5) string(0.5 < 1) -string(0.5 < f32) -string(0.5 < i) -string(0.5 < i32) +string(0.5 < i64) +string(0.5 <= 0.5) string(0.5 <= f64) string(0.5 <= i) -string(0.5 <= i64) +string(0.5 <= i32) string(0.5 == 0.5) string(0.5 == 1) -string(0.5 == f32) -string(0.5 == f64) -string(0.5 == i) -string(0.5 == i32) string(0.5 == i64) string(0.5 == nil) string(0.5 > 0.5) string(0.5 > 1) +string(0.5 > i) string(0.5 > i64) string(0.5 >= 0.5) string(0.5 >= 1) string(0.5 >= f32) -string(0.5 >= f64) -string(0.5 >= i) string(0.5 >= i32) -string(0.5 ^ 0.5) -string(0.5 ^ 1) +string(0.5 >= i64) string(0.5 ^ f32) string(0.5 ^ i) string(0.5 ^ i32) -string(0.5) not endsWith type(1) +string(0.5 ^ i64) +string(0.5 in array) +string(0.5 not in array) +string(1 != 0.5) string(1 != 1) -string(1 != f32) -string(1 != f64) string(1 != i) -string(1 != i32) +string(1 != i64) string(1 != nil) string(1 % 1) string(1 % i) string(1 % i32) -string(1 % i64) -string(1 * 1) -string(1 * i) -string(1 * i64) +string(1 * 0.5) +string(1 * f32) +string(1 * f64) string(1 ** 0.5) string(1 ** 1) -string(1 ** f64) string(1 ** i) -string(1 ** i32) +string(1 ** i64) string(1 + 0.5) -string(1 + f32) +string(1 + 1) string(1 + f64) -string(1 + i64) +string(1 - 0.5) string(1 - f32) -string(1 - i) +string(1 - i32) string(1 - i64) string(1 .. 1) -string(1 .. i) string(1 .. i32) +string(1 .. i64) string(1 / 0.5) -string(1 / 1) -string(1 / f32) +string(1 / f64) string(1 / i) -string(1 < i) -string(1 < i32) -string(1 < i64) -string(1 <= 0.5) +string(1 / i32) +string(1 / i64) +string(1 < 0.5) string(1 <= 1) string(1 <= f32) -string(1 <= f64) +string(1 <= i) string(1 <= i32) -string(1 == 0.5) +string(1 <= i64) string(1 == 1) -string(1 == f64) -string(1 == i) -string(1 == i64) -string(1 == nil) +string(1 == f32) +string(1 == i32) +string(1 > 0.5) string(1 > 1) -string(1 > f32) -string(1 >= 0.5) -string(1 >= 1) +string(1 > i64) string(1 >= f32) -string(1 >= f64) string(1 >= i) -string(1 >= i32) -string(1 >= i64) +string(1 ^ 0.5) string(1 ^ 1) string(1 ^ f32) string(1 ^ f64) -string(1 ^ i) -string(1 ^ i32) string(1 ^ i64) -string(1 in array) string(1 not in array) -string(1)[i64:i64] -string([0.5, f32]) -string([add]) -string([f32]) -string([greet]) -string([i32, half]) -string([i32]) -string([i]) -string([ok]) +string([0.5]) +string([div]) +string([f64]) +string([list]) string([score]) +string([true]) string(abs(0.5)) string(abs(1)) string(abs(f32)) -string(abs(f64)) -string(abs(half(0.5))) string(abs(i)) -string(abs(i64)) +string(abs(i32)) string(add != add) -string(add != half) -string(add != nil) -string(add != score) -string(add == greet) +string(add != div) +string(add == div) +string(add == nil) string(add) -string(add) contains type(list) -string(add) not in foo -string(all(array, false)) +string(add) in foo ? i64 : i32 +string(add) not endsWith foo.Bar +string(all(array, ok)) string(all(array, true)) -string(any(array, false)) -string(any(list, true)) +string(any(array, ok)) +string(any(list, false)) +string(any(list, ok)) string(array != array) -string(array == nil) +string(array != nil) string(array) -string(array) not in foo -string(array[1:i]) -string(array[1]) -string(array[i64]) -string(count(array, # <= #)) -string(count(array, ok)) -string(div != greet) +string(array[i32]) +string(bitnot(1)) +string(bitnot(i32)) +string(bitnot(i64)) +string(ceil(0.5)) +string(ceil(1)) +string(ceil(f32)) +string(ceil(f64)) +string(ceil(i)) +string(ceil(i64)) +string(div != div) string(div != nil) -string(div == nil) -string(div == score) +string(div == add) +string(div == div) string(div) string(f32 != 0.5) -string(f32 != 1) -string(f32 != f32) string(f32 != f64) +string(f32 != i) string(f32 != nil) string(f32 * 0.5) +string(f32 * 1) string(f32 * f64) string(f32 * i) string(f32 * i32) string(f32 ** 1) -string(f32 ** i64) -string(f32 + 1) +string(f32 ** f64) string(f32 + f32) -string(f32 - i) -string(f32 / 1) -string(f32 / i) +string(f32 + f64) +string(f32 + i32) +string(f32 + i64) +string(f32 - 0.5) +string(f32 - 1) +string(f32 - i64) +string(f32 / 0.5) +string(f32 / f64) string(f32 / i64) -string(f32 < 0.5) -string(f32 < f64) -string(f32 < i32) -string(f32 <= 0.5) -string(f32 <= 1) -string(f32 <= f32) +string(f32 < f32) string(f32 <= i) string(f32 <= i32) string(f32 == 0.5) -string(f32 == 1) -string(f32 == i64) -string(f32 == nil) -string(f32 > 1) -string(f32 > f32) +string(f32 == i) +string(f32 > 0.5) string(f32 > f64) -string(f32 > i) -string(f32 > i32) -string(f32 >= 0.5) -string(f32 >= f32) -string(f32 >= f64) -string(f32 >= i32) -string(f32 ^ 1) -string(f32 ^ f32) -string(f32 ^ f64) -string(f32 ^ i) -string(f32 ^ i64) string(f32) -string(f32) matches trim("bar") +string(f32) in foo string(f64 != 1) -string(f64 != f32) +string(f64 != i) +string(f64 != nil) string(f64 * 0.5) -string(f64 * 1) -string(f64 * f32) -string(f64 * f64) string(f64 * i) +string(f64 * i32) +string(f64 * i64) string(f64 ** 0.5) -string(f64 ** 1) string(f64 ** f64) -string(f64 ** i32) +string(f64 ** i) string(f64 + 0.5) string(f64 + 1) string(f64 + f32) -string(f64 + i) -string(f64 + i32) -string(f64 + i64) string(f64 - 0.5) -string(f64 - f64) -string(f64 - i32) +string(f64 - 1) +string(f64 - i) string(f64 / 0.5) -string(f64 / f64) -string(f64 / i64) -string(f64 < 1) -string(f64 < f64) -string(f64 < i32) +string(f64 < f32) +string(f64 < i) +string(f64 <= 1) +string(f64 <= f32) string(f64 <= f64) -string(f64 <= i) -string(f64 == 0.5) string(f64 == 1) string(f64 == f32) -string(f64 == f64) string(f64 == i) -string(f64 == i32) string(f64 == i64) -string(f64 > 0.5) string(f64 > 1) -string(f64 > f32) -string(f64 > f64) -string(f64 > i64) -string(f64 >= 1) string(f64 >= f32) string(f64 >= i) -string(f64 >= i64) string(f64 ^ 0.5) +string(f64 ^ f32) string(f64 ^ i) -string(f64 ^ i32) -string(f64 ^ i64) +string(f64 in array) +string(f64 not in array) string(f64) -string(false && false) -string(false ? 0.5 : i32) -string(false ? 1 : "bar") -string(false ? 1 : f32) -string(false ? 1 : score) -string(false ? div : "foo") -string(false ? f32 : foo) -string(false and true) -string(false) <= foo.Bar -string(false) > string(add) -string(filter(list, ok)) +string(false != nil) +string(false != ok) +string(false != true) +string(false ? array : 0.5) +string(false ? f64 : i32) +string(false ? false : i) +string(false ? greet : f64) +string(false ? half : "bar") +string(false ? half : i) +string(false ? i : i) +string(false ? nil : nil) +string(false and ok) +string(false) endsWith toBase64("foo") +string(filter(array, false)) +string(filter(array, ok)) +string(filter(array, true)) +string(filter(list, false)) string(find(array, ok)) +string(find(array, true)) +string(find(list, ok)) string(findIndex(array, true)) -string(findIndex(list, ok)) -string(findLast(array, # >= #)) string(findLast(array, false)) string(findLast(array, ok)) -string(findLast(list, ok)) -string(findLastIndex(array, not false)) +string(findLast(array, true)) string(findLastIndex(array, ok)) -string(findLastIndex(array, true)) -string(findLastIndex(list, false)) -string(findLastIndex(list, ok)) -string(findLastIndex(list, true)) string(first(array)) string(first(list)) string(float(0.5)) string(float(1)) -string(float(f32)) string(float(f64)) string(float(i)) string(float(i64)) -string(foo != nil) +string(floor(0.5)) +string(floor(f32)) +string(floor(f64)) +string(floor(i)) +string(floor(i32)) +string(floor(i64)) +string(foo == foo) +string(foo == nil) string(foo not in list) string(foo) string(foo.Bar) @@ -13053,367 +16555,330 @@ string(foo?.Bar) string(foo?.Qux) string(foo?.String()) string(foo?.String) -string(get(array, 1)) string(get(array, i)) -string(get(list, i)) +string(get(array, i64)) +string(get(list, 1)) +string(get(list, i32)) string(get(list, i64)) -string(greet != add) -string(greet != greet) string(greet != nil) -string(greet != score) -string(greet == add) string(greet == greet) -string(greet == half) string(greet == nil) -string(greet == score) string(greet("bar")) string(greet("foo")) string(greet) -string(greet)[i64:i] -string(half != add) -string(half != div) -string(half != half) -string(half == greet) +string(greet) == nil ? 0.5 : i +string(groupBy(array, #)) +string(groupBy(array, 1)) +string(groupBy(array, f32)) +string(groupBy(array, false)) +string(groupBy(array, i32)) +string(groupBy(list, #)) +string(groupBy(list, 0.5)) +string(groupBy(list, 1)) +string(groupBy(list, f64)) +string(groupBy(list, false)) +string(groupBy(list, i)) +string(half != nil) string(half == nil) -string(half == score) -string(half(-1)) string(half(0.5)) +string(half(1)) string(half(f64)) string(half) -string(half) > toJSON(nil) -string(half) not endsWith type("foo") -string(i != 0.5) -string(i != f32) -string(i != f64) +string(i != 1) +string(i != i64) string(i % 1) string(i % i32) -string(i * i32) -string(i * i64) -string(i ** 1) +string(i % i64) +string(i * 1) +string(i * f64) string(i ** f32) -string(i + 1) +string(i ** f64) +string(i ** i64) +string(i + 0.5) string(i + i) -string(i + i32) -string(i + i64) string(i - f32) -string(i - i64) string(i .. 1) string(i .. i) -string(i .. i64) +string(i .. i32) string(i / 1) string(i / f32) -string(i / i) +string(i / f64) string(i / i32) string(i / i64) +string(i < 0.5) string(i < 1) -string(i < f32) string(i < i32) -string(i <= 0.5) -string(i <= 1) -string(i == 0.5) -string(i == f32) -string(i == i32) +string(i <= f32) +string(i <= i) +string(i == 1) +string(i == i) string(i > 0.5) string(i > 1) -string(i > f64) -string(i > i64) -string(i >= 1) -string(i >= f64) -string(i ^ 0.5) +string(i > f32) +string(i >= 0.5) +string(i >= i64) string(i ^ 1) +string(i ^ f32) string(i ^ i) -string(i in array) -string(i not in array) +string(i ^ i64) string(i) +string(i) in foo +string(i32 != 0.5) +string(i32 != 1) string(i32 != f64) -string(i32 != i) +string(i32 != i32) string(i32 != nil) -string(i32 * 0.5) +string(i32 % 1) +string(i32 % i) +string(i32 % i64) string(i32 * 1) string(i32 * f32) string(i32 * f64) -string(i32 * i64) +string(i32 * i) string(i32 ** 0.5) string(i32 ** f64) -string(i32 ** i) -string(i32 + f64) -string(i32 + i32) +string(i32 + 0.5) +string(i32 - 0.5) +string(i32 - 1) string(i32 - f32) string(i32 - f64) +string(i32 - i32) +string(i32 - i64) string(i32 .. 1) -string(i32 .. i32) -string(i32 .. i64) +string(i32 .. i) string(i32 / 0.5) -string(i32 / i64) -string(i32 < 0.5) -string(i32 < f32) -string(i32 < i) -string(i32 < i32) +string(i32 < 1) +string(i32 < f64) string(i32 < i64) -string(i32 <= f64) -string(i32 <= i64) -string(i32 == 1) string(i32 == f32) -string(i32 == f64) -string(i32 == i) +string(i32 == i64) string(i32 == nil) string(i32 > 1) -string(i32 > f64) +string(i32 > i) string(i32 >= 0.5) string(i32 >= 1) -string(i32 >= f64) string(i32 >= i) -string(i32 >= i64) -string(i32 ^ 1) +string(i32 ^ f32) string(i32 ^ f64) string(i32 ^ i32) -string(i32 ^ i64) string(i32 in array) string(i32 not in array) string(i32) -string(i32) == type("bar") -string(i64 != 0.5) +string(i32) not startsWith trimSuffix("foo") string(i64 != 1) string(i64 != i) string(i64 != i32) string(i64 != i64) -string(i64 != nil) -string(i64 % 1) -string(i64 % i64) +string(i64 % i32) string(i64 * 1) string(i64 * f32) -string(i64 * i32) -string(i64 * i64) +string(i64 * i) string(i64 ** 0.5) -string(i64 ** f32) -string(i64 ** i) -string(i64 ** i32) -string(i64 + 0.5) -string(i64 + f32) -string(i64 + f64) -string(i64 + i) -string(i64 + i32) -string(i64 - f32) +string(i64 + i64) string(i64 - i) -string(i64 / 0.5) -string(i64 / 1) -string(i64 / f32) +string(i64 - i32) +string(i64 - i64) +string(i64 .. 1) +string(i64 .. i) +string(i64 .. i32) string(i64 / f64) string(i64 / i) string(i64 / i64) -string(i64 < 1) -string(i64 <= 0.5) -string(i64 <= f32) -string(i64 <= i) -string(i64 <= i32) +string(i64 < 0.5) +string(i64 < i) string(i64 <= i64) -string(i64 == 1) +string(i64 == 0.5) string(i64 == i) -string(i64 == i32) -string(i64 == nil) -string(i64 > 1) -string(i64 > f32) -string(i64 > f64) -string(i64 > i) -string(i64 > i32) +string(i64 > 0.5) string(i64 > i64) -string(i64 >= f64) -string(i64 >= i64) +string(i64 >= 0.5) +string(i64 >= 1) string(i64 ^ 0.5) string(i64 ^ f64) -string(i64 ^ i) string(i64 in array) string(i64) -string(i64) >= foo.Bar +string(i64) matches greet("bar") string(i64) not in foo string(int(0.5)) string(int(1)) -string(int(f32 - i)) -string(int(f32)) -string(int(f64)) -string(int(i)) string(int(i32)) string(int(i64)) string(last(array)) -string(last(list)) +string(last(list).String()) +string(len("bar")) string(len(array)) string(len(list)) -string(len(string("foo"))) +string(list != nil) string(list == array) string(list == list) string(list == nil) string(list) -string(list) != toJSON(i64) string(list[1]) +string(list[i32]) string(list[i64]) -string(list[i64].String) -string(lower("bar")) -string(lower("foo")) -string(map(array, "bar")) +string(list[i]) string(map(array, #)) string(map(array, 0.5)) -string(map(array, 1)) -string(map(array, array)) +string(map(array, add)) string(map(array, div)) -string(map(array, greet)) string(map(array, i)) string(map(array, i32)) -string(map(array, ok)) string(map(array, true)) string(map(list, "bar")) string(map(list, "foo")) string(map(list, #)) string(map(list, 0.5)) string(map(list, 1)) -string(map(list, add)) -string(map(list, f32)) -string(map(list, f64)) -string(map(list, false)) -string(map(list, greet)) +string(map(list, array)) +string(map(list, half)) +string(map(list, i32)) string(map(list, i64)) -string(map(list, list)) string(max(0.5)) +string(max(0.5, f32)) string(max(1)) -string(max(1, 0.5)) -string(max(1, f32)) string(max(f32)) string(max(f64)) string(max(i)) -string(max(i32)) -string(max(i32, 1, i64)) string(max(i64)) +string(mean(array)) string(min(0.5)) -string(min(0.5, f64, f32)) -string(min(1)) string(min(f32)) -string(min(f64)) string(min(i)) string(min(i32)) -string(min(i32, i64)) string(min(i64)) -string(nil != "foo") -string(nil != 0.5) -string(nil != 1) -string(nil != array) +string(nil != "bar") string(nil != div) -string(nil != f64) string(nil != false) string(nil != greet) +string(nil != half) string(nil != i) -string(nil != i64) -string(nil != nil) -string(nil != score) -string(nil == "foo") +string(nil != ok) +string(nil == "bar") +string(nil == 0.5) string(nil == 1) -string(nil == add) -string(nil == f32) -string(nil == f64) -string(nil == false) +string(nil == div) +string(nil == foo) string(nil == list) +string(nil == nil) string(nil == ok) -string(nil == true) -string(nil in array) +string(nil == score) string(nil in list) -string(nil) > string(1) -string(nil) >= string(greet) -string(nil) in foo +string(nil not in list) +string(nil) <= list[i].Bar string(none(array, ok)) -string(none(list, true)) +string(none(list, false)) +string(none(list, ok)) +string(not !false) +string(not (i64 == 0.5)) string(not false) string(not ok) string(not true) -string(ok && false) -string(ok && ok) -string(ok == nil) -string(ok == true) -string(ok ? 0.5 : "foo") +string(ok != nil) +string(ok != true) +string(ok ? 0.5 : nil) string(ok ? 0.5 : true) -string(ok ? true : i32) +string(ok ? 1 : array) +string(ok ? 1 : f32) +string(ok ? array : add) +string(ok ? div : array) +string(ok ? half : score) +string(ok ? i : 1) +string(ok ? nil : half) +string(ok ? nil : list) string(ok or false) -string(ok or ok) -string(ok || ok) +string(ok || false) string(ok) -string(one(array, false)) -string(one(array, ok)) string(one(array, true)) string(one(list, true)) +string(reduce(array, #)) +string(reduce(array, 0.5)) +string(reduce(array, 1)) +string(reduce(array, f64)) +string(reduce(array, greet)) +string(reduce(array, half)) +string(reduce(array, i64)) +string(reduce(array, list)) +string(reduce(array, score)) +string(reduce(list, "bar")) +string(reduce(list, #)) +string(reduce(list, 1)) +string(reduce(list, add)) +string(reduce(list, div)) +string(reduce(list, foo)) +string(reduce(list, i)) +string(reduce(list, i64)) +string(reduce(list, list)) +string(round(0.5)) +string(round(1)) +string(round(ceil(i32))) +string(round(f64)) +string(round(i64)) string(score != nil) -string(score == div) string(score == nil) +string(score(1 % 1)) string(score(1)) string(score(i)) -string(score(score(i))) string(score) -string(score) < string(ok) -string(score) not in foo string(sort(array)) +string(sortBy(array, "foo")) string(string("bar")) string(string("foo")) string(string(0.5)) string(string(1)) -string(string(add)) string(string(array)) string(string(div)) +string(string(f32)) string(string(f64)) string(string(false)) -string(string(foo)) string(string(greet)) string(string(half)) string(string(i)) -string(string(i32)) string(string(i64)) -string(string(list)) string(string(nil)) string(string(ok)) string(string(score)) -string(string(true)) +string(sum(array)) +string(toBase64("foo")) string(toJSON("bar")) -string(toJSON("foo")) string(toJSON(0.5)) string(toJSON(1)) string(toJSON(array)) string(toJSON(f32)) string(toJSON(f64)) string(toJSON(false)) -string(toJSON(foo)) string(toJSON(i)) +string(toJSON(i32)) string(toJSON(i64)) string(toJSON(list)) string(toJSON(nil)) string(toJSON(ok)) string(toJSON(true)) -string(trim("foo")) -string(trim(toJSON(0.5))) -string(trimPrefix("bar")) +string(trim("bar")) +string(trim(type(nil))) string(trimPrefix("foo")) -string(trimPrefix(type(f32))) -string(trimSuffix("bar")) -string(true != true) +string(trimSuffix("foo")) +string(true != false) +string(true && ok) string(true == nil) -string(true == ok) -string(true ? 1 : true) -string(true ? array : f32) -string(true ? div : i64) -string(true ? i32 : "foo") -string(true ? i32 : greet) -string(true ? score : 0.5) -string(true ? true : i32) +string(true ? 0.5 : true) +string(true ? f64 : score) +string(true ? false : nil) +string(true ? greet : i) +string(true ? list : ok) string(true and false) -string(true or true) -string(true || false) -string(true) endsWith string(i64) -string(true) not in foo +string(true or false) +string(true or ok) +string(true || true) +string(type("bar")) string(type("foo")) +string(type(-i64)) string(type(0.5)) -string(type(1 < f64)) string(type(1)) -string(type(add)) string(type(array)) -string(type(div)) string(type(f32)) string(type(f64)) -string(type(false)) string(type(foo)) +string(type(greet)) string(type(half)) string(type(i)) string(type(i32)) @@ -13421,116 +16886,131 @@ string(type(i64)) string(type(list)) string(type(nil)) string(type(ok)) -string(type(score(1))) string(type(score)) -string(type(true)) -string(type(type(false))) -string(upper("bar")) string(upper("foo")) -string({"bar": 0.5}) -string({"bar": i32, "foo": i64}) -string({"foo": f64}) -string({"foo": true}) +string({"bar": "foo", "foo": half}) +string({"bar": f32, "foo": i32}) +string({"bar": f32}) +string({"bar": true}) +string({"foo": add}) +string({"foo": array, "foo": list}) +sum(1 .. 1) +sum(1 .. i) +sum(1 .. i32) +sum(1 .. i64) +sum([0.5]) +sum([f32]) +sum(array) +sum(array) != f32 +sum(array) % i +sum(array) % i64 +sum(array) - f32 +sum(array) / -f64 +sum(array) < i +sum(array) == i64 - i +sum(array) ^ f64 +sum(array) not in array +sum(filter(array, ok)) +sum(groupBy(array, i32).String) +sum(i32 .. 1) +sum(i64 .. i32) +sum(i64 .. i64) +sum(list[i:1]) +sum(map(array, #)) +sum(map(array, f32)) +sum(map(list, 0.5)) +sum(map(list, f32)) +sum(map(list, i32)) +sum(ok ? array : i64) +sum(reduce(array, array)) +sum(reduce(list, array)) +sum(sort(array)) +sum(true ? array : i32) +take(array, i) +take(array, i32) +take(array, i64) +take(list, i) +take(list, i32) +take(list, i64) +take(map(array, #), i) +toBase64("bar" + "bar") +toBase64("bar" + "foo") +toBase64("bar") startsWith type(score) +toBase64("foo" + "bar") toBase64(foo.Bar) toBase64(foo.String()) toBase64(foo?.Bar) toBase64(foo?.String()) toBase64(greet("bar")) toBase64(greet("foo")) -toBase64(greet(string(array))) toBase64(lower("bar")) toBase64(lower("foo")) -toBase64(lower(type(i32))) -toBase64(ok ? "foo" : 1) -toBase64(ok ? "foo" : foo) -toBase64(string("bar")) +toBase64(ok ? "bar" : f64) +toBase64(reduce(list, "bar")) toBase64(string("foo")) toBase64(string(0.5)) toBase64(string(1)) +toBase64(string(add)) toBase64(string(array)) -toBase64(string(f32 <= i32)) toBase64(string(f32)) toBase64(string(f64)) -toBase64(string(false)) toBase64(string(foo)) toBase64(string(greet)) toBase64(string(half)) toBase64(string(i)) -toBase64(string(i32)) -toBase64(string(i64)) toBase64(string(list)) -toBase64(string(nil)) toBase64(string(ok)) -toBase64(string(score)) -toBase64(string(true)) toBase64(toBase64("bar")) -toBase64(toBase64("foo")) toBase64(toJSON("bar")) -toBase64(toJSON("foo")) toBase64(toJSON(0.5)) toBase64(toJSON(1)) -toBase64(toJSON(array)) toBase64(toJSON(f32)) toBase64(toJSON(f64)) -toBase64(toJSON(false)) toBase64(toJSON(foo)) -toBase64(toJSON(i)) -toBase64(toJSON(i32)) toBase64(toJSON(i64)) toBase64(toJSON(list)) toBase64(toJSON(nil)) toBase64(toJSON(ok)) toBase64(toJSON(true)) toBase64(trim("bar")) -toBase64(trim("foo")) toBase64(trimPrefix("foo")) -toBase64(trimSuffix("bar")) toBase64(trimSuffix("foo")) -toBase64(true ? "bar" : ok) -toBase64(type("bar")) -toBase64(type("foo")) toBase64(type(0.5)) toBase64(type(1)) toBase64(type(add)) -toBase64(type(array)) toBase64(type(div)) toBase64(type(f32)) toBase64(type(f64)) toBase64(type(false)) toBase64(type(foo)) -toBase64(type(get(array, i))) toBase64(type(greet)) +toBase64(type(half)) toBase64(type(i)) toBase64(type(i32)) toBase64(type(i64)) toBase64(type(list)) -toBase64(type(ok)) -toBase64(type(true)) -toBase64(upper("bar")) +toBase64(type(nil)) +toBase64(type(score)) toBase64(upper("foo")) -toBase64(upper(foo.Bar)) toJSON(!false) toJSON(!ok) toJSON(!true) -toJSON("bar" != "foo") -toJSON("bar" + "bar") -toJSON("bar" + "foo") -toJSON("bar" <= "foo") -toJSON("bar" >= "foo") -toJSON("bar" contains "bar") -toJSON("bar" matches "bar") +toJSON("bar" < "foo") +toJSON("bar" >= "bar") +toJSON("bar" endsWith "bar") +toJSON("bar" matches "foo") +toJSON("bar" not in foo) toJSON("bar" not matches "bar") -toJSON("bar" not matches "foo") +toJSON("bar" not startsWith "foo") +toJSON("bar" startsWith "bar") +toJSON("bar") not in foo toJSON("foo" != "bar") -toJSON("foo" + "bar") -toJSON("foo" <= "bar") -toJSON("foo" == nil) -toJSON("foo" contains "bar") -toJSON("foo" matches "foo") -toJSON("foo" not in foo) -toJSON("foo" not matches "bar") -toJSON("foo") > foo?.Bar -toJSON("foo") not in foo +toJSON("foo" != "foo") +toJSON("foo" < "foo") +toJSON("foo" == "bar") +toJSON("foo" > "foo") +toJSON("foo" >= "foo") +toJSON("foo" startsWith "bar") toJSON(-0.5) toJSON(-1) toJSON(-f32) @@ -13538,133 +17018,104 @@ toJSON(-f64) toJSON(-i) toJSON(-i32) toJSON(-i64) -toJSON(0.5 != 0.5) toJSON(0.5 != 1) -toJSON(0.5 != f32) toJSON(0.5 != f64) -toJSON(0.5 != i) -toJSON(0.5 != i32) -toJSON(0.5 * 0.5) +toJSON(0.5 != nil) toJSON(0.5 * i) toJSON(0.5 * i32) +toJSON(0.5 * i64) +toJSON(0.5 ** 0.5) +toJSON(0.5 ** 1) +toJSON(0.5 ** f32) toJSON(0.5 ** f64) toJSON(0.5 ** i) -toJSON(0.5 ** i64) +toJSON(0.5 ** i32) toJSON(0.5 + 0.5) +toJSON(0.5 + 1) toJSON(0.5 + f32) toJSON(0.5 - 0.5) toJSON(0.5 - 1) toJSON(0.5 - f32) toJSON(0.5 - f64) -toJSON(0.5 / 0.5) +toJSON(0.5 - i) +toJSON(0.5 - i32) toJSON(0.5 / 1) toJSON(0.5 / f32) toJSON(0.5 / f64) -toJSON(0.5 / i) toJSON(0.5 / i32) -toJSON(0.5 / i64) -toJSON(0.5 < 0.5) toJSON(0.5 < 1) toJSON(0.5 < f32) +toJSON(0.5 < f64) toJSON(0.5 < i) +toJSON(0.5 <= 0.5) toJSON(0.5 <= 1) toJSON(0.5 <= f32) -toJSON(0.5 <= f64) -toJSON(0.5 <= i) +toJSON(0.5 <= i64) toJSON(0.5 == 0.5) -toJSON(0.5 == 1) -toJSON(0.5 == f32) +toJSON(0.5 == f64) toJSON(0.5 == i) +toJSON(0.5 == i32) toJSON(0.5 == i64) -toJSON(0.5 > 1) -toJSON(0.5 > f32) -toJSON(0.5 > f64) -toJSON(0.5 > i32) toJSON(0.5 >= 0.5) toJSON(0.5 >= 1) toJSON(0.5 >= f32) -toJSON(0.5 >= f64) -toJSON(0.5 >= i) -toJSON(0.5 >= i32) -toJSON(0.5 >= i64) -toJSON(0.5 ^ 0.5) -toJSON(0.5 ^ 1) toJSON(0.5 ^ f32) -toJSON(0.5 ^ f64) -toJSON(0.5 ^ i) toJSON(0.5 ^ i32) toJSON(0.5 ^ i64) -toJSON(0.5) contains "bar" ? "bar" : array +toJSON(0.5) not in foo toJSON(1 != 0.5) toJSON(1 != f32) toJSON(1 != nil) toJSON(1 % 1) +toJSON(1 % i) toJSON(1 % i32) -toJSON(1 * 0.5) -toJSON(1 * f32) toJSON(1 * f64) toJSON(1 * i32) toJSON(1 * i64) toJSON(1 ** 0.5) toJSON(1 ** 1) -toJSON(1 ** f32) -toJSON(1 ** f64) -toJSON(1 ** i >= f64) toJSON(1 ** i32) toJSON(1 + 0.5) -toJSON(1 + f32) +toJSON(1 + 1) toJSON(1 + f64) -toJSON(1 + i64) -toJSON(1 - 0.5) -toJSON(1 - 1) -toJSON(1 - f32) -toJSON(1 - f64) +toJSON(1 + i) +toJSON(1 + i32) +toJSON(1 - i) toJSON(1 - i32) -toJSON(1 .. 1) -toJSON(1 .. i) +toJSON(1 .. i32) toJSON(1 .. i64) -toJSON(1 / 0.5) toJSON(1 / 1) -toJSON(1 / f32) -toJSON(1 / i32) +toJSON(1 / f64) +toJSON(1 / i64) toJSON(1 < 0.5) toJSON(1 < 1) -toJSON(1 < f32) toJSON(1 < f64) toJSON(1 < i) toJSON(1 <= 0.5) -toJSON(1 <= 1) -toJSON(1 <= i) -toJSON(1 <= i32) -toJSON(1 <= i64) +toJSON(1 <= f32) +toJSON(1 <= f64) toJSON(1 == 0.5) -toJSON(1 == f32) +toJSON(1 == 1) +toJSON(1 == f64) toJSON(1 == i) toJSON(1 == i32) -toJSON(1 == i64) toJSON(1 == nil) -toJSON(1 > 0.5) -toJSON(1 > f64) +toJSON(1 > f32) toJSON(1 > i) -toJSON(1 > i32) -toJSON(1 > i64) -toJSON(1 >= 0.5) toJSON(1 >= 1) toJSON(1 >= f32) toJSON(1 >= i32) -toJSON(1 ^ 0.5) toJSON(1 ^ 1) toJSON(1 ^ f32) -toJSON(1 ^ f64) toJSON(1 ^ i32) toJSON(1 ^ i64) -toJSON(1 in array) -toJSON(1) == nil == true -toJSON(1) in foo -toJSON(1) not in foo -toJSON(1) startsWith foo.String() -toJSON([1]) -toJSON([i64]) +toJSON(1) > reduce(list, "bar") +toJSON(1) not contains string(true) +toJSON([f64]) +toJSON([false]) +toJSON([foo]) +toJSON([nil]) +toJSON([true]) toJSON(abs(0.5)) toJSON(abs(1)) toJSON(abs(f32)) @@ -13672,143 +17123,92 @@ toJSON(abs(f64)) toJSON(abs(i)) toJSON(abs(i32)) toJSON(abs(i64)) -toJSON(add != nil) -toJSON(add != score) -toJSON(add == div) -toJSON(add == half) -toJSON(add == nil) -toJSON(add == score) -toJSON(all(list, false)) -toJSON(all(list, ok)) -toJSON(all(list, true)) +toJSON(add == add) toJSON(any(array, false)) -toJSON(any(array, true)) -toJSON(array != array) -toJSON(array != nil) +toJSON(array == array) +toJSON(array == list) +toJSON(array == nil) toJSON(array) -toJSON(array) != toJSON(ok) -toJSON(array) > "bar" != false -toJSON(array) endsWith greet("foo") -toJSON(array) endsWith string(i32) -toJSON(array) in foo -toJSON(array) not startsWith greet("foo") -toJSON(array[1:1]) -toJSON(array[i32]) +toJSON(array[1:i64]) +toJSON(array[1]) toJSON(array[i]) -toJSON(count(array, false)) +toJSON(bitnot(1)) +toJSON(bitnot(i)) +toJSON(bitnot(i32)) +toJSON(bitnot(i64)) +toJSON(bitshl(i, i32)) +toJSON(ceil(1)) +toJSON(ceil(f64)) +toJSON(ceil(i)) +toJSON(ceil(i32)) +toJSON(ceil(i64)) toJSON(count(array, ok)) toJSON(div != div) -toJSON(div != greet) -toJSON(div != score) toJSON(div == div) -toJSON(div == half) -toJSON(div == nil) -toJSON(div == score) -toJSON(f32 != 1) -toJSON(f32 * 0.5) -toJSON(f32 * 1) +toJSON(f32 != 0.5) +toJSON(f32 != 1 || ok) +toJSON(f32 != f32) +toJSON(f32 != i32) toJSON(f32 * f32) -toJSON(f32 * f64) -toJSON(f32 * i32) -toJSON(f32 ** f32) +toJSON(f32 ** 0.5) +toJSON(f32 ** 1) +toJSON(f32 ** f64) toJSON(f32 ** i32) -toJSON(f32 ** i64) -toJSON(f32 + 1) -toJSON(f32 + i) -toJSON(f32 + i32) +toJSON(f32 + 0.5) +toJSON(f32 + f32) +toJSON(f32 - 0.5) +toJSON(f32 - f32) toJSON(f32 - f64) -toJSON(f32 - i32) -toJSON(f32 / 0.5) -toJSON(f32 / 1) +toJSON(f32 - i64) toJSON(f32 < 0.5) -toJSON(f32 < f32) -toJSON(f32 < f64) -toJSON(f32 <= f32) -toJSON(f32 == 1) +toJSON(f32 < i) +toJSON(f32 < i64) +toJSON(f32 <= 0.5) +toJSON(f32 <= 1) +toJSON(f32 <= i64) toJSON(f32 == f64) toJSON(f32 == i) toJSON(f32 == nil) -toJSON(f32 > 0.5) -toJSON(f32 > f64) toJSON(f32 > i) -toJSON(f32 >= 1) -toJSON(f32 >= f32) -toJSON(f32 ^ 0.5) -toJSON(f32 ^ 1) -toJSON(f32 ^ f64) -toJSON(f32 ^ i) +toJSON(f32 > i32) +toJSON(f32 >= 0.5) toJSON(f32 ^ i64) toJSON(f32) -toJSON(f64 != 1) +toJSON(f32) in foo +toJSON(f64 != 0.5) toJSON(f64 != f32) -toJSON(f64 != f64) toJSON(f64 != i) -toJSON(f64 != i32 / i32) toJSON(f64 != i32) toJSON(f64 != nil) -toJSON(f64 * 0.5) +toJSON(f64 * 1) toJSON(f64 * f64) -toJSON(f64 * i) toJSON(f64 * i64) toJSON(f64 ** 0.5) toJSON(f64 ** f32) -toJSON(f64 ** i) -toJSON(f64 ** i64) -toJSON(f64 + 1) +toJSON(f64 + 0.5) toJSON(f64 + f32) -toJSON(f64 + i) toJSON(f64 + i32) -toJSON(f64 - 1) toJSON(f64 - f64) toJSON(f64 - i) -toJSON(f64 - i32) -toJSON(f64 / 0.5) -toJSON(f64 / f32) -toJSON(f64 / i32) -toJSON(f64 < 1) -toJSON(f64 < f32) -toJSON(f64 < i32) -toJSON(f64 < i64) +toJSON(f64 - i64) +toJSON(f64 / 1) +toJSON(f64 < f64) toJSON(f64 <= 0.5) -toJSON(f64 <= 1) -toJSON(f64 <= i32) -toJSON(f64 == 1) -toJSON(f64 == i64) -toJSON(f64 == nil) -toJSON(f64 > 1) -toJSON(f64 > f64) -toJSON(f64 >= 0.5) -toJSON(f64 >= i64) -toJSON(f64 ^ 1) -toJSON(f64 ^ f64) -toJSON(f64 ^ i) +toJSON(f64 == f64) +toJSON(f64 >= 1) +toJSON(f64 >= f64) +toJSON(f64 ^ f32) toJSON(f64) -toJSON(false != nil) -toJSON(false && false) -toJSON(false == false) -toJSON(false ? 0.5 : nil) -toJSON(false ? 1 : f32) -toJSON(false ? f32 : list) -toJSON(false ? false : i32) -toJSON(false ? greet : 1) -toJSON(false ? greet : i32) -toJSON(false ? nil : f64) -toJSON(false and ok) -toJSON(false and true) -toJSON(filter(array, ok)) -toJSON(filter(list, false)) +toJSON(false != ok) +toJSON(false ? 0.5 : "foo") +toJSON(false ? add : f64) +toJSON(false ? array : 1) +toJSON(false ? false : foo) +toJSON(false ? nil : ok) +toJSON(false ? ok : i32) toJSON(filter(list, true)) -toJSON(find(array, false)) -toJSON(find(array, ok)) -toJSON(findIndex(array, ok)) -toJSON(findIndex(array, true)) -toJSON(findIndex(list, ok)) -toJSON(findIndex(list, true)) -toJSON(findLast(array, false)) -toJSON(findLast(list, true)) -toJSON(findLastIndex(array, true)) -toJSON(findLastIndex(list, false)) -toJSON(findLastIndex(list, ok)) +toJSON(find(list, ok)) +toJSON(findIndex(map(array, list), ok)) toJSON(first(array)) toJSON(first(list)) toJSON(float(0.5)) @@ -13816,297 +17216,272 @@ toJSON(float(1)) toJSON(float(f32)) toJSON(float(f64)) toJSON(float(i)) -toJSON(float(i32)) toJSON(float(i64)) -toJSON(foo != foo) +toJSON(floor(0.5)) +toJSON(floor(f64)) +toJSON(floor(i)) +toJSON(floor(i32)) toJSON(foo != nil) -toJSON(foo == foo) -toJSON(foo == nil) toJSON(foo in list) toJSON(foo) toJSON(foo.Bar) toJSON(foo.String()) toJSON(foo?.Bar) toJSON(foo?.String()) -toJSON(get(array, 1)) +toJSON(get(array, i32)) toJSON(get(array, i64)) toJSON(get(list, 1)) toJSON(get(list, i)) +toJSON(get(list, i32)) toJSON(get(list, i64)) -toJSON(greet != div) -toJSON(greet != greet) -toJSON(greet != half) -toJSON(greet == add) -toJSON(greet == div) +toJSON(greet != nil) toJSON(greet == greet) -toJSON(greet == half) +toJSON(greet == nil) toJSON(greet("bar")) toJSON(greet("foo")) -toJSON(half != greet) -toJSON(half != nil) -toJSON(half != score) -toJSON(half == add) -toJSON(half == div) -toJSON(half == greet) -toJSON(half == nil) -toJSON(half == score) +toJSON(groupBy(array, #)?.div) +toJSON(groupBy(array, ok)?.foo) +toJSON(groupBy(list, #)?.foo) toJSON(half(0.5)) +toJSON(half(1)) toJSON(half(f64)) +toJSON(i != 0.5) toJSON(i != 1) -toJSON(i != f32) -toJSON(i != i) -toJSON(i != i32) -toJSON(i % 1) -toJSON(i % i64) +toJSON(i % i) +toJSON(i % i32) toJSON(i * 0.5) toJSON(i * 1) toJSON(i * f32) +toJSON(i * i) toJSON(i * i32) -toJSON(i ** 0.5) toJSON(i ** f32) -toJSON(i ** i32) +toJSON(i ** i) toJSON(i + 0.5) toJSON(i + 1) -toJSON(i + f32) -toJSON(i + f64) toJSON(i + i) toJSON(i - 1) -toJSON(i .. 1) +toJSON(i - f32) toJSON(i .. i) -toJSON(i / f32) +toJSON(i .. i32) +toJSON(i / i64) +toJSON(i < f32) +toJSON(i < f64) +toJSON(i < i) toJSON(i < i32) -toJSON(i < i64) toJSON(i <= 1) toJSON(i <= f32) toJSON(i <= f64) toJSON(i <= i) toJSON(i <= i32) +toJSON(i <= i64) +toJSON(i == 0.5) +toJSON(i == 1) toJSON(i == i32) -toJSON(i == i64) toJSON(i == nil) toJSON(i > 0.5) -toJSON(i > 1) -toJSON(i > f32) -toJSON(i >= 0.5) -toJSON(i >= 1) -toJSON(i >= f32) -toJSON(i >= i) -toJSON(i ^ 1) -toJSON(i ^ f64) +toJSON(i > i) +toJSON(i > i32) +toJSON(i > i64) +toJSON(i >= f64) +toJSON(i >= i32) +toJSON(i ^ i64) +toJSON(i not in array) toJSON(i) -toJSON(i) != string(1) -toJSON(i32 != f32) +toJSON(i) matches string("bar") toJSON(i32 != i) +toJSON(i32 != i64) toJSON(i32 % 1) -toJSON(i32 % i64) +toJSON(i32 * 0.5) toJSON(i32 * i) +toJSON(i32 * i32) toJSON(i32 * i64) +toJSON(i32 ** f64) toJSON(i32 ** i64) +toJSON(i32 + 0.5) +toJSON(i32 + 1) toJSON(i32 + f64) -toJSON(i32 + i) -toJSON(i32 + i32) -toJSON(i32 + i64) -toJSON(i32 - 0.5) -toJSON(i32 - 1) -toJSON(i32 - f32) -toJSON(i32 - f64) -toJSON(i32 - i) toJSON(i32 .. i) toJSON(i32 .. i64) toJSON(i32 / 0.5) toJSON(i32 / f32) -toJSON(i32 / i) +toJSON(i32 / f64) toJSON(i32 / i64) toJSON(i32 < 0.5) -toJSON(i32 < f32) +toJSON(i32 < 1) +toJSON(i32 < i) +toJSON(i32 < i32) toJSON(i32 <= 0.5) -toJSON(i32 <= i32) -toJSON(i32 == 1) -toJSON(i32 == f32) -toJSON(i32 == i) -toJSON(i32 == nil ? i32 : i32) -toJSON(i32 == nil) -toJSON(i32 > 0.5) toJSON(i32 > f64) toJSON(i32 > i) -toJSON(i32 >= 0.5) -toJSON(i32 >= 1) -toJSON(i32 >= f32) +toJSON(i32 > i32) toJSON(i32 >= f64) -toJSON(i32 >= i) -toJSON(i32 ^ 1) +toJSON(i32 ^ 0.5) +toJSON(i32 ^ f32) toJSON(i32 ^ f64) -toJSON(i32 ^ i) +toJSON(i32 ^ i32) toJSON(i32 in array) toJSON(i32 not in array) toJSON(i32) -toJSON(i32) < string(i64) -toJSON(i64 != 0.5) +toJSON(i32) contains foo.Bar toJSON(i64 != 1) -toJSON(i64 != f32) toJSON(i64 != i) toJSON(i64 != i32) -toJSON(i64 != nil) -toJSON(i64 % 1) -toJSON(i64 % i) toJSON(i64 % i32) -toJSON(i64 % i64) -toJSON(i64 * i) -toJSON(i64 + 0.5) -toJSON(i64 + i) -toJSON(i64 + i64) -toJSON(i64 - 0.5) -toJSON(i64 - 1) -toJSON(i64 - i64) +toJSON(i64 * 0.5) +toJSON(i64 * f64) +toJSON(i64 ** f64) +toJSON(i64 ** i) +toJSON(i64 ** i32) +toJSON(i64 + 1) +toJSON(i64 - i32) toJSON(i64 .. 1) -toJSON(i64 / 1) -toJSON(i64 / f32) +toJSON(i64 .. i32) +toJSON(i64 / f64) toJSON(i64 / i) toJSON(i64 / i64) -toJSON(i64 < 0.5) +toJSON(i64 < 1) +toJSON(i64 < f64) toJSON(i64 < i32) -toJSON(i64 <= 0.5) toJSON(i64 <= 1) -toJSON(i64 <= f32) toJSON(i64 <= i64) toJSON(i64 == 0.5) -toJSON(i64 == 1) -toJSON(i64 == i32) -toJSON(i64 == nil) -toJSON(i64 > f32) +toJSON(i64 > 0.5) +toJSON(i64 > 1) toJSON(i64 > i) -toJSON(i64 >= 0.5) +toJSON(i64 > i32) +toJSON(i64 > i64) toJSON(i64 >= 1) +toJSON(i64 >= i) toJSON(i64 >= i64) -toJSON(i64 ^ i) +toJSON(i64 ^ 0.5) +toJSON(i64 ^ f32) +toJSON(i64 ^ i32) +toJSON(i64 in array) toJSON(i64) toJSON(int(0.5)) toJSON(int(1)) -toJSON(int(f32)) -toJSON(int(f64)) toJSON(int(i)) toJSON(int(i32)) -toJSON(last(list)) +toJSON(int(i64)) toJSON(len("bar")) -toJSON(len("foo")) toJSON(len(array)) +toJSON(len(greet("foo"))) toJSON(len(list)) -toJSON(list != list) -toJSON(list == nil) +toJSON(list != array) +toJSON(list != nil) +toJSON(list == array) +toJSON(list == list) toJSON(list) -toJSON(list) <= foo?.Bar toJSON(list[1]) -toJSON(list[i32]) -toJSON(list[i64:1]) -toJSON(list[i64]) -toJSON(list[i]) toJSON(lower("bar")) -toJSON(lower("foo")) toJSON(map(array, #)) -toJSON(map(array, 0.5)) -toJSON(map(array, 1)) +toJSON(map(array, -#)) +toJSON(map(array, array)) toJSON(map(array, false)) toJSON(map(array, i)) -toJSON(map(array, i32)) +toJSON(map(array, i64)) toJSON(map(array, list)) -toJSON(map(array, true)) -toJSON(map(list, "foo")) toJSON(map(list, #)) +toJSON(map(list, 0.5)) toJSON(map(list, 1)) -toJSON(map(list, f32)) -toJSON(map(list, f64)) +toJSON(map(list, foo)) +toJSON(map(list, i32)) +toJSON(map(list, i64)) toJSON(map(list, list)) -toJSON(max(0.5)) +toJSON(map(list, ok)) toJSON(max(1)) toJSON(max(f32)) toJSON(max(f64)) -toJSON(max(i)) toJSON(max(i32)) -toJSON(max(i64)) +toJSON(mean(array)) +toJSON(median(array)) toJSON(min(0.5)) -toJSON(min(0.5, f32)) toJSON(min(1)) -toJSON(min(1, 1)) toJSON(min(f32)) toJSON(min(f64)) +toJSON(min(f64, f64)) toJSON(min(i)) -toJSON(min(i32) / f32) toJSON(min(i32)) toJSON(min(i64)) -toJSON(nil != "bar") -toJSON(nil != "foo") toJSON(nil != 0.5) +toJSON(nil != 1) toJSON(nil != add) +toJSON(nil != array) toJSON(nil != f32) -toJSON(nil != f64) +toJSON(nil != false) toJSON(nil != foo) -toJSON(nil != i32) -toJSON(nil != list) -toJSON(nil != nil) -toJSON(nil != score) -toJSON(nil != true) +toJSON(nil != greet) +toJSON(nil != half) toJSON(nil == 0.5) toJSON(nil == 1) -toJSON(nil == add) toJSON(nil == div) -toJSON(nil == f32) toJSON(nil == f64) -toJSON(nil == false) -toJSON(nil == foo) +toJSON(nil == half) toJSON(nil == i) toJSON(nil == i64) toJSON(nil == list) +toJSON(nil == nil) toJSON(nil == ok) -toJSON(nil == score) -toJSON(nil == true) toJSON(nil in array) -toJSON(nil not in array) -toJSON(nil not in list) -toJSON(nil) + string("bar") -toJSON(nil) == toJSON(1) -toJSON(nil) == type(nil) -toJSON(nil) in foo +toJSON(nil) + foo.Bar +toJSON(none(array, ok)) toJSON(none(array, true)) -toJSON(none(list, true)) +toJSON(none(list, false)) +toJSON(none(list, ok)) toJSON(not ("foo" not in foo)) +toJSON(not (f32 != 1)) toJSON(not false) toJSON(not ok) toJSON(not true) toJSON(ok != false) -toJSON(ok != nil) -toJSON(ok != ok) -toJSON(ok && true) +toJSON(ok && false) +toJSON(ok && ok) toJSON(ok == nil) toJSON(ok == ok) -toJSON(ok ? 1 : half) -toJSON(ok ? f32 : div) -toJSON(ok ? false : i32) -toJSON(ok ? nil : f32) +toJSON(ok ? "foo" : f32) +toJSON(ok ? 0.5 : f32) +toJSON(ok ? f64 : 0.5) +toJSON(ok ? i : false) +toJSON(ok ? nil : i) +toJSON(ok ? nil : true) +toJSON(ok ? true : greet) +toJSON(ok and ok) toJSON(ok or true) -toJSON(ok || ok) toJSON(ok) -toJSON(one(array, i32 < #)) -toJSON(score != div) -toJSON(score != greet) -toJSON(score != nil) +toJSON(one(array, false)) +toJSON(one(array, true)) +toJSON(reduce(array, #)) +toJSON(reduce(array, 0.5)) +toJSON(reduce(array, array)) +toJSON(reduce(array, foo)) +toJSON(reduce(array, i64)) +toJSON(reduce(array, list)) +toJSON(reduce(array, score(i32 * i64))) +toJSON(reduce(list, #)) +toJSON(reduce(list, 1)) +toJSON(reduce(list, f32)) +toJSON(reduce(list, false)) +toJSON(reduce(list, i)) +toJSON(reduce(list, i32)) +toJSON(reduce(list, list)) +toJSON(reduce(list, ok)) +toJSON(reduce(list, true)) +toJSON(round(1)) +toJSON(round(f64)) +toJSON(round(i32)) toJSON(score != score) -toJSON(score == add) -toJSON(score == div) -toJSON(score == nil) toJSON(score(1)) +toJSON(score(1, 1)) toJSON(score(i)) -toJSON(score(i, i)) +toJSON(sort(array)) toJSON(string("bar")) -toJSON(string("foo")) toJSON(string(0.5)) toJSON(string(1)) toJSON(string(array)) -toJSON(string(div)) toJSON(string(f32)) toJSON(string(f64)) toJSON(string(false)) toJSON(string(foo)) -toJSON(string(greet)) toJSON(string(half)) toJSON(string(i)) toJSON(string(i32)) @@ -14115,11 +17490,11 @@ toJSON(string(list)) toJSON(string(nil)) toJSON(string(ok)) toJSON(string(score)) +toJSON(string(true)) +toJSON(sum(array)) +toJSON(take(array, i32)) toJSON(toBase64("bar")) -toJSON(toBase64("foo")) toJSON(toJSON("bar")) -toJSON(toJSON("foo")) -toJSON(toJSON(1)) toJSON(toJSON(array)) toJSON(toJSON(f32)) toJSON(toJSON(f64)) @@ -14131,50 +17506,58 @@ toJSON(toJSON(i64)) toJSON(toJSON(list)) toJSON(toJSON(nil)) toJSON(toJSON(ok)) -toJSON(toJSON(true)) toJSON(trim("bar")) -toJSON(trim("foo")) toJSON(trimPrefix("foo")) -toJSON(trimSuffix("foo")) -toJSON(true && true) -toJSON(true ? array : nil) -toJSON(true ? i32 : div) -toJSON(true ? list : true) -toJSON(true ? nil : array) -toJSON(true ? ok : list) -toJSON(true ? true : f64) -toJSON(true and ok) +toJSON(trimSuffix("bar")) +toJSON(true != true) +toJSON(true && ok) +toJSON(true == ok) +toJSON(true ? "bar" : "bar") +toJSON(true ? nil : score) +toJSON(true and false) +toJSON(true and true) toJSON(true) in foo -toJSON(type("bar")) toJSON(type("foo")) -toJSON(type(0.5)) -toJSON(type(1)) toJSON(type(add)) toJSON(type(array)) toJSON(type(f32)) toJSON(type(f64)) toJSON(type(false)) toJSON(type(foo)) -toJSON(type(greet)) -toJSON(type(half)) toJSON(type(i)) toJSON(type(i32)) toJSON(type(i64)) toJSON(type(list)) -toJSON(type(nil)) toJSON(type(ok)) toJSON(type(score)) toJSON(type(true)) toJSON(upper("bar")) -toJSON(upper("foo")) -toJSON({"bar": 0.5, "bar": array}) -toJSON({"foo": "foo"}) -toJSON({"foo": 0.5}) +toJSON({"bar": 1, "bar": array}) +toJSON({"bar": 1}) +toJSON({"bar": f64}) +toJSON({"bar": list}) +toJSON({"foo": i}) toJSON({"foo": nil}) -toJSON({"foo": ok, "bar": 0.5}) -trim("bar") in foo -trim("foo" + "foo") -trim(false ? greet : "bar") +toPairs(groupBy(array, # / #)) +toPairs(groupBy(array, #)) +toPairs(groupBy(array, 0.5)) +toPairs(groupBy(array, 1)) +toPairs(groupBy(array, false)) +toPairs(groupBy(array, foo)) +toPairs(groupBy(array, i)) +toPairs(groupBy(array, i32)) +toPairs(groupBy(array, ok)) +toPairs(groupBy(array, true)) +toPairs(groupBy(list, #)) +toPairs(groupBy(list, 1)) +toPairs(groupBy(list, f32)) +toPairs(groupBy(list, i)) +toPairs(groupBy(list, ok)) +toPairs({"bar": f32}) +toPairs({"foo": i32, "bar": score}) +toPairs({"foo": nil}) +trim("bar") not in foo +trim(false ? "bar" : "bar") trim(foo.Bar) trim(foo.String()) trim(foo?.Bar) @@ -14182,84 +17565,58 @@ trim(foo?.String()) trim(greet("bar")) trim(greet("foo")) trim(lower("bar")) -trim(lower(toJSON(0.5))) -trim(ok ? "bar" : i32) -trim(string("foo")) +trim(lower("foo")) +trim(reduce(list, "bar")) +trim(string("bar")) +trim(string(-f64)) trim(string(0.5)) trim(string(1)) trim(string(add)) -trim(string(div)) +trim(string(array)) trim(string(f32)) -trim(string(f64)) -trim(string(false)) trim(string(foo)) -trim(string(greet)) -trim(string(half)) -trim(string(i)) -trim(string(i32)) trim(string(i64)) trim(string(list)) trim(string(nil)) -trim(string(ok)) -trim(string(score)) -trim(string(true)) -trim(toBase64("bar")) -trim(toBase64("foo")) -trim(toJSON("foo")) -trim(toJSON(0.5)) +trim(toJSON("bar")) trim(toJSON(1)) -trim(toJSON(array)) trim(toJSON(f32)) -trim(toJSON(f64)) trim(toJSON(false)) trim(toJSON(foo)) -trim(toJSON(i)) trim(toJSON(i32)) trim(toJSON(i64)) -trim(toJSON(list)) -trim(toJSON(nil)) trim(toJSON(ok)) trim(toJSON(true)) trim(trim("bar")) -trim(trimPrefix("bar")) trim(trimPrefix("foo")) -trim(trimPrefix(string(i))) trim(trimSuffix("bar")) -trim(trimSuffix("foo")) +trim(true ? "foo" : greet) +trim(type("bar")) trim(type("foo")) trim(type(0.5)) trim(type(1)) trim(type(add)) -trim(type(array)) trim(type(div)) trim(type(f32)) trim(type(f64)) -trim(type(false)) -trim(type(foo)) trim(type(greet)) -trim(type(half)) trim(type(i)) -trim(type(i32)) -trim(type(i64)) trim(type(list)) -trim(type(nil != list)) trim(type(nil)) trim(type(ok)) trim(type(score)) -trim(type(toJSON(1))) trim(type(true)) -trim(upper("bar")) -trimPrefix("foo" + "foo") +trimPrefix("bar" + "foo") +trimPrefix("foo" + "bar") +trimPrefix(false ? 1 : "bar") trimPrefix(foo.Bar) trimPrefix(foo.String()) trimPrefix(foo?.Bar) trimPrefix(foo?.String()) trimPrefix(greet("bar")) trimPrefix(greet("foo")) -trimPrefix(greet(foo.String())) +trimPrefix(greet(type(0.5))) trimPrefix(lower("bar")) -trimPrefix(lower("foo")) -trimPrefix(ok ? "bar" : i64) trimPrefix(string("foo")) trimPrefix(string(0.5)) trimPrefix(string(1)) @@ -14267,50 +17624,35 @@ trimPrefix(string(add)) trimPrefix(string(array)) trimPrefix(string(div)) trimPrefix(string(f32)) +trimPrefix(string(f64)) trimPrefix(string(foo)) trimPrefix(string(greet)) trimPrefix(string(half)) trimPrefix(string(i)) trimPrefix(string(i32)) trimPrefix(string(i64)) -trimPrefix(string(list)) trimPrefix(string(nil)) -trimPrefix(string(ok)) trimPrefix(string(score)) +trimPrefix(string(true)) +trimPrefix(string({"bar": greet})) trimPrefix(toBase64("bar")) -trimPrefix(toBase64("foo")) -trimPrefix(toJSON("bar")) trimPrefix(toJSON("foo")) -trimPrefix(toJSON(0.5)) trimPrefix(toJSON(1)) trimPrefix(toJSON(array)) trimPrefix(toJSON(f32)) -trimPrefix(toJSON(f64)) -trimPrefix(toJSON(false)) trimPrefix(toJSON(foo)) -trimPrefix(toJSON(i)) trimPrefix(toJSON(i32)) trimPrefix(toJSON(i64)) +trimPrefix(toJSON(list)) trimPrefix(toJSON(nil)) trimPrefix(toJSON(true)) -trimPrefix(trim("bar")) -trimPrefix(trim("foo")) -trimPrefix(trimPrefix("bar")) trimPrefix(trimPrefix("foo")) -trimPrefix(trimSuffix("bar")) -trimPrefix(trimSuffix("foo")) trimPrefix(type("bar")) -trimPrefix(type(0.5 == 0.5)) trimPrefix(type(0.5)) -trimPrefix(type(1 == f64)) trimPrefix(type(1)) -trimPrefix(type(add)) trimPrefix(type(array)) -trimPrefix(type(div)) trimPrefix(type(f32)) trimPrefix(type(f64)) -trimPrefix(type(false)) -trimPrefix(type(foo)) trimPrefix(type(greet)) trimPrefix(type(half)) trimPrefix(type(i)) @@ -14319,142 +17661,125 @@ trimPrefix(type(i64)) trimPrefix(type(list)) trimPrefix(type(nil)) trimPrefix(type(ok)) -trimPrefix(type(score)) +trimPrefix(type(true)) +trimPrefix(upper("bar")) trimPrefix(upper("foo")) -trimSuffix("bar" + "bar") -trimSuffix("foo") <= trimPrefix("foo") +trimSuffix("bar" + "foo") +trimSuffix("bar") not contains reduce(list, "bar") +trimSuffix("foo" + "bar") +trimSuffix(false ? i64 : "foo") trimSuffix(foo.Bar) trimSuffix(foo.String()) trimSuffix(foo?.Bar) -trimSuffix(foo?.Qux("bar")) trimSuffix(foo?.String()) trimSuffix(greet("bar")) trimSuffix(greet("foo")) -trimSuffix(greet(toJSON(i64))) trimSuffix(lower("bar")) -trimSuffix(lower("foo")) -trimSuffix(repeat("foo", i)) +trimSuffix(reduce(array, "foo")) +trimSuffix(reduce(list, #)?.Bar) trimSuffix(string("bar")) +trimSuffix(string("foo")) trimSuffix(string(0.5)) -trimSuffix(string(1)) trimSuffix(string(add)) trimSuffix(string(array)) -trimSuffix(string(f32)) +trimSuffix(string(div)) trimSuffix(string(f64)) trimSuffix(string(false)) trimSuffix(string(foo)) -trimSuffix(string(greet)) trimSuffix(string(half)) trimSuffix(string(i)) trimSuffix(string(i32)) trimSuffix(string(i64)) trimSuffix(string(list)) trimSuffix(string(nil)) -trimSuffix(string(score)) -trimSuffix(string(type("foo"))) +trimSuffix(string(ok)) +trimSuffix(string(true)) trimSuffix(toBase64("bar")) -trimSuffix(toJSON("bar")) -trimSuffix(toJSON(0.5)) +trimSuffix(toBase64("foo")) +trimSuffix(toJSON(1 > f64)) trimSuffix(toJSON(1)) -trimSuffix(toJSON(array)) +trimSuffix(toJSON(f32)) trimSuffix(toJSON(f64)) trimSuffix(toJSON(false)) -trimSuffix(toJSON(first(array))) trimSuffix(toJSON(foo)) trimSuffix(toJSON(i)) trimSuffix(toJSON(i32)) trimSuffix(toJSON(i64)) trimSuffix(toJSON(list)) trimSuffix(toJSON(nil)) -trimSuffix(toJSON(ok)) +trimSuffix(toJSON(true)) trimSuffix(trim("bar")) trimSuffix(trim("foo")) trimSuffix(trimPrefix("bar")) trimSuffix(trimPrefix("foo")) -trimSuffix(trimSuffix("foo")) -trimSuffix(type("bar")) -trimSuffix(type("foo")) -trimSuffix(type(0.5)) +trimSuffix(trimSuffix("bar")) trimSuffix(type(1)) trimSuffix(type(add)) trimSuffix(type(array)) trimSuffix(type(div)) trimSuffix(type(f32)) -trimSuffix(type(f64)) -trimSuffix(type(false)) trimSuffix(type(foo)) +trimSuffix(type(greet)) trimSuffix(type(half)) -trimSuffix(type(i)) trimSuffix(type(i32)) -trimSuffix(type(i64)) trimSuffix(type(list)) trimSuffix(type(nil)) trimSuffix(type(ok)) -trimSuffix(type(true)) -trimSuffix(upper("bar")) trimSuffix(upper("foo")) -true != nil || true != nil -true == nil && ok -true ? "bar" : 0.5 ^ i -true ? "bar" : 1 <= 1 / 1 -true ? "bar" : i != i32 -true ? "foo" : foo?.Bar -true ? 0.5 : foo.Qux -true ? 1 : f64 + f32 -true ? 1 : nil == array -true ? array : foo.Qux +true != nil || true == true +true != ok != ok +true == ok == ok +true ? 0.5 : i <= f32 +true ? 1 : foo?.Bar +true ? 1 : ok or i64 == 0.5 +true ? add : foo?.Bar +true ? array : 0.5 >= i32 true ? array : foo.String -true ? array : i32 / i32 -true ? array : nil != map(list, #) -true ? array : nil != ok -true ? f32 : f64 == i32 -true ? f64 : foo?.String -true ? greet : 0.5 == i -true ? i : 0.5 + i64 -true ? i : 0.5 >= i64 -true ? i32 : foo.Bar -true ? i64 : foo.Bar -true ? list : f64 / f64 -true ? nil : 0.5 != i32 -true ? nil : foo.Qux +true ? array : foo?.Bar +true ? array : foo?.String +true ? array : i32 ** f64 +true ? div : i64 ** 1 ^ i32 +true ? false : 0.5 > i +true ? false : foo.Qux +true ? foo : 0.5 + -1 +true ? foo : foo.Bar +true ? foo : i64 / f32 +true ? greet : foo.Bar +true ? greet : ok == ok +true ? half : 0.5 / i32 +true ? half : foo.String +true ? i : 1 * i64 +true ? i32 : i32 - f32 +true ? i32 : i32 >= f32 +true ? i64 : f64 != i +true ? list : f32 != i true ? nil : foo.String -true ? nil : i32 .. i -true ? nil : i64 ** -i -true ? ok : f32 / f32 -true ? ok : f64 + f64 -true ? score : foo.Qux -true ? true : f32 >= i64 -true ? true : foo?.String -true and ok and ok -true || 1 not in array +true ? nil : foo?.String +true ? nil : i32 != f64 + 1 +true ? ok : foo.Qux +true ? ok : foo?.String +true ? score : ok or f64 < f32 +true and nil not in list +true and ok or ok +true and true || ok +true or 0.5 not in array +true || f32 not in groupBy(list, #) +true || false ? half : half type(!false) type(!ok) type(!true) -type("bar" != nil) -type("bar" + "foo") -type("bar" < "bar") +type("bar" != "bar") +type("bar" < "foo") type("bar" <= "bar") -type("bar" <= "foo") -type("bar" == nil) -type("bar" > "foo") -type("bar" endsWith "foo") -type("bar" matches "bar") -type("bar" matches "foo") -type("bar" not contains "bar") -type("bar" not endsWith "bar") +type("bar" == "foo") +type("bar" >= "bar") type("bar" not endsWith "foo") -type("bar" startsWith "foo") -type("bar") == string(array) -type("foo" != "bar") -type("foo" == "foo") -type("foo" > "bar") -type("foo" contains "foo") -type("foo" endsWith "foo") -type("foo" in foo) -type("foo" not endsWith "bar") -type("foo" not endsWith "foo") -type("foo" startsWith "foo") -type("foo" startsWith foo.Bar) +type("bar" startsWith "bar") +type("bar") startsWith greet("bar") +type("foo" != nil) +type("foo" + "bar") +type("foo" not startsWith "bar") +type("foo") not in foo type(-0.5) type(-1) type(-f32) @@ -14462,288 +17787,231 @@ type(-f64) type(-i) type(-i32) type(-i64) -type(0.5 != 0.5) -type(0.5 != 1) -type(0.5 != i) +type(-int(f64)) +type(0.5 != f64) type(0.5 != i32) type(0.5 != nil) type(0.5 * 0.5) -type(0.5 * 1) -type(0.5 * i) -type(0.5 * i32) +type(0.5 * f32) +type(0.5 * f64) type(0.5 * i64) type(0.5 ** 0.5) type(0.5 ** 1) type(0.5 ** f32) +type(0.5 ** f64) type(0.5 ** i) type(0.5 ** i32) -type(0.5 ** i64) +type(0.5 + 0.5) +type(0.5 + 1) type(0.5 + f32) -type(0.5 + i32) +type(0.5 + f64) +type(0.5 + i) type(0.5 + i64) -type(0.5 - 0.5) -type(0.5 - i) -type(0.5 / 0.5) +type(0.5 - 1) +type(0.5 - f64) +type(0.5 - i32) type(0.5 / 1) -type(0.5 / f64) +type(0.5 / f32) type(0.5 / i) +type(0.5 / i32) +type(0.5 / i64) type(0.5 < 1) -type(0.5 < f64) -type(0.5 < i) +type(0.5 < f32) +type(0.5 < i32) type(0.5 < i64) type(0.5 <= 1) type(0.5 <= f32) -type(0.5 <= i) type(0.5 <= i64) -type(0.5 == 1) -type(0.5 == i) -type(0.5 == nil) +type(0.5 == 0.5) +type(0.5 == f32) +type(0.5 == f64) +type(0.5 == i32) type(0.5 > 0.5) -type(0.5 > 1) -type(0.5 > f64) +type(0.5 > f32) type(0.5 > i) +type(0.5 > i32) +type(0.5 > i64) type(0.5 >= 0.5) -type(0.5 >= 1) -type(0.5 >= f64) type(0.5 >= i) type(0.5 >= i32) type(0.5 ^ 0.5) -type(0.5 ^ 1) -type(0.5 ^ f32) -type(0.5 ^ f64) type(0.5 ^ i) -type(0.5) not contains trimPrefix("bar") -type(0.5) not in foo -type(0.5) startsWith "bar" == nil -type(0.5)[i32:i64] -type(1 != 0.5) -type(1 != 1) -type(1 != f32) +type(0.5 ^ i32) +type(0.5 ^ i64) +type(0.5 not in array) +type(0.5) in foo type(1 != i32) type(1 != nil) type(1 % 1) type(1 % i) -type(1 % i32) -type(1 % i64) -type(1 * 1) +type(1 * 0.5) type(1 * f32) type(1 * i) -type(1 * i64) +type(1 * i32) type(1 ** 0.5) -type(1 ** 1) type(1 ** f64) -type(1 ** i32) +type(1 ** i) type(1 ** i64) type(1 + 0.5) +type(1 + 1) type(1 + f32) -type(1 + f64) type(1 + i64) type(1 - 0.5) type(1 - 1) -type(1 - f64) -type(1 - i32) +type(1 - i64) type(1 .. 1) -type(1 .. i) type(1 .. i64) -type(1 / 1) -type(1 / f32) type(1 / f64) -type(1 < 1) -type(1 < f32) -type(1 < i) -type(1 <= f32) +type(1 / i) +type(1 < i32) +type(1 < i64) +type(1 <= 0.5) +type(1 <= 1) type(1 <= f64) -type(1 <= i32) -type(1 <= i64) -type(1 == 1) +type(1 <= i) +type(1 == f32) +type(1 == f64) type(1 == i) +type(1 == i32) type(1 == i64) -type(1 == nil) -type(1 > 0.5) -type(1 > 1) -type(1 > f32) -type(1 > f64) +type(1 > i) type(1 >= 0.5) -type(1 >= 1) -type(1 >= f64) type(1 >= i) -type(1 >= i32) type(1 >= i64) -type(1 ^ 0.5) -type(1 ^ f32) +type(1 ^ 1) +type(1 ^ i) type(1 ^ i64) -type(1 in array) -type(1 not in array) -type(1) != toJSON(0.5) -type(1) == nil ? 1 : f64 -type(1) endsWith greet("foo") -type(1) in foo -type(1) in foo != true -type(1) not contains type(nil) -type(1) not endsWith toJSON(ok) -type([half, 1]) -type([nil]) +type(1) endsWith foo.Bar +type(1) in reduce(list, #) +type(1) not endsWith "bar" ? i64 : nil +type(1) not startsWith string(0.5) +type([div]) +type([f32]) type(abs(0.5)) -type(abs(1)) +type(abs(f32)) type(abs(f64)) type(abs(i)) type(abs(i32)) type(abs(i64)) -type(add != add) -type(add != greet) -type(add != half) -type(add == half) -type(add == nil) -type(add(1, 1)) type(add) -type(add) in foo -type(all(array, true)) -type(all(list, false)) +type(all(array, ok)) +type(all(list, ok)) +type(all(list, true)) type(any(array, false)) -type(any(list, true)) +type(any(array, ok)) +type(any(list, false)) +type(array != list) +type(array != nil) type(array == array) -type(array == list) type(array) -type(array) in foo -type(array) not in foo +type(array) >= trimPrefix("foo") type(array[1]) type(array[i32]) type(array[i]) -type(count(list, ok)) -type(count(list, true)) +type(bitand(1, i)) +type(bitnot(i)) +type(bitnot(i32)) +type(bitnot(i64)) +type(bitxor(i64, 1)) +type(ceil(0.5)) +type(ceil(f32)) +type(ceil(f64)) +type(ceil(i64)) +type(count(array, true)) type(div != div) -type(div != half) -type(div != nil) -type(div == add) -type(div == greet) -type(div == half) +type(div == div) type(div) -type(div) not in foo type(f32 != 0.5) type(f32 != 1) -type(f32 != f32) -type(f32 != i32) -type(f32 * 0.5) type(f32 * 1) -type(f32 * f32) -type(f32 * f64) type(f32 * i) -type(f32 * i64) -type(f32 ** 0.5) -type(f32 ** 1) +type(f32 * i32) type(f32 ** f32) -type(f32 ** i) -type(f32 ** i32) -type(f32 + 0.5) type(f32 + 1) -type(f32 + f64) type(f32 + i) -type(f32 + i64) -type(f32 - 0.5) -type(f32 - 1) type(f32 - f32) -type(f32 - i) type(f32 - i32) -type(f32 - i64) +type(f32 / 1) +type(f32 / f32) type(f32 < 1) -type(f32 < f64) -type(f32 < i32) -type(f32 <= 0.5) -type(f32 <= 1) -type(f32 <= i64) +type(f32 < f32) +type(f32 <= f64) type(f32 == 0.5) -type(f32 == 1) +type(f32 == f64) +type(f32 == i) type(f32 == i32) +type(f32 == i64) type(f32 > 1) -type(f32 > f32) -type(f32 > f64) -type(f32 >= 0.5) -type(f32 ^ 0.5) -type(f32 ^ f32) -type(f32 ^ f64) -type(f32 ^ i32) +type(f32 >= f32) +type(f32 >= i) +type(f32 >= i32) type(f32 ^ i64) +type(f32 not in array) type(f32) -type(f64 != f64) -type(f64 != i64) +type(f64 != 0.5) +type(f64 != i) type(f64 * 0.5) type(f64 * 1) -type(f64 * i32) -type(f64 * i64) -type(f64 ** 0.5) +type(f64 * f32) type(f64 ** 1) -type(f64 ** f32) -type(f64 ** i) -type(f64 ** i32) -type(f64 + 0.5) -type(f64 + f64) -type(f64 + i) +type(f64 + f32) +type(f64 + i32) type(f64 - 0.5) -type(f64 - f32) +type(f64 - 1) type(f64 - f64) type(f64 - i) type(f64 / 1) -type(f64 / i) +type(f64 / f32) +type(f64 / i64) type(f64 < 0.5) -type(f64 < 1) +type(f64 < f32) type(f64 < f64) +type(f64 < i32) type(f64 < i64) type(f64 <= 0.5) -type(f64 <= i) -type(f64 <= i32) -type(f64 == 1) -type(f64 == f64) +type(f64 <= f64) +type(f64 <= i64) +type(f64 == 0.5) +type(f64 == f32) +type(f64 == i64) type(f64 == nil) -type(f64 > 1) -type(f64 > f64) type(f64 > i) type(f64 > i32) type(f64 >= 0.5) -type(f64 >= 1) -type(f64 ^ 1) -type(f64 ^ f64) -type(f64 ^ i) -type(f64 ^ i32) -type(f64 ^ i64) +type(f64 >= i) +type(f64 ^ 0.5) +type(f64 not in array) type(f64) type(false != nil) +type(false != ok) type(false && true) -type(false == ok) -type(false ? add : div) -type(false ? half : i) -type(false ? half : i32) -type(false ? i32 : 1) -type(false ? i32 : true) -type(false ? list : "foo") -type(false || ok) -type(false) not contains toJSON(i) -type(filter(array, true)) -type(filter(list, false)) -type(find([f64], "foo" == nil)) +type(false ? "bar" : score) +type(false ? div : f64) +type(false ? half : greet) +type(false ? true : foo) +type(false || true) +type(false) startsWith "bar" ? ok : f32 type(find(array, false)) -type(find(list, false)) -type(findIndex(array, false)) -type(findIndex(list, ok)) -type(findIndex(list, true)) +type(find(array, true)) +type(find(list, true)) +type(findIndex(array, ok)) type(findLast(array, false)) type(findLast(array, ok)) -type(findLast(list, false)) -type(findLastIndex(array, ok)) -type(findLastIndex(array, true)) +type(findLastIndex(array, false)) +type(findLastIndex(list, false)) type(findLastIndex(list, ok)) -type(first(array)) +type(findLastIndex(list, true)) type(first(list)) -type(float(0.5)) -type(float(1)) type(float(f32)) -type(float(f64)) -type(float(i)) type(float(i32)) -type(float(i64)) +type(floor(0.5)) +type(floor(1)) +type(floor(f64)) +type(floor(i64)) type(foo != foo) +type(foo != nil) type(foo in list) type(foo) -type(foo) in foo type(foo.Bar) type(foo.Qux) type(foo.String()) @@ -14753,182 +18021,142 @@ type(foo?.Qux) type(foo?.String()) type(foo?.String) type(get(array, 1)) -type(get(array, i)) -type(get(array, i32)) +type(get(array, i64)) type(get(list, 1)) +type(get(list, i)) type(get(list, i32)) -type(greet != div) -type(greet != half) -type(greet != score) -type(greet == div) -type(greet == greet) -type(greet == half) +type(get(list, i64)) type(greet("bar")) type(greet("foo")) -type(greet(lower("foo"))) type(greet) -type(greet) not in foo -type(half != add) -type(half != nil) -type(half == add) -type(half == div) +type(groupBy(array, #)) +type(groupBy(array, #).score) +type(groupBy(array, 0.5)) +type(groupBy(array, false)?.add) +type(groupBy(array, i)) +type(groupBy(array, i32)) +type(groupBy(array, i64)) +type(groupBy(list, "bar")) +type(groupBy(list, #)) +type(groupBy(list, #)?.Bar) +type(groupBy(list, 1)) +type(groupBy(list, i64)) +type(groupBy(list, true)) type(half(0.5)) +type(half(1)) type(half(f64)) type(half) -type(half) endsWith toJSON(1) -type(i != 0.5) -type(i != 1) -type(i != f32) -type(i != i64) +type(half) not in foo type(i % 1) +type(i % i32) type(i * 0.5) -type(i * i64) -type(i ** 0.5) -type(i ** 1) +type(i * i32) type(i ** f32) type(i ** f64) type(i ** i) -type(i ** i32) -type(i + 1) -type(i + i) type(i + i32) -type(i .. i64) +type(i - 0.5) +type(i - 1) +type(i - i) +type(i - i64) +type(i .. i) type(i / 0.5) -type(i / 1) -type(i < f32) -type(i < i64) -type(i == f32) -type(i == i32) -type(i == i64) -type(i > f64) -type(i >= 1) -type(i >= f32) -type(i >= f64) -type(i ^ 0.5) +type(i / i32) +type(i < 0.5) +type(i < 1) +type(i <= 0.5) +type(i <= 1) +type(i == 1) +type(i > 0.5) +type(i > 1) +type(i > f32) +type(i > i64) +type(i >= i32) type(i ^ 1) -type(i ^ f32) -type(i ^ f64) +type(i ^ i) +type(i ^ i32) type(i ^ i64) -type(i not in array) type(i) -type(i) not endsWith greet("foo") -type(i32 != 0.5) +type(i) + foo.Bar type(i32 != 1) -type(i32 != nil) -type(i32 % 1) -type(i32 % i64) +type(i32 != f64) type(i32 * 0.5) -type(i32 * 1) -type(i32 * i32) -type(i32 * i64) -type(i32 ** f32) +type(i32 * i) +type(i32 ** 0.5) type(i32 ** f64) type(i32 ** i) type(i32 + 1) -type(i32 + f32) -type(i32 + f64) -type(i32 + i) -type(i32 + i32) -type(i32 + i64) -type(i32 - f32) -type(i32 - i32) -type(i32 .. 1) -type(i32 .. i) +type(i32 - 1) +type(i32 .. i32) +type(i32 / 0.5) type(i32 / f64) -type(i32 / i32) -type(i32 < 1) -type(i32 < f32) -type(i32 < i) -type(i32 < i64) +type(i32 < 0.5) +type(i32 <= 0.5) type(i32 <= f64) type(i32 <= i32) -type(i32 <= i64) -type(i32 == 0.5) type(i32 == 1) -type(i32 == f32) -type(i32 == f64) -type(i32 == i) -type(i32 == i64) +type(i32 == nil) type(i32 > 0.5) -type(i32 > 1) type(i32 > f64) -type(i32 > i32) +type(i32 > i64) type(i32 >= 1) type(i32 >= f32) -type(i32 >= i) -type(i32 >= i32) -type(i32 ^ 0.5) +type(i32 >= i64) +type(i32 ^ 1) +type(i32 ^ f32) +type(i32 ^ f64) type(i32 ^ i) -type(i32 ^ i32) -type(i32 ^ i64) -type(i32 in array) +type(i32 not in array) type(i32) -type(i32) startsWith greet("foo") +type(i32) in foo +type(i32) not matches trim("foo") type(i64 != 1) -type(i64 != array[i32]) -type(i64 != f32) -type(i64 != i) -type(i64 != nil) -type(i64 % i) -type(i64 % i64) -type(i64 * 0.5) +type(i64 != f64) +type(i64 % 1) type(i64 * f32) -type(i64 * f64) type(i64 * i64) -type(i64 ** 1) +type(i64 ** 0.5) +type(i64 ** f64) +type(i64 ** i32) type(i64 + 0.5) -type(i64 + f64) -type(i64 + i) +type(i64 + 1) type(i64 + i64) type(i64 - 0.5) -type(i64 .. 1) +type(i64 - f32) +type(i64 - f64) +type(i64 - i32) type(i64 .. i32) -type(i64 .. i64) type(i64 / 0.5) -type(i64 / 1) -type(i64 / i) +type(i64 / f32) type(i64 / i64) -type(i64 < 1) +type(i64 < 0.5) +type(i64 < f32) type(i64 < f64) type(i64 < i) type(i64 < i64) +type(i64 <= 0.5) type(i64 <= 1) type(i64 <= f32) -type(i64 <= i64) -type(i64 == i32) -type(i64 == nil) -type(i64 > f64) -type(i64 >= 0.5) -type(i64 >= f32) -type(i64 >= i) -type(i64 >= i64) -type(i64 ^ 0.5) -type(i64 ^ 1) -type(i64 ^ f32) +type(i64 <= i) +type(i64 == 1) +type(i64 == f64) +type(i64 > i64) +type(i64 >= 1) type(i64 ^ f64) type(i64 ^ i) -type(i64 ^ i32) -type(i64 in array) type(i64 not in array) type(i64) -type(i64) != foo?.Bar -type(i64) contains string(foo) ? i : array -type(i64) not in foo -type(i64) not startsWith lower("foo") type(int(0.5)) -type(int(1)) type(int(f32)) type(int(f64)) type(int(i)) type(int(i32)) -type(int(i64) <= f32) type(int(i64)) type(last(array)) type(last(list)) -type(len("bar")) -type(len("foo")) type(len(array)) type(len(list)) +type(list != nil) type(list == array) type(list == nil) type(list) @@ -14936,1423 +18164,1413 @@ type(list[1]) type(list[i32]) type(list[i64]) type(list[i]) -type(lower("bar")) -type(lower("foo")) -type(lower(string(nil))) +type(map(array, "bar")) type(map(array, "foo")) type(map(array, #)) -type(map(array, 0.5)) -type(map(array, add)) -type(map(array, array)) -type(map(array, false)) +type(map(array, 1)) +type(map(array, div)) +type(map(array, f32)) type(map(array, foo)) -type(map(array, half)) -type(map(array, i)) -type(map(array, i64)) +type(map(array, greet)) type(map(array, ok)) -type(map(i .. i32, i64)) +type(map(array, true)) +type(map(list, "bar")) type(map(list, #)) -type(map(list, 0.5)) -type(map(list, 1)) type(map(list, array)) -type(map(list, f32)) -type(map(list, f64)) -type(map(list, foo)) type(map(list, greet)) -type(map(list, i)) +type(map(list, i64)) type(map(list, list)) type(map(list, ok)) type(max(0.5)) +type(max(0.5, f64)) type(max(1)) -type(max(f32)) -type(max(f32, i32)) +type(max(1, i32)) type(max(f64)) -type(max(f64, 0.5)) -type(max(i)) -type(max(i32)) -type(max(i32, i64)) type(max(i64)) -type(min(0.5)) +type(median(array)) type(min(1)) -type(min(1, 0.5)) -type(min(1, 1, f32)) type(min(f32)) -type(min(f64)) type(min(i)) -type(min(i, 1)) type(min(i32)) -type(min(i32, 0.5)) type(min(i64)) -type(nil != "bar") +type(nil != "foo") type(nil != 0.5) type(nil != 1) -type(nil != div) -type(nil != f64) -type(nil != false) -type(nil != foo) type(nil != greet) +type(nil != half) type(nil != i32) +type(nil != i64) type(nil != nil) -type(nil != ok) -type(nil == "bar") +type(nil != score) type(nil == "foo") -type(nil == 0.5) -type(nil == 1) -type(nil == add) type(nil == array) type(nil == f32) -type(nil == f64) -type(nil == i) -type(nil == i32) +type(nil == false) +type(nil == foo) +type(nil == greet) type(nil == nil) -type(nil == ok) type(nil == score) -type(nil == true) type(nil in array) +type(nil in list) type(nil not in array) -type(nil) != type(1) -type(none(array, ok)) -type(none(array, true)) +type(nil not in list) type(none(list, ok)) type(none(list, true)) +type(not (f64 <= i)) type(not false) type(not ok) type(not true) +type(ok != false) type(ok != nil) -type(ok == false) -type(ok ? 0.5 : i32) -type(ok ? 0.5 : list) -type(ok ? 1 : f32) -type(ok ? add : "bar") -type(ok ? false : i64) -type(ok ? foo : false) -type(ok ? half : half) -type(ok ? i32 : f64) -type(ok ? i64 : "bar") -type(ok ? list : "foo") -type(ok ? ok : half) -type(ok ? true : false) +type(ok != true) +type(ok && false) +type(ok == nil) +type(ok ? "bar" : half) +type(ok ? 1 : "bar") +type(ok ? array : i64) +type(ok ? array : score) +type(ok ? i : "bar") +type(ok ? i : nil) +type(ok ? nil : 0.5) +type(ok ? nil : div) type(ok and ok) -type(ok and true) type(ok or false) -type(ok or true) -type(ok || true) +type(ok || false) type(ok) -type(ok) in foo -type(ok) not matches string(i64) -type(ok) not startsWith lower("bar") -type(score != div) -type(score != greet) -type(score != half) -type(score != nil) -type(score == add) -type(score == foo.String) -type(score == greet) -type(score == half) +type(one(array, false)) +type(one(array, true)) +type(one(list, false)) +type(one(list, true)) +type(reduce(array, "bar")) +type(reduce(array, #)) +type(reduce(array, 1)) +type(reduce(array, foo)) +type(reduce(array, greet)) +type(reduce(array, i)) +type(reduce(array, ok)) +type(reduce(list, "foo")) +type(reduce(list, #)) +type(reduce(list, array)) +type(reduce(list, i64)) +type(reduce(list, ok)) +type(round(0.5)) +type(round(1)) +type(round(f64)) +type(round(i)) +type(round(i64)) +type(score != score) type(score == nil) -type(score == score) type(score(1)) +type(score(1, 1)) type(score(i)) -type(score(i, 1)) type(score) -type(score) < foo?.Bar -type(score) > string(score) -type(score) in foo -type(score) not contains type(1) type(sort(array)) -type(string("bar")) -type(string("foo")) type(string(0.5)) type(string(1)) type(string(add)) -type(string(array)) type(string(div)) +type(string(f32)) type(string(f64)) type(string(false)) -type(string(foo)) type(string(greet)) -type(string(half)) -type(string(i <= i32)) -type(string(i)) +type(string(i32)) type(string(i64)) type(string(list)) type(string(nil)) type(string(ok)) type(string(score)) -type(toBase64("foo")) +type(toBase64("bar")) type(toJSON("bar")) type(toJSON("foo")) -type(toJSON(0.5 < i)) type(toJSON(0.5)) type(toJSON(1)) type(toJSON(array)) -type(toJSON(f32)) -type(toJSON(f64)) type(toJSON(false)) -type(toJSON(foo)) +type(toJSON(i)) type(toJSON(i32)) type(toJSON(i64)) type(toJSON(list)) type(toJSON(nil)) -type(toJSON(ok)) -type(toJSON(true)) -type(trim("bar")) type(trim("foo")) -type(trimPrefix("foo")) -type(trimPrefix(toJSON(true))) -type(trimSuffix("bar")) +type(trimPrefix("bar")) +type(true != nil) type(true == false) type(true == nil) -type(true ? "bar" : 0.5) -type(true ? div : 0.5) -type(true ? f64 : array) -type(true ? foo : foo) -type(true ? foo : true) -type(true ? greet : "foo") -type(true ? list : ok) -type(true ? nil : list) -type(true ? nil : ok) -type(true ? true : 1) +type(true ? array : false) +type(true ? array : half) +type(true ? div : add) +type(true ? f64 : i32) +type(true ? ok : 1) +type(true and false) type(true and true) -type(true) endsWith toBase64("foo") -type(type("bar")) -type(type("foo")) +type(true or true) +type(true || ok) +type(true || true) +type(true) in foo +type(true) matches string(list) type(type(0.5)) type(type(1)) type(type(add)) -type(type(array)) type(type(div)) -type(type(f32)) -type(type(f64)) -type(type(false)) type(type(foo)) +type(type(greet)) type(type(half)) type(type(i)) type(type(i32)) type(type(i64)) -type(type(list)) type(type(nil)) type(type(ok)) -type(type(score)) type(type(true)) -type(upper("bar")) type(upper("foo")) -type({"bar": 0.5}) type({"bar": 1}) -type({"bar": greet}) -type({"foo": 0.5, "bar": foo}) -type({"foo": div}) -type({"foo": i64}) -type({"foo": nil}) -upper("bar" + "foo") -upper("bar") <= type(nil) -upper("bar") contains lower("foo") -upper("foo" + "bar") -upper(false ? 0.5 : "foo") +type({"bar": array}) +type({"foo": "foo"}) +type({"foo": f64}) +type({"foo": false, "foo": foo}.Bar) +upper("bar") not in foo +upper("foo" + "foo") +upper("foo") == toJSON("bar") upper(foo.Bar) upper(foo.String()) upper(foo?.Bar) upper(foo?.String()) +upper(greet("bar")) upper(greet("foo")) -upper(greet(string(ok))) +upper(last(list).Bar) upper(lower("bar")) -upper(ok ? "bar" : i) -upper(string("bar")) +upper(lower("foo")) +upper(reduce(list, #)?.Bar) upper(string("foo")) upper(string(0.5)) upper(string(1)) +upper(string(add)) upper(string(array)) -upper(string(div)) upper(string(f32)) -upper(string(f64)) -upper(string(foo)) -upper(string(greet)) -upper(string(half)) -upper(string(i)) upper(string(i32)) upper(string(i64)) upper(string(list)) upper(string(nil)) -upper(string(ok)) upper(string(score)) -upper(string(string(0.5))) upper(string(true)) +upper(toBase64("bar")) upper(toBase64("foo")) upper(toJSON("foo")) -upper(toJSON(0.5)) upper(toJSON(1)) -upper(toJSON(array)) upper(toJSON(f32)) -upper(toJSON(f64)) upper(toJSON(false)) upper(toJSON(foo)) upper(toJSON(i)) upper(toJSON(i32)) -upper(toJSON(i64)) upper(toJSON(list)) upper(toJSON(nil)) -upper(toJSON(ok)) upper(toJSON(true)) upper(trim("bar")) -upper(trim("bar", "bar")) upper(trim("foo")) -upper(trimPrefix("bar")) -upper(trimPrefix("foo")) upper(trimSuffix("bar")) upper(trimSuffix("foo")) -upper(true ? "bar" : f32) -upper(true ? "foo" : i32) upper(type("bar")) upper(type("foo")) -upper(type(0.5)) -upper(type(1)) -upper(type(add)) +upper(type(array)) upper(type(div)) upper(type(f32)) -upper(type(f64)) -upper(type(false)) -upper(type(foo)) +upper(type(foo.Bar)) upper(type(greet)) -upper(type(half)) upper(type(i)) -upper(type(i64)) +upper(type(i32)) upper(type(list)) upper(type(nil)) +upper(type(ok)) upper(type(score)) upper(type(true)) -upper(upper("bar")) -values({"bar": f32}) -values({"bar": greet}) -values({"bar": i64}) -values({"foo": 1}) -values({"foo": div}) -values({"foo": false}) -values({"foo": foo, "foo": ok}) -values({"foo": list, "bar": 1}) -{"bar": !false} -{"bar": !true} -{"bar": "bar", "foo": nil}?.String -{"bar": "bar", "foo": score}.i -{"bar": "bar", "foo": true}?.i?.foo -{"bar": "bar"}.add +upper(upper("foo")) +values(groupBy(array, "bar")) +values(groupBy(array, "foo")) +values(groupBy(array, #)) +values(groupBy(array, 0.5)) +values(groupBy(array, 1)) +values(groupBy(array, foo)) +values(groupBy(array, i)) +values(groupBy(list, #)) +values(groupBy(list, 1)) +values(groupBy(list, i)) +values(groupBy(list, i32)) +values(groupBy(list, true)) +values({"bar": "bar"}) +values({"bar": array}) +values({"foo": add, "bar": div}) +values({"foo": ok}) +{"bar": "bar" <= "foo"} +{"bar": "bar", "bar": half}.add +{"bar": "bar", "bar": i}.Qux +{"bar": "bar", "bar": i}.String +{"bar": "bar", "foo": 0.5}.i64 +{"bar": "bar", "foo": i64}?.Qux +{"bar": "bar", "foo": score}.f32 +{"bar": "bar"}.String?.foo {"bar": "bar"}.array -{"bar": "bar"}.f32 {"bar": "bar"}.f64 +{"bar": "bar"}.greet {"bar": "bar"}.list {"bar": "bar"}.ok -{"bar": "bar"}?.Bar -{"bar": "bar"}?.greet +{"bar": "bar"}?.Qux +{"bar": "bar"}?.array {"bar": "bar"}?.half -{"bar": "bar"}?.i -{"bar": "foo", "foo": 0.5}.add -{"bar": "foo", "foo": 1}.String?.ok -{"bar": "foo", "foo": greet}.half -{"bar": "foo", "foo": ok, "bar": f64}?.Bar -{"bar": "foo", "foo": ok}.Qux -{"bar": "foo", "foo": true}.ok -{"bar": "foo"}.Qux -{"bar": "foo"}.String -{"bar": "foo"}.add -{"bar": "foo"}.array -{"bar": "foo"}.div +{"bar": "bar"}?.list +{"bar": "foo", "bar": div}.half +{"bar": "foo", "foo": f32}.String +{"bar": "foo", "foo": i64}.ok?.f64 +{"bar": "foo", "foo": ok}?.i64 +{"bar": "foo"}.Bar {"bar": "foo"}.f32 +{"bar": "foo"}.foo +{"bar": "foo"}.half {"bar": "foo"}.i {"bar": "foo"}.i64 -{"bar": "foo"}.score -{"bar": "foo"}?.Qux -{"bar": "foo"}?.Qux?.score {"bar": "foo"}?.String -{"bar": "foo"}?.div +{"bar": "foo"}?.f32 {"bar": "foo"}?.foo +{"bar": "foo"}?.greet +{"bar": "foo"}?.i {"bar": "foo"}?.i32 -{"bar": "foo"}?.i64 +{"bar": "foo"}?.i?.String() +{"bar": "foo"}?.list +{"bar": "foo"}?.ok {"bar": -0.5} -{"bar": -1} -{"bar": -1}?.array {"bar": -f32} -{"bar": 0.5 * f64} -{"bar": 0.5 + 1} -{"bar": 0.5 - i32} -{"bar": 0.5 - i64} -{"bar": 0.5 < i64} -{"bar": 0.5 == nil} -{"bar": 0.5 > 1}.Qux -{"bar": 0.5, "bar": "bar"}.ok -{"bar": 0.5, "bar": 0.5}.f32 -{"bar": 0.5, "bar": 1}?.half -{"bar": 0.5, "foo": array}?.ok -{"bar": 0.5, "foo": i32, "bar": add}?.Bar -{"bar": 0.5}.Bar +{"bar": -f64} +{"bar": -i32} +{"bar": 0.5 != nil} +{"bar": 0.5 * 1}.foo +{"bar": 0.5, "bar": 0.5}.half +{"bar": 0.5, "bar": add, "foo": i32}.list +{"bar": 0.5, "bar": i}?.add +{"bar": 0.5, "bar": list}?.div +{"bar": 0.5, "bar": nil, "bar": nil}.i32 +{"bar": 0.5, "bar": ok, "foo": 1}?.String +{"bar": 0.5, "bar": true}.score +{"bar": 0.5, "foo": 0.5}?.f32 +{"bar": 0.5, "foo": array}?.list +{"bar": 0.5, "foo": f32}.i32?.Bar +{"bar": 0.5, "foo": ok}?.array {"bar": 0.5}.Qux {"bar": 0.5}.String {"bar": 0.5}.add -{"bar": 0.5}.div -{"bar": 0.5}.div?.array.foo +{"bar": 0.5}.array {"bar": 0.5}.f32 {"bar": 0.5}.f64 -{"bar": 0.5}.foo -{"bar": 0.5}.greet +{"bar": 0.5}.half +{"bar": 0.5}.i {"bar": 0.5}.i32 +{"bar": 0.5}.i64 {"bar": 0.5}.ok -{"bar": 0.5}.score {"bar": 0.5}?.Bar +{"bar": 0.5}?.Qux {"bar": 0.5}?.String -{"bar": 0.5}?.add -{"bar": 0.5}?.array {"bar": 0.5}?.div -{"bar": 0.5}?.f32 {"bar": 0.5}?.foo -{"bar": 0.5}?.greet?.i32 +{"bar": 0.5}?.greet {"bar": 0.5}?.half {"bar": 0.5}?.i {"bar": 0.5}?.i32 -{"bar": 0.5}?.i32?.i32 {"bar": 0.5}?.i64 -{"bar": 1 * i32} +{"bar": 0.5}?.list +{"bar": 0.5}?.score {"bar": 1 * i} -{"bar": 1 + i32} -{"bar": 1 - f32} +{"bar": 1 ** 0.5} {"bar": 1 / 0.5} -{"bar": 1 < f32} -{"bar": 1 <= 1} -{"bar": 1, "bar": "bar"}.i32 -{"bar": 1, "bar": array}?.f32 -{"bar": 1, "bar": false}.array -{"bar": 1, "bar": greet, "foo": "bar"}?.i64 -{"bar": 1, "bar": i64}?.array -{"bar": 1, "foo": 0.5}?.String -{"bar": 1, "foo": add, "foo": f32}?.i -{"bar": 1, "foo": foo}.div -{"bar": 1, "foo": i64}.i64 -{"bar": 1}.Bar -{"bar": 1}.Qux +{"bar": 1 / f32} +{"bar": 1 ^ 1} +{"bar": 1, "bar": add, "foo": "bar"}?.add +{"bar": 1, "bar": add}.div +{"bar": 1, "bar": f32}?.Bar +{"bar": 1, "bar": f64, "foo": array}.ok +{"bar": 1, "foo": "bar"}.half +{"bar": 1, "foo": array, "bar": score}?.i +{"bar": 1, "foo": i}?.list +{"bar": 1, "foo": i}?.ok +{"bar": 1, "foo": ok}?.f32 +{"bar": 1, "foo": score}.f64 {"bar": 1}.String {"bar": 1}.add -{"bar": 1}.div -{"bar": 1}.f64 +{"bar": 1}.f32 +{"bar": 1}.foo {"bar": 1}.greet {"bar": 1}.half {"bar": 1}.i -{"bar": 1}.ok -{"bar": 1}?.Bar +{"bar": 1}.i32 +{"bar": 1}.list +{"bar": 1}.score +{"bar": 1}?.Qux {"bar": 1}?.add -{"bar": 1}?.add?.i32 -{"bar": 1}?.div?.list +{"bar": 1}?.div {"bar": 1}?.f32 {"bar": 1}?.f64 {"bar": 1}?.i {"bar": 1}?.i32 +{"bar": 1}?.i64 +{"bar": 1}?.list {"bar": 1}?.ok -{"bar": ["bar", score]} -{"bar": add, "bar": "foo"}.String?.array -{"bar": add, "bar": 1}?.i64 -{"bar": add, "bar": div}?.f32 -{"bar": add, "bar": foo} -{"bar": add, "bar": list}.Bar -{"bar": add, "bar": score}.f64?.f64 -{"bar": add, "foo": "foo"}.i64 -{"bar": add, "foo": f64}?.score -{"bar": add, "foo": i32}?.half -{"bar": add, "foo": ok} -{"bar": add, "foo": score} +{"bar": add, "bar": half}.div +{"bar": add, "bar": i, "bar": ok}?.foo +{"bar": add, "bar": list} +{"bar": add, "bar": ok, "foo": 1}?.ok +{"bar": add, "foo": "foo"}?.f64 {"bar": add} {"bar": add}.Qux {"bar": add}.String -{"bar": add}.f64 -{"bar": add}.foo -{"bar": add}.greet -{"bar": add}.i32 -{"bar": add}.list +{"bar": add}.add +{"bar": add}.array +{"bar": add}.div +{"bar": add}.half +{"bar": add}?.Qux {"bar": add}?.String {"bar": add}?.add +{"bar": add}?.array {"bar": add}?.div -{"bar": add}?.i -{"bar": add}?.i64 -{"bar": add}?.score -{"bar": any(array, false)} -{"bar": any(list, ok)} -{"bar": array, "bar": f64} -{"bar": array, "bar": false, "bar": i}?.Qux -{"bar": array, "bar": false}.Qux -{"bar": array, "bar": half}.i32 -{"bar": array, "bar": i64}.i64 -{"bar": array, "bar": score} -{"bar": array, "foo": "foo"}?.array -{"bar": array, "foo": add == add} -{"bar": array, "foo": count(list, true)}.add +{"bar": add}?.f64 +{"bar": add}?.f64 != half +{"bar": add}?.half +{"bar": add}?.ok +{"bar": add}?.score?.div +{"bar": array, "bar": "bar"}?.i +{"bar": array, "bar": array}?.foo +{"bar": array, "bar": f32} +{"bar": array, "bar": nil}.i64 +{"bar": array, "foo": f32}?.String +{"bar": array, "foo": f64} +{"bar": array, "foo": half}?.add +{"bar": array, "foo": i32} +{"bar": array, "foo": score} {"bar": array} {"bar": array}.Bar -{"bar": array}.Qux -{"bar": array}.String -{"bar": array}.add -{"bar": array}.f32 -{"bar": array}.half?.foo +{"bar": array}.div +{"bar": array}.div?.Qux +{"bar": array}.greet {"bar": array}.i {"bar": array}.i64 -{"bar": array}?.Bar +{"bar": array}.list +{"bar": array}.score +{"bar": array}?.add?.ok {"bar": array}?.div +{"bar": array}?.f64 {"bar": array}?.greet {"bar": array}?.half -{"bar": array}?.i32 {"bar": array}?.i64 {"bar": array}?.ok -{"bar": div != greet} -{"bar": div, "bar": "bar", "bar": foo}.greet -{"bar": div, "bar": "bar", "foo": 1}?.div -{"bar": div, "bar": greet}?.i32 -{"bar": div, "bar": i32}?.array -{"bar": div, "foo": div}?.list -{"bar": div, "foo": greet, "foo": 1}?.score?.Qux -{"bar": div, "foo": i}?.i -{"bar": div, "foo": list}.f64 -{"bar": div, "foo": ok}?.i64 +{"bar": div, "bar": array, "bar": 0.5}.i64 +{"bar": div, "bar": div}?.f32 +{"bar": div, "bar": foo}.foo +{"bar": div, "bar": ok} +{"bar": div, "foo": 1, "bar": ok}.Qux +{"bar": div, "foo": false}?.String +{"bar": div, "foo": foo, "foo": score}.Bar +{"bar": div, "foo": greet}.i +{"bar": div, "foo": greet}?.ok {"bar": div, "foo": score} {"bar": div} -{"bar": div}.add -{"bar": div}.div +{"bar": div}.array {"bar": div}.f32 -{"bar": div}.f32?.score -{"bar": div}.half -{"bar": div}.i32 -{"bar": div}.i64 -{"bar": div}.score -{"bar": div}?.div -{"bar": div}?.div?.f32 -{"bar": div}?.foo +{"bar": div}.f64 +{"bar": div}.i64?.Qux +{"bar": div}.list +{"bar": div}.ok +{"bar": div}?.Bar +{"bar": div}?.array +{"bar": div}?.f64 +{"bar": div}?.greet {"bar": div}?.half -{"bar": div}?.i -{"bar": div}?.i64 {"bar": div}?.list {"bar": div}?.ok -{"bar": f32 ** 1} -{"bar": f32 - i32} -{"bar": f32, "bar": true, "bar": list}?.Bar -{"bar": f32, "foo": i32} -{"bar": f32, "foo": ok, "foo": f32}.half -{"bar": f32, "foo": score}?.greet +{"bar": div}?.score +{"bar": f32 ** i} +{"bar": f32 - 0.5} +{"bar": f32 >= 0.5} +{"bar": f32 ^ 1} +{"bar": f32, "bar": "foo"}.add +{"bar": f32, "bar": false}?.Bar +{"bar": f32, "bar": true}?.String +{"bar": f32, "foo": add, "foo": false}?.String +{"bar": f32, "foo": f32}.ok +{"bar": f32, "foo": f64} +{"bar": f32, "foo": half, "foo": ok} +{"bar": f32, "foo": half} +{"bar": f32, "foo": list}?.f32 +{"bar": f32, "foo": nil}?.f64?.foo {"bar": f32} -{"bar": f32}.Bar -{"bar": f32}.Qux?.i64 -{"bar": f32}.String -{"bar": f32}.add -{"bar": f32}.half -{"bar": f32}.list -{"bar": f32}?.String?.score +{"bar": f32}.Qux +{"bar": f32}.div +{"bar": f32}.f64 +{"bar": f32}.greet +{"bar": f32}.i +{"bar": f32}.i32 +{"bar": f32}.i64 +{"bar": f32}?.Bar +{"bar": f32}?.String +{"bar": f32}?.array {"bar": f32}?.f64 -{"bar": f32}?.foo -{"bar": f32}?.i32 -{"bar": f32}?.i64 +{"bar": f32}?.half {"bar": f32}?.list -{"bar": f32}?.score -{"bar": f64, "bar": 0.5}.div -{"bar": f64, "bar": i} -{"bar": f64, "bar": nil}?.f64 -{"bar": f64, "foo": "foo"}?.half -{"bar": f64, "foo": 0.5, "bar": foo}?.half -{"bar": f64, "foo": f64}.foo -{"bar": f64, "foo": i32} +{"bar": f64 + 1} +{"bar": f64 == i32} +{"bar": f64 > 0.5} +{"bar": f64 ^ i32} +{"bar": f64, "bar": "bar"}.i +{"bar": f64, "bar": foo}?.i +{"bar": f64, "bar": i64}?.i64 +{"bar": f64, "bar": i}.f64 +{"bar": f64, "bar": true}?.i +{"bar": f64, "foo": 0.5, "foo": score}.ok +{"bar": f64, "foo": 1}.f32 +{"bar": f64, "foo": f64}?.score +{"bar": f64, "foo": i}?.Qux?.f64 {"bar": f64} -{"bar": f64}.String -{"bar": f64}.div?.String() -{"bar": f64}.f32 +{"bar": f64}.array +{"bar": f64}.f32?.Bar {"bar": f64}.f64 -{"bar": f64}.f64?.list -{"bar": f64}.greet -{"bar": f64}.half +{"bar": f64}.foo {"bar": f64}.i +{"bar": f64}.i32 {"bar": f64}.ok {"bar": f64}?.Bar -{"bar": f64}?.Qux -{"bar": f64}?.f64 -{"bar": f64}?.half -{"bar": f64}?.i32 +{"bar": f64}?.Bar?.Qux +{"bar": f64}?.add +{"bar": f64}?.div +{"bar": f64}?.f32 +{"bar": f64}?.foo +{"bar": f64}?.i {"bar": f64}?.i64 -{"bar": f64}?.score -{"bar": false, "bar": 0.5, "bar": foo}.add -{"bar": false, "foo": greet, "foo": i64}.div -{"bar": false}.add -{"bar": false}.div +{"bar": f64}?.list +{"bar": f64}?.ok +{"bar": false, "bar": array}?.list +{"bar": false, "bar": i32}?.div +{"bar": false, "bar": i}?.i64 +{"bar": false, "bar": nil}.ok +{"bar": false}.Bar +{"bar": false}.Qux +{"bar": false}.array +{"bar": false}.f32 {"bar": false}.f64 -{"bar": false}.foo -{"bar": false}.greet {"bar": false}.half +{"bar": false}.i {"bar": false}.i32 -{"bar": false}.list {"bar": false}.ok {"bar": false}.score +{"bar": false}?.Bar {"bar": false}?.array -{"bar": false}?.greet -{"bar": false}?.i32 -{"bar": false}?.ok?.Qux?.score() -{"bar": false}?.score -{"bar": first(list)} -{"bar": float(f32)} -{"bar": foo, "bar": 0.5}.div -{"bar": foo, "bar": div}.array -{"bar": foo, "bar": half} -{"bar": foo, "bar": list}.f32 -{"bar": foo, "foo": greet}?.div -{"bar": foo, "foo": i32}.score -{"bar": foo, "foo": true}?.f32 +{"bar": false}?.div +{"bar": false}?.foo +{"bar": false}?.half +{"bar": false}?.i +{"bar": false}?.list +{"bar": false}?.ok +{"bar": filter(list, ok)} +{"bar": float(0.5)} +{"bar": floor(0.5)}.score +{"bar": floor(i32)} +{"bar": foo != nil, "foo": array} +{"bar": foo, "bar": "foo", "bar": score}?.score +{"bar": foo, "bar": 1, "bar": score}?.ok +{"bar": foo, "bar": greet} +{"bar": foo, "bar": i}?.i +{"bar": foo, "bar": score}?.ok +{"bar": foo, "foo": 0.5, "foo": ok}?.half +{"bar": foo, "foo": 0.5}.score +{"bar": foo, "foo": 1, "foo": i}?.add +{"bar": foo, "foo": f64} +{"bar": foo, "foo": f64}.Bar {"bar": foo.Bar} {"bar": foo.String()} -{"bar": foo?.Qux}?.foo +{"bar": foo?.Qux, "bar": f32} {"bar": foo?.String} {"bar": foo} -{"bar": foo}.Qux -{"bar": foo}.String +{"bar": foo}.Bar {"bar": foo}.array -{"bar": foo}.div -{"bar": foo}.f64 +{"bar": foo}.f32 {"bar": foo}.half -{"bar": foo}.half?.list(i32).array {"bar": foo}.i {"bar": foo}.list {"bar": foo}.ok -{"bar": foo}?.div -{"bar": foo}?.f64 +{"bar": foo}?.Bar +{"bar": foo}?.add {"bar": foo}?.greet {"bar": foo}?.i +{"bar": foo}?.i32 {"bar": foo}?.i64 {"bar": foo}?.list -{"bar": greet, "bar": foo} -{"bar": greet, "bar": nil}.f64 -{"bar": greet, "foo": foo} +{"bar": foo}?.ok +{"bar": foo}?.score +{"bar": get(list, i32)} +{"bar": greet("foo")} +{"bar": greet, "bar": 0.5}.i32 +{"bar": greet, "bar": 1}.Bar +{"bar": greet, "bar": f32}.Bar +{"bar": greet, "bar": i32} +{"bar": greet, "bar": not ok} +{"bar": greet, "foo": "bar"}.ok +{"bar": greet, "foo": f64} +{"bar": greet, "foo": false, "bar": ok}.i32 +{"bar": greet, "foo": i32} {"bar": greet} -{"bar": greet}.Qux -{"bar": greet}.add +{"bar": greet}.Bar {"bar": greet}.array -{"bar": greet}.div -{"bar": greet}.foo -{"bar": greet}.i -{"bar": greet}.i32 -{"bar": greet}.ok -{"bar": greet}.score -{"bar": greet}?.Bar -{"bar": greet}?.String -{"bar": greet}?.add +{"bar": greet}.f32 +{"bar": greet}.greet +{"bar": greet}.half +{"bar": greet}.list +{"bar": greet}?.Qux +{"bar": greet}?.div {"bar": greet}?.f32 -{"bar": greet}?.foo?.foo +{"bar": greet}?.f64 +{"bar": greet}?.greet {"bar": greet}?.half -{"bar": greet}?.i -{"bar": greet}?.list +{"bar": greet}?.i32 {"bar": greet}?.ok -{"bar": half(0.5), "bar": ok} -{"bar": half(0.5)} -{"bar": half(0.5)}?.array -{"bar": half, "bar": "foo", "bar": ok}?.String -{"bar": half, "bar": array}?.div?.i32 -{"bar": half, "bar": div} -{"bar": half, "bar": f32} -{"bar": half, "bar": greet}?.i64 +{"bar": greet}?.score +{"bar": groupBy(array, f32)} +{"bar": half == nil} +{"bar": half(f64)} +{"bar": half, "bar": add, "bar": f64}?.i32 +{"bar": half, "bar": foo} {"bar": half, "bar": list} -{"bar": half, "bar": score, "bar": i == f32} {"bar": half, "bar": score} -{"bar": half, "foo": array} -{"bar": half, "foo": f64 == i64} -{"bar": half, "foo": greet} -{"bar": half, "foo": i64}.array -{"bar": half, "foo": list}?.list?.ok +{"bar": half, "foo": 1}?.i64 +{"bar": half, "foo": list} +{"bar": half, "foo": ok, "bar": i} +{"bar": half, "foo": ok}.Qux +{"bar": half, "foo": true}?.String {"bar": half} +{"bar": half}.Bar?.i +{"bar": half}.Qux {"bar": half}.String -{"bar": half}.String?.score +{"bar": half}.div?.i +{"bar": half}.f32 +{"bar": half}.foo {"bar": half}.half {"bar": half}.i32 -{"bar": half}.i64 -{"bar": half}.ok -{"bar": half}.score -{"bar": half}?.Qux -{"bar": half}?.Qux?.f32 -{"bar": half}?.div +{"bar": half}.list +{"bar": half}.list?.String() +{"bar": half}?.Bar +{"bar": half}?.String +{"bar": half}?.array {"bar": half}?.f32 -{"bar": half}?.foo?.f32() -{"bar": half}?.half -{"bar": half}?.half?.f32 -{"bar": half}?.i -{"bar": i ** 0.5} -{"bar": i + i64} -{"bar": i .. i32} -{"bar": i .. i} -{"bar": i > i32} -{"bar": i >= 0.5, "bar": array} -{"bar": i >= i} -{"bar": i, "bar": 0.5}?.Qux -{"bar": i, "bar": foo}.foo -{"bar": i, "bar": nil}?.f32 -{"bar": i, "foo": 1 >= f64} -{"bar": i, "foo": array}.array -{"bar": i, "foo": f64}.i64 -{"bar": i, "foo": greet}?.foo -{"bar": i32 + 0.5} -{"bar": i32 < i32} -{"bar": i32 <= f64} -{"bar": i32, "bar": "foo"}?.half -{"bar": i32, "foo": f64}?.foo -{"bar": i32, "foo": foo, "foo": i32}?.i32?.String() -{"bar": i32, "foo": i64, "bar": true}?.i64 -{"bar": i32, "foo": i64}.half -{"bar": i32, "foo": list} -{"bar": i32, "foo": score, "foo": 1}.array -{"bar": i32, "foo": score, "foo": greet}.add -{"bar": i32, "foo": score, "foo": ok}.foo +{"bar": half}?.greet +{"bar": half}?.i32 +{"bar": half}?.list +{"bar": i % i32} +{"bar": i ** f64} +{"bar": i < 1}?.half +{"bar": i, "bar": 1}.add +{"bar": i, "bar": 1}?.i64 +{"bar": i, "bar": array}?.half +{"bar": i, "bar": div}.ok +{"bar": i, "bar": f64, "bar": "foo"}?.foo +{"bar": i, "bar": f64, "bar": nil}.i32 +{"bar": i, "bar": score} +{"bar": i, "foo": half} +{"bar": i, "foo": i32}?.score +{"bar": i, "foo": nil}?.String +{"bar": i32 ^ 0.5} +{"bar": i32 ^ f64} +{"bar": i32, "bar": list} +{"bar": i32, "foo": "bar"}.i64 +{"bar": i32, "foo": array}.div +{"bar": i32, "foo": f64, "foo": add}.f64 +{"bar": i32, "foo": foo}?.add +{"bar": i32, "foo": ok}.ok {"bar": i32} -{"bar": i32}.Bar +{"bar": i32}.Qux +{"bar": i32}.f64 {"bar": i32}.i -{"bar": i32}.i64 +{"bar": i32}.i32 {"bar": i32}.list -{"bar": i32}.score?.f32 -{"bar": i32}?.String +{"bar": i32}.ok +{"bar": i32}.score +{"bar": i32}?.Qux +{"bar": i32}?.add +{"bar": i32}?.array {"bar": i32}?.div {"bar": i32}?.f32 -{"bar": i32}?.foo -{"bar": i32}?.greet -{"bar": i32}?.half -{"bar": i32}?.i -{"bar": i32}?.list?.list +{"bar": i32}?.i32 +{"bar": i32}?.list {"bar": i32}?.ok -{"bar": i32}?.score -{"bar": i64 != f32, "bar": score} -{"bar": i64 ** f64} -{"bar": i64 / f64} -{"bar": i64, "bar": "bar", "foo": i64}.array -{"bar": i64, "bar": foo}.list -{"bar": i64, "bar": greet, "foo": score}.array -{"bar": i64, "bar": half}?.f64 -{"bar": i64, "bar": i64}?.Qux?.array() -{"bar": i64, "bar": list} -{"bar": i64, "foo": "foo"}.Bar -{"bar": i64, "foo": 0.5, "foo": list}.i64 -{"bar": i64, "foo": f32, "foo": nil}.i32 -{"bar": i64, "foo": f32}?.half -{"bar": i64, "foo": i, "foo": greet}.array -{"bar": i64, "foo": nil}.add -{"bar": i64, "foo": nil}?.Qux +{"bar": i64 + 1} +{"bar": i64 <= 0.5} +{"bar": i64 == 0.5} +{"bar": i64 in array} +{"bar": i64, "bar": !ok} +{"bar": i64, "bar": 0.5}.f32 +{"bar": i64, "bar": greet}.array +{"bar": i64, "bar": score}.ok +{"bar": i64, "foo": nil}?.i32 +{"bar": i64, "foo": ok} +{"bar": i64, "foo": ok}?.f32 {"bar": i64} -{"bar": i64}.add -{"bar": i64}.array +{"bar": i64}.array?.Bar {"bar": i64}.div -{"bar": i64}.div?.i64 {"bar": i64}.f32 -{"bar": i64}.foo -{"bar": i64}.greet -{"bar": i64}.i64 +{"bar": i64}.f64 +{"bar": i64}.i {"bar": i64}.list {"bar": i64}.ok -{"bar": i64}?.Qux -{"bar": i64}?.String -{"bar": i64}?.array -{"bar": i64}?.array?.foo +{"bar": i64}.score {"bar": i64}?.div {"bar": i64}?.f32 -{"bar": i64}?.i64 +{"bar": i64}?.f64 +{"bar": i64}?.half +{"bar": i64}?.i +{"bar": i64}?.i32 +{"bar": i64}?.i?.ok {"bar": i64}?.list -{"bar": i64}?.ok -{"bar": i64}?.score +{"bar": int(f64)} {"bar": i} -{"bar": i}.Bar -{"bar": i}.String +{"bar": i}.add {"bar": i}.array -{"bar": i}.div +{"bar": i}.div?.Qux.div {"bar": i}.f64 -{"bar": i}.foo -{"bar": i}.greet {"bar": i}.half {"bar": i}.i -{"bar": i}.i32 {"bar": i}.i64 -{"bar": i}.list?.list -{"bar": i}?.Qux +{"bar": i}.list {"bar": i}?.String -{"bar": i}?.add +{"bar": i}?.array +{"bar": i}?.f64 {"bar": i}?.foo {"bar": i}?.greet -{"bar": i}?.list -{"bar": list, "bar": 1}?.f64 -{"bar": list, "bar": div} -{"bar": list, "bar": f32, "bar": i64}.Bar -{"bar": list, "bar": f32, "bar": ok}.add -{"bar": list, "bar": f64}.foo -{"bar": list, "bar": false, "bar": 1}?.f32 -{"bar": list, "bar": i32}.half -{"bar": list, "bar": ok} -{"bar": list, "foo": div, "foo": ok}?.i64 -{"bar": list, "foo": f64, "foo": list}.half -{"bar": list, "foo": half}?.Qux -{"bar": list, "foo": i} -{"bar": list, "foo": list} -{"bar": list, "foo": ok, "foo": f64}?.half +{"bar": i}?.i +{"bar": i}?.i32 +{"bar": i}?.i64 +{"bar": i}?.score +{"bar": list == nil} +{"bar": list, "bar": half}?.Bar +{"bar": list, "bar": score} +{"bar": list, "foo": "foo"}.String +{"bar": list, "foo": 1, "foo": nil}.score +{"bar": list, "foo": 1, "foo": score}?.array +{"bar": list, "foo": array}?.i64 +{"bar": list, "foo": f64}.div?.Qux +{"bar": list, "foo": f64}.list +{"bar": list, "foo": half}?.f32 +{"bar": list, "foo": i64}?.array +{"bar": list, "foo": nil}.i64 +{"bar": list[i32:i32]} {"bar": list} -{"bar": list}.Bar +{"bar": list}.String {"bar": list}.add -{"bar": list}.f32 +{"bar": list}.array +{"bar": list}.array?.i64 {"bar": list}.f64 {"bar": list}.greet -{"bar": list}.score +{"bar": list}.i +{"bar": list}.list +{"bar": list}?.Bar +{"bar": list}?.Qux {"bar": list}?.add -{"bar": list}?.add?.array {"bar": list}?.div -{"bar": list}?.half -{"bar": list}?.i32 -{"bar": list}?.list +{"bar": list}?.f64 +{"bar": list}?.i64 {"bar": list}?.score -{"bar": map(list, i32)} -{"bar": min(0.5)} -{"bar": min(f32)} +{"bar": lower("bar")} +{"bar": map(array, #)} +{"bar": map(array, i)} +{"bar": map(list, #)} {"bar": nil != "bar"} -{"bar": nil != false} -{"bar": nil == "foo"} -{"bar": nil == 1} -{"bar": nil == f64} -{"bar": nil, "bar": div}.f32 -{"bar": nil, "bar": greet, "foo": "bar"}?.i64 -{"bar": nil, "bar": greet}.score -{"bar": nil, "bar": i}.f64 -{"bar": nil, "foo": 0.5}?.array -{"bar": nil, "foo": f64}?.add -{"bar": nil, "foo": half}?.foo -{"bar": nil}.String +{"bar": nil != nil} +{"bar": nil == 0.5} +{"bar": nil == nil} +{"bar": nil, "bar": "bar"}?.i32 +{"bar": nil, "bar": add, "bar": i}.add +{"bar": nil, "bar": foo}?.list +{"bar": nil, "foo": "foo"}.f64 +{"bar": nil, "foo": 1, "foo": add}.ok +{"bar": nil, "foo": foo}?.add +{"bar": nil, "foo": i}?.f64 +{"bar": nil, "foo": list}?.f32 +{"bar": nil}.Bar {"bar": nil}.add -{"bar": nil}.array +{"bar": nil}.div {"bar": nil}.f32 {"bar": nil}.foo +{"bar": nil}.greet {"bar": nil}.half -{"bar": nil}?.Bar +{"bar": nil}.i +{"bar": nil}.i32 +{"bar": nil}.i32?.greet +{"bar": nil}.i64 +{"bar": nil}.i?.f64 +{"bar": nil}.list +{"bar": nil}.ok +{"bar": nil}?.Qux +{"bar": nil}?.String {"bar": nil}?.add -{"bar": nil}?.array +{"bar": nil}?.div {"bar": nil}?.f32 {"bar": nil}?.f64 -{"bar": nil}?.foo -{"bar": nil}?.foo?.i32 -{"bar": nil}?.greet {"bar": nil}?.half +{"bar": nil}?.i {"bar": nil}?.i32 -{"bar": nil}?.i64 {"bar": nil}?.list {"bar": nil}?.ok -{"bar": ok or ok} -{"bar": ok || ok} -{"bar": ok, "bar": list} -{"bar": ok, "bar": nil == half}.f64 -{"bar": ok, "foo": div, "bar": "bar"}.Qux -{"bar": ok, "foo": i32, "bar": 1}.score +{"bar": none(list, ok)} +{"bar": not true} +{"bar": ok ? "bar" : i} +{"bar": ok ? i32 : "foo"} +{"bar": ok ? nil : greet} +{"bar": ok, "bar": 1, "foo": f64}.half +{"bar": ok, "bar": array} +{"bar": ok, "bar": i64, "foo": 1}?.Qux +{"bar": ok, "bar": i} +{"bar": ok, "bar": list}?.div +{"bar": ok, "bar": ok}.f32 +{"bar": ok, "foo": 0.5}?.score +{"bar": ok, "foo": 1}.i +{"bar": ok, "foo": greet} +{"bar": ok, "foo": half} +{"bar": ok, "foo": list} +{"bar": ok, "foo": list}?.f64 +{"bar": ok, "foo": nil}?.i32 +{"bar": ok, "foo": ok}.div {"bar": ok} -{"bar": ok}.String -{"bar": ok}.add -{"bar": ok}.array -{"bar": ok}.i +{"bar": ok}.Bar +{"bar": ok}.div +{"bar": ok}.f32 +{"bar": ok}.greet +{"bar": ok}.i32 {"bar": ok}.i64 +{"bar": ok}.list {"bar": ok}.ok +{"bar": ok}.score {"bar": ok}?.Qux -{"bar": ok}?.array -{"bar": ok}?.f64 -{"bar": ok}?.foo -{"bar": ok}?.greet -{"bar": ok}?.i +{"bar": ok}?.add +{"bar": ok}?.f32 {"bar": ok}?.i32 {"bar": ok}?.i64 -{"bar": score != score} -{"bar": score, "bar": 0.5}?.Bar -{"bar": score, "bar": div} -{"bar": score, "bar": foo} -{"bar": score, "bar": i64}.div -{"bar": score, "bar": i} -{"bar": score, "foo": greet} +{"bar": ok}?.list +{"bar": ok}?.score +{"bar": one(list, false)} +{"bar": reduce(array, i)}.i64 +{"bar": reduce(list, half)} +{"bar": score(i)} +{"bar": score, "bar": "bar", "bar": "foo"}?.f32 +{"bar": score, "bar": add}.String +{"bar": score, "bar": i64}.f32 +{"bar": score, "bar": nil}.i +{"bar": score, "foo": div} +{"bar": score, "foo": foo}.i +{"bar": score, "foo": half, "foo": i}?.array +{"bar": score, "foo": half} +{"bar": score, "foo": score}?.greet {"bar": score} -{"bar": score}.Bar {"bar": score}.add {"bar": score}.array {"bar": score}.div {"bar": score}.f64 -{"bar": score}.i32 -{"bar": score}.i64 +{"bar": score}.foo +{"bar": score}.half {"bar": score}.list -{"bar": score}.ok -{"bar": score}.score +{"bar": score}?.String +{"bar": score}?.array {"bar": score}?.f32 -{"bar": score}?.f64 +{"bar": score}?.foo +{"bar": score}?.half +{"bar": score}?.i {"bar": score}?.i32 {"bar": score}?.list {"bar": score}?.score -{"bar": string(array)} -{"bar": toJSON(array)} -{"bar": toJSON(i)}.i64?.i64 -{"bar": toJSON(i32)} -{"bar": true, "bar": false}.Bar -{"bar": true, "bar": foo}?.String -{"bar": true, "foo": 0.5}?.i -{"bar": true, "foo": div}.score -{"bar": true, "foo": foo}.div +{"bar": string(0.5)} +{"bar": string(i64)} +{"bar": string(ok)} +{"bar": toJSON(list)} +{"bar": true == false} +{"bar": true, "bar": f64}?.score +{"bar": true, "bar": i32}.array +{"bar": true, "foo": nil}?.f32 {"bar": true}.Bar -{"bar": true}.Qux?.greet() -{"bar": true}.f32 -{"bar": true}.f64 +{"bar": true}.Qux +{"bar": true}.String +{"bar": true}.div {"bar": true}.half -{"bar": true}.i -{"bar": true}.list?.String() -{"bar": true}.score +{"bar": true}.i32 {"bar": true}?.Bar +{"bar": true}?.add +{"bar": true}?.array +{"bar": true}?.div +{"bar": true}?.half +{"bar": true}?.i32 {"bar": true}?.i64 -{"bar": true}?.list -{"bar": type(f64)} -{"bar": type(greet)} -{"bar": {"foo": "bar", "bar": "bar", "bar": nil}} -{"foo": "bar", "bar": i32}.half -{"foo": "bar", "bar": nil}?.add?.i64 +{"bar": type(greet)}.Bar +{"bar": type(half)} +{"bar": type(score)} +{"foo": !ok} +{"foo": "bar" < "bar"} +{"foo": "bar" > "bar"} +{"foo": "bar", "bar": list}.div +{"foo": "bar", "bar": nil}.f64 +{"foo": "bar", "foo": 0.5}?.add +{"foo": "bar", "foo": 0.5}?.list +{"foo": "bar", "foo": array}?.f64?.list() +{"foo": "bar", "foo": list}.list {"foo": "bar"}.Bar {"foo": "bar"}.Qux {"foo": "bar"}.String -{"foo": "bar"}.array -{"foo": "bar"}.f64 +{"foo": "bar"}.foo {"foo": "bar"}.half {"foo": "bar"}.i {"foo": "bar"}.i64 -{"foo": "bar"}.list -{"foo": "bar"}.ok +{"foo": "bar"}?.Bar +{"foo": "bar"}?.String {"foo": "bar"}?.add -{"foo": "bar"}?.div?.ok +{"foo": "bar"}?.array +{"foo": "bar"}?.div +{"foo": "bar"}?.f32 {"foo": "bar"}?.f64 {"foo": "bar"}?.foo {"foo": "bar"}?.half -{"foo": "foo" != "bar"} -{"foo": "foo", "bar": nil}?.String -{"foo": "foo", "foo": add, "foo": "foo"}?.i -{"foo": "foo", "foo": div}.i64 -{"foo": "foo", "foo": greet}.array -{"foo": "foo", "foo": i, "bar": greet}?.score -{"foo": "foo", "foo": i32, "bar": f32}.greet -{"foo": "foo", "foo": i}?.foo -{"foo": "foo", "foo": list}.f32 -{"foo": "foo"}.Bar -{"foo": "foo"}.array +{"foo": "bar"}?.i32 +{"foo": "bar"}?.score +{"foo": "foo" <= "foo"} +{"foo": "foo" endsWith "foo"} +{"foo": "foo", "bar": false}.greet +{"foo": "foo", "bar": half}?.String +{"foo": "foo", "bar": list, "bar": div}?.String +{"foo": "foo", "foo": add}?.f32 +{"foo": "foo"}.Qux +{"foo": "foo"}.div {"foo": "foo"}.f32 -{"foo": "foo"}.foo -{"foo": "foo"}.greet -{"foo": "foo"}.i64 -{"foo": "foo"}?.Bar -{"foo": "foo"}?.add +{"foo": "foo"}.i +{"foo": "foo"}.i32 +{"foo": "foo"}.list {"foo": "foo"}?.div -{"foo": "foo"}?.greet -{"foo": "foo"}?.half +{"foo": "foo"}?.f32 +{"foo": "foo"}?.foo +{"foo": "foo"}?.i +{"foo": "foo"}?.i32 {"foo": "foo"}?.score +{"foo": -0.5} {"foo": -1} +{"foo": -f64} {"foo": -i64} -{"foo": -i} -{"foo": 0.5 ** i64} -{"foo": 0.5 - 0.5} +{"foo": 0.5 != 0.5} +{"foo": 0.5 ** f64} +{"foo": 0.5 < i64}.div {"foo": 0.5 <= 0.5} -{"foo": 0.5 > i64} -{"foo": 0.5, "bar": 1}.half -{"foo": 0.5, "bar": add}.Bar -{"foo": 0.5, "bar": div}.array -{"foo": 0.5, "bar": i32}?.String -{"foo": 0.5, "bar": score, "foo": score}.half -{"foo": 0.5, "foo": 1, "foo": list}.div -{"foo": 0.5, "foo": nil}?.div -{"foo": 0.5, "foo": nil}?.i64 -{"foo": 0.5}.Bar -{"foo": 0.5}.Qux +{"foo": 0.5, "bar": 0.5}.String +{"foo": 0.5, "bar": 0.5}.foo +{"foo": 0.5, "bar": 0.5}?.score +{"foo": 0.5, "bar": 1}?.div +{"foo": 0.5, "bar": i64}.i32 +{"foo": 0.5, "bar": list}?.i64 +{"foo": 0.5, "foo": 1}.Qux +{"foo": 0.5, "foo": array}.i64 +{"foo": 0.5, "foo": f64}.i +{"foo": 0.5, "foo": false, "bar": list}.add +{"foo": 0.5, "foo": greet}.i32 +{"foo": 0.5, "foo": score}.foo +{"foo": 0.5}.Qux?.half +{"foo": 0.5}.String +{"foo": 0.5}.add {"foo": 0.5}.array +{"foo": 0.5}.div {"foo": 0.5}.f32 -{"foo": 0.5}.f64 -{"foo": 0.5}.greet {"foo": 0.5}.half -{"foo": 0.5}.i {"foo": 0.5}.i64 {"foo": 0.5}.list -{"foo": 0.5}.ok -{"foo": 0.5}?.Bar?.i +{"foo": 0.5}.score +{"foo": 0.5}?.Bar {"foo": 0.5}?.String -{"foo": 0.5}?.add -{"foo": 0.5}?.array -{"foo": 0.5}?.array?.score -{"foo": 0.5}?.foo -{"foo": 0.5}?.greet +{"foo": 0.5}?.div +{"foo": 0.5}?.f32 +{"foo": 0.5}?.f64 {"foo": 0.5}?.half -{"foo": 0.5}?.i64 +{"foo": 0.5}?.i +{"foo": 0.5}?.list {"foo": 0.5}?.ok -{"foo": 1 + 0.5} -{"foo": 1 / 0.5} {"foo": 1 / i64} -{"foo": 1 < i32}?.i64 -{"foo": 1 not in array} -{"foo": 1, "bar": 0.5}.array -{"foo": 1, "bar": div}.f32 -{"foo": 1, "bar": f32}.Qux?.half?.list -{"foo": 1, "bar": i64, "foo": 0.5}.list -{"foo": 1, "bar": i64}?.ok -{"foo": 1, "bar": score}.foo -{"foo": 1, "foo": 0.5}.f32 -{"foo": 1, "foo": array}?.array -{"foo": 1, "foo": ok}.add -{"foo": 1, "foo": true}?.Qux +{"foo": 1 == f32} +{"foo": 1, "bar": nil}?.add +{"foo": 1, "bar": score}.greet +{"foo": 1, "foo": 1}.f64 +{"foo": 1, "foo": f64}.i +{"foo": 1, "foo": false}?.f32 +{"foo": 1, "foo": half}?.f32 +{"foo": 1, "foo": ok}.Bar +{"foo": 1, "foo": ok}.f32 +{"foo": 1, "foo": ok}.i32 +{"foo": 1, "foo": score}.half +{"foo": 1}.Bar {"foo": 1}.add +{"foo": 1}.div {"foo": 1}.f32 +{"foo": 1}.f64 {"foo": 1}.foo {"foo": 1}.greet {"foo": 1}.half +{"foo": 1}.i {"foo": 1}.i64 {"foo": 1}.list -{"foo": 1}.ok -{"foo": 1}?.Bar +{"foo": 1}?.String {"foo": 1}?.add -{"foo": 1}?.div -{"foo": 1}?.f32 -{"foo": 1}?.foo +{"foo": 1}?.f64 {"foo": 1}?.greet {"foo": 1}?.half -{"foo": 1}?.i -{"foo": 1}?.i32 -{"foo": 1}?.score -{"foo": abs(0.5)} -{"foo": add, "bar": 0.5}.i -{"foo": add, "bar": nil}.score -{"foo": add, "bar": ok} -{"foo": add, "bar": score}.half -{"foo": add, "foo": "bar"}?.String -{"foo": add, "foo": half, "foo": div}?.greet -{"foo": add, "foo": i32}.foo -{"foo": add, "foo": nil}?.list +{"foo": 1}?.list +{"foo": 1}?.ok +{"foo": abs(i64)} +{"foo": add, "bar": half} +{"foo": add, "bar": nil}.i +{"foo": add, "bar": nil}?.i +{"foo": add, "bar": ok, "foo": array}?.i32 +{"foo": add, "foo": 1, "bar": i32}.add +{"foo": add, "foo": array}?.f32 +{"foo": add, "foo": foo}?.i64 +{"foo": add, "foo": half} +{"foo": add, "foo": score, "bar": i32}.list {"foo": add} -{"foo": add}.Bar +{"foo": add}.array {"foo": add}.div +{"foo": add}.f32 {"foo": add}.foo {"foo": add}.half {"foo": add}.i -{"foo": add}.i64 +{"foo": add}.i32 +{"foo": add}.i?.score {"foo": add}.list -{"foo": add}.ok +{"foo": add}?.Bar +{"foo": add}?.Qux {"foo": add}?.String -{"foo": add}?.array {"foo": add}?.div +{"foo": add}?.f32 +{"foo": add}?.foo {"foo": add}?.greet {"foo": add}?.half -{"foo": add}?.i32 -{"foo": add}?.ok -{"foo": array, "bar": "foo"}?.f32 -{"foo": array, "bar": f64} -{"foo": array, "bar": greet} -{"foo": array, "bar": list}?.f32 -{"foo": array, "bar": ok} -{"foo": array, "foo": add} -{"foo": array, "foo": greet} -{"foo": array, "foo": true}?.i +{"foo": add}?.i +{"foo": add}?.i64 +{"foo": add}?.score +{"foo": array, "bar": "bar"}.add +{"foo": array, "bar": 0.5}?.div +{"foo": array, "bar": add}.ok +{"foo": array, "bar": array}.f32 +{"foo": array, "bar": i64}?.add +{"foo": array, "bar": list} +{"foo": array, "bar": nil}.half +{"foo": array, "bar": ok, "bar": i} +{"foo": array, "foo": "foo"}.array +{"foo": array, "foo": array} +{"foo": array, "foo": f32, "foo": half}.ok +{"foo": array, "foo": f64} +{"foo": array, "foo": list} {"foo": array} +{"foo": array}.Bar {"foo": array}.Qux -{"foo": array}.Qux?.String -{"foo": array}.String -{"foo": array}.f64 +{"foo": array}.f32 +{"foo": array}.foo {"foo": array}.greet +{"foo": array}.i {"foo": array}.i32 -{"foo": array}.ok -{"foo": array}?.Bar -{"foo": array}?.String +{"foo": array}.i64 +{"foo": array}.score +{"foo": array}?.Qux {"foo": array}?.add {"foo": array}?.array -{"foo": array}?.div -{"foo": array}?.f64 -{"foo": array}?.half +{"foo": array}?.greet +{"foo": array}?.i64?.add +{"foo": array}?.list {"foo": array}?.ok -{"foo": div, "bar": 1}?.add -{"foo": div, "bar": add} -{"foo": div, "bar": div} -{"foo": div, "bar": half}.half -{"foo": div, "bar": list, "bar": 0.5}?.Qux -{"foo": div, "foo": array}.Bar -{"foo": div, "foo": true}?.Qux +{"foo": div, "bar": "foo"}.array +{"foo": div, "bar": array} +{"foo": div, "bar": foo, "foo": true}?.i64 +{"foo": div, "bar": half} +{"foo": div, "bar": i64} +{"foo": div, "foo": array} +{"foo": div, "foo": f32} +{"foo": div, "foo": greet}?.i64 {"foo": div} {"foo": div}.Qux {"foo": div}.array {"foo": div}.div -{"foo": div}.foo -{"foo": div}.greet +{"foo": div}.f32 +{"foo": div}.greet?.i +{"foo": div}.i32 +{"foo": div}.i64 {"foo": div}?.Bar {"foo": div}?.Qux {"foo": div}?.String -{"foo": div}?.add -{"foo": div}?.f64 +{"foo": div}?.div +{"foo": div}?.greet {"foo": div}?.half -{"foo": div}?.i +{"foo": div}?.i32 {"foo": div}?.i64 {"foo": div}?.list -{"foo": div}?.ok -{"foo": f32 != i} -{"foo": f32 - f32} -{"foo": f32 == 0.5} -{"foo": f32, "bar": "bar"}?.String -{"foo": f32, "bar": 0.5}.f32 -{"foo": f32, "bar": i32} -{"foo": f32, "bar": list} -{"foo": f32, "foo": 1, "foo": i32}?.i32 -{"foo": f32, "foo": div} -{"foo": f32, "foo": i} -{"foo": f32, "foo": ok}?.i -{"foo": f32, "foo": type("bar")} +{"foo": div}?.score +{"foo": f32 > 1} +{"foo": f32 >= 1} +{"foo": f32, "bar": 0.5}.list +{"foo": f32, "bar": div} +{"foo": f32, "bar": f32} +{"foo": f32, "bar": f64} +{"foo": f32, "bar": greet}.greet +{"foo": f32, "bar": half} +{"foo": f32, "bar": ok}?.add +{"foo": f32, "bar": score}?.i64 +{"foo": f32, "foo": "foo"}.ok +{"foo": f32, "foo": add}?.half?.f64() +{"foo": f32, "foo": foo}?.half {"foo": f32} -{"foo": f32}.String +{"foo": f32}.Qux {"foo": f32}.add -{"foo": f32}.array {"foo": f32}.f32 {"foo": f32}.foo {"foo": f32}.greet {"foo": f32}.half {"foo": f32}.i {"foo": f32}.i32 +{"foo": f32}.i64 {"foo": f32}.list +{"foo": f32}.score?.greet {"foo": f32}?.Bar -{"foo": f32}?.Qux -{"foo": f32}?.add -{"foo": f32}?.f32 -{"foo": f32}?.f64 -{"foo": f32}?.half -{"foo": f32}?.i32 -{"foo": f32}?.score -{"foo": f64 * i} -{"foo": f64 / 1} -{"foo": f64 == 0.5} -{"foo": f64 >= 1} -{"foo": f64 ^ f32} -{"foo": f64, "bar": "foo"}.Qux -{"foo": f64, "bar": "foo"}.add -{"foo": f64, "bar": 0.5}.div -{"foo": f64, "bar": div} -{"foo": f64, "bar": greet} -{"foo": f64, "bar": half}?.list -{"foo": f64, "bar": ok}.half -{"foo": f64, "foo": foo, "bar": greet}.String -{"foo": f64, "foo": foo, "foo": "foo"}.Bar -{"foo": f64, "foo": greet} -{"foo": f64, "foo": ok, "foo": i64}?.f64 +{"foo": f32}?.String +{"foo": f32}?.array +{"foo": f32}?.f64?.i +{"foo": f32}?.i +{"foo": f32}?.ok +{"foo": f64 < f64} +{"foo": f64 > f32} +{"foo": f64 >= 0.5} +{"foo": f64 >= f32} +{"foo": f64 in array} +{"foo": f64, "bar": 0.5}.greet +{"foo": f64, "bar": add, "foo": greet}.Bar +{"foo": f64, "bar": list}.i64 +{"foo": f64, "bar": sum(array)} +{"foo": f64, "bar": true}?.greet +{"foo": f64, "foo": list, "foo": i}?.add {"foo": f64} +{"foo": f64}.Bar {"foo": f64}.Qux -{"foo": f64}.String?.f32 -{"foo": f64}.String?.i64 -{"foo": f64}.add -{"foo": f64}.array +{"foo": f64}.div +{"foo": f64}.f32 {"foo": f64}.f64 -{"foo": f64}.foo {"foo": f64}.greet -{"foo": f64}.i +{"foo": f64}.i32 {"foo": f64}.list -{"foo": f64}?.Bar +{"foo": f64}.ok {"foo": f64}?.String -{"foo": f64}?.div {"foo": f64}?.f32 {"foo": f64}?.f64 {"foo": f64}?.foo {"foo": f64}?.greet -{"foo": f64}?.i +{"foo": f64}?.i32 +{"foo": f64}?.i64 {"foo": f64}?.ok -{"foo": false, "foo": greet}?.add -{"foo": false, "foo": ok}.score -{"foo": false}.Bar +{"foo": f64}?.ok?.ok +{"foo": f64}?.score +{"foo": false or false}.array +{"foo": false, "bar": 0.5, "foo": add}.score +{"foo": false, "foo": foo, "bar": half}.array +{"foo": false, "foo": score, "foo": nil}?.div +{"foo": false, "foo": true}?.i32 {"foo": false}.array -{"foo": false}.div -{"foo": false}.half {"foo": false}.i -{"foo": false}?.array +{"foo": false}.ok {"foo": false}?.f32 {"foo": false}?.f64 -{"foo": false}?.foo -{"foo": false}?.i64 {"foo": false}?.list -{"foo": foo, "bar": add, "foo": foo}.Bar -{"foo": foo, "bar": ok, "foo": array}.String -{"foo": foo, "foo": foo} -{"foo": foo, "foo": list, "foo": greet}.i -{"foo": foo, "foo": nil}?.f32 -{"foo": foo, "foo": true}?.array +{"foo": foo == nil} +{"foo": foo, "bar": div} +{"foo": foo, "bar": foo} +{"foo": foo, "bar": ok}.i32 +{"foo": foo, "bar": {"foo": 1}} +{"foo": foo, "foo": add} +{"foo": foo, "foo": half} +{"foo": foo, "foo": i} +{"foo": foo, "foo": ok} +{"foo": foo, "foo": score, "foo": f64}.i +{"foo": foo.Bar} +{"foo": foo.String, "bar": foo} +{"foo": foo.String} +{"foo": foo?.Bar} {"foo": foo?.Qux} +{"foo": foo?.String()} +{"foo": foo?.String} {"foo": foo} -{"foo": foo}.div -{"foo": foo}.f64 +{"foo": foo}.Bar?.Bar +{"foo": foo}.Qux +{"foo": foo}.String +{"foo": foo}.String?.String +{"foo": foo}.f32 {"foo": foo}.greet -{"foo": foo}.list -{"foo": foo}.ok -{"foo": foo}.score -{"foo": foo}?.String +{"foo": foo}.half +{"foo": foo}.i64 +{"foo": foo}?.Qux +{"foo": foo}?.add {"foo": foo}?.array -{"foo": foo}?.div -{"foo": foo}?.f32 -{"foo": foo}?.foo +{"foo": foo}?.array?.Bar +{"foo": foo}?.f64 {"foo": foo}?.greet -{"foo": foo}?.half +{"foo": foo}?.i32 {"foo": foo}?.list {"foo": foo}?.ok -{"foo": get(array, i32)}?.i64 -{"foo": greet, "bar": 0.5, "bar": "foo"}?.half -{"foo": greet, "bar": 0.5}.Bar -{"foo": greet, "bar": f64} -{"foo": greet, "bar": f64}.list -{"foo": greet, "bar": i, "foo": foo}?.f32 -{"foo": greet, "foo": "bar", "foo": score}.i -{"foo": greet, "foo": f32} +{"foo": greet("foo")} +{"foo": greet, "bar": "bar"}?.i32 +{"foo": greet, "bar": i64} +{"foo": greet, "bar": i}.list +{"foo": greet, "foo": add}.String +{"foo": greet, "foo": nil}?.add {"foo": greet} +{"foo": greet}.Bar {"foo": greet}.Qux {"foo": greet}.String {"foo": greet}.add {"foo": greet}.array -{"foo": greet}.f32?.greet -{"foo": greet}.half?.greet +{"foo": greet}.f32 +{"foo": greet}.i +{"foo": greet}.i32 {"foo": greet}.i64 -{"foo": greet}.list +{"foo": greet}.i64?.greet {"foo": greet}.ok -{"foo": greet}?.add +{"foo": greet}.score +{"foo": greet}?.Qux {"foo": greet}?.array +{"foo": greet}?.div {"foo": greet}?.f32 -{"foo": greet}?.half +{"foo": greet}?.f64 {"foo": greet}?.i32 {"foo": greet}?.i64 {"foo": greet}?.list +{"foo": greet}?.ok {"foo": greet}?.score -{"foo": half(0.5)} -{"foo": half(f64)} -{"foo": half, "bar": 1}?.half -{"foo": half, "bar": add}?.foo -{"foo": half, "bar": f32}.i32 -{"foo": half, "bar": foo} -{"foo": half, "bar": half} -{"foo": half, "bar": i64, "bar": i32}.foo -{"foo": half, "bar": i64} -{"foo": half, "bar": nil}?.ok -{"foo": half, "foo": 1}?.ok -{"foo": half, "foo": div} -{"foo": half, "foo": greet, "bar": f32}?.add -{"foo": half, "foo": true}.f64 +{"foo": groupBy(array, 1)} +{"foo": groupBy(list, #)} +{"foo": half, "bar": "foo"}?.half +{"foo": half, "bar": add, "foo": true}?.array +{"foo": half, "bar": array}.half +{"foo": half, "bar": greet}?.half +{"foo": half, "bar": half}?.i +{"foo": half, "bar": list, "foo": 1}?.f64 +{"foo": half, "bar": list} +{"foo": half, "bar": true}?.Qux +{"foo": half, "foo": 1}?.i32 +{"foo": half, "foo": div, "foo": array}?.i32 +{"foo": half, "foo": f64} +{"foo": half, "foo": list, "foo": half}.half +{"foo": half, "foo": score, "foo": list}.String {"foo": half} {"foo": half}.Bar {"foo": half}.String +{"foo": half}.add {"foo": half}.div -{"foo": half}.f64 -{"foo": half}.greet +{"foo": half}.f32 +{"foo": half}.foo {"foo": half}.half {"foo": half}.i -{"foo": half}.i32 +{"foo": half}.i64 {"foo": half}.ok +{"foo": half}.score {"foo": half}?.Bar {"foo": half}?.Qux -{"foo": half}?.add -{"foo": half}?.f64 +{"foo": half}?.String +{"foo": half}?.div +{"foo": half}?.f32 {"foo": half}?.foo -{"foo": half}?.greet -{"foo": half}?.half -{"foo": half}?.list +{"foo": half}?.i32 +{"foo": half}?.i64 {"foo": half}?.score -{"foo": hasPrefix("bar", "foo")} -{"foo": i < f64} -{"foo": i > 0.5} -{"foo": i, "bar": score} -{"foo": i, "foo": i}.i64 -{"foo": i, "foo": ok} -{"foo": i, "foo": ok}?.ok -{"foo": i32, "bar": 0.5, "foo": array}.Bar -{"foo": i32, "bar": i32}.i64 -{"foo": i32, "bar": nil}?.i64 -{"foo": i32, "foo": 0.5}.i -{"foo": i32, "foo": add} -{"foo": i32, "foo": div, "foo": nil}.Bar -{"foo": i32, "foo": foo} -{"foo": i32, "foo": greet}?.foo -{"foo": i32, "foo": i32}?.score -{"foo": i32, "foo": ok, "bar": true}.f32 -{"foo": i32, "foo": ok}?.i32 +{"foo": i != 1} +{"foo": i - f64} +{"foo": i / 1} +{"foo": i ^ 1} +{"foo": i, "bar": 0.5}?.half +{"foo": i, "bar": f32} +{"foo": i, "bar": foo} +{"foo": i, "bar": list}.foo +{"foo": i, "foo": "bar"}?.div?.f32 +{"foo": i, "foo": 1}.list +{"foo": i, "foo": 1}?.list +{"foo": i, "foo": add} +{"foo": i, "foo": array, "bar": 0.5}?.f32 +{"foo": i, "foo": half}?.list +{"foo": i, "foo": score} +{"foo": i, "foo": score}?.f32 +{"foo": i32 != i} +{"foo": i32 * 0.5} +{"foo": i32 + 1} +{"foo": i32 - f32}.foo +{"foo": i32 - f64} +{"foo": i32 / 1} +{"foo": i32 < 1} +{"foo": i32, "bar": 0.5, "bar": foo}.i64 +{"foo": i32, "bar": foo}?.score +{"foo": i32, "bar": nil}?.ok +{"foo": i32, "foo": false, "bar": f32}?.foo +{"foo": i32, "foo": greet}?.greet {"foo": i32} -{"foo": i32}.Bar -{"foo": i32}.Qux -{"foo": i32}.i64 -{"foo": i32}.list +{"foo": i32}.i {"foo": i32}.ok -{"foo": i32}.score {"foo": i32}?.Bar -{"foo": i32}?.Qux +{"foo": i32}?.String {"foo": i32}?.add -{"foo": i32}?.div {"foo": i32}?.f32 -{"foo": i32}?.greet -{"foo": i32}?.half +{"foo": i32}?.f64 {"foo": i32}?.i +{"foo": i32}?.i32 {"foo": i32}?.i64 +{"foo": i32}?.list {"foo": i32}?.score -{"foo": i64 * f64, "foo": i64} -{"foo": i64 <= 0.5} -{"foo": i64 ^ i32} -{"foo": i64, "bar": "bar"}.Qux -{"foo": i64, "bar": array}.add -{"foo": i64, "bar": div} -{"foo": i64, "bar": f64, "bar": greet}.f32 -{"foo": i64, "bar": list} -{"foo": i64, "foo": 0.5, "bar": 0.5}.half -{"foo": i64, "foo": div} -{"foo": i64, "foo": i32} +{"foo": i64 % 1} +{"foo": i64 * f32} +{"foo": i64 .. i64} +{"foo": i64, "bar": array} +{"foo": i64, "foo": array}.f32 +{"foo": i64, "foo": f32} +{"foo": i64, "foo": i32}?.foo +{"foo": i64, "foo": i64, "bar": f64}.foo +{"foo": i64, "foo": i64} +{"foo": i64, "foo": i64}.greet +{"foo": i64, "foo": i64}?.foo {"foo": i64} -{"foo": i64}.Qux -{"foo": i64}.add +{"foo": i64}.Bar {"foo": i64}.array +{"foo": i64}.div +{"foo": i64}.foo +{"foo": i64}.greet +{"foo": i64}.half +{"foo": i64}.i +{"foo": i64}.i32 +{"foo": i64}.list {"foo": i64}?.Qux -{"foo": i64}?.String +{"foo": i64}?.add +{"foo": i64}?.array {"foo": i64}?.f32 -{"foo": i64}?.foo -{"foo": i64}?.greet +{"foo": i64}?.f64 +{"foo": i64}?.half {"foo": i64}?.i32 -{"foo": i64}?.list -{"foo": i64}?.score +{"foo": i64}?.i32?.f32 +{"foo": i64}?.i64 +{"foo": i64}?.score?.list +{"foo": int(i)} +{"foo": int(i32)} +{"foo": int(i64)} {"foo": i} {"foo": i}.Bar {"foo": i}.String -{"foo": i}.div -{"foo": i}.foo +{"foo": i}.add +{"foo": i}.array +{"foo": i}.f64 {"foo": i}.greet -{"foo": i}.i32?.add +{"foo": i}.i {"foo": i}.ok -{"foo": i}.score -{"foo": i}?.Bar -{"foo": i}?.array {"foo": i}?.div -{"foo": i}?.f64 -{"foo": i}?.foo -{"foo": i}?.half +{"foo": i}?.greet +{"foo": i}?.i +{"foo": i}?.i32 {"foo": i}?.i64 {"foo": i}?.score -{"foo": list == list}.f32 -{"foo": list, "bar": f32, "foo": i32}.i32 -{"foo": list, "bar": foo}?.list -{"foo": list, "bar": i64} -{"foo": list, "bar": score} -{"foo": list, "foo": score} +{"foo": last(list)} +{"foo": len(list)} +{"foo": list, "bar": add} +{"foo": list, "bar": all(list, false)} +{"foo": list, "bar": array} +{"foo": list, "bar": f32}.f64 +{"foo": list, "bar": half} +{"foo": list, "bar": i32, "bar": score}.array +{"foo": list, "bar": true}?.foo {"foo": list} -{"foo": list}.Bar +{"foo": list}.Qux {"foo": list}.String {"foo": list}.add {"foo": list}.div -{"foo": list}.foo +{"foo": list}.f32 +{"foo": list}.greet {"foo": list}.half +{"foo": list}.i {"foo": list}.i32 -{"foo": list}.score -{"foo": list}?.add +{"foo": list}?.String {"foo": list}?.div +{"foo": list}?.f32 +{"foo": list}?.foo {"foo": list}?.i +{"foo": list}?.i32 {"foo": list}?.i64 {"foo": list}?.ok +{"foo": list}?.score {"foo": map(array, #)} -{"foo": map(array, 0.5)} -{"foo": map(array, foo)} -{"foo": map(array, ok), "bar": i32} -{"foo": map(list, 0.5)} -{"foo": map(list, score)} -{"foo": min(0.5)} -{"foo": min(1)}?.f32 -{"foo": nil == 0.5} -{"foo": nil, "bar": 0.5}.score -{"foo": nil, "bar": add}?.array -{"foo": nil, "bar": div}.Bar -{"foo": nil, "bar": f64, "foo": div}.i32 -{"foo": nil, "bar": greet}?.add -{"foo": nil, "bar": i64}?.i64 -{"foo": nil, "bar": list}?.i32 -{"foo": nil, "foo": "foo"}.add -{"foo": nil, "foo": 1}.score -{"foo": nil, "foo": false}?.add -{"foo": nil, "foo": i64}.add -{"foo": nil}.Bar -{"foo": nil}.Qux -{"foo": nil}.String -{"foo": nil}.array +{"foo": map(array, i64)} +{"foo": nil, "bar": 0.5}.ok +{"foo": nil, "bar": add, "bar": f32}?.list +{"foo": nil, "bar": div, "bar": 1}.i64 +{"foo": nil, "bar": f32}.score +{"foo": nil, "bar": foo}?.String +{"foo": nil, "bar": score}?.ok?.div +{"foo": nil, "foo": "foo"}.Bar +{"foo": nil, "foo": greet}.String +{"foo": nil, "foo": half}.f64 +{"foo": nil, "foo": i64, "bar": f64}?.list +{"foo": nil, "foo": i}.div +{"foo": nil, "foo": list}.add +{"foo": nil, "foo": list}?.array +{"foo": nil, "foo": nil}.ok +{"foo": nil}.array?.half() {"foo": nil}.div {"foo": nil}.f32 {"foo": nil}.f64 -{"foo": nil}.greet?.i() -{"foo": nil}.greet?.i32 {"foo": nil}.half {"foo": nil}.i -{"foo": nil}.i64 +{"foo": nil}.i32 +{"foo": nil}.i64?.Bar() {"foo": nil}.list +{"foo": nil}.ok +{"foo": nil}.score {"foo": nil}?.Bar -{"foo": nil}?.Qux -{"foo": nil}?.String +{"foo": nil}?.Bar?.score +{"foo": nil}?.add {"foo": nil}?.array -{"foo": nil}?.div -{"foo": nil}?.f32?.ok -{"foo": nil}?.greet +{"foo": nil}?.f64 +{"foo": nil}?.foo +{"foo": nil}?.half {"foo": nil}?.i32 -{"foo": nil}?.i?.half +{"foo": nil}?.i64 {"foo": nil}?.list -{"foo": nil}?.list?.greet() -{"foo": nil}?.score -{"foo": not false} -{"foo": not ok} -{"foo": ok && ok} -{"foo": ok == nil} -{"foo": ok ? true : div} +{"foo": ok == false} +{"foo": ok, "bar": "foo"}?.i64 +{"foo": ok, "bar": add}.String {"foo": ok, "bar": f32} -{"foo": ok, "bar": i, "foo": greet}.i32 -{"foo": ok, "bar": i32} -{"foo": ok, "foo": 0.5}?.array -{"foo": ok, "foo": 1}.Qux -{"foo": ok, "foo": half, "bar": div}.score -{"foo": ok, "foo": i64} -{"foo": ok, "foo": i64}.i -{"foo": ok, "foo": nil}?.add +{"foo": ok, "foo": half}.ok +{"foo": ok, "foo": list} {"foo": ok} {"foo": ok}.Bar -{"foo": ok}.add +{"foo": ok}.Bar?.i +{"foo": ok}.String +{"foo": ok}.array {"foo": ok}.div {"foo": ok}.f64 -{"foo": ok}.greet -{"foo": ok}.i -{"foo": ok}.score +{"foo": ok}.foo +{"foo": ok}.i32 +{"foo": ok}.i64 +{"foo": ok}.ok {"foo": ok}?.Qux {"foo": ok}?.String -{"foo": ok}?.div +{"foo": ok}?.String?.Bar +{"foo": ok}?.array {"foo": ok}?.f32 +{"foo": ok}?.foo {"foo": ok}?.greet -{"foo": ok}?.half?.half +{"foo": ok}?.half {"foo": ok}?.i32 {"foo": ok}?.i64 {"foo": ok}?.list -{"foo": score(1)} -{"foo": score, "bar": 0.5}.list -{"foo": score, "bar": 1 ^ 1} -{"foo": score, "bar": i32} -{"foo": score, "bar": i64} -{"foo": score, "foo": 0.5}.add -{"foo": score, "foo": 1}?.div -{"foo": score, "foo": add, "bar": ok} -{"foo": score, "foo": f32, "bar": false}.div -{"foo": score, "foo": f32}?.i32 -{"foo": score, "foo": i}?.f32 -{"foo": score} -{"foo": score}.Bar -{"foo": score}.array -{"foo": score}.list -{"foo": score}?.Bar -{"foo": score}?.String -{"foo": score}?.add -{"foo": score}?.f32 -{"foo": score}?.greet -{"foo": score}?.half -{"foo": score}?.i -{"foo": score}?.list -{"foo": score}?.score -{"foo": string(i32)} -{"foo": string(list)} -{"foo": toBase64("bar")} -{"foo": toJSON(f32)} -{"foo": toJSON(i64)}?.i32 -{"foo": toJSON(nil)} -{"foo": true, "bar": false}?.array -{"foo": true, "bar": nil}?.div -{"foo": true, "bar": true}.f64 -{"foo": true, "foo": array, "bar": i32}?.ok -{"foo": true, "foo": i32}.i64 -{"foo": true, "foo": ok, "foo": add}.foo -{"foo": true}.String -{"foo": true}.f32 -{"foo": true}.foo -{"foo": true}.i -{"foo": true}.i64 -{"foo": true}?.String -{"foo": true}?.greet -{"foo": true}?.i32 -{"foo": type(1)} -{"foo": type(list)} -{"foo": type(nil)} -{"foo": type(ok)} +{"foo": reduce(array, "foo")} +{"foo": reduce(array, #)} +{"foo": reduce(list, #).String()} +{"foo": reduce(list, #)} +{"foo": reduce(list, #)}?.list +{"foo": score, "bar": add}.add +{"foo": score, "bar": div} +{"foo": score, "bar": f64} +{"foo": score, "bar": false}?.array +{"foo": score, "bar": false}?.i +{"foo": score, "bar": true}.div?.i +{"foo": score, "foo": 0.5}?.String +{"foo": score, "foo": 1}.array +{"foo": score, "foo": add} +{"foo": score, "foo": array}.array +{"foo": score, "foo": f32} +{"foo": score, "foo": greet} diff --git a/test/fuzz/fuzz_test.go b/test/fuzz/fuzz_test.go index f1844b2f7..78f910db9 100644 --- a/test/fuzz/fuzz_test.go +++ b/test/fuzz/fuzz_test.go @@ -51,6 +51,9 @@ func FuzzExpr(f *testing.F) { regexp.MustCompile(`cannot parse .* as .*`), regexp.MustCompile(`operator "in" not defined on .*`), regexp.MustCompile(`cannot sum .*`), + regexp.MustCompile(`index out of range: .* \(array length is .*\)`), + regexp.MustCompile(`cannot use as argument \(type .*\) to call .*`), + regexp.MustCompile(`illegal base64 data at input byte .*`), } env := NewEnv() From 29dff34ad1fcc78c2d6081471433fbfb0d0827e9 Mon Sep 17 00:00:00 2001 From: Anton Medvedev Date: Sat, 8 Mar 2025 17:01:31 +0100 Subject: [PATCH 061/113] Make all builtins working with deref Fixes #730 --- builtin/builtin.go | 41 ++++++++++++++++++++----------------- builtin/builtin_test.go | 45 ++++++++++++++++++++++++++++++++++------- builtin/lib.go | 23 +++++++-------------- builtin/utils.go | 3 +++ internal/deref/deref.go | 4 ++++ 5 files changed, 74 insertions(+), 42 deletions(-) diff --git a/builtin/builtin.go b/builtin/builtin.go index f4a14ce58..27400a25b 100644 --- a/builtin/builtin.go +++ b/builtin/builtin.go @@ -164,7 +164,7 @@ var Builtins = []*Function{ if len(args) != 1 { return anyType, fmt.Errorf("invalid number of arguments (expected 1, got %d)", len(args)) } - switch kind(deref.Type(args[0])) { + switch kind(args[0]) { case reflect.Interface: return integerType, nil case reflect.Float32, reflect.Float64, reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64, reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64: @@ -642,18 +642,21 @@ var Builtins = []*Function{ if len(args) != 2 { return nil, fmt.Errorf("invalid number of arguments (expected 2, got %d)", len(args)) } - v := reflect.ValueOf(args[0]) + v := deref.ValueOf(args[0]) if v.Kind() != reflect.Slice && v.Kind() != reflect.Array { return nil, fmt.Errorf("cannot take from %s", v.Kind()) } - n := reflect.ValueOf(args[1]) + n := deref.ValueOf(args[1]) if !n.CanInt() { return nil, fmt.Errorf("cannot take %s elements", n.Kind()) } + to := 0 if n.Int() > int64(v.Len()) { - return args[0], nil + to = v.Len() + } else { + to = int(n.Int()) } - return v.Slice(0, int(n.Int())).Interface(), nil + return v.Slice(0, to).Interface(), nil }, Validate: func(args []reflect.Type) (reflect.Type, error) { if len(args) != 2 { @@ -678,7 +681,7 @@ var Builtins = []*Function{ if len(args) != 1 { return nil, fmt.Errorf("invalid number of arguments (expected 1, got %d)", len(args)) } - v := reflect.ValueOf(args[0]) + v := deref.ValueOf(args[0]) if v.Kind() != reflect.Map { return nil, fmt.Errorf("cannot get keys from %s", v.Kind()) } @@ -708,7 +711,7 @@ var Builtins = []*Function{ if len(args) != 1 { return nil, fmt.Errorf("invalid number of arguments (expected 1, got %d)", len(args)) } - v := reflect.ValueOf(args[0]) + v := deref.ValueOf(args[0]) if v.Kind() != reflect.Map { return nil, fmt.Errorf("cannot get values from %s", v.Kind()) } @@ -738,7 +741,7 @@ var Builtins = []*Function{ if len(args) != 1 { return nil, fmt.Errorf("invalid number of arguments (expected 1, got %d)", len(args)) } - v := reflect.ValueOf(args[0]) + v := deref.ValueOf(args[0]) if v.Kind() != reflect.Map { return nil, fmt.Errorf("cannot transform %s to pairs", v.Kind()) } @@ -766,7 +769,7 @@ var Builtins = []*Function{ if len(args) != 1 { return nil, fmt.Errorf("invalid number of arguments (expected 1, got %d)", len(args)) } - v := reflect.ValueOf(args[0]) + v := deref.ValueOf(args[0]) if v.Kind() != reflect.Slice && v.Kind() != reflect.Array { return nil, fmt.Errorf("cannot transform %s from pairs", v) } @@ -798,14 +801,14 @@ var Builtins = []*Function{ }, { Name: "reverse", - Func: func(args ...any) (any, error) { + Safe: func(args ...any) (any, uint, error) { if len(args) != 1 { - return nil, fmt.Errorf("invalid number of arguments (expected 1, got %d)", len(args)) + return nil, 0, fmt.Errorf("invalid number of arguments (expected 1, got %d)", len(args)) } - v := reflect.ValueOf(args[0]) + v := deref.ValueOf(args[0]) if v.Kind() != reflect.Slice && v.Kind() != reflect.Array { - return nil, fmt.Errorf("cannot reverse %s", v.Kind()) + return nil, 0, fmt.Errorf("cannot reverse %s", v.Kind()) } size := v.Len() @@ -815,7 +818,7 @@ var Builtins = []*Function{ arr[i] = v.Index(size - i - 1).Interface() } - return arr, nil + return arr, uint(size), nil }, Validate: func(args []reflect.Type) (reflect.Type, error) { @@ -838,7 +841,7 @@ var Builtins = []*Function{ return nil, fmt.Errorf("invalid number of arguments (expected 1, got %d)", len(args)) } - v := reflect.ValueOf(deref.Deref(args[0])) + v := deref.ValueOf(deref.Deref(args[0])) if v.Kind() != reflect.Array && v.Kind() != reflect.Slice { return nil, fmt.Errorf("cannot uniq %s", v.Kind()) } @@ -892,7 +895,7 @@ var Builtins = []*Function{ var arr []any for _, arg := range args { - v := reflect.ValueOf(deref.Deref(arg)) + v := deref.ValueOf(deref.Deref(arg)) if v.Kind() != reflect.Slice && v.Kind() != reflect.Array { return nil, 0, fmt.Errorf("cannot concat %s", v.Kind()) @@ -914,7 +917,7 @@ var Builtins = []*Function{ } for _, arg := range args { - switch kind(deref.Type(arg)) { + switch kind(arg) { case reflect.Interface, reflect.Slice, reflect.Array: default: return anyType, fmt.Errorf("cannot concat %s", arg) @@ -931,7 +934,7 @@ var Builtins = []*Function{ if len(args) != 1 { return nil, 0, fmt.Errorf("invalid number of arguments (expected 1, got %d)", len(args)) } - v := reflect.ValueOf(deref.Deref(args[0])) + v := deref.ValueOf(deref.Deref(args[0])) if v.Kind() != reflect.Array && v.Kind() != reflect.Slice { return nil, size, fmt.Errorf("cannot flatten %s", v.Kind()) } @@ -945,7 +948,7 @@ var Builtins = []*Function{ } for _, arg := range args { - switch kind(deref.Type(arg)) { + switch kind(arg) { case reflect.Interface, reflect.Slice, reflect.Array: default: return anyType, fmt.Errorf("cannot flatten %s", arg) diff --git a/builtin/builtin_test.go b/builtin/builtin_test.go index 6427c1aec..0620f0c45 100644 --- a/builtin/builtin_test.go +++ b/builtin/builtin_test.go @@ -639,15 +639,46 @@ func Test_int_unwraps_underlying_value(t *testing.T) { assert.Equal(t, true, out) } -func TestBuiltin_int_with_deref(t *testing.T) { +func TestBuiltin_with_deref(t *testing.T) { x := 42 + arr := []any{1, 2, 3} + m := map[string]any{"a": 1, "b": 2} env := map[string]any{ - "x": &x, + "x": &x, + "arr": &arr, + "m": &m, } - program, err := expr.Compile(`int(x)`, expr.Env(env)) - require.NoError(t, err) - out, err := expr.Run(program, env) - require.NoError(t, err) - assert.Equal(t, 42, out) + tests := []struct { + input string + want any + }{ + {`int(x)`, 42}, + {`float(x)`, 42.0}, + {`abs(x)`, 42}, + {`first(arr)`, 1}, + {`last(arr)`, 3}, + {`take(arr, 1)`, []any{1}}, + {`take(arr, x)`, []any{1, 2, 3}}, + {`'a' in keys(m)`, true}, + {`1 in values(m)`, true}, + {`len(arr)`, 3}, + {`type(arr)`, "array"}, + {`type(m)`, "map"}, + {`reverse(arr)`, []any{3, 2, 1}}, + {`uniq(arr)`, []any{1, 2, 3}}, + {`concat(arr, arr)`, []any{1, 2, 3, 1, 2, 3}}, + {`flatten([arr, [arr]])`, []any{1, 2, 3, 1, 2, 3}}, + } + + for _, test := range tests { + t.Run(test.input, func(t *testing.T) { + program, err := expr.Compile(test.input, expr.Env(env)) + require.NoError(t, err) + + out, err := expr.Run(program, env) + require.NoError(t, err) + assert.Equal(t, test.want, out) + }) + } } diff --git a/builtin/lib.go b/builtin/lib.go index 34131dfc0..5547bc094 100644 --- a/builtin/lib.go +++ b/builtin/lib.go @@ -11,7 +11,7 @@ import ( ) func Len(x any) any { - v := reflect.ValueOf(x) + v := deref.ValueOf(x) switch v.Kind() { case reflect.Array, reflect.Slice, reflect.Map: return v.Len() @@ -26,16 +26,7 @@ func Type(arg any) any { if arg == nil { return "nil" } - v := reflect.ValueOf(arg) - for { - if v.Kind() == reflect.Ptr { - v = v.Elem() - } else if v.Kind() == reflect.Interface { - v = v.Elem() - } else { - break - } - } + v := deref.ValueOf(arg) if v.Type().Name() != "" && v.Type().PkgPath() != "" { return fmt.Sprintf("%s.%s", v.Type().PkgPath(), v.Type().Name()) } @@ -66,7 +57,7 @@ func Type(arg any) any { } func Abs(x any) any { - switch x := x.(type) { + switch x := deref.Deref(x).(type) { case float32: if x < 0 { return -x @@ -221,7 +212,7 @@ func Int(x any) any { } func Float(x any) any { - switch x := x.(type) { + switch x := deref.Deref(x).(type) { case float32: return float64(x) case float64: @@ -264,7 +255,7 @@ func String(arg any) any { func minMax(name string, fn func(any, any) bool, args ...any) (any, error) { var val any for _, arg := range args { - rv := reflect.ValueOf(deref.Deref(arg)) + rv := deref.ValueOf(arg) switch rv.Kind() { case reflect.Array, reflect.Slice: size := rv.Len() @@ -307,7 +298,7 @@ func mean(args ...any) (int, float64, error) { var count int for _, arg := range args { - rv := reflect.ValueOf(deref.Deref(arg)) + rv := deref.ValueOf(arg) switch rv.Kind() { case reflect.Array, reflect.Slice: size := rv.Len() @@ -339,7 +330,7 @@ func median(args ...any) ([]float64, error) { var values []float64 for _, arg := range args { - rv := reflect.ValueOf(deref.Deref(arg)) + rv := deref.ValueOf(arg) switch rv.Kind() { case reflect.Array, reflect.Slice: size := rv.Len() diff --git a/builtin/utils.go b/builtin/utils.go index 29a95731a..262bb379d 100644 --- a/builtin/utils.go +++ b/builtin/utils.go @@ -4,6 +4,8 @@ import ( "fmt" "reflect" "time" + + "github.com/expr-lang/expr/internal/deref" ) var ( @@ -20,6 +22,7 @@ func kind(t reflect.Type) reflect.Kind { if t == nil { return reflect.Invalid } + t = deref.Type(t) return t.Kind() } diff --git a/internal/deref/deref.go b/internal/deref/deref.go index acdc89811..5e0e0b04e 100644 --- a/internal/deref/deref.go +++ b/internal/deref/deref.go @@ -45,3 +45,7 @@ func Value(v reflect.Value) reflect.Value { } return v } + +func ValueOf(v any) reflect.Value { + return Value(reflect.ValueOf(v)) +} From 4511e92881c25d58ffb257c58ba427ea257c7e43 Mon Sep 17 00:00:00 2001 From: Anton Medvedev Date: Sat, 8 Mar 2025 17:11:49 +0100 Subject: [PATCH 062/113] Remove pointer accessor check in parser --- parser/parser.go | 4 ---- parser/parser_test.go | 3 --- 2 files changed, 7 deletions(-) diff --git a/parser/parser.go b/parser/parser.go index febfb051a..af2776c89 100644 --- a/parser/parser.go +++ b/parser/parser.go @@ -385,10 +385,6 @@ func (p *parser) parsePrimary() Node { } return p.parsePostfixExpression(node) } - } else { - if token.Is(Operator, "#") || token.Is(Operator, ".") { - p.error("cannot use pointer accessor outside predicate") - } } if token.Is(Operator, "::") { diff --git a/parser/parser_test.go b/parser/parser_test.go index 3a7bb461a..4e373ff50 100644 --- a/parser/parser_test.go +++ b/parser/parser_test.go @@ -875,9 +875,6 @@ func TestParse_error(t *testing.T) { {`foo({.bar})`, `a map key must be a quoted string, a number, a identifier, or an expression enclosed in parentheses (unexpected token Operator(".")) (1:6) | foo({.bar}) | .....^`}, - {`.foo`, `cannot use pointer accessor outside predicate (1:1) - | .foo - | ^`}, {`[1, 2, 3,,]`, `unexpected token Operator(",") (1:10) | [1, 2, 3,,] | .........^`}, From 435b79df38cd6c7687a5b70f7bb66c99a45ab31d Mon Sep 17 00:00:00 2001 From: Anton Medvedev Date: Sat, 8 Mar 2025 17:28:39 +0100 Subject: [PATCH 063/113] Make sure get() returns nil for map[string]string on missing keys Fixes #723 --- builtin/builtin.go | 9 +---- builtin/lib.go | 67 +++++++++++++++++++++++++++++++++++ test/fuzz/fuzz_corpus.txt | 31 ---------------- test/issues/723/issue_test.go | 24 +++++++++++++ testdata/examples.txt | 31 ---------------- 5 files changed, 92 insertions(+), 70 deletions(-) create mode 100644 test/issues/723/issue_test.go diff --git a/builtin/builtin.go b/builtin/builtin.go index 27400a25b..58ce5e4ca 100644 --- a/builtin/builtin.go +++ b/builtin/builtin.go @@ -627,14 +627,7 @@ var Builtins = []*Function{ }, { Name: "get", - Func: func(args ...any) (out any, err error) { - defer func() { - if r := recover(); r != nil { - return - } - }() - return runtime.Fetch(args[0], args[1]), nil - }, + Func: get, }, { Name: "take", diff --git a/builtin/lib.go b/builtin/lib.go index 5547bc094..6c1979d3b 100644 --- a/builtin/lib.go +++ b/builtin/lib.go @@ -8,6 +8,7 @@ import ( "unicode/utf8" "github.com/expr-lang/expr/internal/deref" + "github.com/expr-lang/expr/vm/runtime" ) func Len(x any) any { @@ -367,3 +368,69 @@ func flatten(arg reflect.Value) []any { } return ret } + +func get(params ...any) (out any, err error) { + from := params[0] + i := params[1] + v := reflect.ValueOf(from) + + if v.Kind() == reflect.Invalid { + panic(fmt.Sprintf("cannot fetch %v from %T", i, from)) + } + + // Methods can be defined on any type. + if v.NumMethod() > 0 { + if methodName, ok := i.(string); ok { + method := v.MethodByName(methodName) + if method.IsValid() { + return method.Interface(), nil + } + } + } + + v = deref.Value(v) + i = deref.Deref(i) + + switch v.Kind() { + case reflect.Array, reflect.Slice, reflect.String: + index := runtime.ToInt(i) + l := v.Len() + if index < 0 { + index = l + index + } + if 0 <= index && index < l { + value := v.Index(index) + if value.IsValid() { + return value.Interface(), nil + } + } + + case reflect.Map: + var value reflect.Value + if i == nil { + value = v.MapIndex(reflect.Zero(v.Type().Key())) + } else { + value = v.MapIndex(reflect.ValueOf(i)) + } + if value.IsValid() { + return value.Interface(), nil + } + + case reflect.Struct: + fieldName := i.(string) + value := v.FieldByNameFunc(func(name string) bool { + field, _ := v.Type().FieldByName(name) + if field.Tag.Get("expr") == fieldName { + return true + } + return name == fieldName + }) + if value.IsValid() { + return value.Interface(), nil + } + } + + // Main difference from runtime.Fetch + // is that we return `nil` instead of panic. + return nil, nil +} diff --git a/test/fuzz/fuzz_corpus.txt b/test/fuzz/fuzz_corpus.txt index a7d574275..72afdf6ce 100644 --- a/test/fuzz/fuzz_corpus.txt +++ b/test/fuzz/fuzz_corpus.txt @@ -7088,58 +7088,33 @@ get(false ? i32 : list, i64) get(false ? i64 : true, f64) get(false ? score : ok, trimSuffix("bar", "bar")) get(filter(list, true), i) -get(groupBy(array, "bar"), add) get(groupBy(array, "bar"), i) get(groupBy(array, "bar"), ok) -get(groupBy(array, "foo"), half) -get(groupBy(array, #), add) -get(groupBy(array, #), array) get(groupBy(array, #), f32) get(groupBy(array, #), f64) get(groupBy(array, #), foo) -get(groupBy(array, #), greet) -get(groupBy(array, #), half) get(groupBy(array, #), i) get(groupBy(array, #), i64 * 0.5) get(groupBy(array, #), i64) -get(groupBy(array, #)?.String, i64) -get(groupBy(array, 0.5), add) -get(groupBy(array, 0.5), div) get(groupBy(array, 0.5), ok) -get(groupBy(array, 1), add) get(groupBy(array, 1), f32) get(groupBy(array, f64), i64) get(groupBy(array, false), findIndex(array, ok)) get(groupBy(array, i), ok) -get(groupBy(array, i), score) -get(groupBy(array, i64), add) -get(groupBy(array, ok), add) get(groupBy(array, true), i32) get(groupBy(list, "bar"), i32) -get(groupBy(list, "foo"), greet) -get(groupBy(list, #), div) get(groupBy(list, #), f32 <= f64) get(groupBy(list, #), f32) get(groupBy(list, #), foo) -get(groupBy(list, #), greet) -get(groupBy(list, #), half) get(groupBy(list, #), i) get(groupBy(list, #), i32) get(groupBy(list, #), i64) get(groupBy(list, #), int(f32)) -get(groupBy(list, #), list) get(groupBy(list, #), reduce(array, foo)) get(groupBy(list, #), score(1)) -get(groupBy(list, #), score) -get(groupBy(list, 0.5), array) -get(groupBy(list, 0.5), div) get(groupBy(list, 0.5), ok) get(groupBy(list, 1), i32) -get(groupBy(list, f32), greet) -get(groupBy(list, foo), add) get(groupBy(list, foo), i32) -get(groupBy(list, ok), greet) -get(groupBy(list, ok), list) get(i .. 1, 1 * 1) get(i .. i32, i) get(i32 .. i, i64) @@ -7200,12 +7175,10 @@ get(list, max(i32)) get(list, min(i32)) get(list, min(i64)) get(list, ok ? 0.5 : "foo") -get(list, ok ? array : "foo") get(list, reduce(list, i64)) get(list, score(1)) get(list, score(i)) get(list, true ? i : i32) -get(list, {"foo": i32}?.i) get(list[i64:1], i) get(map(array, #), i) get(map(array, #), i32) @@ -7221,18 +7194,15 @@ get(map(list, 1), i32) get(map(list, array), i) get(map(list, i32), i64) get(map(list, i64), i64) -get(ok ? "bar" : false, array) get(ok ? 1 : "bar", f32) get(ok ? add : f32, array) get(ok ? f64 : div, i64) get(ok ? false : list, f32 > i) -get(ok ? foo : 0.5, div) get(ok ? half : i32, i) get(ok ? half : ok, f64) get(ok ? i : 0.5, half) get(ok ? i32 : half, f64) get(ok ? i64 : foo, f32) -get(ok ? list : "foo", add) get(ok ? list : i32, f32) get(ok ? ok : div, greet) get(ok ? score : f64, i) @@ -7241,7 +7211,6 @@ get(reduce(list, array), i32) get(sort(array), i32) get(take(list, i), i64) get(true ? "bar" : ok, score(i)) -get(true ? "foo" : half, list) get(true ? 0.5 : i32, array) get(true ? f32 : 0.5, ok) get(true ? false : foo, i64 > 0.5) diff --git a/test/issues/723/issue_test.go b/test/issues/723/issue_test.go new file mode 100644 index 000000000..c1dd6585d --- /dev/null +++ b/test/issues/723/issue_test.go @@ -0,0 +1,24 @@ +package issue_test + +import ( + "testing" + + "github.com/expr-lang/expr" + "github.com/expr-lang/expr/internal/testify/require" +) + +func TestIssue723(t *testing.T) { + emptyMap := make(map[string]string) + env := map[string]interface{}{ + "empty_map": emptyMap, + } + + code := `get(empty_map, "non_existing_key")` + + program, err := expr.Compile(code, expr.Env(env)) + require.NoError(t, err) + + output, err := expr.Run(program, env) + require.NoError(t, err) + require.Equal(t, nil, output) +} diff --git a/testdata/examples.txt b/testdata/examples.txt index a7d574275..72afdf6ce 100644 --- a/testdata/examples.txt +++ b/testdata/examples.txt @@ -7088,58 +7088,33 @@ get(false ? i32 : list, i64) get(false ? i64 : true, f64) get(false ? score : ok, trimSuffix("bar", "bar")) get(filter(list, true), i) -get(groupBy(array, "bar"), add) get(groupBy(array, "bar"), i) get(groupBy(array, "bar"), ok) -get(groupBy(array, "foo"), half) -get(groupBy(array, #), add) -get(groupBy(array, #), array) get(groupBy(array, #), f32) get(groupBy(array, #), f64) get(groupBy(array, #), foo) -get(groupBy(array, #), greet) -get(groupBy(array, #), half) get(groupBy(array, #), i) get(groupBy(array, #), i64 * 0.5) get(groupBy(array, #), i64) -get(groupBy(array, #)?.String, i64) -get(groupBy(array, 0.5), add) -get(groupBy(array, 0.5), div) get(groupBy(array, 0.5), ok) -get(groupBy(array, 1), add) get(groupBy(array, 1), f32) get(groupBy(array, f64), i64) get(groupBy(array, false), findIndex(array, ok)) get(groupBy(array, i), ok) -get(groupBy(array, i), score) -get(groupBy(array, i64), add) -get(groupBy(array, ok), add) get(groupBy(array, true), i32) get(groupBy(list, "bar"), i32) -get(groupBy(list, "foo"), greet) -get(groupBy(list, #), div) get(groupBy(list, #), f32 <= f64) get(groupBy(list, #), f32) get(groupBy(list, #), foo) -get(groupBy(list, #), greet) -get(groupBy(list, #), half) get(groupBy(list, #), i) get(groupBy(list, #), i32) get(groupBy(list, #), i64) get(groupBy(list, #), int(f32)) -get(groupBy(list, #), list) get(groupBy(list, #), reduce(array, foo)) get(groupBy(list, #), score(1)) -get(groupBy(list, #), score) -get(groupBy(list, 0.5), array) -get(groupBy(list, 0.5), div) get(groupBy(list, 0.5), ok) get(groupBy(list, 1), i32) -get(groupBy(list, f32), greet) -get(groupBy(list, foo), add) get(groupBy(list, foo), i32) -get(groupBy(list, ok), greet) -get(groupBy(list, ok), list) get(i .. 1, 1 * 1) get(i .. i32, i) get(i32 .. i, i64) @@ -7200,12 +7175,10 @@ get(list, max(i32)) get(list, min(i32)) get(list, min(i64)) get(list, ok ? 0.5 : "foo") -get(list, ok ? array : "foo") get(list, reduce(list, i64)) get(list, score(1)) get(list, score(i)) get(list, true ? i : i32) -get(list, {"foo": i32}?.i) get(list[i64:1], i) get(map(array, #), i) get(map(array, #), i32) @@ -7221,18 +7194,15 @@ get(map(list, 1), i32) get(map(list, array), i) get(map(list, i32), i64) get(map(list, i64), i64) -get(ok ? "bar" : false, array) get(ok ? 1 : "bar", f32) get(ok ? add : f32, array) get(ok ? f64 : div, i64) get(ok ? false : list, f32 > i) -get(ok ? foo : 0.5, div) get(ok ? half : i32, i) get(ok ? half : ok, f64) get(ok ? i : 0.5, half) get(ok ? i32 : half, f64) get(ok ? i64 : foo, f32) -get(ok ? list : "foo", add) get(ok ? list : i32, f32) get(ok ? ok : div, greet) get(ok ? score : f64, i) @@ -7241,7 +7211,6 @@ get(reduce(list, array), i32) get(sort(array), i32) get(take(list, i), i64) get(true ? "bar" : ok, score(i)) -get(true ? "foo" : half, list) get(true ? 0.5 : i32, array) get(true ? f32 : 0.5, ok) get(true ? false : foo, i64 > 0.5) From 8f8320313179e1da0d18589d00d4d8cde9be3301 Mon Sep 17 00:00:00 2001 From: zhuliquan Date: Sun, 9 Mar 2025 17:45:17 +0800 Subject: [PATCH 064/113] Allow tailing comma in arguments (#623) * feat: extract code for compiling equal operator * feat: support last argument append with comma --------- Co-authored-by: Anton Medvedev --- parser/parser.go | 7 +++++++ parser/parser_test.go | 36 ++++++++++++++++++++++++++++++++++++ 2 files changed, 43 insertions(+) diff --git a/parser/parser.go b/parser/parser.go index af2776c89..5ba16d2a2 100644 --- a/parser/parser.go +++ b/parser/parser.go @@ -549,6 +549,10 @@ func (p *parser) parseCall(token Token, arguments []Node, checkOverrides bool) N arguments = append(arguments, node) } + // skip last comma + if p.current.Is(Operator, ",") { + p.next() + } p.expect(Bracket, ")") node = p.createNode(&BuiltinNode{ @@ -593,6 +597,9 @@ func (p *parser) parseArguments(arguments []Node) []Node { if len(arguments) > offset { p.expect(Operator, ",") } + if p.current.Is(Bracket, ")") { + break + } node := p.parseExpression(0) arguments = append(arguments, node) } diff --git a/parser/parser_test.go b/parser/parser_test.go index 4e373ff50..51dc0ac06 100644 --- a/parser/parser_test.go +++ b/parser/parser_test.go @@ -839,6 +839,42 @@ world`}, Expr: &IdentifierNode{Value: "x"}, }, }, + { + `all( + [ + true, + false, + ], + #, + )`, + &BuiltinNode{ + Name: "all", + Arguments: []Node{ + &ArrayNode{ + Nodes: []Node{ + &BoolNode{Value: true}, + &BoolNode{Value: false}, + }, + }, + &PredicateNode{ + Node: &PointerNode{}, + }, + }, + }, + }, + { + `func( + parameter1, + parameter2, + )`, + &CallNode{ + Callee: &IdentifierNode{Value: "func"}, + Arguments: []Node{ + &IdentifierNode{Value: "parameter1"}, + &IdentifierNode{Value: "parameter2"}, + }, + }, + }, } for _, test := range tests { t.Run(test.input, func(t *testing.T) { From 2d9f6165d887633bb922b51190e12d6aa7cec8fc Mon Sep 17 00:00:00 2001 From: Anton Medvedev Date: Sun, 9 Mar 2025 10:48:37 +0100 Subject: [PATCH 065/113] Add more tailing comma tests --- parser/parser_test.go | 18 ++++++++++++++++++ 1 file changed, 18 insertions(+) diff --git a/parser/parser_test.go b/parser/parser_test.go index 51dc0ac06..9c707856d 100644 --- a/parser/parser_test.go +++ b/parser/parser_test.go @@ -862,6 +862,18 @@ world`}, }, }, }, + { + `list | all(#,)`, + &BuiltinNode{ + Name: "all", + Arguments: []Node{ + &IdentifierNode{Value: "list"}, + &PredicateNode{ + Node: &PointerNode{}, + }, + }, + }, + }, { `func( parameter1, @@ -974,6 +986,12 @@ func TestParse_error(t *testing.T) { | 1 + if true { 2 } else { 3 } | ....^`, }, + { + `list | all(#,,)`, + `unexpected token Operator(",") (1:14) + | list | all(#,,) + | .............^`, + }, } for _, test := range tests { From 80f0ea62ea6935a06d6562c5844a801362bf57a1 Mon Sep 17 00:00:00 2001 From: Anton Medvedev Date: Sun, 9 Mar 2025 13:07:38 +0100 Subject: [PATCH 066/113] Correctly add OpDeref if needed Fixes #739 --- builtin/builtin.go | 9 ++++++++ builtin/builtin_test.go | 16 ++++++++++--- builtin/function.go | 1 + checker/checker.go | 8 +++++++ checker/nature/nature.go | 18 +++++++++++++++ compiler/compiler.go | 43 ++++++++++++++++++++++++++--------- expr.go | 1 + patcher/value/value_test.go | 1 - test/deref/deref_test.go | 17 ++++++++++++++ test/issues/739/issue_test.go | 19 ++++++++++++++++ 10 files changed, 118 insertions(+), 15 deletions(-) create mode 100644 test/issues/739/issue_test.go diff --git a/builtin/builtin.go b/builtin/builtin.go index 58ce5e4ca..33febb09a 100644 --- a/builtin/builtin.go +++ b/builtin/builtin.go @@ -493,6 +493,9 @@ var Builtins = []*Function{ } return anyType, fmt.Errorf("invalid number of arguments (expected 0, got %d)", len(args)) }, + Deref: func(i int, arg reflect.Type) bool { + return false + }, }, { Name: "duration", @@ -567,6 +570,12 @@ var Builtins = []*Function{ } return timeType, nil }, + Deref: func(i int, arg reflect.Type) bool { + if arg.AssignableTo(locationType) { + return false + } + return true + }, }, { Name: "timezone", diff --git a/builtin/builtin_test.go b/builtin/builtin_test.go index 0620f0c45..75e279631 100644 --- a/builtin/builtin_test.go +++ b/builtin/builtin_test.go @@ -642,11 +642,17 @@ func Test_int_unwraps_underlying_value(t *testing.T) { func TestBuiltin_with_deref(t *testing.T) { x := 42 arr := []any{1, 2, 3} + arrStr := []string{"1", "2", "3"} m := map[string]any{"a": 1, "b": 2} + jsonString := `["1"]` + str := "1,2,3" env := map[string]any{ - "x": &x, - "arr": &arr, - "m": &m, + "x": &x, + "arr": &arr, + "arrStr": &arrStr, + "m": &m, + "json": &jsonString, + "str": &str, } tests := []struct { @@ -669,6 +675,10 @@ func TestBuiltin_with_deref(t *testing.T) { {`uniq(arr)`, []any{1, 2, 3}}, {`concat(arr, arr)`, []any{1, 2, 3, 1, 2, 3}}, {`flatten([arr, [arr]])`, []any{1, 2, 3, 1, 2, 3}}, + {`toJSON(arr)`, "[\n 1,\n 2,\n 3\n]"}, + {`fromJSON(json)`, []any{"1"}}, + {`split(str, ",")`, []string{"1", "2", "3"}}, + {`join(arrStr, ",")`, "1,2,3"}, } for _, test := range tests { diff --git a/builtin/function.go b/builtin/function.go index d4d78b1ce..6634ac3f8 100644 --- a/builtin/function.go +++ b/builtin/function.go @@ -11,6 +11,7 @@ type Function struct { Safe func(args ...any) (any, uint, error) Types []reflect.Type Validate func(args []reflect.Type) (reflect.Type, error) + Deref func(i int, arg reflect.Type) bool Predicate bool } diff --git a/checker/checker.go b/checker/checker.go index d410b9549..fc01746fe 100644 --- a/checker/checker.go +++ b/checker/checker.go @@ -975,6 +975,14 @@ func (v *checker) checkFunction(f *builtin.Function, node ast.Node, arguments [] lastErr = err continue } + + // As we found the correct function overload, we can stop the loop. + // Also, we need to set the correct nature of the callee so compiler, + // can correctly handle OpDeref opcode. + if callNode, ok := node.(*ast.CallNode); ok { + callNode.Callee.SetType(t) + } + return outNature } if lastErr != nil { diff --git a/checker/nature/nature.go b/checker/nature/nature.go index 6720acb4c..e25fbf219 100644 --- a/checker/nature/nature.go +++ b/checker/nature/nature.go @@ -25,6 +25,24 @@ type Nature struct { FieldIndex []int // Index of field in type. } +func (n Nature) IsNil() bool { + return n.Nil +} + +func (n Nature) IsAny() bool { + return n.Kind() == reflect.Interface && n.NumMethods() == 0 +} + +func (n Nature) IsUnknown() bool { + switch { + case n.Type == nil && !n.Nil: + return true + case isAny(n): + return true + } + return false +} + func (n Nature) String() string { if n.Type != nil { return n.Type.String() diff --git a/compiler/compiler.go b/compiler/compiler.go index ca2750c18..7f0371216 100644 --- a/compiler/compiler.go +++ b/compiler/compiler.go @@ -750,17 +750,15 @@ func (c *compiler) CallNode(node *ast.CallNode) { } for i, arg := range node.Arguments { c.compile(arg) - if k := kind(arg.Type()); k == reflect.Ptr || k == reflect.Interface { - var in reflect.Type - if fn.IsVariadic() && i >= fnNumIn-1 { - in = fn.In(fn.NumIn() - 1).Elem() - } else { - in = fn.In(i + fnInOffset) - } - if k = kind(in); k != reflect.Ptr && k != reflect.Interface { - c.emit(OpDeref) - } + + var in reflect.Type + if fn.IsVariadic() && i >= fnNumIn-1 { + in = fn.In(fn.NumIn() - 1).Elem() + } else { + in = fn.In(i + fnInOffset) } + + c.derefParam(in, arg) } } else { for _, arg := range node.Arguments { @@ -1059,8 +1057,19 @@ func (c *compiler) BuiltinNode(node *ast.BuiltinNode) { if id, ok := builtin.Index[node.Name]; ok { f := builtin.Builtins[id] - for _, arg := range node.Arguments { + for i, arg := range node.Arguments { c.compile(arg) + argType := arg.Type() + if argType.Kind() == reflect.Ptr || arg.Nature().IsUnknown() { + if f.Deref == nil { + // By default, builtins expect arguments to be dereferenced. + c.emit(OpDeref) + } else { + if f.Deref(i, argType) { + c.emit(OpDeref) + } + } + } } if f.Fast != nil { @@ -1218,6 +1227,18 @@ func (c *compiler) derefInNeeded(node ast.Node) { } } +func (c *compiler) derefParam(in reflect.Type, param ast.Node) { + if param.Nature().Nil { + return + } + if param.Type().AssignableTo(in) { + return + } + if in.Kind() != reflect.Ptr && param.Type().Kind() == reflect.Ptr { + c.emit(OpDeref) + } +} + func (c *compiler) optimize() { for i, op := range c.bytecode { switch op { diff --git a/expr.go b/expr.go index 5e60791e1..0325f81f8 100644 --- a/expr.go +++ b/expr.go @@ -244,6 +244,7 @@ func Eval(input string, env any) (any, error) { if err != nil { return nil, err } + println(program.Disassemble()) output, err := Run(program, env) if err != nil { diff --git a/patcher/value/value_test.go b/patcher/value/value_test.go index 30c8a56ad..d04a4120a 100644 --- a/patcher/value/value_test.go +++ b/patcher/value/value_test.go @@ -88,7 +88,6 @@ func Test_valueAddInt(t *testing.T) { program, err := expr.Compile("ValueOne + ValueTwo", expr.Env(env), ValueGetter) require.NoError(t, err) - out, err := vm.Run(program, env) require.NoError(t, err) diff --git a/test/deref/deref_test.go b/test/deref/deref_test.go index 0b3ea5837..8df682faf 100644 --- a/test/deref/deref_test.go +++ b/test/deref/deref_test.go @@ -320,3 +320,20 @@ func TestDeref_ignore_struct_func_args(t *testing.T) { require.NoError(t, err) require.Equal(t, "UTC", out) } + +func TestDeref_keep_pointer_if_arg_in_interface(t *testing.T) { + x := 42 + env := map[string]any{ + "x": &x, + "fn": func(p any) int { + return *p.(*int) + 1 + }, + } + + program, err := expr.Compile(`fn(x)`, expr.Env(env)) + require.NoError(t, err) + + out, err := expr.Run(program, env) + require.NoError(t, err) + require.Equal(t, 43, out) +} diff --git a/test/issues/739/issue_test.go b/test/issues/739/issue_test.go new file mode 100644 index 000000000..c58633fe8 --- /dev/null +++ b/test/issues/739/issue_test.go @@ -0,0 +1,19 @@ +package issue_test + +import ( + "testing" + + "github.com/expr-lang/expr" + "github.com/expr-lang/expr/internal/testify/require" +) + +func TestIssue739(t *testing.T) { + jsonString := `{"Num": 1}` + env := map[string]any{ + "aJSONString": &jsonString, + } + + result, err := expr.Eval("fromJSON(aJSONString)", env) + require.NoError(t, err) + require.Contains(t, result, "Num") +} From 7d564c003e90a5fdab6e453dd74974bb085bb34e Mon Sep 17 00:00:00 2001 From: Anton Medvedev Date: Sun, 9 Mar 2025 23:39:16 +0100 Subject: [PATCH 067/113] Remove print --- expr.go | 1 - 1 file changed, 1 deletion(-) diff --git a/expr.go b/expr.go index 0325f81f8..5e60791e1 100644 --- a/expr.go +++ b/expr.go @@ -244,7 +244,6 @@ func Eval(input string, env any) (any, error) { if err != nil { return nil, err } - println(program.Disassemble()) output, err := Run(program, env) if err != nil { From f4bbea526036057a4ae0ddc8df6615084cde007e Mon Sep 17 00:00:00 2001 From: Anton Medvedev Date: Mon, 10 Mar 2025 13:38:02 +0100 Subject: [PATCH 068/113] Add support deref in all builtins --- builtin/builtin_test.go | 29 ++++++++++++++++++++++++++--- checker/checker.go | 20 ++++++++++---------- compiler/compiler.go | 16 ++++++++++++++++ 3 files changed, 52 insertions(+), 13 deletions(-) diff --git a/builtin/builtin_test.go b/builtin/builtin_test.go index 75e279631..c0b2842f7 100644 --- a/builtin/builtin_test.go +++ b/builtin/builtin_test.go @@ -641,7 +641,7 @@ func Test_int_unwraps_underlying_value(t *testing.T) { func TestBuiltin_with_deref(t *testing.T) { x := 42 - arr := []any{1, 2, 3} + arr := []int{1, 2, 3} arrStr := []string{"1", "2", "3"} m := map[string]any{"a": 1, "b": 2} jsonString := `["1"]` @@ -659,13 +659,31 @@ func TestBuiltin_with_deref(t *testing.T) { input string want any }{ + {`all(arr, # > 0)`, true}, + {`none(arr, # < 0)`, true}, + {`any(arr, # > 0)`, true}, + {`one(arr, # > 2)`, true}, + {`filter(arr, # > 0)`, []any{1, 2, 3}}, + {`map(arr, # * #)`, []any{1, 4, 9}}, + {`count(arr, # > 0)`, 3}, + {`sum(arr)`, 6}, + {`find(arr, # > 0)`, 1}, + {`findIndex(arr, # > 1)`, 1}, + {`findLast(arr, # > 0)`, 3}, + {`findLastIndex(arr, # > 0)`, 2}, + {`groupBy(arr, # % 2 == 0)`, map[any][]any{false: {1, 3}, true: {2}}}, + {`sortBy(arr, -#)`, []any{3, 2, 1}}, + {`reduce(arr, # + #acc, x)`, 6 + 42}, + {`ceil(x)`, 42.0}, + {`floor(x)`, 42.0}, + {`round(x)`, 42.0}, {`int(x)`, 42}, {`float(x)`, 42.0}, {`abs(x)`, 42}, {`first(arr)`, 1}, {`last(arr)`, 3}, - {`take(arr, 1)`, []any{1}}, - {`take(arr, x)`, []any{1, 2, 3}}, + {`take(arr, 1)`, []int{1}}, + {`take(arr, x)`, []int{1, 2, 3}}, {`'a' in keys(m)`, true}, {`1 in values(m)`, true}, {`len(arr)`, 3}, @@ -685,10 +703,15 @@ func TestBuiltin_with_deref(t *testing.T) { t.Run(test.input, func(t *testing.T) { program, err := expr.Compile(test.input, expr.Env(env)) require.NoError(t, err) + println(program.Disassemble()) out, err := expr.Run(program, env) require.NoError(t, err) assert.Equal(t, test.want, out) + + out, err = expr.Eval(test.input, env) + require.NoError(t, err) + assert.Equal(t, test.want, out) }) } } diff --git a/checker/checker.go b/checker/checker.go index fc01746fe..f49234137 100644 --- a/checker/checker.go +++ b/checker/checker.go @@ -660,7 +660,7 @@ func (v *checker) functionReturnType(node *ast.CallNode) Nature { func (v *checker) BuiltinNode(node *ast.BuiltinNode) Nature { switch node.Name { case "all", "none", "any", "one": - collection := v.visit(node.Arguments[0]) + collection := v.visit(node.Arguments[0]).Deref() if !isArray(collection) && !isUnknown(collection) { return v.error(node.Arguments[0], "builtin %v takes only array (got %v)", node.Name, collection) } @@ -681,7 +681,7 @@ func (v *checker) BuiltinNode(node *ast.BuiltinNode) Nature { return v.error(node.Arguments[1], "predicate should has one input and one output param") case "filter": - collection := v.visit(node.Arguments[0]) + collection := v.visit(node.Arguments[0]).Deref() if !isArray(collection) && !isUnknown(collection) { return v.error(node.Arguments[0], "builtin %v takes only array (got %v)", node.Name, collection) } @@ -705,7 +705,7 @@ func (v *checker) BuiltinNode(node *ast.BuiltinNode) Nature { return v.error(node.Arguments[1], "predicate should has one input and one output param") case "map": - collection := v.visit(node.Arguments[0]) + collection := v.visit(node.Arguments[0]).Deref() if !isArray(collection) && !isUnknown(collection) { return v.error(node.Arguments[0], "builtin %v takes only array (got %v)", node.Name, collection) } @@ -723,7 +723,7 @@ func (v *checker) BuiltinNode(node *ast.BuiltinNode) Nature { return v.error(node.Arguments[1], "predicate should has one input and one output param") case "count": - collection := v.visit(node.Arguments[0]) + collection := v.visit(node.Arguments[0]).Deref() if !isArray(collection) && !isUnknown(collection) { return v.error(node.Arguments[0], "builtin %v takes only array (got %v)", node.Name, collection) } @@ -748,7 +748,7 @@ func (v *checker) BuiltinNode(node *ast.BuiltinNode) Nature { return v.error(node.Arguments[1], "predicate should has one input and one output param") case "sum": - collection := v.visit(node.Arguments[0]) + collection := v.visit(node.Arguments[0]).Deref() if !isArray(collection) && !isUnknown(collection) { return v.error(node.Arguments[0], "builtin %v takes only array (got %v)", node.Name, collection) } @@ -771,7 +771,7 @@ func (v *checker) BuiltinNode(node *ast.BuiltinNode) Nature { } case "find", "findLast": - collection := v.visit(node.Arguments[0]) + collection := v.visit(node.Arguments[0]).Deref() if !isArray(collection) && !isUnknown(collection) { return v.error(node.Arguments[0], "builtin %v takes only array (got %v)", node.Name, collection) } @@ -795,7 +795,7 @@ func (v *checker) BuiltinNode(node *ast.BuiltinNode) Nature { return v.error(node.Arguments[1], "predicate should has one input and one output param") case "findIndex", "findLastIndex": - collection := v.visit(node.Arguments[0]) + collection := v.visit(node.Arguments[0]).Deref() if !isArray(collection) && !isUnknown(collection) { return v.error(node.Arguments[0], "builtin %v takes only array (got %v)", node.Name, collection) } @@ -816,7 +816,7 @@ func (v *checker) BuiltinNode(node *ast.BuiltinNode) Nature { return v.error(node.Arguments[1], "predicate should has one input and one output param") case "groupBy": - collection := v.visit(node.Arguments[0]) + collection := v.visit(node.Arguments[0]).Deref() if !isArray(collection) && !isUnknown(collection) { return v.error(node.Arguments[0], "builtin %v takes only array (got %v)", node.Name, collection) } @@ -835,7 +835,7 @@ func (v *checker) BuiltinNode(node *ast.BuiltinNode) Nature { return v.error(node.Arguments[1], "predicate should has one input and one output param") case "sortBy": - collection := v.visit(node.Arguments[0]) + collection := v.visit(node.Arguments[0]).Deref() if !isArray(collection) && !isUnknown(collection) { return v.error(node.Arguments[0], "builtin %v takes only array (got %v)", node.Name, collection) } @@ -857,7 +857,7 @@ func (v *checker) BuiltinNode(node *ast.BuiltinNode) Nature { return v.error(node.Arguments[1], "predicate should has one input and one output param") case "reduce": - collection := v.visit(node.Arguments[0]) + collection := v.visit(node.Arguments[0]).Deref() if !isArray(collection) && !isUnknown(collection) { return v.error(node.Arguments[0], "builtin %v takes only array (got %v)", node.Name, collection) } diff --git a/compiler/compiler.go b/compiler/compiler.go index 7f0371216..90e54e54b 100644 --- a/compiler/compiler.go +++ b/compiler/compiler.go @@ -791,6 +791,7 @@ func (c *compiler) BuiltinNode(node *ast.BuiltinNode) { switch node.Name { case "all": c.compile(node.Arguments[0]) + c.derefInNeeded(node.Arguments[0]) c.emit(OpBegin) var loopBreak int c.emitLoop(func() { @@ -805,6 +806,7 @@ func (c *compiler) BuiltinNode(node *ast.BuiltinNode) { case "none": c.compile(node.Arguments[0]) + c.derefInNeeded(node.Arguments[0]) c.emit(OpBegin) var loopBreak int c.emitLoop(func() { @@ -820,6 +822,7 @@ func (c *compiler) BuiltinNode(node *ast.BuiltinNode) { case "any": c.compile(node.Arguments[0]) + c.derefInNeeded(node.Arguments[0]) c.emit(OpBegin) var loopBreak int c.emitLoop(func() { @@ -834,6 +837,7 @@ func (c *compiler) BuiltinNode(node *ast.BuiltinNode) { case "one": c.compile(node.Arguments[0]) + c.derefInNeeded(node.Arguments[0]) c.emit(OpBegin) c.emitLoop(func() { c.compile(node.Arguments[1]) @@ -849,6 +853,7 @@ func (c *compiler) BuiltinNode(node *ast.BuiltinNode) { case "filter": c.compile(node.Arguments[0]) + c.derefInNeeded(node.Arguments[0]) c.emit(OpBegin) c.emitLoop(func() { c.compile(node.Arguments[1]) @@ -868,6 +873,7 @@ func (c *compiler) BuiltinNode(node *ast.BuiltinNode) { case "map": c.compile(node.Arguments[0]) + c.derefInNeeded(node.Arguments[0]) c.emit(OpBegin) c.emitLoop(func() { c.compile(node.Arguments[1]) @@ -879,6 +885,7 @@ func (c *compiler) BuiltinNode(node *ast.BuiltinNode) { case "count": c.compile(node.Arguments[0]) + c.derefInNeeded(node.Arguments[0]) c.emit(OpBegin) c.emitLoop(func() { if len(node.Arguments) == 2 { @@ -896,6 +903,7 @@ func (c *compiler) BuiltinNode(node *ast.BuiltinNode) { case "sum": c.compile(node.Arguments[0]) + c.derefInNeeded(node.Arguments[0]) c.emit(OpBegin) c.emit(OpInt, 0) c.emit(OpSetAcc) @@ -915,6 +923,7 @@ func (c *compiler) BuiltinNode(node *ast.BuiltinNode) { case "find": c.compile(node.Arguments[0]) + c.derefInNeeded(node.Arguments[0]) c.emit(OpBegin) var loopBreak int c.emitLoop(func() { @@ -942,6 +951,7 @@ func (c *compiler) BuiltinNode(node *ast.BuiltinNode) { case "findIndex": c.compile(node.Arguments[0]) + c.derefInNeeded(node.Arguments[0]) c.emit(OpBegin) var loopBreak int c.emitLoop(func() { @@ -960,6 +970,7 @@ func (c *compiler) BuiltinNode(node *ast.BuiltinNode) { case "findLast": c.compile(node.Arguments[0]) + c.derefInNeeded(node.Arguments[0]) c.emit(OpBegin) var loopBreak int c.emitLoopBackwards(func() { @@ -987,6 +998,7 @@ func (c *compiler) BuiltinNode(node *ast.BuiltinNode) { case "findLastIndex": c.compile(node.Arguments[0]) + c.derefInNeeded(node.Arguments[0]) c.emit(OpBegin) var loopBreak int c.emitLoopBackwards(func() { @@ -1005,6 +1017,7 @@ func (c *compiler) BuiltinNode(node *ast.BuiltinNode) { case "groupBy": c.compile(node.Arguments[0]) + c.derefInNeeded(node.Arguments[0]) c.emit(OpBegin) c.emit(OpCreate, 1) c.emit(OpSetAcc) @@ -1018,6 +1031,7 @@ func (c *compiler) BuiltinNode(node *ast.BuiltinNode) { case "sortBy": c.compile(node.Arguments[0]) + c.derefInNeeded(node.Arguments[0]) c.emit(OpBegin) if len(node.Arguments) == 3 { c.compile(node.Arguments[2]) @@ -1036,9 +1050,11 @@ func (c *compiler) BuiltinNode(node *ast.BuiltinNode) { case "reduce": c.compile(node.Arguments[0]) + c.derefInNeeded(node.Arguments[0]) c.emit(OpBegin) if len(node.Arguments) == 3 { c.compile(node.Arguments[2]) + c.derefInNeeded(node.Arguments[2]) c.emit(OpSetAcc) } else { c.emit(OpPointer) From 2bc0eed148d3313a42c33e7f5a91778d94c85ca7 Mon Sep 17 00:00:00 2001 From: Anton Medvedev Date: Mon, 10 Mar 2025 13:52:54 +0100 Subject: [PATCH 069/113] Remove duplicated dereferences --- builtin/builtin.go | 20 ++++++++++---------- builtin/builtin_test.go | 1 + builtin/lib.go | 19 ++++++++----------- internal/deref/deref.go | 6 +----- internal/deref/deref_test.go | 8 ++++---- vm/vm.go | 2 +- 6 files changed, 25 insertions(+), 31 deletions(-) diff --git a/builtin/builtin.go b/builtin/builtin.go index 33febb09a..c23daf468 100644 --- a/builtin/builtin.go +++ b/builtin/builtin.go @@ -644,11 +644,11 @@ var Builtins = []*Function{ if len(args) != 2 { return nil, fmt.Errorf("invalid number of arguments (expected 2, got %d)", len(args)) } - v := deref.ValueOf(args[0]) + v := reflect.ValueOf(args[0]) if v.Kind() != reflect.Slice && v.Kind() != reflect.Array { return nil, fmt.Errorf("cannot take from %s", v.Kind()) } - n := deref.ValueOf(args[1]) + n := reflect.ValueOf(args[1]) if !n.CanInt() { return nil, fmt.Errorf("cannot take %s elements", n.Kind()) } @@ -683,7 +683,7 @@ var Builtins = []*Function{ if len(args) != 1 { return nil, fmt.Errorf("invalid number of arguments (expected 1, got %d)", len(args)) } - v := deref.ValueOf(args[0]) + v := reflect.ValueOf(args[0]) if v.Kind() != reflect.Map { return nil, fmt.Errorf("cannot get keys from %s", v.Kind()) } @@ -713,7 +713,7 @@ var Builtins = []*Function{ if len(args) != 1 { return nil, fmt.Errorf("invalid number of arguments (expected 1, got %d)", len(args)) } - v := deref.ValueOf(args[0]) + v := reflect.ValueOf(args[0]) if v.Kind() != reflect.Map { return nil, fmt.Errorf("cannot get values from %s", v.Kind()) } @@ -743,7 +743,7 @@ var Builtins = []*Function{ if len(args) != 1 { return nil, fmt.Errorf("invalid number of arguments (expected 1, got %d)", len(args)) } - v := deref.ValueOf(args[0]) + v := reflect.ValueOf(args[0]) if v.Kind() != reflect.Map { return nil, fmt.Errorf("cannot transform %s to pairs", v.Kind()) } @@ -771,7 +771,7 @@ var Builtins = []*Function{ if len(args) != 1 { return nil, fmt.Errorf("invalid number of arguments (expected 1, got %d)", len(args)) } - v := deref.ValueOf(args[0]) + v := reflect.ValueOf(args[0]) if v.Kind() != reflect.Slice && v.Kind() != reflect.Array { return nil, fmt.Errorf("cannot transform %s from pairs", v) } @@ -808,7 +808,7 @@ var Builtins = []*Function{ return nil, 0, fmt.Errorf("invalid number of arguments (expected 1, got %d)", len(args)) } - v := deref.ValueOf(args[0]) + v := reflect.ValueOf(args[0]) if v.Kind() != reflect.Slice && v.Kind() != reflect.Array { return nil, 0, fmt.Errorf("cannot reverse %s", v.Kind()) } @@ -843,7 +843,7 @@ var Builtins = []*Function{ return nil, fmt.Errorf("invalid number of arguments (expected 1, got %d)", len(args)) } - v := deref.ValueOf(deref.Deref(args[0])) + v := reflect.ValueOf(args[0]) if v.Kind() != reflect.Array && v.Kind() != reflect.Slice { return nil, fmt.Errorf("cannot uniq %s", v.Kind()) } @@ -897,7 +897,7 @@ var Builtins = []*Function{ var arr []any for _, arg := range args { - v := deref.ValueOf(deref.Deref(arg)) + v := reflect.ValueOf(arg) if v.Kind() != reflect.Slice && v.Kind() != reflect.Array { return nil, 0, fmt.Errorf("cannot concat %s", v.Kind()) @@ -936,7 +936,7 @@ var Builtins = []*Function{ if len(args) != 1 { return nil, 0, fmt.Errorf("invalid number of arguments (expected 1, got %d)", len(args)) } - v := deref.ValueOf(deref.Deref(args[0])) + v := reflect.ValueOf(args[0]) if v.Kind() != reflect.Array && v.Kind() != reflect.Slice { return nil, size, fmt.Errorf("cannot flatten %s", v.Kind()) } diff --git a/builtin/builtin_test.go b/builtin/builtin_test.go index c0b2842f7..71f775a49 100644 --- a/builtin/builtin_test.go +++ b/builtin/builtin_test.go @@ -693,6 +693,7 @@ func TestBuiltin_with_deref(t *testing.T) { {`uniq(arr)`, []any{1, 2, 3}}, {`concat(arr, arr)`, []any{1, 2, 3, 1, 2, 3}}, {`flatten([arr, [arr]])`, []any{1, 2, 3, 1, 2, 3}}, + {`flatten(arr)`, []any{1, 2, 3}}, {`toJSON(arr)`, "[\n 1,\n 2,\n 3\n]"}, {`fromJSON(json)`, []any{"1"}}, {`split(str, ",")`, []string{"1", "2", "3"}}, diff --git a/builtin/lib.go b/builtin/lib.go index 6c1979d3b..5a70a6b91 100644 --- a/builtin/lib.go +++ b/builtin/lib.go @@ -12,7 +12,7 @@ import ( ) func Len(x any) any { - v := deref.ValueOf(x) + v := reflect.ValueOf(x) switch v.Kind() { case reflect.Array, reflect.Slice, reflect.Map: return v.Len() @@ -27,7 +27,7 @@ func Type(arg any) any { if arg == nil { return "nil" } - v := deref.ValueOf(arg) + v := reflect.ValueOf(arg) if v.Type().Name() != "" && v.Type().PkgPath() != "" { return fmt.Sprintf("%s.%s", v.Type().PkgPath(), v.Type().Name()) } @@ -58,7 +58,7 @@ func Type(arg any) any { } func Abs(x any) any { - switch x := deref.Deref(x).(type) { + switch x := x.(type) { case float32: if x < 0 { return -x @@ -172,7 +172,7 @@ func Round(x any) any { } func Int(x any) any { - switch x := deref.Deref(x).(type) { + switch x := x.(type) { case float32: return int(x) case float64: @@ -213,7 +213,7 @@ func Int(x any) any { } func Float(x any) any { - switch x := deref.Deref(x).(type) { + switch x := x.(type) { case float32: return float64(x) case float64: @@ -256,7 +256,7 @@ func String(arg any) any { func minMax(name string, fn func(any, any) bool, args ...any) (any, error) { var val any for _, arg := range args { - rv := deref.ValueOf(arg) + rv := reflect.ValueOf(arg) switch rv.Kind() { case reflect.Array, reflect.Slice: size := rv.Len() @@ -299,7 +299,7 @@ func mean(args ...any) (int, float64, error) { var count int for _, arg := range args { - rv := deref.ValueOf(arg) + rv := reflect.ValueOf(arg) switch rv.Kind() { case reflect.Array, reflect.Slice: size := rv.Len() @@ -331,7 +331,7 @@ func median(args ...any) ([]float64, error) { var values []float64 for _, arg := range args { - rv := deref.ValueOf(arg) + rv := reflect.ValueOf(arg) switch rv.Kind() { case reflect.Array, reflect.Slice: size := rv.Len() @@ -388,9 +388,6 @@ func get(params ...any) (out any, err error) { } } - v = deref.Value(v) - i = deref.Deref(i) - switch v.Kind() { case reflect.Array, reflect.Slice, reflect.String: index := runtime.ToInt(i) diff --git a/internal/deref/deref.go b/internal/deref/deref.go index 5e0e0b04e..da3e28ce6 100644 --- a/internal/deref/deref.go +++ b/internal/deref/deref.go @@ -5,7 +5,7 @@ import ( "reflect" ) -func Deref(p any) any { +func Interface(p any) any { if p == nil { return nil } @@ -45,7 +45,3 @@ func Value(v reflect.Value) reflect.Value { } return v } - -func ValueOf(v any) reflect.Value { - return Value(reflect.ValueOf(v)) -} diff --git a/internal/deref/deref_test.go b/internal/deref/deref_test.go index 5f812bee5..d7896b33b 100644 --- a/internal/deref/deref_test.go +++ b/internal/deref/deref_test.go @@ -15,7 +15,7 @@ func TestDeref(t *testing.T) { c := &b d := &c - got := deref.Deref(d) + got := deref.Interface(d) assert.Equal(t, uint(42), got) } @@ -25,14 +25,14 @@ func TestDeref_mix_ptr_with_interface(t *testing.T) { var c any = &b d := &c - got := deref.Deref(d) + got := deref.Interface(d) assert.Equal(t, uint(42), got) } func TestDeref_nil(t *testing.T) { var a *int - assert.Nil(t, deref.Deref(a)) - assert.Nil(t, deref.Deref(nil)) + assert.Nil(t, deref.Interface(a)) + assert.Nil(t, deref.Interface(nil)) } func TestType(t *testing.T) { diff --git a/vm/vm.go b/vm/vm.go index fb1d772c1..de13cade1 100644 --- a/vm/vm.go +++ b/vm/vm.go @@ -457,7 +457,7 @@ func (vm *VM) Run(program *Program, env any) (_ any, err error) { case OpDeref: a := vm.pop() - vm.push(deref.Deref(a)) + vm.push(deref.Interface(a)) case OpIncrementIndex: vm.scope().Index++ From a9cda30aa51cf1f44fa02356c025473b18f5cef7 Mon Sep 17 00:00:00 2001 From: Anton Medvedev Date: Mon, 10 Mar 2025 15:00:21 +0100 Subject: [PATCH 070/113] Test for issue 756 Fixes #756 --- test/issues/756/issue_test.go | 31 +++++++++++++++++++++++++++++++ 1 file changed, 31 insertions(+) create mode 100644 test/issues/756/issue_test.go diff --git a/test/issues/756/issue_test.go b/test/issues/756/issue_test.go new file mode 100644 index 000000000..93180a27a --- /dev/null +++ b/test/issues/756/issue_test.go @@ -0,0 +1,31 @@ +package issue_test + +import ( + "context" + "testing" + + "github.com/expr-lang/expr" + "github.com/expr-lang/expr/internal/testify/require" +) + +type X struct{} + +func (x *X) HelloCtx(ctx context.Context, text string) error { + return nil +} + +func TestIssue756(t *testing.T) { + env := map[string]any{ + "_goctx_": context.TODO(), + "_g_": map[string]*X{ + "rpc": {}, + }, + "text": "еуче", + } + exprStr := `let v = _g_.rpc.HelloCtx(text); v` + program, err := expr.Compile(exprStr, expr.Env(env), expr.WithContext("_goctx_")) + require.NoError(t, err) + + _, err = expr.Run(program, env) + require.NoError(t, err) +} From 25690fe0143fb89027f0d6a01cafcc437472a464 Mon Sep 17 00:00:00 2001 From: 2pac Date: Thu, 13 Mar 2025 14:10:14 +0100 Subject: [PATCH 071/113] chore: Added SOLO to the companies list (#769) Signed-off-by: 2pac --- README.md | 1 + 1 file changed, 1 insertion(+) diff --git a/README.md b/README.md index ab4f2baaa..c0778a84d 100644 --- a/README.md +++ b/README.md @@ -170,6 +170,7 @@ func main() { * [WoodpeckerCI](https://woodpecker-ci.org) uses Expr for [filtering workflows/steps](https://woodpecker-ci.org/docs/usage/workflow-syntax#evaluate). * [FastSchema](https://github.com/fastschema/fastschema) - A BaaS leveraging Expr for its customizable and dynamic Access Control system. * [WunderGraph Cosmo](https://github.com/wundergraph/cosmo) - GraphQL Federeration Router uses Expr to customize Middleware behaviour +* [SOLO](https://solo.one) uses Expr interally to allow dynamic code execution with custom defined functions. [Add your company too](https://github.com/expr-lang/expr/edit/master/README.md) From 3be6386f86a53e713a5b083e33582d94710653cc Mon Sep 17 00:00:00 2001 From: Anton Medvedev Date: Sat, 15 Mar 2025 16:41:40 +0100 Subject: [PATCH 072/113] Code style: remove repeated helper functions --- checker/nature/nature.go | 8 ++------ checker/nature/utils.go | 4 ---- checker/types.go | 12 +----------- 3 files changed, 3 insertions(+), 21 deletions(-) diff --git a/checker/nature/nature.go b/checker/nature/nature.go index e25fbf219..993c9fcf8 100644 --- a/checker/nature/nature.go +++ b/checker/nature/nature.go @@ -25,10 +25,6 @@ type Nature struct { FieldIndex []int // Index of field in type. } -func (n Nature) IsNil() bool { - return n.Nil -} - func (n Nature) IsAny() bool { return n.Kind() == reflect.Interface && n.NumMethods() == 0 } @@ -37,7 +33,7 @@ func (n Nature) IsUnknown() bool { switch { case n.Type == nil && !n.Nil: return true - case isAny(n): + case n.IsAny(): return true } return false @@ -92,7 +88,7 @@ func (n Nature) Elem() Nature { func (n Nature) AssignableTo(nt Nature) bool { if n.Nil { // Untyped nil is assignable to any interface, but implements only the empty interface. - if isAny(nt) { + if nt.IsAny() { return true } } diff --git a/checker/nature/utils.go b/checker/nature/utils.go index 8d07ce48c..c242f91a6 100644 --- a/checker/nature/utils.go +++ b/checker/nature/utils.go @@ -6,10 +6,6 @@ import ( "github.com/expr-lang/expr/internal/deref" ) -func isAny(nt Nature) bool { - return nt.Kind() == reflect.Interface && nt.NumMethods() == 0 -} - func fieldName(field reflect.StructField) string { if taggedName := field.Tag.Get("expr"); taggedName != "" { return taggedName diff --git a/checker/types.go b/checker/types.go index 7912931c5..09896de5d 100644 --- a/checker/types.go +++ b/checker/types.go @@ -71,17 +71,7 @@ func or(l, r Nature, fns ...func(Nature) bool) bool { } func isUnknown(nt Nature) bool { - switch { - case nt.Type == nil && !nt.Nil: - return true - case isAny(nt): - return true - } - return false -} - -func isAny(nt Nature) bool { - return nt.Kind() == reflect.Interface && nt.NumMethods() == 0 + return nt.IsUnknown() } func isInteger(nt Nature) bool { From 1598c621e1813e22893ea731c0b8b2e6ee357bcd Mon Sep 17 00:00:00 2001 From: Anton Medvedev Date: Sun, 16 Mar 2025 10:35:06 +0100 Subject: [PATCH 073/113] Update language-definition.md --- docs/language-definition.md | 8 ++++++++ 1 file changed, 8 insertions(+) diff --git a/docs/language-definition.md b/docs/language-definition.md index 640c7d63b..5e530a57d 100644 --- a/docs/language-definition.md +++ b/docs/language-definition.md @@ -697,6 +697,14 @@ Flattens given array into one-dimensional array. flatten([1, 2, [3, 4]]) == [1, 2, 3, 4] ``` +### uniq(array) {#uniq} + +Removes duplicates from an array. + +```expr +uniq([1, 2, 3, 2, 1]) == [1, 2, 3] +``` + ### join(array[, delimiter]) {#join} Joins an array of strings into a single string with the given delimiter. From 8419ba4a916cd5036c6a847ae810f63485ead0f9 Mon Sep 17 00:00:00 2001 From: Anton Medvedev Date: Mon, 17 Mar 2025 10:10:42 +0100 Subject: [PATCH 074/113] Update SECURITY.md --- SECURITY.md | 7 ++----- 1 file changed, 2 insertions(+), 5 deletions(-) diff --git a/SECURITY.md b/SECURITY.md index 8d692a398..e18771f5d 100644 --- a/SECURITY.md +++ b/SECURITY.md @@ -11,11 +11,8 @@ unless this is not possible or feasible with a reasonable effort. | Version | Supported | |---------|--------------------| -| 1.16 | :white_check_mark: | -| 1.15 | :white_check_mark: | -| 1.14 | :white_check_mark: | -| 1.13 | :white_check_mark: | -| < 1.13 | :x: | +| 1.x | :white_check_mark: | +| 0.x | :x: | ## Reporting a Vulnerability From 0f99b19176217bbe49ba348b7120c486f1560d9e Mon Sep 17 00:00:00 2001 From: Anton Medvedev Date: Mon, 17 Mar 2025 14:28:04 +0100 Subject: [PATCH 075/113] Update docs --- docs/configuration.md | 29 ++++++++++++++--------------- docs/environment.md | 20 ++++++++++++++++++-- docs/functions.md | 3 +++ docs/getting-started.md | 16 ++++++---------- docs/patch.md | 23 +++++++++++++++++------ docs/visitor.md | 13 +++++++++++-- 6 files changed, 69 insertions(+), 35 deletions(-) diff --git a/docs/configuration.md b/docs/configuration.md index 511ebd48b..0aaaf99dd 100644 --- a/docs/configuration.md +++ b/docs/configuration.md @@ -6,15 +6,15 @@ Usually, the return type of expression is anything. But we can instruct type che expression. For example, in filter expressions, we expect the return type to be a boolean. -```go +```go program, err := expr.Compile(code, expr.AsBool()) if err != nil { -panic(err) + panic(err) } output, err := expr.Run(program, env) if err != nil { -panic(err) + panic(err) } ok := output.(bool) // It is safe to assert the output to bool, if the expression is type checked as bool. @@ -82,6 +82,9 @@ Function `expr.WithContext()` takes the name of context variable. The context va ```go env := map[string]any{ "ctx": context.Background(), + "customFunc": func(ctx context.Context, a int) int { + return a + }, } program, err := expr.Compile(code, expr.Env(env), expr.WithContext("ctx")) @@ -116,20 +119,16 @@ fib(12+12) // will be transformed to 267914296 during the compilation fib(x) // will **not** be transformed and will be evaluated at runtime ``` -## Options +## Timezone -Compiler options can be defined as an array: +By default, the timezone is set to `time.Local`. We can change the timezone via the [`Timezone`](https://pkg.go.dev/github.com/expr-lang/expr#Timezone) option. ```go -options := []expr.Option{ - expr.Env(Env{}) - expr.AsInt(), - expr.WarnOnAny(), - expr.WithContext("ctx"), - expr.ConstExpr("fib"), -} - -program, err := expr.Compile(code, options...) +program, err := expr.Compile(code, expr.Timezone(time.UTC)) ``` -Full list of available options can be found in the [pkg.go.dev](https://pkg.go.dev/github.com/expr-lang/expr#Option) documentation. +The timezone is used for the following functions: +```expr +date("2024-11-23 12:00:00") // parses the date in the specified timezone +now() // returns the current time in the specified timezone +``` diff --git a/docs/environment.md b/docs/environment.md index 2ae2f0af6..450e9e30c 100644 --- a/docs/environment.md +++ b/docs/environment.md @@ -84,12 +84,28 @@ is the value's type. env := map[string]any{ "object": map[string]any{ "field": 42, - }, + }, + "struct": struct { + Field int `expr:"field"` + }{42}, } ``` Expr will infer the type of the `object` variable as `map[string]any`. +Accessing fields of the `object` and `struct` variables will return the following results. -By default, Expr will return an error if unknown variables are used in the expression. +```expr +object.field // 42 +object.unknown // nil (no error) + +struct.field // 42 +struct.unknown // error (unknown field) + +foobar // error (unknown variable) +``` +:::note +The `foobar` variable is not defined in the environment. +By default, Expr will return an error if unknown variables are used in the expression. You can disable this behavior by passing [`AllowUndefinedVariables`](https://pkg.go.dev/github.com/expr-lang/expr#AllowUndefinedVariables) option to the compiler. +::: diff --git a/docs/functions.md b/docs/functions.md index 03b5b9641..0e2783ed3 100644 --- a/docs/functions.md +++ b/docs/functions.md @@ -49,6 +49,7 @@ atoi := expr.Function( func(params ...any) (any, error) { return strconv.Atoi(params[0].(string)) }, + // highlight-next-line new(func(string) int), ) ``` @@ -80,7 +81,9 @@ toInt := expr.Function( } return nil, fmt.Errorf("invalid type") }, + // highlight-start new(func(float64) int), new(func(string) int), + // highlight-end ) ``` diff --git a/docs/getting-started.md b/docs/getting-started.md index 8ee14fd49..6ff7fc852 100644 --- a/docs/getting-started.md +++ b/docs/getting-started.md @@ -72,6 +72,7 @@ env := map[string]any{ program, err := expr.Compile(`name + age`, expr.Env(env)) if err != nil { + // highlight-next-line panic(err) // Will panic with "invalid operation: string + int" } ``` @@ -85,9 +86,7 @@ env := map[string]any{ "sprintf": fmt.Sprintf, } -code := `sprintf(greet, names[0])` - -program, err := expr.Compile(code, expr.Env(env)) +program, err := expr.Compile(`sprintf(greet, names[0])`, expr.Env(env)) if err != nil { panic(err) } @@ -100,17 +99,14 @@ if err != nil { fmt.Print(output) // Hello, world! ``` -Also, Expr can use a struct as an environment. Methods defined on the struct become functions. -The struct fields can be renamed with the `expr` tag. - -Here is an example: +Also, Expr can use a struct as an environment. Here is an example: ```go type Env struct { Posts []Post `expr:"posts"` } -func (Env) Format(t time.Time) string { +func (Env) Format(t time.Time) string { // Methods defined on the struct become functions. return t.Format(time.RFC822) } @@ -122,7 +118,7 @@ type Post struct { func main() { code := `map(posts, Format(.Date) + ": " + .Body)` - program, err := expr.Compile(code, expr.Env(Env{})) + program, err := expr.Compile(code, expr.Env(Env{})) // Pass the struct as an environment. if err != nil { panic(err) } @@ -172,7 +168,7 @@ if err != nil { fmt.Print(output) // 7 ``` -:::tip +:::info Eval = Compile + Run For one-off expressions, you can use the `expr.Eval` function. It compiles and runs the expression in one step. ```go output, err := expr.Eval(`2 + 2`, env) diff --git a/docs/patch.md b/docs/patch.md index 835e78f6a..b3df6648c 100644 --- a/docs/patch.md +++ b/docs/patch.md @@ -1,8 +1,8 @@ # Patch Sometimes it may be necessary to modify an expression before the compilation. -Expr provides a powerful mechanism to modify the expression using -the [`Patch`](https://pkg.go.dev/github.com/expr-lang/expr#Patch) option. +For example, you may want to replace a variable with a constant, transform an expression into a function call, +or even modify the expression to use a different operator. ## Simple example @@ -19,12 +19,15 @@ type FooPatcher struct{} func (FooPatcher) Visit(node *ast.Node) { if n, ok := (*node).(*ast.IdentifierNode); ok && n.Value == "foo" { + // highlight-next-line ast.Patch(node, &ast.IntegerNode{Value: 42}) } } ``` -Now we can use the `FooPatcher` to modify the expression: +We used the [ast.Patch](https://pkg.go.dev/github.com/expr-lang/expr/ast#Patch) function to replace the `foo` variable with an integer node. + +Now we can use the `FooPatcher` to modify the expression on compilation via the [expr.Patch](https://pkg.go.dev/github.com/expr-lang/expr#Patch) option: ```go program, err := expr.Compile(`foo + bar`, expr.Patch(FooPatcher{})) @@ -61,17 +64,24 @@ var decimalType = reflect.TypeOf(Decimal{}) func (DecimalPatcher) Visit(node *ast.Node) { if n, ok := (*node).(*ast.BinaryNode); ok && n.Operator == "+" { + if !n.Left.Type().AssignableTo(decimalType) { return // skip, left side is not a Decimal } + if !n.Right.Type().AssignableTo(decimalType) { return // skip, right side is not a Decimal } - ast.Patch(node, &ast.CallNode{ + + // highlight-start + callNode := &ast.CallNode{ Callee: &ast.IdentifierNode{Value: "add"}, Arguments: []ast.Node{n.Left, n.Right}, - }) - (*node).SetType(decimalType) // set the type, so patcher can be used multiple times + } + ast.Patch(node, callNode) + // highlight-end + + (*node).SetType(decimalType) // set the type, so the patcher can be applied recursively } } ``` @@ -97,6 +107,7 @@ env := map[string]interface{}{ code := `a + b + c` +// highlight-next-line program, err := expr.Compile(code, expr.Env(env), expr.Patch(DecimalPatcher{})) if err != nil { panic(err) diff --git a/docs/visitor.md b/docs/visitor.md index 24532d3da..f771c62ef 100644 --- a/docs/visitor.md +++ b/docs/visitor.md @@ -1,11 +1,13 @@ # Visitor -Expr provides an interface to traverse the AST of the expression before the compilation. +Expr provides an interface to traverse the AST of the expression before the compilation. The `Visitor` interface allows you to collect information about the expression, modify the expression, or even generate a new expression. Let's start with an [ast.Visitor](https://pkg.go.dev/github.com/expr-lang/expr/ast#Visitor) implementation which will -collect all variables used in the expression: +collect all variables used in the expression. + +Visitor must implement a single method `Visit(*ast.Node)`, which will be called for each node in the AST. ```go type Visitor struct { @@ -30,6 +32,7 @@ if err != nil { } v := &Visitor{} +// highlight-next-line ast.Walk(&tree.Node, v) fmt.Println(v.Identifiers) // [foo, bar] @@ -40,6 +43,12 @@ fmt.Println(v.Identifiers) // [foo, bar] Although it is possible to access the AST of compiled program, it may be already be modified by patchers, optimizers, etc. ```go +program, err := expr.Compile(`foo + bar`) +if err != nil { + panic(err) +} + +// highlight-next-line node := program.Node() v := &Visitor{} From e135bda12b39f28b59545530229fbcab51efbaf4 Mon Sep 17 00:00:00 2001 From: Anton Medvedev Date: Tue, 18 Mar 2025 10:49:13 +0100 Subject: [PATCH 076/113] Fix parsing of variable declaration nodes combined with sequence node (#773) Fixes #772 --- parser/parser.go | 6 ++-- parser/parser_test.go | 72 +++++++++++++++++++++++++++++++------------ 2 files changed, 56 insertions(+), 22 deletions(-) diff --git a/parser/parser.go b/parser/parser.go index 5ba16d2a2..91c0fa8f8 100644 --- a/parser/parser.go +++ b/parser/parser.go @@ -323,13 +323,13 @@ func (p *parser) parseConditional(node Node) Node { p.next() if !p.current.Is(Operator, ":") { - expr1 = p.parseSequenceExpression() + expr1 = p.parseExpression(0) p.expect(Operator, ":") - expr2 = p.parseSequenceExpression() + expr2 = p.parseExpression(0) } else { p.next() expr1 = node - expr2 = p.parseSequenceExpression() + expr2 = p.parseExpression(0) } node = p.createNode(&ConditionalNode{ diff --git a/parser/parser_test.go b/parser/parser_test.go index 9c707856d..16dac6b79 100644 --- a/parser/parser_test.go +++ b/parser/parser_test.go @@ -683,18 +683,20 @@ world`}, }, }, { - "true ? 1; 2; 3 : 4", - &ConditionalNode{ - Cond: &BoolNode{Value: true}, - Exp1: &SequenceNode{ - Nodes: []Node{ - &IntegerNode{Value: 1}, - &IntegerNode{Value: 2}, - &IntegerNode{Value: 3}}}, - Exp2: &IntegerNode{Value: 4}}, + "true ? 1 : 2; 3 ; 4", + &SequenceNode{ + Nodes: []Node{ + &ConditionalNode{ + Cond: &BoolNode{Value: true}, + Exp1: &IntegerNode{Value: 1}, + Exp2: &IntegerNode{Value: 2}}, + &IntegerNode{Value: 3}, + &IntegerNode{Value: 4}, + }, + }, }, { - "true ? 1 : 2; 3 ; 4", + "true ? 1 : ( 2; 3; 4 )", &ConditionalNode{ Cond: &BoolNode{Value: true}, Exp1: &IntegerNode{Value: 1}, @@ -702,18 +704,50 @@ world`}, Nodes: []Node{ &IntegerNode{Value: 2}, &IntegerNode{Value: 3}, - &IntegerNode{Value: 4}}}}, + &IntegerNode{Value: 4}, + }, + }, + }, }, { "true ?: 1; 2; 3", - &ConditionalNode{ - Cond: &BoolNode{Value: true}, - Exp1: &BoolNode{Value: true}, - Exp2: &SequenceNode{ - Nodes: []Node{ - &IntegerNode{Value: 1}, - &IntegerNode{Value: 2}, - &IntegerNode{Value: 3}}}}, + &SequenceNode{ + Nodes: []Node{ + &ConditionalNode{ + Cond: &BoolNode{Value: true}, + Exp1: &BoolNode{Value: true}, + Exp2: &IntegerNode{Value: 1}}, + &IntegerNode{Value: 2}, + &IntegerNode{Value: 3}, + }, + }, + }, + { + `let x = true ? 1 : 2; x`, + &VariableDeclaratorNode{ + Name: "x", + Value: &ConditionalNode{ + Cond: &BoolNode{Value: true}, + Exp1: &IntegerNode{Value: 1}, + Exp2: &IntegerNode{Value: 2}}, + Expr: &IdentifierNode{Value: "x"}}, + }, + { + "let x = true ? 1 : ( 2; 3; 4 ); x", + &VariableDeclaratorNode{ + Name: "x", + Value: &ConditionalNode{ + Cond: &BoolNode{Value: true}, + Exp1: &IntegerNode{Value: 1}, + Exp2: &SequenceNode{ + Nodes: []Node{ + &IntegerNode{Value: 2}, + &IntegerNode{Value: 3}, + &IntegerNode{Value: 4}, + }, + }, + }, + Expr: &IdentifierNode{Value: "x"}}, }, { "if true { 1; 2; 3 } else { 4; 5; 6 }", From 437bc8e5730238db5d30184a57a239507a533c86 Mon Sep 17 00:00:00 2001 From: Anton Medvedev Date: Tue, 18 Mar 2025 23:08:02 +0100 Subject: [PATCH 077/113] Refactor random code get --- test/gen/env.go | 47 +++++++ test/gen/gen.go | 298 ++++++++++++++++++++----------------------- test/gen/gen_test.go | 4 +- test/gen/utils.go | 36 ++---- 4 files changed, 195 insertions(+), 190 deletions(-) create mode 100644 test/gen/env.go diff --git a/test/gen/env.go b/test/gen/env.go new file mode 100644 index 000000000..a2a7b0ce1 --- /dev/null +++ b/test/gen/env.go @@ -0,0 +1,47 @@ +package main + +var Env = map[string]any{ + "ok": true, + "i": 1, + "str": "str", + "f64": .5, + "f32": float32(.5), + "i64": int64(1), + "i32": int32(2), + "u64": uint64(4), + "u32": uint32(5), + "u16": uint16(6), + "u8": uint8(7), + "array": []int{1, 2, 3, 4, 5}, + "foo": Foo{"foo"}, + "bar": Bar{42, "bar"}, + "listOfFoo": []Foo{{"bar"}, {"baz"}}, + "add": func(a, b int) int { return a + b }, + "div": func(a, b int) int { return a / b }, + "half": func(a float64) float64 { return a / 2 }, + "sumUp": func(a int, x ...int) int { + s := a + for _, n := range x { + s += n + } + return s + }, + "greet": func(name string) string { return "Hello, " + name }, +} + +type Foo struct { + Bar string +} + +func (f Foo) String() string { + return "foo" +} + +func (f Foo) Qux(s string) string { + return f.Bar + s +} + +type Bar struct { + I int `expr:"i"` + Str string `expr:"str"` +} diff --git a/test/gen/gen.go b/test/gen/gen.go index 1eb36c9bf..4e184621d 100644 --- a/test/gen/gen.go +++ b/test/gen/gen.go @@ -2,50 +2,14 @@ package main import ( "fmt" - "math/rand" "reflect" "runtime/debug" + "strings" "github.com/expr-lang/expr" - "github.com/expr-lang/expr/ast" "github.com/expr-lang/expr/builtin" ) -var env = map[string]any{ - "ok": true, - "f64": .5, - "f32": float32(.5), - "i": 1, - "i64": int64(1), - "i32": int32(1), - "array": []int{1, 2, 3, 4, 5}, - "list": []Foo{{"bar"}, {"baz"}}, - "foo": Foo{"bar"}, - "add": func(a, b int) int { return a + b }, - "div": func(a, b int) int { return a / b }, - "half": func(a float64) float64 { return a / 2 }, - "score": func(a int, x ...int) int { - s := a - for _, n := range x { - s += n - } - return s - }, - "greet": func(name string) string { return "Hello, " + name }, -} - -type Foo struct { - Bar string -} - -func (f Foo) String() string { - return "foo" -} - -func (f Foo) Qux(s string) string { - return f.Bar + s -} - var ( dict []string predicates []string @@ -83,7 +47,7 @@ var ( ) func init() { - for name, x := range env { + for name, x := range Env { dict = append(dict, name) v := reflect.ValueOf(x) if v.Kind() == reflect.Struct { @@ -121,7 +85,7 @@ func main() { var corpus = map[string]struct{}{} for { - code = node(weightedRandomInt([]intWeight{ + code = node(oneOf(list[int]{ {3, 100}, {4, 40}, {5, 50}, @@ -130,13 +94,13 @@ func main() { {8, 10}, {9, 5}, {10, 5}, - })).String() + })) - program, err := expr.Compile(code, expr.Env(env)) + program, err := expr.Compile(code, expr.Env(Env)) if err != nil { continue } - _, err = expr.Run(program, env) + _, err = expr.Run(program, Env) if err != nil { continue } @@ -149,9 +113,11 @@ func main() { } } -func node(depth int) ast.Node { +type fn func(depth int) string + +func node(depth int) string { if depth <= 0 { - return weightedRandom([]fnWeight{ + return oneOf(list[fn]{ {nilNode, 1}, {floatNode, 1}, {integerNode, 1}, @@ -161,7 +127,7 @@ func node(depth int) ast.Node { {pointerNode, 10}, })(depth - 1) } - return weightedRandom([]fnWeight{ + return oneOf(list[fn]{ {arrayNode, 1}, {mapNode, 1}, {identifierNode, 1000}, @@ -169,6 +135,7 @@ func node(depth int) ast.Node { {unaryNode, 100}, {binaryNode, 2000}, {callNode, 2000}, + {pipeNode, 1000}, {builtinNode, 500}, {predicateNode, 1000}, {pointerNode, 500}, @@ -177,183 +144,192 @@ func node(depth int) ast.Node { })(depth - 1) } -func nilNode(_ int) ast.Node { - return &ast.NilNode{} +func nilNode(_ int) string { + return "nil" } -func floatNode(_ int) ast.Node { - return &ast.FloatNode{ - Value: .5, - } +func floatNode(_ int) string { + return oneOf(list[string]{ + {"1.0", 1}, + {".5", 1}, + {"0.0", 1}, + {"-1.0", 1}, + {"1e+10", 1}, + {"1e-10", 1}, + }) } -func integerNode(_ int) ast.Node { - return &ast.IntegerNode{ - Value: 1, - } +func integerNode(_ int) string { + return oneOf(list[string]{ + {"1", 1}, + {"2", 1}, + {"-1", 1}, + {"0", 1}, + }) } -func stringNode(_ int) ast.Node { - words := []string{ - "foo", - "bar", - } - return &ast.StringNode{ - Value: words[rand.Intn(len(words))], - } +func stringNode(_ int) string { + return oneOf(list[string]{ + {"foo", 1}, + {"bar", 1}, + {"str", 1}, + }) } -func booleanNode(_ int) ast.Node { - return &ast.BoolNode{ - Value: maybe(), +func booleanNode(_ int) string { + if maybe() { + return "true" } + return "false" } -func identifierNode(_ int) ast.Node { - return &ast.IdentifierNode{ - Value: dict[rand.Intn(len(dict))], - } +func identifierNode(_ int) string { + return random(dict) } -func memberNode(depth int) ast.Node { - return &ast.MemberNode{ - Node: node(depth - 1), - Property: weightedRandom([]fnWeight{ - {func(_ int) ast.Node { return &ast.StringNode{Value: dict[rand.Intn(len(dict))]} }, 5}, - {node, 1}, - })(depth - 1), - Optional: maybe(), +func memberNode(depth int) string { + dot := "." + if maybe() { + dot = "?." } + prop := oneOf(list[fn]{ + {func(_ int) string { return random(dict) }, 5}, + {node, 1}, + })(depth - 1) + if maybe() { + return fmt.Sprintf("%v%v%v", node(depth-1), dot, prop) + } + return fmt.Sprintf("%v%v[%v]", node(depth-1), dot, prop) } -func unaryNode(depth int) ast.Node { - cases := []string{"-", "!", "not"} - return &ast.UnaryNode{ - Operator: cases[rand.Intn(len(cases))], - Node: node(depth - 1), - } +func unaryNode(depth int) string { + return random([]string{"-", "!", "not"}) } -func binaryNode(depth int) ast.Node { - return &ast.BinaryNode{ - Operator: operators[rand.Intn(len(operators))], - Left: node(depth - 1), - Right: node(depth - 1), - } +func binaryNode(depth int) string { + return fmt.Sprintf("%v %v %v", node(depth-1), random(operators), node(depth-1)) } -func methodNode(depth int) ast.Node { - return &ast.MemberNode{ - Node: node(depth - 1), - Property: &ast.StringNode{Value: dict[rand.Intn(len(dict))]}, - Optional: maybe(), +func methodNode(depth int) string { + dot := "." + if maybe() { + dot = "?." + } + method := random(dict) + if maybe() { + return fmt.Sprintf("%v%v%v", node(depth-1), dot, method) } + return fmt.Sprintf("%v%v[%v]", node(depth-1), dot, method) } -func funcNode(_ int) ast.Node { - return &ast.IdentifierNode{ - Value: dict[rand.Intn(len(dict))], - } +func funcNode(_ int) string { + return random(dict) } -func callNode(depth int) ast.Node { - var args []ast.Node - max := weightedRandomInt([]intWeight{ +func callNode(depth int) string { + var args []string + for i := 0; i < oneOf(list[int]{ {0, 100}, {1, 100}, {2, 50}, {3, 25}, {4, 10}, {5, 5}, - }) - for i := 0; i < max; i++ { + }); i++ { args = append(args, node(depth-1)) } - return &ast.CallNode{ - Callee: weightedRandom([]fnWeight{ - {methodNode, 2}, - {funcNode, 2}, - })(depth - 1), - Arguments: args, - } + + fn := oneOf(list[fn]{ + {methodNode, 2}, + {funcNode, 2}, + })(depth - 1) + + return fmt.Sprintf("%v(%v)", fn, strings.Join(args, ", ")) +} + +func pipeNode(depth int) string { + a := node(depth - 1) + b := oneOf(list[fn]{ + {callNode, 2}, + {builtinNode, 5}, + {predicateNode, 10}, + })(depth - 1) + + return fmt.Sprintf("%v | %v", a, b) } -func builtinNode(depth int) ast.Node { - var args []ast.Node - max := weightedRandomInt([]intWeight{ +func builtinNode(depth int) string { + var args []string + for i := 0; i < oneOf(list[int]{ {1, 100}, {2, 50}, {3, 50}, {4, 10}, - }) - for i := 0; i < max; i++ { + }); i++ { args = append(args, node(depth-1)) } - return &ast.BuiltinNode{ - Name: builtins[rand.Intn(len(builtins))], - Arguments: args, - } + return fmt.Sprintf("%v(%v)", random(builtins), strings.Join(args, ", ")) } -func predicateNode(depth int) ast.Node { - return &ast.BuiltinNode{ - Name: predicates[rand.Intn(len(predicates))], - Arguments: []ast.Node{ - node(depth - 1), - node(depth - 1), - }, +func predicateNode(depth int) string { + var args []string + for i := 0; i < oneOf(list[int]{ + {1, 100}, + {2, 50}, + {3, 50}, + }); i++ { + args = append(args, node(depth-1)) } + return fmt.Sprintf("%v(%v)", random(builtins), strings.Join(args, ", ")) } -func pointerNode(_ int) ast.Node { - return &ast.PointerNode{} +func pointerNode(_ int) string { + return oneOf(list[string]{ + {"#", 100}, + {"#." + random(dict), 100}, + {"." + random(dict), 100}, + {"#acc", 10}, + {"#index", 10}, + }) } -func arrayNode(depth int) ast.Node { - var items []ast.Node - max := weightedRandomInt([]intWeight{ +func arrayNode(depth int) string { + var items []string + for i := 0; i < oneOf(list[int]{ {1, 100}, {2, 50}, {3, 25}, - }) - for i := 0; i < max; i++ { + }); i++ { items = append(items, node(depth-1)) } - return &ast.ArrayNode{ - Nodes: items, - } + return fmt.Sprintf("[%v]", strings.Join(items, ", ")) } -func mapNode(depth int) ast.Node { - var items []ast.Node - max := weightedRandomInt([]intWeight{ +func mapNode(depth int) string { + var items []string + for i := 0; i < oneOf(list[int]{ {1, 100}, {2, 50}, {3, 25}, - }) - for i := 0; i < max; i++ { - items = append(items, &ast.PairNode{ - Key: stringNode(depth - 1), - Value: node(depth - 1), - }) - } - return &ast.MapNode{ - Pairs: items, + }); i++ { + items = append(items, fmt.Sprintf("%v: %v", stringNode(depth-1), node(depth-1))) } + return fmt.Sprintf("{%v}", strings.Join(items, ", ")) } -func sliceNode(depth int) ast.Node { - return &ast.SliceNode{ - Node: node(depth - 1), - From: node(depth - 1), - To: node(depth - 1), - } +func sliceNode(depth int) string { + return oneOf(list[string]{ + {fmt.Sprintf("%v[%v:%v]", node(depth-1), node(depth-1), node(depth-1)), 100}, + {fmt.Sprintf("%v[%v:]", node(depth-1), node(depth-1)), 100}, + {fmt.Sprintf("%v[:%v]", node(depth-1), node(depth-1)), 100}, + {fmt.Sprintf("%v[:]", node(depth-1)), 1}, + }) } -func conditionalNode(depth int) ast.Node { - return &ast.ConditionalNode{ - Cond: node(depth - 1), - Exp1: node(depth - 1), - Exp2: node(depth - 1), - } +func conditionalNode(depth int) string { + return oneOf(list[string]{ + {fmt.Sprintf("if %v { %v } else { %v }", node(depth-1), node(depth-1), node(depth-1)), 100}, + {fmt.Sprintf("%v ? %v : %v", node(depth-1), node(depth-1), node(depth-1)), 100}, + {fmt.Sprintf("%v ?: %v", node(depth-1), node(depth-1)), 20}, + }) } diff --git a/test/gen/gen_test.go b/test/gen/gen_test.go index ef4a30bc8..cb6c08e00 100644 --- a/test/gen/gen_test.go +++ b/test/gen/gen_test.go @@ -25,7 +25,7 @@ func TestGenerated(t *testing.T) { for _, line := range strings.Split(examples, "\n") { line := line t.Run(line, func(t *testing.T) { - program, err := expr.Compile(line, expr.Env(env)) + program, err := expr.Compile(line, expr.Env(Env)) if err != nil { if !*updateFlag { t.Errorf("Compilation failed: %v", err) @@ -33,7 +33,7 @@ func TestGenerated(t *testing.T) { return } - _, err = expr.Run(program, env) + _, err = expr.Run(program, Env) if err != nil { if !*updateFlag { t.Errorf("Execution failed: %v", err) diff --git a/test/gen/utils.go b/test/gen/utils.go index b485fd1a1..3ef76d0e1 100644 --- a/test/gen/utils.go +++ b/test/gen/utils.go @@ -2,27 +2,25 @@ package main import ( "math/rand" - - "github.com/expr-lang/expr/ast" ) func maybe() bool { return rand.Intn(2) == 0 } -type fn func(int) ast.Node +type list[T any] []element[T] -type fnWeight struct { - value fn +type element[T any] struct { + value T weight int } -func weightedRandom(cases []fnWeight) fn { - totalWeight := 0 +func oneOf[T any](cases []element[T]) T { + total := 0 for _, c := range cases { - totalWeight += c.weight + total += c.weight } - r := rand.Intn(totalWeight) + r := rand.Intn(total) for _, c := range cases { if r < c.weight { return c.value @@ -32,22 +30,6 @@ func weightedRandom(cases []fnWeight) fn { return cases[0].value } -type intWeight struct { - value int - weight int -} - -func weightedRandomInt(cases []intWeight) int { - totalWeight := 0 - for _, c := range cases { - totalWeight += c.weight - } - r := rand.Intn(totalWeight) - for _, c := range cases { - if r < c.weight { - return c.value - } - r -= c.weight - } - return cases[0].value +func random[T any](array []T) T { + return array[rand.Intn(len(array))] } From dc7c30218dc15f496c259431cf6ffd1e545836b0 Mon Sep 17 00:00:00 2001 From: Anton Medvedev Date: Tue, 18 Mar 2025 23:20:00 +0100 Subject: [PATCH 078/113] gen: use all cpus --- test/gen/gen.go | 93 ++++++++++++++++++++++++++++++------------------- 1 file changed, 57 insertions(+), 36 deletions(-) diff --git a/test/gen/gen.go b/test/gen/gen.go index 4e184621d..184ae46ed 100644 --- a/test/gen/gen.go +++ b/test/gen/gen.go @@ -3,8 +3,10 @@ package main import ( "fmt" "reflect" + "runtime" "runtime/debug" "strings" + "sync" "github.com/expr-lang/expr" "github.com/expr-lang/expr/builtin" @@ -74,43 +76,62 @@ func init() { } func main() { - var code string - defer func() { - if r := recover(); r != nil { - fmt.Printf("==========================\n%s\n==========================\n%s\n==========================\n", code, r) - debug.PrintStack() - } - }() - - var corpus = map[string]struct{}{} - - for { - code = node(oneOf(list[int]{ - {3, 100}, - {4, 40}, - {5, 50}, - {6, 30}, - {7, 20}, - {8, 10}, - {9, 5}, - {10, 5}, - })) - - program, err := expr.Compile(code, expr.Env(Env)) - if err != nil { - continue - } - _, err = expr.Run(program, Env) - if err != nil { - continue - } - - if _, ok := corpus[code]; ok { - continue - } - corpus[code] = struct{}{} - fmt.Println(code) + runtime.GOMAXPROCS(runtime.NumCPU()) + + var corpus = make(map[string]struct{}) + var corpusMutex sync.Mutex + + numWorkers := runtime.NumCPU() + var wg sync.WaitGroup + wg.Add(numWorkers) + + for i := 0; i < numWorkers; i++ { + go func(workerID int) { + defer func() { + if r := recover(); r != nil { + fmt.Printf("Worker %d recovered from panic: %v\n", workerID, r) + debug.PrintStack() + } + }() + + defer wg.Done() + for { + var code string + + code = node(oneOf(list[int]{ + {3, 100}, + {4, 40}, + {5, 50}, + {6, 30}, + {7, 20}, + {8, 10}, + {9, 5}, + {10, 5}, + })) + + program, err := expr.Compile(code, expr.Env(Env)) + if err != nil { + continue + } + _, err = expr.Run(program, Env) + if err != nil { + continue + } + + corpusMutex.Lock() + if _, exists := corpus[code]; exists { + corpusMutex.Unlock() + continue + } + corpus[code] = struct{}{} + corpusMutex.Unlock() + + fmt.Println(code) + } + }(i) } + + wg.Wait() } type fn func(depth int) string From a81f28a14747aa1f64eb5be4ec306253e497cf5d Mon Sep 17 00:00:00 2001 From: Anton Medvedev Date: Tue, 18 Mar 2025 23:38:28 +0100 Subject: [PATCH 079/113] gen: simplify search --- test/gen/env.go | 42 ++++++++---------------------------------- test/gen/gen.go | 22 +++------------------- 2 files changed, 11 insertions(+), 53 deletions(-) diff --git a/test/gen/env.go b/test/gen/env.go index a2a7b0ce1..077575280 100644 --- a/test/gen/env.go +++ b/test/gen/env.go @@ -1,31 +1,14 @@ package main var Env = map[string]any{ - "ok": true, - "i": 1, - "str": "str", - "f64": .5, - "f32": float32(.5), - "i64": int64(1), - "i32": int32(2), - "u64": uint64(4), - "u32": uint32(5), - "u16": uint16(6), - "u8": uint8(7), - "array": []int{1, 2, 3, 4, 5}, - "foo": Foo{"foo"}, - "bar": Bar{42, "bar"}, - "listOfFoo": []Foo{{"bar"}, {"baz"}}, - "add": func(a, b int) int { return a + b }, - "div": func(a, b int) int { return a / b }, - "half": func(a float64) float64 { return a / 2 }, - "sumUp": func(a int, x ...int) int { - s := a - for _, n := range x { - s += n - } - return s - }, + "ok": true, + "i": 1, + "str": "str", + "f64": .5, + "array": []int{1, 2, 3, 4, 5}, + "foo": Foo{"foo"}, + "list": []Foo{{"bar"}, {"baz"}}, + "add": func(a, b int) int { return a + b }, "greet": func(name string) string { return "Hello, " + name }, } @@ -36,12 +19,3 @@ type Foo struct { func (f Foo) String() string { return "foo" } - -func (f Foo) Qux(s string) string { - return f.Bar + s -} - -type Bar struct { - I int `expr:"i"` - Str string `expr:"str"` -} diff --git a/test/gen/gen.go b/test/gen/gen.go index 184ae46ed..02d4cdbef 100644 --- a/test/gen/gen.go +++ b/test/gen/gen.go @@ -170,38 +170,22 @@ func nilNode(_ int) string { } func floatNode(_ int) string { - return oneOf(list[string]{ - {"1.0", 1}, - {".5", 1}, - {"0.0", 1}, - {"-1.0", 1}, - {"1e+10", 1}, - {"1e-10", 1}, - }) + return "1.0" } func integerNode(_ int) string { return oneOf(list[string]{ {"1", 1}, - {"2", 1}, - {"-1", 1}, {"0", 1}, }) } func stringNode(_ int) string { - return oneOf(list[string]{ - {"foo", 1}, - {"bar", 1}, - {"str", 1}, - }) + return "foo" } func booleanNode(_ int) string { - if maybe() { - return "true" - } - return "false" + return random([]string{"true", "false"}) } func identifierNode(_ int) string { From ccfad1d322f591b004bd2f56c14028426f4f0bc8 Mon Sep 17 00:00:00 2001 From: Anton Medvedev Date: Tue, 18 Mar 2025 23:45:05 +0100 Subject: [PATCH 080/113] gen: add vars --- test/gen/gen.go | 27 +++++++++++++++++++++++++-- 1 file changed, 25 insertions(+), 2 deletions(-) diff --git a/test/gen/gen.go b/test/gen/gen.go index 02d4cdbef..4825c348b 100644 --- a/test/gen/gen.go +++ b/test/gen/gen.go @@ -149,8 +149,10 @@ func node(depth int) string { })(depth - 1) } return oneOf(list[fn]{ - {arrayNode, 1}, - {mapNode, 1}, + {sequenceNode, 1}, + {variableNode, 1}, + {arrayNode, 10}, + {mapNode, 10}, {identifierNode, 1000}, {memberNode, 1500}, {unaryNode, 100}, @@ -189,6 +191,9 @@ func booleanNode(_ int) string { } func identifierNode(_ int) string { + if maybe() { + return "x" + } return random(dict) } @@ -338,3 +343,21 @@ func conditionalNode(depth int) string { {fmt.Sprintf("%v ?: %v", node(depth-1), node(depth-1)), 20}, }) } + +func sequenceNode(depth int) string { + var items []string + for i := 0; i < oneOf(list[int]{ + {2, 50}, + {3, 25}, + }); i++ { + items = append(items, node(depth-1)) + } + if maybe() { + return strings.Join(items, "; ") + } + return fmt.Sprintf("(%v)", strings.Join(items, ", ")) +} + +func variableNode(depth int) string { + return fmt.Sprintf("let x = %v; %v", node(depth-1), node(depth-1)) +} From 0a4ba824070233a518d47c066a7e8519116c9731 Mon Sep 17 00:00:00 2001 From: Anton Medvedev Date: Tue, 18 Mar 2025 23:54:38 +0100 Subject: [PATCH 081/113] gen: add $env --- test/gen/gen.go | 16 ++++++++++++++-- 1 file changed, 14 insertions(+), 2 deletions(-) diff --git a/test/gen/gen.go b/test/gen/gen.go index 4825c348b..9b8b788df 100644 --- a/test/gen/gen.go +++ b/test/gen/gen.go @@ -140,6 +140,7 @@ func node(depth int) string { if depth <= 0 { return oneOf(list[fn]{ {nilNode, 1}, + {envNode, 1}, {floatNode, 1}, {integerNode, 1}, {stringNode, 1}, @@ -171,6 +172,10 @@ func nilNode(_ int) string { return "nil" } +func envNode(_ int) string { + return "$env" +} + func floatNode(_ int) string { return "1.0" } @@ -192,7 +197,7 @@ func booleanNode(_ int) string { func identifierNode(_ int) string { if maybe() { - return "x" + return "foobar" } return random(dict) } @@ -359,5 +364,12 @@ func sequenceNode(depth int) string { } func variableNode(depth int) string { - return fmt.Sprintf("let x = %v; %v", node(depth-1), node(depth-1)) + e := node(depth - 1) + if e == "foobar" { + return "~!@" + } + if !strings.Contains(e, "foobar") { + return "~!@" + } + return fmt.Sprintf("let foobar = %v; %v", node(depth-1), e) } From 253a4a111873689b6a3e0e8c83c45e29e47da56e Mon Sep 17 00:00:00 2001 From: Anton Medvedev Date: Tue, 18 Mar 2025 23:57:51 +0100 Subject: [PATCH 082/113] gen: less string vars --- test/gen/gen.go | 3 --- 1 file changed, 3 deletions(-) diff --git a/test/gen/gen.go b/test/gen/gen.go index 9b8b788df..2bd06fadd 100644 --- a/test/gen/gen.go +++ b/test/gen/gen.go @@ -365,9 +365,6 @@ func sequenceNode(depth int) string { func variableNode(depth int) string { e := node(depth - 1) - if e == "foobar" { - return "~!@" - } if !strings.Contains(e, "foobar") { return "~!@" } From 27604cf508c84ba0db613db4cdb94544a3539ecc Mon Sep 17 00:00:00 2001 From: Anton Medvedev Date: Wed, 19 Mar 2025 12:32:03 +0100 Subject: [PATCH 083/113] gen: fix predicate generator --- test/gen/gen.go | 30 +++++++++++++++--------------- 1 file changed, 15 insertions(+), 15 deletions(-) diff --git a/test/gen/gen.go b/test/gen/gen.go index 2bd06fadd..a13a8f810 100644 --- a/test/gen/gen.go +++ b/test/gen/gen.go @@ -150,21 +150,21 @@ func node(depth int) string { })(depth - 1) } return oneOf(list[fn]{ - {sequenceNode, 1}, - {variableNode, 1}, - {arrayNode, 10}, - {mapNode, 10}, - {identifierNode, 1000}, - {memberNode, 1500}, - {unaryNode, 100}, - {binaryNode, 2000}, - {callNode, 2000}, - {pipeNode, 1000}, - {builtinNode, 500}, + //{sequenceNode, 1}, + //{variableNode, 1}, + //{arrayNode, 10}, + //{mapNode, 10}, + //{identifierNode, 1000}, + //{memberNode, 1500}, + //{unaryNode, 100}, + //{binaryNode, 2000}, + //{callNode, 2000}, + //{pipeNode, 1000}, + //{builtinNode, 500}, {predicateNode, 1000}, - {pointerNode, 500}, - {sliceNode, 100}, - {conditionalNode, 100}, + //{pointerNode, 500}, + //{sliceNode, 100}, + //{conditionalNode, 100}, })(depth - 1) } @@ -295,7 +295,7 @@ func predicateNode(depth int) string { }); i++ { args = append(args, node(depth-1)) } - return fmt.Sprintf("%v(%v)", random(builtins), strings.Join(args, ", ")) + return fmt.Sprintf("%v(%v)", random(predicates), strings.Join(args, ", ")) } func pointerNode(_ int) string { From 6565f13d2a596119bacadd7a4049f30bff1df2d6 Mon Sep 17 00:00:00 2001 From: Anton Medvedev Date: Wed, 19 Mar 2025 12:32:26 +0100 Subject: [PATCH 084/113] gen: fix --- test/gen/gen.go | 28 ++++++++++++++-------------- 1 file changed, 14 insertions(+), 14 deletions(-) diff --git a/test/gen/gen.go b/test/gen/gen.go index a13a8f810..b43b677c0 100644 --- a/test/gen/gen.go +++ b/test/gen/gen.go @@ -150,21 +150,21 @@ func node(depth int) string { })(depth - 1) } return oneOf(list[fn]{ - //{sequenceNode, 1}, - //{variableNode, 1}, - //{arrayNode, 10}, - //{mapNode, 10}, - //{identifierNode, 1000}, - //{memberNode, 1500}, - //{unaryNode, 100}, - //{binaryNode, 2000}, - //{callNode, 2000}, - //{pipeNode, 1000}, - //{builtinNode, 500}, + {sequenceNode, 1}, + {variableNode, 1}, + {arrayNode, 10}, + {mapNode, 10}, + {identifierNode, 1000}, + {memberNode, 1500}, + {unaryNode, 100}, + {binaryNode, 2000}, + {callNode, 2000}, + {pipeNode, 1000}, + {builtinNode, 500}, {predicateNode, 1000}, - //{pointerNode, 500}, - //{sliceNode, 100}, - //{conditionalNode, 100}, + {pointerNode, 500}, + {sliceNode, 100}, + {conditionalNode, 100}, })(depth - 1) } From ac5b2c7313f4757672d4a0783ca21225b4f5c44a Mon Sep 17 00:00:00 2001 From: Anton Medvedev Date: Wed, 19 Mar 2025 15:29:59 +0100 Subject: [PATCH 085/113] Update examples.txt --- testdata/examples.txt | 38936 +++++++++++++++++++++------------------- 1 file changed, 20875 insertions(+), 18061 deletions(-) diff --git a/testdata/examples.txt b/testdata/examples.txt index 72afdf6ce..557fa9511 100644 --- a/testdata/examples.txt +++ b/testdata/examples.txt @@ -1,19545 +1,22359 @@ -!!!false -!!(1 <= f64) -!!(1 > 0.5) -!!(i64 != f64) -!!all(array, ok) -!!false -!!ok -!!true -!("bar" != "bar") -!("bar" != "foo") -!("bar" != nil) -!("bar" < "foo") -!("bar" <= "foo") -!("bar" == "bar") -!("bar" == "foo") -!("bar" == nil) -!("bar" > "bar") -!("bar" > "foo") -!("bar" >= "bar") -!("bar" >= "foo") -!("bar" contains "bar") -!("bar" contains "foo") -!("bar" endsWith "bar") -!("bar" endsWith "foo") -!("bar" in foo) -!("bar" matches "foo") -!("bar" not contains "bar") -!("bar" not endsWith "bar") -!("bar" not endsWith "foo") -!("bar" not in foo) -!("bar" not matches "bar") -!("bar" not startsWith "bar") -!("bar" not startsWith "foo") -!("bar" startsWith "bar") -!("foo" != "bar") -!("foo" != nil) -!("foo" < "foo") -!("foo" <= "bar") -!("foo" <= "foo") -!("foo" == "bar") -!("foo" == nil) -!("foo" > "bar") -!("foo" > "foo") -!("foo" >= "bar") -!("foo" contains "bar") -!("foo" contains "foo") -!("foo" endsWith "foo") -!("foo" in foo) -!("foo" matches "bar") -!("foo" matches "foo") -!("foo" not contains "bar") -!("foo" not contains "foo") -!("foo" not endsWith "bar") -!("foo" not matches "bar") -!("foo" not matches "foo") -!("foo" not startsWith "bar") -!("foo" not startsWith "foo") -!("foo" startsWith "bar") -!("foo" startsWith "foo") -!(-f32 < f32) -!(-i < i32) -!(-i32 >= i) -!(0.5 != 0.5) -!(0.5 != 1) -!(0.5 != f32) -!(0.5 != f64) -!(0.5 != i) -!(0.5 != i32) -!(0.5 != i64) -!(0.5 != nil) -!(0.5 < 0.5) -!(0.5 < 1) -!(0.5 < f32) -!(0.5 < f64) -!(0.5 < i) -!(0.5 < i32) -!(0.5 < i64) -!(0.5 <= 0.5) -!(0.5 <= 1) -!(0.5 <= f32) -!(0.5 <= f64) -!(0.5 <= i) -!(0.5 <= i32) -!(0.5 <= i64) -!(0.5 == 0.5) -!(0.5 == 1) -!(0.5 == f32) -!(0.5 == f64) -!(0.5 == i) -!(0.5 == i32) -!(0.5 == i64) -!(0.5 == nil) -!(0.5 > 0.5) -!(0.5 > 1) -!(0.5 > f32) -!(0.5 > f64) -!(0.5 > i) -!(0.5 > i32) -!(0.5 > i64) -!(0.5 >= 0.5) -!(0.5 >= 1) -!(0.5 >= f32) -!(0.5 >= f64) -!(0.5 >= i) -!(0.5 >= i32) -!(0.5 >= i64) -!(0.5 in array) -!(0.5 not in array) -!(1 != 0.5) -!(1 != 1) -!(1 != f32) -!(1 != f64) -!(1 != i) -!(1 != i32) -!(1 != i64) -!(1 != nil) -!(1 / i64 == i64) -!(1 < 0.5) -!(1 < 1) -!(1 < f32) -!(1 < f64) -!(1 < i) -!(1 < i32) -!(1 < i64) -!(1 <= 0.5) -!(1 <= 1) -!(1 <= f32) -!(1 <= f64) -!(1 <= i) -!(1 <= i32) -!(1 <= i64) -!(1 == 0.5) -!(1 == 1) -!(1 == f32) -!(1 == f64) -!(1 == i) -!(1 == i32) -!(1 == i64) -!(1 == nil) -!(1 > 0.5) -!(1 > 1) -!(1 > f32) -!(1 > f64) -!(1 > i) -!(1 > i32) -!(1 > i64) -!(1 >= 0.5) -!(1 >= 1) -!(1 >= f32) -!(1 >= f64) -!(1 >= i) -!(1 >= i32) -!(1 >= i64) -!(1 in array) -!(1 not in array) -!(add != add) -!(add != div) -!(add != nil) -!(add == add) -!(add == div) -!(add == nil) -!(array != array) -!(array != list) -!(array != nil) -!(array == array) -!(array == list) -!(array == nil) -!(div != add) -!(div != div) -!(div != nil) -!(div == add) -!(div == div) -!(f32 != 0.5) -!(f32 != 1) -!(f32 != f32) -!(f32 != f64) -!(f32 != i) -!(f32 != i32) -!(f32 != i64) -!(f32 != nil) -!(f32 < 0.5) -!(f32 < 1) -!(f32 < f32) -!(f32 < f64) -!(f32 < i) -!(f32 < i32) -!(f32 < i64) -!(f32 <= 0.5) -!(f32 <= 1) -!(f32 <= f32) -!(f32 <= f64) -!(f32 <= i32) -!(f32 <= i64) -!(f32 == 0.5) -!(f32 == 1) -!(f32 == f32) -!(f32 == f64) -!(f32 == i) -!(f32 == i32) -!(f32 == i64) -!(f32 == nil) -!(f32 > 0.5) -!(f32 > 1) -!(f32 > f32) -!(f32 > f64) -!(f32 > i) -!(f32 > i32) -!(f32 > i64) -!(f32 >= 0.5) -!(f32 >= 1) -!(f32 >= f32) -!(f32 >= i) -!(f32 >= i32) -!(f32 >= i64) -!(f32 in array) -!(f32 not in array) -!(f64 != 0.5) -!(f64 != 1) -!(f64 != f32) -!(f64 != f64) -!(f64 != i) -!(f64 != i32) -!(f64 != i64) -!(f64 != nil) -!(f64 < 0.5 + 1) -!(f64 < 0.5) -!(f64 < 1) -!(f64 < f64) -!(f64 < i) -!(f64 < i32) -!(f64 < i64) -!(f64 < max(1)) -!(f64 <= 0.5) -!(f64 <= 1) -!(f64 <= i32) -!(f64 <= i64) -!(f64 == 0.5) -!(f64 == 1) -!(f64 == f32) -!(f64 == f64) -!(f64 == i) -!(f64 == i32) -!(f64 == i64) -!(f64 == nil) -!(f64 > 0.5) -!(f64 > 1) -!(f64 > f32) -!(f64 > f64) -!(f64 > i) -!(f64 > i32) -!(f64 > i64) -!(f64 >= 0.5) -!(f64 >= 1) -!(f64 >= f32) -!(f64 >= f64) -!(f64 >= i) -!(f64 >= i32) -!(f64 >= i64) -!(f64 in array) -!(f64 not in array) -!(false != false) -!(false != nil) -!(false != ok) -!(false != true) -!(false && false) -!(false && ok) -!(false && true) -!(false == false) -!(false == nil) -!(false == ok) -!(false == true) -!(false and false) -!(false and ok) -!(false and true) -!(false or false) -!(false or ok) -!(false || false) -!(false || ok) -!(false || true) -!(foo != foo) -!(foo != nil) -!(foo == foo) -!(foo == nil) -!(foo == reduce(list, #)) -!(foo in list) -!(foo not in list) -!(greet != greet) -!(greet != nil) -!(greet == greet) -!(greet == nil) -!(half != half) -!(half != nil) -!(half == half) -!(half == nil) -!(i != 0.5) -!(i != 1) -!(i != f32) -!(i != f64) -!(i != i) -!(i != i32) -!(i != i64) -!(i != nil) -!(i < 0.5) -!(i < 1) -!(i < f64) -!(i < i) -!(i < i32) -!(i < i64) -!(i <= 0.5) -!(i <= 1) -!(i <= f32) -!(i <= f64) -!(i <= i32) -!(i == 0.5) -!(i == 1) -!(i == f32) -!(i == f64) -!(i == i) -!(i == i32) -!(i == i64) -!(i == nil) -!(i > 0.5) -!(i > 1) -!(i > f32) -!(i > f64) -!(i > i) -!(i > i32) -!(i > i64) -!(i >= 0.5) -!(i >= 1 * i64) -!(i >= 1) -!(i >= f32) -!(i >= f64) -!(i >= i) -!(i >= i32) -!(i >= i64) -!(i in array) -!(i not in array) -!(i32 != 0.5) -!(i32 != 1) -!(i32 != f32) -!(i32 != f64) -!(i32 != i) -!(i32 != i32) -!(i32 != i64) -!(i32 != nil) -!(i32 < 0.5) -!(i32 < 1) -!(i32 < f32) -!(i32 < f64) -!(i32 < i) -!(i32 < i32) -!(i32 < i64) -!(i32 <= 0.5) -!(i32 <= 1) -!(i32 <= f32) -!(i32 <= f64) -!(i32 <= i) -!(i32 <= i32) -!(i32 <= i64) -!(i32 == 0.5) -!(i32 == 1) -!(i32 == f32) -!(i32 == f64) -!(i32 == i) -!(i32 == i32) -!(i32 == i64) -!(i32 == nil) -!(i32 > 0.5) -!(i32 > 1) -!(i32 > f32) -!(i32 > f64) -!(i32 > i) -!(i32 > i32) -!(i32 >= 0.5) -!(i32 >= 1) -!(i32 >= f32) -!(i32 >= f64) -!(i32 >= i) -!(i32 >= i32) -!(i32 >= i64) -!(i32 in array) -!(i32 not in array) -!(i64 != 0.5) -!(i64 != 1) -!(i64 != f32) -!(i64 != f64) -!(i64 != i) -!(i64 != i32) -!(i64 != i64) -!(i64 != nil) -!(i64 < 0.5) -!(i64 < 1) -!(i64 < f32) -!(i64 < f64) -!(i64 < i) -!(i64 < i32 + i64) -!(i64 < i32) -!(i64 < i64) -!(i64 <= 0.5) -!(i64 <= 1) -!(i64 <= f32) -!(i64 <= f64) -!(i64 <= i) -!(i64 <= i32) -!(i64 <= i64) -!(i64 == 0.5) -!(i64 == 1) -!(i64 == f32) -!(i64 == f64) -!(i64 == i32) -!(i64 == i64) -!(i64 == nil) -!(i64 > 0.5) -!(i64 > 1) -!(i64 > f32) -!(i64 > f64) -!(i64 > i) -!(i64 > i32) -!(i64 > i64) -!(i64 >= 0.5) -!(i64 >= 1) -!(i64 >= f32) -!(i64 >= f64) -!(i64 >= i) -!(i64 >= i32) -!(i64 >= i64) -!(i64 in array) -!(len("bar") <= i) -!(list != array) -!(list != list) -!(list != nil) -!(list == array) -!(list == list) -!(list == nil) -!(nil != "bar") -!(nil != "foo") -!(nil != 0.5) -!(nil != 1) -!(nil != add) -!(nil != array) -!(nil != div) -!(nil != f32) -!(nil != f64) -!(nil != false) -!(nil != foo) -!(nil != greet) -!(nil != half) -!(nil != i) -!(nil != i32) -!(nil != i64) -!(nil != list) -!(nil != nil) -!(nil != ok) -!(nil != score) -!(nil != true) -!(nil == "bar") -!(nil == "foo") -!(nil == 0.5) -!(nil == 1) -!(nil == add) -!(nil == array) -!(nil == div) -!(nil == f32) -!(nil == f64) -!(nil == false) -!(nil == foo) -!(nil == greet) -!(nil == half) -!(nil == i) -!(nil == i32) -!(nil == i64) -!(nil == list) -!(nil == nil) -!(nil == ok) -!(nil == score) -!(nil == true) -!(nil in array) -!(nil in list) -!(nil not in array) -!(nil not in list) -!(ok != false) -!(ok != nil) -!(ok != ok) -!(ok != true) -!(ok && false) -!(ok && ok) -!(ok && true) -!(ok == nil) -!(ok == ok) -!(ok == true) -!(ok and ok) -!(ok and true) -!(ok or false) -!(ok or ok) -!(ok or true) -!(ok || false) -!(ok || ok) -!(ok || true) -!(score != nil) -!(score != score) -!(score == nil) -!(score == score) -!(true != false) -!(true != nil) -!(true != ok) -!(true != true) -!(true && false) -!(true && ok) -!(true && true) -!(true == false) -!(true == nil) -!(true == ok) -!(true == true) -!(true and ok) -!(true and true) -!(true or ok) -!(true or true) -!(true || false) -!(true || ok) -!(true || true) -!all(array, false) -!all(array, ok) -!all(array, true) -!all(list, false) -!all(list, ok) -!all(list, true) -!any(array, i == #) -!any(array, ok) -!any(array, true) -!any(list, false) -!any(list, ok) -!any(list, true) -!false != not true -!false != ok -!false && 0.5 == 1 -!false == ok -!false ? "foo" : 0.5 -!false ? "foo" : f32 -!false ? 0.5 : "foo" -!false ? 0.5 : f32 -!false ? 1 : half -!false ? 1 : i -!false ? add : f32 -!false ? add : i64 -!false ? array : add -!false ? array : ok -!false ? div : array -!false ? div : greet -!false ? div : half -!false ? f32 : add -!false ? f32 : false -!false ? f64 : "foo" -!false ? foo : "bar" -!false ? half : 1 -!false ? half : add -!false ? half : list -!false ? half : true -!false ? i : nil -!false ? i32 : list -!false ? i64 : foo -!false ? i64 : i64 -!false ? nil : add -!false ? nil : f64 -!false ? nil : foo -!false ? nil : half -!false ? ok : 1 -!false ? score : "bar" -!false ? score : foo -!false ? score : ok -!false ? true : "foo" -!false or 0.5 > i32 -!false or ok -!false || ok -!hasPrefix("foo", "foo") -!none(array, # > #) -!none(array, # >= #) -!none(array, false) -!none(array, ok) -!none(list, ok) -!none(list, true) -!not ("bar" == nil) -!not (1 <= 1) -!not (1 > 0.5) -!not (greet == nil) -!not (i32 == f64) -!not false -!not none(list, true) -!not ok -!not true -!ok -!ok != !true -!ok != ok -!ok && ok -!ok == ok -!ok ? "bar" : "foo" -!ok ? "bar" : foo -!ok ? "foo" : 0.5 -!ok ? "foo" : list -!ok ? 0.5 : 1 -!ok ? 0.5 : i -!ok ? 1 : array -!ok ? 1 : div -!ok ? 1 : f64 -!ok ? 1 : list -!ok ? 1 : ok -!ok ? add : 0.5 -!ok ? array : div -!ok ? array : f32 -!ok ? array : foo -!ok ? array : i -!ok ? array : i32 -!ok ? div : "foo" -!ok ? div : 1 -!ok ? div : i -!ok ? f32 : "bar" -!ok ? f32 : add -!ok ? f32 : false -!ok ? f32 : greet -!ok ? f64 : "bar" -!ok ? f64 : "foo" -!ok ? f64 : 0.5 -!ok ? f64 : half -!ok ? f64 : score -!ok ? false : ok -!ok ? foo : "foo" -!ok ? foo : f32 -!ok ? foo : false -!ok ? foo : i32 -!ok ? greet : div -!ok ? greet : list -!ok ? greet : nil -!ok ? half : f64 -!ok ? i : "bar" -!ok ? i : array -!ok ? i : div -!ok ? i : foo -!ok ? i32 : 0.5 -!ok ? i32 : f32 -!ok ? i32 : greet -!ok ? i32 : nil -!ok ? i64 : 0.5 -!ok ? i64 : 1 -!ok ? i64 : f32 -!ok ? i64 : true -!ok ? list : f32 -!ok ? list : i -!ok ? nil : 1 -!ok ? nil : array -!ok ? ok : f32 -!ok ? ok : list -!ok and ok -!ok or f32 < i64 -!ok or false or false -!ok or ok -!ok || ok -!one(array, false) -!one(array, ok) -!one(array, true) -!one(list, false) -!one(list, ok) -!one(list, true) -!reduce(array, false) -!reduce(array, ok) -!reduce(array, true) -!reduce(list, # != #) -!reduce(list, false) -!reduce(list, ok) -!reduce(list, true) -!true != all(array, ok) -!true ? "bar" : "foo" -!true ? "bar" : true -!true ? "foo" : "foo" -!true ? "foo" : 0.5 -!true ? "foo" : i -!true ? 1 : "foo" -!true ? 1 : i64 -!true ? add : 0.5 -!true ? add : score -!true ? array : f64 -!true ? array : list -!true ? div : add -!true ? f32 : false -!true ? f64 : f64 -!true ? foo : 1 -!true ? foo : array -!true ? greet : ok -!true ? greet : score -!true ? greet : true -!true ? half : f64 -!true ? i : 1 -!true ? i : add -!true ? i : ok -!true ? i32 : 1 -!true ? i64 : false -!true ? i64 : i64 -!true ? i64 : list -!true ? list : 0.5 -!true ? list : nil -!true ? list : score -!true ? nil : 0.5 -!true ? nil : false -!true ? nil : ok -!true ? ok : add -!true ? ok : div -!true ? score : false -!true ? true : f32 -!true ? true : half -!true and foo != nil -!true || ok -"bar" != "bar" || ok -"bar" != foo.Bar -"bar" != foo?.Bar -"bar" + "bar" not in foo -"bar" + foo.Bar -"bar" + foo?.Bar -"bar" < foo.Bar -"bar" < foo?.Bar -"bar" < foo?.String() -"bar" <= foo.Bar -"bar" <= foo.String() -"bar" <= foo?.Bar -"bar" == foo.Bar -"bar" == foo?.Bar -"bar" == foo?.String() -"bar" > "bar" or ok ? f32 : i64 -"bar" > foo.Bar -"bar" > foo?.String() -"bar" >= foo.Bar -"bar" >= foo.String() -"bar" >= foo?.Bar -"bar" contains foo.Bar -"bar" contains foo.String() -"bar" contains foo?.Bar -"bar" endsWith foo.Bar -"bar" endsWith foo?.Bar -"bar" endsWith foo?.String() -"bar" matches "bar" and ok -"bar" matches foo.Bar -"bar" matches foo.String() -"bar" matches foo?.Bar -"bar" matches foo?.String() -"bar" not contains foo.Bar -"bar" not contains foo?.Bar -"bar" not endsWith foo.Bar -"bar" not endsWith foo?.Bar -"bar" not endsWith foo?.String() -"bar" not matches foo.Bar -"bar" not matches foo.String() -"bar" not matches foo?.Bar -"bar" not matches foo?.String() -"bar" not startsWith foo.Bar -"bar" not startsWith foo?.Bar -"bar" not startsWith foo?.String() -"bar" startsWith "foo" or list == array -"bar" startsWith foo.Bar -"bar" startsWith foo.String() -"foo" != "foo" ? f64 : array -"foo" != "foo" or ok -"foo" != foo.Bar -"foo" != foo.String() -"foo" != foo?.Bar -"foo" != foo?.String() -"foo" + "bar" not in foo -"foo" + foo.Bar -"foo" + foo?.Bar -"foo" + foo?.String() -"foo" < "bar" and ok -"foo" < foo.Bar -"foo" < foo?.Bar -"foo" < foo?.String() -"foo" <= foo.Bar -"foo" <= foo?.Bar -"foo" == "bar" != ok -"foo" == "bar" and ok -"foo" == foo.Bar -"foo" == foo?.Bar -"foo" == foo?.String() -"foo" > foo.Bar -"foo" > foo.String() -"foo" > foo?.Bar -"foo" >= foo.Bar -"foo" >= foo.String() -"foo" >= foo?.Bar -"foo" >= foo?.String() -"foo" contains "bar" == ok -"foo" contains foo?.Bar -"foo" endsWith foo.Bar -"foo" endsWith foo?.Bar -"foo" matches "bar" ? add : div -"foo" matches "foo" || true ? greet : "bar" -"foo" matches foo.Bar -"foo" matches foo.String() -"foo" matches foo?.Bar -"foo" not contains foo.Bar -"foo" not contains foo?.Bar -"foo" not contains foo?.String() -"foo" not endsWith foo.Bar -"foo" not endsWith foo?.Bar -"foo" not matches foo.Bar -"foo" not matches foo?.Bar -"foo" not matches foo?.String() -"foo" not startsWith foo.Bar -"foo" not startsWith foo?.Bar -"foo" not startsWith foo?.String() -"foo" startsWith foo.Bar -"foo" startsWith foo?.Bar -("bar" not endsWith "bar") != ok -("bar" not endsWith "foo") != ok -("bar" not endsWith "foo") && false != nil -("bar" not matches "foo") || reduce(list, ok) -("foo" not matches "bar") == ok -(0.5 * 0.5) ** i -(0.5 * 0.5) ^ f32 -(0.5 * 1) ** f64 -(0.5 * 1) ** i -(0.5 * 1) ^ i32 -(0.5 * f64) ^ f32 -(0.5 * i) ^ i -(0.5 + 0.5) * f32 -(0.5 + 0.5) ^ i32 -(0.5 + 1) ^ i -(0.5 + f64) * f64 -(0.5 + f64) / i32 -(0.5 + i) ** i -(0.5 + i) ^ i -(0.5 + i64) ** f32 -(0.5 + i64) / f32 -(0.5 + i64) / i -(0.5 - 0.5) * (i32 - 0.5) -(0.5 - 0.5) * i64 -(0.5 - 0.5) ** f32 -(0.5 - 1) * i32 -(0.5 - 1) ** f64 -(0.5 - 1) ^ i64 -(0.5 - f32) ** i -(0.5 - f64) * i -(0.5 - f64) / f32 -(0.5 - f64) / f64 -(0.5 - i) ^ f32 -(0.5 - i32) ** (i32 * 1) -(0.5 - i32) / f64 -(0.5 - i32) ^ f32 -(0.5 - i64) * i -(0.5 - i64) / f64 -(0.5 - i64) / i64 -(0.5 / 0.5) ** f32 -(0.5 / 0.5) ** i32 -(0.5 / 0.5) ^ f64 -(0.5 / 1) ^ f32 -(0.5 / i) ** f64 -(0.5 / i) ** i -(0.5 / i32) ** i -(0.5 / i32) ^ f32 -(1 * 0.5) ** (f64 * 1) -(1 * 0.5) ** i32 -(1 * 0.5) ^ f64 -(1 * 1) ^ -1 -(1 * 1) ^ f32 -(1 * f32) ^ i32 -(1 * i) ** i32 -(1 * i32) ^ i -(1 * i64) ** i64 -(1 + 0.5) ** i -(1 + 1) * i64 -(1 + 1) / i -(1 + f32) ^ i -(1 + f64) ^ i -(1 + f64) ^ i32 -(1 + i) ** f32 -(1 + i) / f64 -(1 + i) ^ i64 -(1 + i32) * f64 -(1 + i32) ^ f64 -(1 - 0.5) * f32 ^ 1 -(1 - 0.5) * i64 -(1 - 0.5) / i -(1 - 0.5) ^ min(f32) -(1 - f32) * f32 -(1 - f64) ** f64 -(1 - i) * -i32 -(1 - i32) ^ f32 -(1 - i32) ^ i -(1 - i64) ** f32 -(1 - i64) / f64 -(1 - i64) / i64 -(1 / 0.5) ** f32 -(1 / 0.5) ^ i32 -(1 / 1) ** (f64 * 0.5) -(1 / 1) ^ ceil(i64) -(1 / 1) ^ max(0.5) -(1 / f32) ^ f32 -(1 / i) ^ f32 -(1 / i32) ^ i -(1 / i64) ** i64 -(f32 * 0.5) ** f64 -(f32 * 0.5) ^ i32 -(f32 * f32) ^ -f32 -(f32 * f32) ^ i -(f32 * i) ^ -1 -(f32 * i64) ** i -(f32 + f64) * i -(f32 + i) ^ f64 -(f32 - 0.5) / f64 -(f32 - 0.5) ^ f32 -(f32 - 1) / f64 -(f32 - 1) ^ f64 -(f32 - f32) / i64 -(f32 - i32) * i64 -(f32 / 0.5) ^ f32 -(f32 / i64) ^ f64 -(f64 * 0.5) ** f32 -(f64 * 0.5) ** i64 -(f64 * f32) ** f64 -(f64 * i64) ** f64 -(f64 * i64) ** i32 -(f64 + 0.5) * f32 -(f64 + 0.5) * i64 -(f64 + f32) ** get(array, i) -(f64 + f32) ** i32 -(f64 + f64) * (i64 - i64) -(f64 + f64) ^ f64 -(f64 + i) * (0.5 + i64) -(f64 + i32) ^ i64 -(f64 + i64) ^ i -(f64 - 0.5) ** f64 -(f64 - 1) ** i64 -(f64 - 1) ^ i32 -(f64 - f32) ** i -(f64 - f32) ^ i64 -(f64 - i) * i32 -(f64 - i32) / i -(f64 - i64) ** i -(f64 - i64) / f32 -(f64 - i64) / f64 -(f64 / 1) ** i64 -(f64 / f32) ^ i -(f64 / f64) ** i32 -(f64 / f64) ^ i32 ** 0.5 -(false || ok) == ok -(i % i) ^ i -(i % i32) ^ (1 - i32) -(i % i64) ^ f64 -(i * 0.5) ** f32 -(i * 1) ^ f64 -(i * 1) ^ i -(i * i64) ** f32 -(i + 0.5) ** half(f64) -(i + 1) % i64 -(i + 1) / i64 -(i + i) ^ i64 -(i + i32) * i64 ^ f64 -(i + i32) / i32 -(i + i32) ^ f32 -(i + i64) ^ i32 -(i - 0.5) / i64 -(i - 1) ^ i64 -(i / 0.5) ** f32 -(i / f32) ^ f64 -(i32 % 1) ** f32 -(i32 % i) ** f32 -(i32 % i32) ** i32 -(i32 % i32) ^ i32 -(i32 * 0.5) ^ f32 -(i32 * 1) ^ i32 -(i32 + 0.5) ** i64 -(i32 + f32) * i64 -(i32 + f64) / i -(i32 + i) / i -(i32 + i32) ^ i32 -(i32 - 0.5) * f64 -(i32 - 0.5) / i64 -(i32 - 1) ^ f64 -(i32 - f32) / i64 -(i32 - i) % i64 -(i32 - i) / f32 -(i32 - i32) ^ (i32 * i) -(i32 - i64) * i32 -(i32 - i64) * i32 * i64 -(i32 / i) ** f32 -(i32 / i) ^ i64 -(i32 < f64 ? nil : i) .. i32 -(i32 not in array) and ok -(i64 % i) ** f32 -(i64 * 0.5) ^ f64 -(i64 * f32) ^ i64 -(i64 * f64) ^ i32 -(i64 * i) ** score(1) -(i64 * i64) ** i ** 0.5 -(i64 * i64) ^ i -(i64 + 0.5) * f32 -(i64 + 0.5) ** i64 -(i64 + 1) % i -(i64 + 1) ^ i -(i64 + f32) * -i32 -(i64 + f32) ** i32 -(i64 + f32) / f64 -(i64 + f32) / i -(i64 + f32) / i32 -(i64 + f64) * i32 -(i64 + i) % i64 -(i64 + i) / f64 -(i64 + i32) * i64 -(i64 + i64) / i64 -(i64 - 0.5) / f64 -(i64 - 0.5) ^ i64 -(i64 - 1) ^ i32 -(i64 - f32) ** f64 -(i64 - f32) ^ i64 -(i64 - i) ** i -(i64 - i32) * i64 -(i64 / 1) ** f32 -(i64 / f64) ** i32 -(nil not in array) || ok -(ok || true) && (ok or true) --((i64 + 1) % i32) --(0.5 * 0.5) --(0.5 * 1) --(0.5 * f32) --(0.5 * f64) --(0.5 * i) --(0.5 * i32) --(0.5 * i64) --(0.5 ** 0.5) --(0.5 ** 1) --(0.5 ** f32) --(0.5 ** f64) --(0.5 ** i) --(0.5 ** i32) --(0.5 ** i64) --(0.5 + 0.5) --(0.5 + 1) --(0.5 + f32) --(0.5 + f64) --(0.5 + i) --(0.5 + i32) --(0.5 + i64) --(0.5 - 0.5) --(0.5 - 1) --(0.5 - f32) --(0.5 - f64) --(0.5 - i) --(0.5 - i32) --(0.5 - i64) --(0.5 / 0.5) --(0.5 / 1) --(0.5 / f32) --(0.5 / f64) --(0.5 / i) --(0.5 / i32) --(0.5 / i64) --(0.5 ^ 0.5) --(0.5 ^ 1) --(0.5 ^ f32) --(0.5 ^ f64) --(0.5 ^ i) --(0.5 ^ i32) --(0.5 ^ i64) --(1 % 1) --(1 % i) --(1 % i32) --(1 % i64) --(1 * 0.5) --(1 * 1) --(1 * f32) --(1 * f64) --(1 * i) --(1 * i32) --(1 * i64) --(1 ** 0.5) --(1 ** 1) --(1 ** f32) --(1 ** f64) --(1 ** i) --(1 ** i32) --(1 ** i64) --(1 + 0.5) --(1 + 1) --(1 + f32) --(1 + f64) --(1 + i) --(1 + i32) --(1 + i64) --(1 - 0.5) --(1 - 1) --(1 - f32) --(1 - f64) --(1 - i) --(1 - i32) --(1 - i64) --(1 / 0.5) --(1 / 1) --(1 / f32) --(1 / f64) --(1 / i) --(1 / i32) --(1 / i64) --(1 ^ 0.5) --(1 ^ 1) --(1 ^ f32) --(1 ^ f64) --(1 ^ i) --(1 ^ i32) --(1 ^ i64) --(f32 * 0.5) --(f32 * 1) --(f32 * f32) --(f32 * f64) --(f32 * i) --(f32 * i32) --(f32 * i64) --(f32 ** 0.5) --(f32 ** 1) --(f32 ** f32) --(f32 ** f64) --(f32 ** i) --(f32 ** i32) --(f32 ** i64) --(f32 + 0.5) --(f32 + 1) --(f32 + f32) --(f32 + f64) --(f32 + i) --(f32 + i64) --(f32 - 0.5) --(f32 - 1) --(f32 - f32) --(f32 - i) --(f32 - i32) --(f32 - i64) --(f32 / 0.5) --(f32 / 1) --(f32 / f32) --(f32 / f64) --(f32 / i) --(f32 / i32) --(f32 / i64) --(f32 ^ 0.5) --(f32 ^ 1) --(f32 ^ f32) --(f32 ^ f64) --(f32 ^ i) --(f32 ^ i32) --(f32 ^ i64) --(f64 * 0.5) --(f64 * 1) --(f64 * f32) --(f64 * f64) --(f64 * i) --(f64 * i32) --(f64 * i64) --(f64 ** 0.5) --(f64 ** 1) --(f64 ** f32) --(f64 ** f64) --(f64 ** i) --(f64 ** i32) --(f64 ** i64) --(f64 + 0.5) --(f64 + 1) --(f64 + f32) --(f64 + i) --(f64 + i32) --(f64 + i64) --(f64 - 0.5) --(f64 - 1) --(f64 - f32) --(f64 - f64) --(f64 - i) --(f64 - i64) --(f64 / 0.5) --(f64 / 1) --(f64 / f32) --(f64 / f64) --(f64 / i) --(f64 / i64) --(f64 ^ 0.5) --(f64 ^ 1) --(f64 ^ f32) --(f64 ^ f64) --(f64 ^ i) --(f64 ^ i32) --(f64 ^ i64) --(i % 1) --(i % i) --(i % i32) --(i % i64) --(i * 0.5) --(i * 1) --(i * f32) --(i * f64) --(i * i) --(i * i32) --(i * i64) --(i ** 0.5) --(i ** 1) --(i ** f64) --(i ** i) --(i ** i32) --(i ** i64) --(i + 0.5) --(i + 1) --(i + i32) --(i + i64) --(i - 0.5) --(i - 1) --(i - f32) --(i - f64) --(i - i ** 1) --(i - i) --(i - i32) --(i - i64) --(i / 0.5) --(i / 1) --(i / f32) --(i / f64) --(i / i) --(i / i32) --(i / i64) --(i ^ 0.5) --(i ^ 1) --(i ^ f32) --(i ^ f64) --(i ^ i) --(i ^ i32) --(i ^ i64) --(i32 % 1) --(i32 % i) --(i32 % i32) --(i32 % i64) --(i32 * 0.5) --(i32 * 1) --(i32 * f32) --(i32 * f64) --(i32 * i) --(i32 * i32) --(i32 * i64) --(i32 ** 0.5) --(i32 ** 1) --(i32 ** f32) --(i32 ** f64) --(i32 ** i) --(i32 ** i32) --(i32 ** i64) --(i32 + 0.5) --(i32 + 1) --(i32 + f32) --(i32 + f64) --(i32 + i) --(i32 + i32) --(i32 + i64) --(i32 - 0.5) --(i32 - 1) --(i32 - f32) --(i32 - f64) --(i32 - i) --(i32 - i32) --(i32 - i64) --(i32 / 0.5) --(i32 / 1) --(i32 / f64) --(i32 / i) --(i32 / i32) --(i32 / i64) --(i32 ^ 0.5) --(i32 ^ 1) --(i32 ^ f32) --(i32 ^ f64) --(i32 ^ i) --(i32 ^ i32) --(i32 ^ i64) --(i64 % 1) --(i64 % i) --(i64 % i32) --(i64 % i64) --(i64 * 0.5) --(i64 * 1) --(i64 * f32) --(i64 * f64) --(i64 * i) --(i64 * i32) --(i64 * i64) --(i64 ** 0.5) --(i64 ** 1) --(i64 ** f32) --(i64 ** f64) --(i64 ** i) --(i64 ** i32) --(i64 ** i64) --(i64 + 0.5) --(i64 + 1) --(i64 + f32) --(i64 + f64) --(i64 + i32) --(i64 + i64) --(i64 - 0.5) --(i64 - 1) --(i64 - f32) --(i64 - f64) --(i64 - i) --(i64 - i32) --(i64 - i64) --(i64 / 0.5) --(i64 / 1) --(i64 / f32) --(i64 / f64) --(i64 / i) --(i64 / i32) --(i64 / i64) --(i64 ^ 0.5) --(i64 ^ 1) --(i64 ^ f32) --(i64 ^ f64) --(i64 ^ i) --(i64 ^ i32) --(i64 ^ i64) --(max(f32) ^ i32) --(min(0.5) ^ i32) ---(f64 ** 0.5) ---(i64 ** i64) ---0.5 ---1 ---ceil(1) ---f32 ---f64 ---f64 ** i64 ---float(f64) ---i ---i32 ---i64 --0.5 != f32 --0.5 != i32 --0.5 * 1 ** 1 --0.5 * f32 --0.5 * f64 --0.5 * i32 --0.5 * i64 --0.5 ** -1 --0.5 ** ceil(i) --0.5 ** f32 --0.5 ** f64 --0.5 ** i --0.5 ** i32 --0.5 ** i64 --0.5 + f64 --0.5 + i --0.5 + i32 --0.5 + i64 --0.5 - abs(i) --0.5 - f32 --0.5 - f64 --0.5 - i --0.5 - i32 --0.5 - i64 --0.5 / f32 --0.5 / i --0.5 / i32 --0.5 < i32 --0.5 < i64 --0.5 <= 0.5 + 0.5 --0.5 <= f32 --0.5 <= i --0.5 <= i32 --0.5 <= i64 --0.5 == f32 --0.5 == f64 --0.5 == i --0.5 == i32 --0.5 == i32 ^ i32 --0.5 == i64 --0.5 > f32 --0.5 > i --0.5 >= f32 --0.5 >= f32 ? f32 : i32 --0.5 >= f64 --0.5 >= i --0.5 >= i32 --0.5 >= i64 --0.5 ^ f32 --0.5 ^ f64 --0.5 ^ float(f64) --0.5 ^ i32 --0.5 ^ i64 --0.5 in array --0.5 not in sort(array) --1 != -i --1 != f32 --1 != f64 --1 != i32 --1 != i64 --1 % i --1 % i32 --1 * array[i] --1 * f32 --1 * f64 --1 * i --1 * i32 --1 * i64 --1 ** (f32 + f32) --1 ** (i + i64) --1 ** ceil(0.5) --1 ** f32 --1 ** f64 --1 ** i --1 ** i64 ^ 1 --1 + -i32 --1 + f32 --1 + f64 --1 + i --1 + i32 --1 + i64 --1 + reduce(array, #) --1 + reduce(list, f32) --1 - f64 --1 - i --1 - i % i32 --1 - i32 --1 - i64 --1 .. i --1 .. i64 --1 / f32 --1 / f64 --1 / i --1 / i32 --1 < f64 --1 < i --1 < i64 --1 <= -1 --1 <= f64 --1 <= i --1 <= i32 --1 <= i64 --1 == f32 --1 == f64 --1 == floor(f64) --1 == i --1 == i32 --1 == i64 --1 > f32 --1 > i --1 > i64 --1 >= f32 * f32 --1 >= f64 --1 >= i32 --1 >= i64 --1 ^ f32 --1 ^ f64 --1 ^ i32 --1 ^ i64 --1 in array --1 not in array --abs(0.5) --abs(1) --abs(f32) --abs(f64) --abs(i) --abs(i32) --abs(i64) --add(i, 1) --add(i, i) --array[1] --array[i32] --array[i64] --array[i] --bitand(i64, i32) --bitnand(1, i) --bitnot(1) --bitnot(i) --bitnot(i32) --bitnot(i64) --bitor(1, i64) --bitor(i, i32) --bitshl(i, 1) --bitshl(i, i32) --bitshl(i, i64) --bitshl(i64, i32) --bitshr(i, i) --bitshr(i64, i32) --bitushr(i, i32) --bitxor(1, 1) --bitxor(i, i32) --ceil(0.5) --ceil(1) --ceil(f32) --ceil(f64) --ceil(i) --ceil(i32) --ceil(i64) --count(array, false) --count(array, ok) --count(array, true) --count(list, ok) --count(list, true) --div(1, 1) --f32 --f32 != i32 --f32 * i64 --f32 ** (i + 1) --f32 ** f32 --f32 ** f64 --f32 ** i --f32 ** i32 --f32 ** i64 --f32 + i32 --f32 - i --f32 - round(i) --f32 / f32 --f32 / f64 --f32 / i --f32 < f32 ** 0.5 --f32 < f64 --f32 < i --f32 < i32 --f32 <= f32 --f32 <= i --f32 <= i32 --f32 <= i64 --f32 == f32 --f32 == f64 --f32 > 0.5 ? f32 : "bar" --f32 > f32 --f32 > f64 --f32 >= f32 --f32 >= f64 --f32 >= i64 --f32 ^ i --f32 ^ i32 --f32 ^ i64 --f32 in array --f32 not in array --f64 --f64 != f32 --f64 != f64 --f64 != i --f64 != i32 --f64 * -1 --f64 * -f64 --f64 * f32 --f64 * f64 --f64 * i --f64 * i32 --f64 * i64 --f64 ** 0.5 ** f32 --f64 ** f32 --f64 ** i --f64 ** i32 --f64 + f32 --f64 + i64 --f64 - 0.5 / i64 --f64 - f32 --f64 - i --f64 - i32 --f64 - i64 --f64 - int(f64) --f64 / f32 --f64 / f64 --f64 / i --f64 / i32 --f64 / i64 --f64 < 0.5 ^ f32 --f64 < f64 --f64 < f64 ** 1 --f64 < half(0.5) --f64 < half(f64) --f64 < i --f64 < i ^ f32 --f64 < i32 --f64 < i64 --f64 <= f32 --f64 <= f64 --f64 == f64 --f64 == i --f64 == i32 --f64 == i64 --f64 > f32 --f64 > f32 ? false : array --f64 > f64 --f64 > i32 --f64 > i64 --f64 >= f32 --f64 >= f32 / f64 --f64 >= f64 --f64 >= i32 --f64 ^ f32 --f64 ^ f64 --f64 ^ i64 --f64 not in array --find(array, ok) --find(array, true) --findIndex(array, # <= #) --findIndex(array, ok) --findIndex(array, true) --findIndex(list, ok) --findIndex(list, true) --findLast(array, # <= #) --findLast(array, ok) --findLast(array, true) --findLastIndex(array, ok) --findLastIndex(array, true) --findLastIndex(list, ok) --findLastIndex(list, true) --first(array) --float(0.5 ** 0.5) --float(0.5 ^ 0.5) --float(0.5) --float(1) --float(bitnot(i64)) --float(f32) --float(f64) --float(i) --float(i32) --float(i64) --floor(0.5) --floor(1) --floor(f32) --floor(f64) --floor(i) --floor(i32) --floor(i64) --get(array, 1) --get(array, i) --get(array, i32) --get(array, i64) --half(-0.5) --half(-1) --half(0.5) --half(1) --half(f32 + i64) --half(f64) --half(median(array)) --i --i != f32 --i != f64 --i != f64 ? foo : 1 --i != i --i != i + f64 --i != i32 --i != i64 --i % i32 --i % i64 --i * abs(0.5) --i * f64 --i * i --i * i64 --i * reduce(array, 0.5) --i ** f32 --i ** f64 --i ** i --i + f32 --i + f64 --i + i32 --i + i64 * 1 --i - f32 --i - i64 --i .. i --i .. i64 --i / f32 --i / i64 --i < f32 --i < half(1) --i < i --i < i64 --i <= 0.5 ? half : "bar" --i <= 1 - 0.5 --i <= f32 --i <= i --i <= i32 --i <= i64 --i <= i64 ** 0.5 --i == f32 --i == f64 --i == f64 ^ f32 --i == i --i == i32 --i > f32 --i > i --i > i32 --i >= f32 --i >= f64 --i >= i --i >= i64 --i >= score(1) --i ^ 0.5 ** 0.5 --i ^ f32 --i ^ f32 ^ 0.5 --i ^ f64 --i ^ i --i ^ i64 --i in array --i not in array --i32 --i32 != f32 --i32 != i --i32 != i32 ** 1 --i32 != i64 --i32 % i --i32 % i32 --i32 % i64 --i32 * i --i32 * i32 --i32 * i64 --i32 ** f32 --i32 ** f64 --i32 ** i64 --i32 + f32 --i32 + i --i32 + i32 --i32 - f32 --i32 .. i32 --i32 / i32 --i32 / i64 --i32 < i --i32 < i32 --i32 < i64 --i32 < round(f64) --i32 <= f64 --i32 <= i --i32 <= i32 --i32 <= i64 --i32 == 1 % i --i32 == f32 --i32 == f64 --i32 == i64 --i32 == max(1) --i32 > f32 --i32 > f64 --i32 > i --i32 > i ** 0.5 --i32 > i32 --i32 > i64 --i32 >= f64 --i32 >= i --i32 >= i == nil --i32 >= i32 --i32 ^ f32 --i32 ^ i32 --i32 ^ i64 --i32 ^ score(1) --i32 in array --i64 --i64 != f32 --i64 != f64 --i64 != i32 --i64 != i64 --i64 != i64 ? score : foo --i64 * (1 + f64) --i64 * f32 --i64 * i --i64 * i32 --i64 * i64 --i64 * indexOf("foo", "bar") --i64 ** i --i64 ** i32 --i64 + f32 --i64 + i --i64 + i32 --i64 + i64 --i64 - f32 --i64 - i --i64 - i32 --i64 .. i --i64 .. i32 --i64 .. i64 --i64 / f64 --i64 / i32 --i64 < f32 --i64 < f64 --i64 < half(f64) --i64 < i32 --i64 < i64 --i64 <= i --i64 <= i32 --i64 == 1 ^ i64 --i64 == f32 --i64 == f64 --i64 == i --i64 == i32 --i64 > f32 --i64 > f64 --i64 > i --i64 > i32 --i64 >= f32 --i64 >= i --i64 >= i32 --i64 ^ f64 --i64 ^ float(i) --i64 ^ i --i64 ^ i32 --i64 ^ i64 --i64 in array --i64 not in array --int(0.5) --int(1) --int(f32) --int(f64) --int(i) --int(i32) --int(i64) --last(array) --len("bar") --len("foo") --len(array) --len(list) --max(0.5) --max(0.5, 0.5, f64) --max(1) --max(f32) --max(f64) --max(i) --max(i, 0.5) --max(i32 - 1) --max(i32) --max(i32, f32) --max(i64 * 0.5) --max(i64) --max(i64, f64) --max(i64, i) --mean(array) --median(array) --min(-1) --min(0.5) --min(1) --min(1, 0.5) --min(f32) --min(f32, 1) --min(f64) --min(float(0.5)) --min(i) --min(i, 1) --min(i32) --min(i32, 0.5) --min(i64) --min(i64, i, 0.5) --reduce(array, #) --reduce(array, -#) --reduce(array, 0.5) --reduce(array, 1) --reduce(array, 1) - f32 --reduce(array, f64) --reduce(array, i) --reduce(array, i32) --reduce(array, i64) --reduce(list, 0.5) --reduce(list, 1) --reduce(list, f32) --reduce(list, f64) --reduce(list, i) --reduce(list, i32) --round(0.5) --round(1) --round(f32) --round(f64) --round(i) --round(i32) --round(i64) --score(1) --score(1, 1) --score(1, i) --score(i) --score(i32 + i) --score(int(i)) --sum(array) --sum(i .. 1) -0.5 != 0.5 == ok -0.5 != f64 ? list : f32 -0.5 != f64 and !true -0.5 != f64 and ok -0.5 != i == ok -0.5 != i32 && ok -0.5 != i32 == ok -0.5 != i32 ? ok : ok -0.5 != i32 and 1 > f64 -0.5 != nil == ok -0.5 * 0.5 * f64 -0.5 * 0.5 / f32 -0.5 * 0.5 / f64 -0.5 * 0.5 < f64 -0.5 * 0.5 >= i64 -0.5 * 1 * i64 -0.5 * 1 <= f32 -0.5 * 1 > i32 -0.5 * 1 not in array -0.5 * f32 * f32 -0.5 * f32 * i32 -0.5 * f32 + f32 -0.5 * f32 - f64 -0.5 * f32 / half(1) -0.5 * f32 == i32 -0.5 * f32 > i -0.5 * f64 != i64 -0.5 * f64 < i -0.5 * f64 <= i -0.5 * i + i -0.5 * i + mean(array) -0.5 * i - i32 -0.5 * i == 0.5 ? ok : ok -0.5 * i32 / f32 -0.5 * i64 < f64 -0.5 * i64 == 1 ** i64 -0.5 ** 0.5 != i64 -0.5 ** 0.5 * max(1) -0.5 ** 0.5 ** i64 -0.5 ** 0.5 + -f32 -0.5 ** 0.5 < f64 -0.5 ** 0.5 == i -0.5 ** 0.5 ^ f32 -0.5 ** 0.5 not in array -0.5 ** 1 != i -0.5 ** 1 != i32 -0.5 ** 1 - f64 -0.5 ** 1 / f64 -0.5 ** 1 / i32 -0.5 ** 1 ^ i64 -0.5 ** f32 + f32 / i64 -0.5 ** f32 <= f32 -0.5 ** f32 ^ i -0.5 ** f64 * f64 -0.5 ** f64 > f64 ? 1 : nil -0.5 ** f64 >= i64 -0.5 ** i / i -0.5 ** i > i -0.5 ** i32 * i32 -0.5 ** i32 > f64 -0.5 ** i32 >= mean(array) -0.5 + 0.5 != i -0.5 + 0.5 == i32 -0.5 + 0.5 > f32 -0.5 + 1 != f64 -0.5 + 1 + i32 -0.5 + 1 - i32 -0.5 + 1 < float(1) -0.5 + 1 == f32 -0.5 + f32 - i64 -0.5 + f32 <= ceil(f32) -0.5 + f32 <= i32 -0.5 + f32 > f32 -0.5 + f64 != i64 -0.5 + f64 <= i32 -0.5 + f64 == 1 / 0.5 -0.5 + i + i -0.5 + i > i64 -0.5 + i in array -0.5 + i32 - i64 -0.5 + i32 <= f32 -0.5 + i64 - i -0.5 + i64 > i64 * 0.5 -0.5 - 0.5 - i32 -0.5 - 0.5 >= f32 -0.5 - 0.5 >= i -0.5 - 0.5 >= i32 -0.5 - 1 + i -0.5 - 1 + i / i -0.5 - 1 <= f64 -0.5 - f32 != i64 -0.5 - f32 >= i64 -0.5 - f64 - f32 -0.5 - f64 < i -0.5 - f64 in array -0.5 - i != i64 -0.5 - i + i -0.5 - i > f32 -0.5 - i32 != f32 -0.5 - i64 + -f64 -0.5 - i64 == i -0.5 - i64 not in array -0.5 / 0.5 + i -0.5 / 0.5 - i -0.5 / 0.5 - i32 -0.5 / 0.5 - i64 -0.5 / 0.5 / half(0.5) -0.5 / 0.5 < i32 -0.5 / 0.5 == i64 -0.5 / 0.5 >= f32 -0.5 / 0.5 >= f64 -0.5 / 1 * i -0.5 / 1 / f64 -0.5 / 1 < f64 -0.5 / 1 == i -0.5 / 1 > f32 -0.5 / 1 >= i32 -0.5 / 1 not in array -0.5 / f32 * f64 -0.5 / f64 + f64 -0.5 / f64 - i -0.5 / f64 / f64 -0.5 / f64 < i -0.5 / f64 == f32 -0.5 / i != i64 -0.5 / i * i64 -0.5 / i / i32 -0.5 / i <= i -0.5 / i32 + i64 -0.5 / i32 > i ^ i -0.5 / i32 > i64 -0.5 / i32 >= f64 -0.5 / i64 != f64 -0.5 / i64 != i -0.5 / i64 != min(f32) -0.5 / i64 * i32 -0.5 < 0.5 ? f32 : array -0.5 < 0.5 ? foo : greet -0.5 < 1 == ok -0.5 < 1 || ok -0.5 < f32 && ok -0.5 < f32 || ok -0.5 <= f64 ? i : i64 -0.5 <= f64 || ok -0.5 == 1 and ok -0.5 == 1 || ok -0.5 == array[ok ? 0.5 : score] -0.5 == f32 and i64 == i32 -0.5 == f64 ? i : (false ? i : i64) -0.5 == f64 and i64 == 0.5 -0.5 == i or ok -0.5 == i32 and ok -0.5 == i64 and ok -0.5 == nil or "foo" endsWith "bar" -0.5 == nil or ok -0.5 == nil || ok -0.5 > 0.5 == ok -0.5 > array[i64] -0.5 > f32 and ok -0.5 > i && 0.5 < i64 -0.5 > i64 ? -i : array -0.5 >= 0.5 ? array[i64] : f32 -0.5 >= 0.5 and ok -0.5 >= i && 1 < 0.5 -0.5 >= i32 == ok -0.5 >= i32 and ok -0.5 ^ 0.5 == f64 -0.5 ^ 0.5 >= i32 -0.5 ^ 0.5 >= i64 -0.5 ^ 1 ** i64 -0.5 ^ 1 - f32 -0.5 ^ 1 < f32 -0.5 ^ 1 < i -0.5 ^ 1 <= i32 -0.5 ^ 1 > f64 / 1 -0.5 ^ 1 >= i -0.5 ^ f32 * i -0.5 ^ f32 ** i64 -0.5 ^ f32 <= i32 -0.5 ^ f32 > i64 -0.5 ^ f32 >= i -0.5 ^ f64 - i64 -0.5 ^ f64 / f32 -0.5 ^ f64 < f32 -0.5 ^ f64 > i32 -0.5 ^ i != f64 -0.5 ^ i * reduce(array, i) -0.5 ^ i ** floor(0.5) -0.5 ^ i / (0.5 + i32) -0.5 ^ i < -f64 -0.5 ^ i <= i32 -0.5 ^ i >= i64 -0.5 ^ i32 * reduce(list, f64) -0.5 ^ i32 ** f32 -0.5 ^ i32 < f32 ? ok : i32 -0.5 ^ i32 == i64 -0.5 ^ i32 ^ f64 -0.5 ^ i32 in array -0.5 ^ i64 * i -0.5 ^ i64 ** i -0.5 ^ i64 ** i64 -0.5 ^ i64 > i32 -0.5 in array != ok -0.5 in array && ok -1 != 0.5 != ok -1 != 0.5 and 1 == 1 -1 != 1 && ok -1 != 1 ? f64 : 0.5 > i -1 != 1 ? list : score -1 != f32 != ok -1 != f32 ? ok : half -1 != i or ok -1 != i64 ? add : div -1 != nil && ok -1 != nil == ok -1 != nil or not false -1 % 1 != i -1 % 1 != i32 -1 % 1 % i -1 % 1 / f32 -1 % 1 / i32 -1 % 1 < f64 -1 % 1 < i -1 % 1 == f64 -1 % 1 == i ? nil : 0.5 -1 % 1 == i32 -1 % array[i32] -1 % array[i] -1 % i != -i64 -1 % i != 1 != nil -1 % i - i64 -1 % i < i32 -1 % i >= f64 -1 % i >= i -1 % i not in array -1 % i32 != i -1 % i32 <= f32 -1 % i32 > i64 -1 % i32 >= f64 -1 % i64 - f32 -1 % i64 < score(i) -1 % i64 > f32 -1 * 0.5 + f64 -1 * 0.5 + i32 -1 * 0.5 + round(f64) -1 * 0.5 / i -1 * 0.5 / i64 -1 * 0.5 < i64 -1 * 0.5 == f32 -1 * 0.5 >= f32 -1 * 1 - i32 -1 * 1 <= int(i) -1 * 1 >= f32 -1 * f32 != f64 - 0.5 -1 * f32 <= reduce(array, #) -1 * f32 >= f64 -1 * f64 * i64 -1 * f64 <= i64 -1 * f64 > i -1 * f64 >= f64 -1 * i * f32 -1 * i - i32 -1 * i / f64 -1 * i < f32 -1 * i > i32 -1 * i not in array -1 * i32 + i32 -1 * i32 - i -1 * i32 < i -1 * i64 * f32 -1 * i64 + i -1 * i64 - f64 -1 * i64 / f64 -1 * i64 <= f64 -1 * i64 in array -1 ** 0.5 * i -1 ** 0.5 ** f32 -1 ** 0.5 ** f64 -1 ** 0.5 ** i64 -1 ** 0.5 - f32 -1 ** 0.5 - i32 -1 ** 0.5 - i64 -1 ** 0.5 < -f32 -1 ** 0.5 > i -1 ** 0.5 > i64 -1 ** 0.5 ^ f64 -1 ** 1 ** f64 -1 ** 1 + f64 -1 ** 1 + i64 -1 ** 1 - round(0.5) -1 ** 1 / f64 -1 ** 1 < f32 -1 ** 1 == 0.5 + i32 -1 ** 1 >= i -1 ** 1 >= i32 -1 ** 1 ^ i -1 ** 1 ^ i32 -1 ** 1 in array -1 ** array[i32] -1 ** f32 / i32 -1 ** f32 / i64 -1 ** f32 <= f32 -1 ** f32 <= i64 -1 ** f32 == i64 ? i32 : array -1 ** f32 >= f32 -1 ** f32 >= i -1 ** f32 ^ f32 -1 ** f32 ^ i64 -1 ** i + i32 -1 ** i >= i -1 ** i32 != i32 -1 ** i32 + f32 -1 ** i32 + i64 -1 ** i64 <= f32 -1 ** i64 <= f64 -1 ** i64 <= i32 -1 ** i64 > f32 -1 + 0.5 != i32 -1 + 0.5 + i -1 + 0.5 - i64 -1 + 0.5 < f32 -1 + 0.5 < i -1 + 0.5 == f64 -1 + 0.5 == f64 != nil -1 + 0.5 > i64 -1 + 0.5 not in array -1 + 1 != 0.5 ? 0.5 : half -1 + 1 - f32 -1 + 1 - i -1 + 1 < i -1 + 1 == f64 * i64 -1 + 1 > f32 -1 + 1 >= half(0.5) -1 + 1 >= i -1 + f32 != i32 -1 + f32 < i32 -1 + f32 <= i -1 + f32 > i64 -1 + f64 == i64 -1 + f64 >= f64 -1 + i .. i32 -1 + i <= ceil(f32) -1 + i <= f64 -1 + i >= min(i64) -1 + i32 != i32 -1 + i32 - f64 -1 + i32 < f32 -1 + i32 < i32 -1 + i32 <= f64 -1 + i32 > reduce(array, #) -1 + i32 >= f64 -1 + i64 != i32 -1 + i64 != i64 -1 + i64 < i32 -1 + i64 <= i64 -1 - 0.5 != f32 -1 - 0.5 + i -1 - 0.5 - f32 -1 - 0.5 <= i32 -1 - 0.5 <= i64 -1 - 1 < i64 ? 0.5 : "foo" -1 - 1 <= i32 + i64 -1 - 1 == f64 -1 - 1 > i32 / i32 -1 - f32 != f32 -1 - f32 <= i64 -1 - f64 != f32 -1 - f64 + f32 -1 - f64 + i - 0.5 -1 - f64 <= i -1 - f64 in array -1 - f64 not in array -1 - i > f64 +$env != $env == ok +$env != $env ?: greet +$env != $env.add +$env != $env.array +$env != $env.f64 +$env != $env.foo +$env != $env.greet +$env != $env.i +$env != $env.list +$env != $env.ok +$env != $env.str +$env != $env?.Bar +$env != $env?.Bar?.add +$env != $env?.Bar?.list +$env != $env?.String +$env != $env?.[Bar] +$env != $env?.[Bar]?.sum(foobar matches Bar) +$env != $env?.[String] +$env != $env?.[String]?.[array] +$env != $env?.[String]?.greet +$env != $env?.[foobar] +$env != $env?.[str] +$env != $env?.add +$env != $env?.array +$env != $env?.f64 +$env != $env?.foo +$env != $env?.foobar +$env != $env?.foobar?.greet +$env != $env?.greet +$env != $env?.i +$env != $env?.list +$env != $env?.ok +$env != $env?.str +$env != 0 != ok +$env != 0 && 1.0 != nil +$env != 0 ?: $env?.[f64] +$env != 1 / f64 +$env != 1.0 * i +$env != 1.0 + f64 +$env != 1.0 - f64 +$env != 1.0 / i +$env != 1.0 || abs($env) +$env != add ? add : ok ?: array +$env != array?.[i] +$env != f64 / f64 +$env != false != ok +$env != foo == $env?.[String] +$env != foo and ok +$env != foo.Bar +$env != foo.String +$env != foo.String() +$env != foo?.Bar +$env != foo?.String +$env != foo?.String() +$env != i not in toPairs($env) +$env != list or ok +$env != list?.[i] +$env != nil != ok +$env != str && ok +$env != str + str +$env != str || 1 in $env +$env != true and nil != nil +$env && false and $env matches $env +$env && false or ok +$env * 1 || true == true +$env - 1.0 not startsWith $env && false +$env .. $env in $env || true +$env == $env && nil in list +$env == $env ?: i != $env +$env == $env and ok +$env == $env or $env?.Bar() +$env == $env.add +$env == $env.array +$env == $env.f64 +$env == $env.foo +$env == $env.greet +$env == $env.i +$env == $env.list +$env == $env.list?.[i] +$env == $env.ok +$env == $env.str +$env == $env?.Bar +$env == $env?.String +$env == $env?.String?.foo +$env == $env?.String?.foobar?.[array] +$env == $env?.[Bar] +$env == $env?.[Bar]?.[ok]?.[array] +$env == $env?.[Bar]?.foo +$env == $env?.[Bar]?.i +$env == $env?.[String] +$env == $env?.[str] +$env == $env?.add +$env == $env?.array +$env == $env?.f64 +$env == $env?.f64 / i +$env == $env?.foo +$env == $env?.foobar +$env == $env?.greet +$env == $env?.i +$env == $env?.list +$env == $env?.ok +$env == $env?.str +$env == 0 ^ f64 +$env == 0 and take($env, 0) +$env == 1 ?: array +$env == 1.0 && $env != greet +$env == 1.0 && map($env, false)?.[i] +$env == 1.0 ** 1 ?: 1 +$env == 1.0 == none(array, true) +$env == 1.0 ?: $env?.greet +$env == 1.0 ^ $env?.f64 +$env == 1.0 ^ f64 +$env == 1.0 and add != add +$env == add and $env[foo:] +$env == array and ok +$env == array?.[i] +$env == f64 * f64 +$env == false not in $env?.[Bar] +$env == false not in $env?.[String] +$env == foo && ok +$env == foo.Bar +$env == foo.String +$env == foo.String() +$env == foo?.Bar +$env == foo?.String +$env == foo?.String() +$env == i ** f64 +$env == i || ok +$env == list && $env not in list +$env == list && findLast($env, .array) +$env == list?.[i] +$env == list[i:] +$env == nil && 1.0 > i +$env == ok and $env in foo +$env == str && ok or $env +$env == str || ok +$env >= 1.0 == $env or true +$env contains $env?.Bar +$env contains $env?.String +$env contains $env?.[Bar] +$env contains $env?.[Bar]?.[f64] +$env contains $env?.[String] +$env contains $env?.[str[:1.0]] +$env contains $env?.foobar +$env contains $env?.nil?.[list] +$env endsWith $env?.Bar +$env endsWith $env?.String +$env endsWith $env?.[Bar] +$env endsWith $env?.[Bar]?.str +$env endsWith $env?.[String] +$env endsWith $env?.[foobar?.[add]] +$env endsWith $env?.foobar +$env in $env.array +$env in $env.list +$env in $env?.Bar +$env in $env?.Bar?.foo +$env in $env?.String +$env in $env?.String?.list +$env in $env?.[Bar] +$env in $env?.[String?.[str]] +$env in $env?.[String] +$env in $env?.array +$env in $env?.foobar +$env in $env?.foobar?.foo +$env in $env?.list +$env in $env?.true?.f64(foobar) +$env in 0 .. i +$env in 1 .. i +$env in array or ok +$env in i .. $env.i +$env in list && $env and $env +$env in list and $env?.[f64] +$env matches $env && ok or true +$env matches $env?.$env?.add +$env matches $env?.Bar +$env matches $env?.String +$env matches $env?.[Bar] +$env matches $env?.[Bar]?.[f64] +$env matches $env?.[String] +$env matches $env?.[String]?.ok() +$env matches $env?.[foobar] +$env matches $env?.foobar +$env matches $env?.foobar?.Bar(foobar, foobar) +$env matches $env?.foobar?.greet() +$env not contains $env?.Bar +$env not contains $env?.String +$env not contains $env?.String?.[str] +$env not contains $env?.String?.array +$env not contains $env?.[Bar] +$env not contains $env?.[Bar]?.add() +$env not contains $env?.[Bar]?.ok +$env not contains $env?.[String] +$env not contains $env?.[first(foobar, greet)] +$env not contains $env?.[foobar] +$env not contains $env?.[toJSON(foobar)] +$env not contains $env?.foobar +$env not contains $env?.foobar?.[ok] +$env not contains $env?.foobar?.greet() +$env not endsWith $env?.Bar +$env not endsWith $env?.Bar?.[list] +$env not endsWith $env?.String +$env not endsWith $env?.[Bar] +$env not endsWith $env?.[String] +$env not endsWith $env?.[foobar] +$env not endsWith $env?.foobar +$env not in $env.array +$env not in $env.list +$env not in $env?.Bar +$env not in $env?.Bar?.[ok] +$env not in $env?.String +$env not in $env?.String?.f64 +$env not in $env?.[Bar] +$env not in $env?.[String] +$env not in $env?.[foobar] +$env not in $env?.array +$env not in $env?.list +$env not in array && ok +$env not in array == $env || false +$env not in array == $env?.[String] +$env not in array[:i] +$env not in list or ok +$env not matches $env?.Bar +$env not matches $env?.Bar?.[add] +$env not matches $env?.Bar?.array +$env not matches $env?.String +$env not matches $env?.String?.[add] +$env not matches $env?.String?.[ok] +$env not matches $env?.[Bar] +$env not matches $env?.[String?.[Bar]] +$env not matches $env?.[String] +$env not matches $env?.[foobar] +$env not startsWith $env?.Bar +$env not startsWith $env?.Bar?.[greet] +$env not startsWith $env?.String +$env not startsWith $env?.[Bar] +$env not startsWith $env?.[Bar]?.f64 +$env not startsWith $env?.[String] +$env not startsWith $env?.[foobar] +$env not startsWith $env?.foobar +$env not startsWith $env?.foobar?.[foo] +$env not startsWith $env?.foobar?.add +$env or nil != nil || true +$env or nil == list and false +$env or true ?: greet +$env startsWith $env?.Bar +$env startsWith $env?.String +$env startsWith $env?.[Bar] +$env startsWith $env?.[String] +$env startsWith $env?.[foobar] +$env startsWith $env?.[foobar]?.[i] +$env startsWith $env?.foobar +$env startsWith $env?.foobar?.Bar() +$env | any(false) != ok +$env | filter(#.f64) | filter(false) +$env | filter(false) | count(.i.greet) +$env | filter(false) | find($env) +$env | filter(false) | findIndex(.foo) +$env | filter(false) | findLast(.greet) +$env | filter(false) | findLast(.ok) +$env | filter(false) | findLastIndex(.i) +$env | filter(false) | map(#) +$env | filter(false) | one(#) +$env | filter(false) | sum(.greet) +$env | filter(true) | map($env) +$env | find(.add) startsWith str || true +$env | findLast(false) == str or true +$env | findLastIndex(true) - i +$env | map(#index) | groupBy(f64) +$env | map(#index) | map(i) +$env | map(#index) | reduce(f64, nil) +$env | map($env) | find(#.ok) +$env | map($env) | map(list) +$env | map($env) | sortBy(#.i) +$env | map($env) | sortBy(.i) +$env | map($env) | sortBy(i) +$env | map(0) | groupBy(1) +$env | map(0) | sortBy(#) +$env | map(0) | sortBy(1.0) +$env | map(1) | sum(#) +$env | map(1.0) | filter(true) +$env | map(1.0) | findLastIndex(ok) +$env | map(1.0) | groupBy(foo) +$env | map(1.0) | mean(0) +$env | map(1.0) | none(true) +$env | map(1.0) | reduce(1.0) +$env | map(1.0) | reduce(false, list) +$env | map(1.0) | sortBy(#) +$env | map(false) | map(f64) +$env | map(false) | reduce(str) +$env | map(foo) | any(false) +$env | map(foo) | findIndex(true) +$env | map(foo) | groupBy(1) +$env | map(foo) | reduce(#acc) +$env | map(foo) | sum(1) +$env | map(greet) | map(array) +$env | map(i) | count(false) +$env | map(list) | reduce(ok) +$env | map(ok) | findLast(ok) +$env | map(ok) | map($env) +$env | map(ok) | none(#) +$env | map(ok) | one(#) +$env | map(ok) | reduce(0) +$env | map(ok) | reduce(false) +$env | map(str) | groupBy(foo) +$env | map(true) | all(#) +$env | map(true) | findLastIndex(#) +$env | map(true) | map($env) +$env | none(true) && ok +$env | one(ok) || ok +$env | reduce(#, nil) > $env and false +$env | reduce($env, $env) | count(ok) +$env | reduce($env, 1) | sum(0) +$env | reduce(1.0, 1) <= f64 +$env | reduce(false, $env); list +$env | reduce(ok, 1) ?: greet +$env | sortBy(#, 0) * $env && false +$env | sum(1.0) in array +$env | sum(f64) > f64 +$env | sum(i) / bitnot(i) +$env || true || $env < 1 +$env.add == $env.add +$env.add == $env?.add +$env.add == add +$env.array != array +$env.array != list +$env.array == $env?.array +$env.array == array +$env.array == list +$env.array | any($env?.ok) +$env.array | any(false) +$env.array | any(ok) +$env.array | concat(array) +$env.array | concat(list) +$env.array | count(false) +$env.array | filter(false) +$env.array | filter(ok) +$env.array | filter(true) +$env.array | find(false) +$env.array | find(ok) +$env.array | find(true) +$env.array | findIndex(false) +$env.array | findIndex(nil == list) +$env.array | findIndex(ok) +$env.array | findIndex(true) +$env.array | findLast(ok) +$env.array | findLast(true) +$env.array | findLastIndex(false) +$env.array | findLastIndex(ok) +$env.array | findLastIndex(true) +$env.array | groupBy(#) +$env.array | groupBy(0) +$env.array | groupBy(1) +$env.array | groupBy(1.0) +$env.array | groupBy(f64) +$env.array | groupBy(foo) +$env.array | groupBy(i) +$env.array | groupBy(ok) +$env.array | map(#) +$env.array | map(#index) +$env.array | map($env) +$env.array | map(1) +$env.array | map(array) +$env.array | map(f64) +$env.array | map(false) +$env.array | map(foo) +$env.array | map(greet) +$env.array | map(i) +$env.array | map(list) +$env.array | map(ok) +$env.array | map(str) +$env.array | map(true) +$env.array | mean(1.0) +$env.array | mean(f64) +$env.array | mean(i) +$env.array | median(0, array) +$env.array | median(1) +$env.array | none(ok) +$env.array | none(true) +$env.array | one(ok) +$env.array | reduce(#) +$env.array | reduce(#, 0) +$env.array | reduce(#, foo) +$env.array | reduce($env) +$env.array | reduce(1) +$env.array | reduce(1.0, greet) +$env.array | reduce(add) +$env.array | reduce(array) +$env.array | reduce(f64) +$env.array | reduce(false) +$env.array | reduce(foo) +$env.array | reduce(foo, 1) +$env.array | reduce(foo, 1.0) +$env.array | reduce(foo, array) +$env.array | reduce(greet) +$env.array | reduce(i) +$env.array | reduce(i, true) +$env.array | reduce(list) +$env.array | reduce(ok) +$env.array | reduce(str) +$env.array | reduce(str, false) +$env.array | reduce(true) +$env.array | reduce(true, false) +$env.array | reduce(true, true) +$env.array | sortBy(#) +$env.array | sortBy(1) +$env.array | sortBy(1.0) +$env.array | sortBy(f64) +$env.array | sortBy(str) +$env.array | sum(#) +$env.array | sum(0) +$env.array | sum(1) +$env.array | sum(1.0) +$env.array | take(0) +$env.array?.[i] +$env.array[:] +$env.array[:i] +$env.f64 != $env.i +$env.f64 != 0 % i +$env.f64 != abs(f64) +$env.f64 != i +$env.f64 * 0 >= 1.0 +$env.f64 * array?.[i] +$env.f64 * f64 +$env.f64 * i +$env.f64 ** i +$env.f64 ** sum(array) +$env.f64 + f64 == 1 +$env.f64 + i +$env.f64 - 1 >= f64 +$env.f64 - 1.0 > 0 +$env.f64 - f64 +$env.f64 - i +$env.f64 / f64 +$env.f64 / i +$env.f64 < 1.0 || ok +$env.f64 < f64 +$env.f64 < i +$env.f64 <= f64 +$env.f64 <= i +$env.f64 == f64 +$env.f64 > $env.f64 +$env.f64 > f64 +$env.f64 > i +$env.f64 > sum($env, f64) +$env.f64 >= 1.0 - 1.0 +$env.f64 >= abs(1.0) +$env.f64 >= i +$env.f64 ^ 0 / 0 +$env.f64 ^ f64 +$env.f64 ^ i +$env.f64 ^ i != $env +$env.f64 in array +$env.f64 not in first($env) +$env.f64 | max(f64) +$env.f64 | mean(1) +$env.f64 | mean(f64) +$env.f64 | median(i) +$env.foo != foo +$env.foo == $env?.foo +$env.foo == foo +$env.foo == nil == $env +$env.foo == nil and ok +$env.foo in list +$env.foo not in list +$env.foo.Bar +$env.foo.String +$env.foo.String() +$env.foo?.Bar +$env.foo?.String +$env.foo?.String() +$env.greet != greet +$env.greet == greet +$env.greet($env.str) +$env.greet($env?.[str]) +$env.greet(foo.Bar) +$env.greet(foo.String()) +$env.greet(foo?.String()) +$env.greet(greet(str)) +$env.greet(str) +$env.greet(string($env)) +$env.i != $env?.Bar +$env.i != $env?.[Bar]?.foo() +$env.i != 1 / 1 +$env.i % i +$env.i * f64 +$env.i * i +$env.i ** f64 +$env.i ** i +$env.i ** mean(1.0) +$env.i - f64 +$env.i / $env.f64 +$env.i / f64 +$env.i / find(array, true) +$env.i < 1.0 or $env +$env.i < i +$env.i < i / i +$env.i <= f64 +$env.i == f64 +$env.i == i +$env.i > $env.i +$env.i > f64 +$env.i >= f64 +$env.i >= i +$env.i ^ f64 +$env.i ^ i +$env.i in array +$env.i in array != nil +$env.i not in $env?.[String] +$env.i not in $env?.array +$env.i | add(i) +$env.i | bitnand(i) +$env.i | bitor(1) +$env.i | bitshl(0) +$env.i | bitshr(i) +$env.i | bitushr(1) +$env.i | bitushr(i) +$env.i | bitxor(0) +$env.i | max(1.0) +$env.i | mean(i) +$env.list != array +$env.list != list +$env.list == $env?.Bar +$env.list == array +$env.list == list +$env.list == nil || $env +$env.list | all(false) +$env.list | all(ok) +$env.list | all(true) +$env.list | any(false) +$env.list | any(ok) +$env.list | any(true) +$env.list | concat(array) +$env.list | count(false) +$env.list | count(true) +$env.list | filter(false) +$env.list | filter(true) +$env.list | find(false) +$env.list | find(nil not in list) +$env.list | find(ok) +$env.list | findIndex(false) +$env.list | findIndex(ok) +$env.list | findIndex(true) +$env.list | findLast(true) +$env.list | findLastIndex(true) +$env.list | groupBy(#) +$env.list | groupBy(.Bar) +$env.list | groupBy(0) +$env.list | groupBy(1) +$env.list | groupBy(1.0) +$env.list | groupBy(f64) +$env.list | groupBy(false != false) +$env.list | groupBy(false) +$env.list | groupBy(foo) +$env.list | map(#) +$env.list | map(#.Bar) +$env.list | map(#.String) +$env.list | map(#index) +$env.list | map($env) +$env.list | map(.Bar) +$env.list | map(0) +$env.list | map(1) +$env.list | map(1.0) +$env.list | map(add) +$env.list | map(array) +$env.list | map(f64) +$env.list | map(foo) +$env.list | map(greet) +$env.list | map(i) +$env.list | map(list) +$env.list | map(ok) +$env.list | map(str) +$env.list | map(true) +$env.list | one(false) +$env.list | one(true) +$env.list | reduce(#) +$env.list | reduce(#, nil) +$env.list | reduce(#.Bar) +$env.list | reduce($env) +$env.list | reduce(.Bar, 1) +$env.list | reduce(.String) +$env.list | reduce(0) +$env.list | reduce(1) +$env.list | reduce(1.0) +$env.list | reduce(1.0, f64) +$env.list | reduce(1.0, false) +$env.list | reduce(add) +$env.list | reduce(add, nil) +$env.list | reduce(array) +$env.list | reduce(f64) +$env.list | reduce(foo == #) +$env.list | reduce(foo) +$env.list | reduce(foo, 0) +$env.list | reduce(foo, foo) +$env.list | reduce(foo, nil) +$env.list | reduce(foo, str) +$env.list | reduce(i) +$env.list | reduce(i, 1.0) +$env.list | reduce(list) +$env.list | reduce(str) +$env.list | reduce(true, 1) +$env.list | sortBy(#.Bar) +$env.list | sortBy(.Bar) +$env.list | sortBy(1.0) +$env.list | sum(0) +$env.list | sum(1) +$env.list | sum(1.0) +$env.list | sum(i) +$env.list?.[i] +$env.list?.[i].Bar +$env.list?.[i].String() +$env.list[:sum(array, #)] +$env.list[i:] +$env.ok != ok +$env.ok && $env?.[nil] +$env.ok && ok +$env.ok == ok +$env.ok ? list : date(1) +$env.ok ?: array +$env.ok ?: f64 +$env.ok and $env?.[foobar] +$env.ok and $env?.[nil] +$env.ok and ok +$env.ok in $env?.[nil] +$env.ok in keys($env) +$env.ok not in $env?.$env +$env.ok or ok +$env.ok || ok +$env.str != str +$env.str + str +$env.str + type($env) +$env.str < $env?.[str] +$env.str < foo.Bar +$env.str <= str +$env.str > str +$env.str > type(nil) +$env.str >= greet(str) +$env.str >= str +$env.str contains $env?.String +$env.str contains str +$env.str endsWith str +$env.str in foo +$env.str matches str +$env.str matches str ?: 1.0 +$env.str matches string(1.0) +$env.str not contains $env.str +$env.str not contains str +$env.str not endsWith str +$env.str not in $env ? foo : 0 +$env.str not in foo +$env.str not matches str +$env.str not startsWith str +$env.str | greet() +$env.str | hasSuffix(str) +$env.str | split(str) +$env.str[:] +$env.str[i:] +$env; $env.add +$env; $env?.foo +$env; $env?.i +$env; $env?.str +$env; false; $env?.foo +$env?.$env != $env.array +$env?.$env != foo +$env?.$env != i +$env?.$env == add +$env?.$env not contains str +$env?.$env?.Bar +$env?.$env?.Bar?.foo +$env?.$env?.String +$env?.$env?.String() +$env?.$env?.[add] +$env?.$env?.[array] +$env?.$env?.[f64] +$env?.$env?.[f64]?.str +$env?.$env?.[foo] +$env?.$env?.[foo].ok +$env?.$env?.[greet] +$env?.$env?.[i] +$env?.$env?.[i].f64 +$env?.$env?.[i].str +$env?.$env?.[i]?.[ok] +$env?.$env?.[list] +$env?.$env?.[ok] +$env?.$env?.[str] +$env?.$env?.[str]?.[foo]?.str +$env?.$env?.add +$env?.$env?.add() +$env?.$env?.add?.ok +$env?.$env?.array +$env?.$env?.array() +$env?.$env?.array.i +$env?.$env?.array?.[ok] +$env?.$env?.f64 +$env?.$env?.f64() +$env?.$env?.f64.String +$env?.$env?.filter(1.0, foo) +$env?.$env?.foo +$env?.$env?.foobar.i(foo) +$env?.$env?.greet +$env?.$env?.greet() +$env?.$env?.greet.foo() +$env?.$env?.greet?.i() +$env?.$env?.i +$env?.$env?.i() +$env?.$env?.i()?.list +$env?.$env?.i(str, foobar?.f64) +$env?.$env?.i?.greet +$env?.$env?.list +$env?.$env?.list() +$env?.$env?.list?.foo +$env?.$env?.ok +$env?.$env?.ok() +$env?.$env?.ok(String) +$env?.$env?.ok?.String +$env?.$env?.str +$env?.$env?.str() +$env?.$env?.str()?.[add] +$env?.$env?.str(foobar) +$env?.$env?.sum(0, list) +$env?.Bar != $env.add +$env?.Bar != add +$env?.Bar != f64 +$env?.Bar != foo +$env?.Bar != greet +$env?.Bar != i +$env?.Bar != list +$env?.Bar != min(1) +$env?.Bar != ok +$env?.Bar != str +$env?.Bar != type(1.0) +$env?.Bar + 1.0 or true +$env?.Bar == $env?.f64 +$env?.Bar == 1.0 / f64 +$env?.Bar == add +$env?.Bar == array +$env?.Bar == f64 +$env?.Bar == greet +$env?.Bar == greet(str) +$env?.Bar == i +$env?.Bar == map(list, 1.0) +$env?.Bar == ok +$env?.Bar == ok or true +$env?.Bar == string(list) +$env?.Bar contains $env?.$env +$env?.Bar contains str +$env?.Bar endsWith str +$env?.Bar endsWith str ? foo : 1 +$env?.Bar in array +$env?.Bar matches str +$env?.Bar matches string(i) +$env?.Bar not contains str +$env?.Bar not endsWith foo.Bar +$env?.Bar not in $env?.String +$env?.Bar not in [f64, $env] +$env?.Bar not in array +$env?.Bar not in list +$env?.Bar not in list and $env +$env?.Bar not matches str +$env?.Bar not startsWith $env?.str +$env?.Bar not startsWith str +$env?.Bar startsWith $env?.[String] +$env?.Bar startsWith str +$env?.Bar?.Bar +$env?.Bar?.Bar() +$env?.Bar?.Bar().Bar +$env?.Bar?.Bar()?.[f64] +$env?.Bar?.Bar(foobar) +$env?.Bar?.Bar(foobar?.String) +$env?.Bar?.Bar.add +$env?.Bar?.Bar.i +$env?.Bar?.Bar.ok +$env?.Bar?.Bar?.Bar +$env?.Bar?.Bar?.Bar().greet +$env?.Bar?.Bar?.String +$env?.Bar?.Bar?.[f64] +$env?.Bar?.Bar?.i +$env?.Bar?.Bar?.ok +$env?.Bar?.Bar?.str +$env?.Bar?.String +$env?.Bar?.String() +$env?.Bar?.String(foo) +$env?.Bar?.String(foobar) +$env?.Bar?.String(foobar)?.[add] +$env?.Bar?.String(foobar)?.[ok]?.[str] +$env?.Bar?.String(foobar)?.str +$env?.Bar?.String(foobar?.Bar?.[f64]) +$env?.Bar?.String(foobar?.[true]) +$env?.Bar?.String(greet) +$env?.Bar?.String(i) +$env?.Bar?.String(str | toBase64(foobar), foobar) +$env?.Bar?.String.i +$env?.Bar?.String?.String +$env?.Bar?.String?.[i] +$env?.Bar?.String?.[str] +$env?.Bar?.String?.foo +$env?.Bar?.String?.str() +$env?.Bar?.[$env.i] +$env?.Bar?.[$env?.[add]].Bar +$env?.Bar?.[add] +$env?.Bar?.[add].add +$env?.Bar?.[add].foo +$env?.Bar?.[add].i +$env?.Bar?.[add]?.foo +$env?.Bar?.[add]?.ok +$env?.Bar?.[add]?.str +$env?.Bar?.[array] +$env?.Bar?.[array].ok() +$env?.Bar?.[array]?.Bar +$env?.Bar?.[array]?.add +$env?.Bar?.[array]?.foo +$env?.Bar?.[array]?.list +$env?.Bar?.[f64] +$env?.Bar?.[f64].Bar +$env?.Bar?.[f64].list +$env?.Bar?.[f64]?.Bar +$env?.Bar?.[f64]?.[greet] +$env?.Bar?.[f64]?.[list] +$env?.Bar?.[f64]?.array() +$env?.Bar?.[false != $env] +$env?.Bar?.[foo] +$env?.Bar?.[foo].add +$env?.Bar?.[foo].array() +$env?.Bar?.[foo].greet +$env?.Bar?.[foo]?.Bar +$env?.Bar?.[foo]?.String +$env?.Bar?.[foo]?.[greet] +$env?.Bar?.[foo]?.[ok] +$env?.Bar?.[foo]?.str +$env?.Bar?.[greet] +$env?.Bar?.[greet].add +$env?.Bar?.[greet].f64 +$env?.Bar?.[greet].foo +$env?.Bar?.[greet].i +$env?.Bar?.[greet].ok +$env?.Bar?.[greet]?.f64 +$env?.Bar?.[groupBy(list, #)] +$env?.Bar?.[i] +$env?.Bar?.[i].foo +$env?.Bar?.[i].ok +$env?.Bar?.[i]?.Bar +$env?.Bar?.[i]?.String +$env?.Bar?.[i]?.[greet] +$env?.Bar?.[i]?.[ok] +$env?.Bar?.[i]?.f64 +$env?.Bar?.[i]?.foo +$env?.Bar?.[i]?.str() +$env?.Bar?.[list] +$env?.Bar?.[list].Bar +$env?.Bar?.[list].add +$env?.Bar?.[list].f64 +$env?.Bar?.[list].greet +$env?.Bar?.[list].i(foobar) +$env?.Bar?.[list].str() +$env?.Bar?.[list]?.String +$env?.Bar?.[list]?.[foo] +$env?.Bar?.[list]?.[i] +$env?.Bar?.[list]?.array.list +$env?.Bar?.[list]?.f64 +$env?.Bar?.[list]?.list() +$env?.Bar?.[list]?.str() +$env?.Bar?.[median(0)] +$env?.Bar?.[ok] +$env?.Bar?.[ok].Bar +$env?.Bar?.[ok].String +$env?.Bar?.[ok].f64 +$env?.Bar?.[ok]?.String +$env?.Bar?.[ok]?.[i] +$env?.Bar?.[ok]?.[str] +$env?.Bar?.[ok]?.add +$env?.Bar?.[ok]?.array +$env?.Bar?.[ok]?.array() +$env?.Bar?.[ok]?.f64() +$env?.Bar?.[ok]?.greet.array(foobar?.[str]) +$env?.Bar?.[ok]?.ok +$env?.Bar?.[str] +$env?.Bar?.[str].i +$env?.Bar?.[str]?.[array] +$env?.Bar?.[str]?.[foo] +$env?.Bar?.[str]?.[i] +$env?.Bar?.add +$env?.Bar?.add not contains $env +$env?.Bar?.add($env.foo).String +$env?.Bar?.add() +$env?.Bar?.add().f64 +$env?.Bar?.add().f64(foobar) +$env?.Bar?.add()?.i() +$env?.Bar?.add(add) +$env?.Bar?.add(foobar) +$env?.Bar?.add(foobar?.Bar?.[list]) +$env?.Bar?.add.i +$env?.Bar?.add.list +$env?.Bar?.add.ok() +$env?.Bar?.add?.[add] +$env?.Bar?.add?.[greet] +$env?.Bar?.any(str) +$env?.Bar?.array +$env?.Bar?.array($env) +$env?.Bar?.array() +$env?.Bar?.array(array) +$env?.Bar?.array(f64) +$env?.Bar?.array(foobar) +$env?.Bar?.array(foobar?.foo).ok +$env?.Bar?.array(list) +$env?.Bar?.array(ok) +$env?.Bar?.array(reduce(list, foobar))?.Bar +$env?.Bar?.array(str) +$env?.Bar?.array.Bar +$env?.Bar?.array.array +$env?.Bar?.array.list(string(list) endsWith foobar?.String) +$env?.Bar?.array.str +$env?.Bar?.array?.[array] +$env?.Bar?.array?.[f64] +$env?.Bar?.array?.[foo] +$env?.Bar?.array?.[str] +$env?.Bar?.array?.array +$env?.Bar?.array?.foo +$env?.Bar?.bitand(foobar) +$env?.Bar?.bitnand(i, f64) +$env?.Bar?.bitshl(str, foobar) +$env?.Bar?.bitshr(foobar) +$env?.Bar?.f64 +$env?.Bar?.f64() +$env?.Bar?.f64().add() +$env?.Bar?.f64(1) +$env?.Bar?.f64(Bar?.[ok]) +$env?.Bar?.f64(foobar) +$env?.Bar?.f64(foobar, foobar?.str()) +$env?.Bar?.f64.Bar(0) +$env?.Bar?.f64.array() +$env?.Bar?.f64.list +$env?.Bar?.f64?.Bar() +$env?.Bar?.f64?.[f64] +$env?.Bar?.f64?.[i] +$env?.Bar?.f64?.f64 +$env?.Bar?.f64?.list() +$env?.Bar?.f64?.str +$env?.Bar?.false?.[foo] +$env?.Bar?.false?.list +$env?.Bar?.findIndex(false) +$env?.Bar?.findLastIndex(1, foobar) +$env?.Bar?.foo +$env?.Bar?.foo not contains $env +$env?.Bar?.foo($env matches foobar) +$env?.Bar?.foo() +$env?.Bar?.foo().greet.str +$env?.Bar?.foo(foobar) +$env?.Bar?.foo(foobar, foobar) +$env?.Bar?.foo(i) +$env?.Bar?.foo(list) +$env?.Bar?.foo.Bar +$env?.Bar?.foo.array +$env?.Bar?.foo.i +$env?.Bar?.foo?.Bar +$env?.Bar?.foo?.[ok] +$env?.Bar?.foo?.str +$env?.Bar?.foobar +$env?.Bar?.foobar.add +$env?.Bar?.foobar.foobar +$env?.Bar?.foobar.i +$env?.Bar?.foobar.list +$env?.Bar?.foobar.str()?.ok +$env?.Bar?.foobar?.[i].String +$env?.Bar?.foobar?.[list] +$env?.Bar?.foobar?.i +$env?.Bar?.foobar?.list +$env?.Bar?.fromPairs(0) +$env?.Bar?.greet +$env?.Bar?.greet() +$env?.Bar?.greet()?.String +$env?.Bar?.greet(array) +$env?.Bar?.greet(foo) +$env?.Bar?.greet(foobar startsWith foobar) +$env?.Bar?.greet(foobar) +$env?.Bar?.greet(foobar?.ok()) +$env?.Bar?.greet(ok) +$env?.Bar?.greet.add() +$env?.Bar?.greet.f64 +$env?.Bar?.greet.foo +$env?.Bar?.greet?.[array] +$env?.Bar?.greet?.foo +$env?.Bar?.greet?.i() +$env?.Bar?.groupBy(add) +$env?.Bar?.i +$env?.Bar?.i() +$env?.Bar?.i(String) +$env?.Bar?.i(foobar?.[str]) +$env?.Bar?.i(list) +$env?.Bar?.i.array() +$env?.Bar?.i?.[add] +$env?.Bar?.i?.[greet]?.[array] +$env?.Bar?.i?.array +$env?.Bar?.i?.foo +$env?.Bar?.i?.ok +$env?.Bar?.len(greet) +$env?.Bar?.list +$env?.Bar?.list() +$env?.Bar?.list().ok +$env?.Bar?.list()?.ok +$env?.Bar?.list(f64) +$env?.Bar?.list(foobar) +$env?.Bar?.list(list)?.str +$env?.Bar?.list(type(foobar)) +$env?.Bar?.list.Bar +$env?.Bar?.list.foobar +$env?.Bar?.list?.String +$env?.Bar?.list?.[foo]?.String()?.list +$env?.Bar?.list?.[list] +$env?.Bar?.list?.add +$env?.Bar?.list?.f64 +$env?.Bar?.list?.foo +$env?.Bar?.list?.i +$env?.Bar?.map(foobar) +$env?.Bar?.map(foobar, greet, String) +$env?.Bar?.median(true, $env) +$env?.Bar?.nil.array() +$env?.Bar?.none(foobar) +$env?.Bar?.ok +$env?.Bar?.ok() +$env?.Bar?.ok().greet +$env?.Bar?.ok()?.f64 +$env?.Bar?.ok()?.list +$env?.Bar?.ok(f64) +$env?.Bar?.ok(foobar) +$env?.Bar?.ok(greet) +$env?.Bar?.ok(list) +$env?.Bar?.ok(str) +$env?.Bar?.ok.String() +$env?.Bar?.ok.greet +$env?.Bar?.ok.str +$env?.Bar?.ok?.Bar +$env?.Bar?.ok?.String +$env?.Bar?.ok?.[array] +$env?.Bar?.ok?.[f64] +$env?.Bar?.ok?.f64 +$env?.Bar?.ok?.foo +$env?.Bar?.ok?.str +$env?.Bar?.reduce(foobar, foobar) +$env?.Bar?.reduce(true) +$env?.Bar?.round(foobar) +$env?.Bar?.sortBy($env, false) +$env?.Bar?.sortBy(nil) +$env?.Bar?.split(false) +$env?.Bar?.str +$env?.Bar?.str != ok +$env?.Bar?.str() +$env?.Bar?.str()?.f64 +$env?.Bar?.str()?.greet +$env?.Bar?.str(1, foobar) +$env?.Bar?.str(add) +$env?.Bar?.str(foobar) +$env?.Bar?.str.foo +$env?.Bar?.str?.[foo] +$env?.Bar?.str?.[greet] +$env?.Bar?.str?.[ok] +$env?.Bar?.str?.[str] +$env?.Bar?.str?.i() +$env?.Bar?.string(foobar) +$env?.String != $env ? ok : true +$env?.String != foo +$env?.String != greet +$env?.String != list +$env?.String != str +$env?.String == array +$env?.String == f64 +$env?.String == greet +$env?.String == i +$env?.String == list +$env?.String == str +$env?.String contains str +$env?.String endsWith $env && $env +$env?.String endsWith str +$env?.String in $env ? 1 : true +$env?.String in array +$env?.String in list +$env?.String matches $env?.nil +$env?.String matches str +$env?.String not contains str +$env?.String not endsWith $env and $env +$env?.String not endsWith $env.str +$env?.String not in $env?.Bar?.array +$env?.String not in array +$env?.String not in list +$env?.String not matches $env?.[String] +$env?.String not startsWith str +$env?.String startsWith str +$env?.String?.$env != true +$env?.String?.Bar +$env?.String?.Bar() +$env?.String?.Bar(String) +$env?.String?.Bar(add) +$env?.String?.Bar(foobar) +$env?.String?.Bar(ok) +$env?.String?.Bar.String +$env?.String?.Bar.add +$env?.String?.Bar.add() +$env?.String?.Bar.i +$env?.String?.Bar.list +$env?.String?.Bar.str +$env?.String?.Bar?.String +$env?.String?.Bar?.[greet] +$env?.String?.Bar?.[ok] +$env?.String?.Bar?.i +$env?.String?.Bar?.str +$env?.String?.String +$env?.String?.String() +$env?.String?.String(foobar) +$env?.String?.String(str) +$env?.String?.String.add.f64 +$env?.String?.String.f64 +$env?.String?.String.i +$env?.String?.String.ok +$env?.String?.String?.[foo] +$env?.String?.String?.f64 +$env?.String?.String?.foo +$env?.String?.String?.greet +$env?.String?.String?.one(foobar?.list) +$env?.String?.[$env?.[f64]] +$env?.String?.[add] +$env?.String?.[add] != greet +$env?.String?.[add].array +$env?.String?.[add].i +$env?.String?.[add]?.Bar?.array +$env?.String?.[add]?.[f64] +$env?.String?.[add]?.[i] +$env?.String?.[add]?.[list] +$env?.String?.[array] +$env?.String?.[array].f64 +$env?.String?.[array].f64() +$env?.String?.[array].str +$env?.String?.[array]?.array +$env?.String?.[array]?.foo() +$env?.String?.[f64] +$env?.String?.[f64].add +$env?.String?.[f64].foobar +$env?.String?.[f64]?.Bar +$env?.String?.[f64]?.String +$env?.String?.[f64]?.[str] +$env?.String?.[f64]?.array +$env?.String?.[f64]?.greet +$env?.String?.[f64]?.list +$env?.String?.[foo] +$env?.String?.[foo].array +$env?.String?.[foo].f64() +$env?.String?.[foo].i +$env?.String?.[foo]?.[foo] +$env?.String?.[foo]?.[i] +$env?.String?.[foo]?.add +$env?.String?.[foo]?.foo +$env?.String?.[foo]?.i +$env?.String?.[foo]?.list +$env?.String?.[foo]?.ok +$env?.String?.[greet] +$env?.String?.[greet].add +$env?.String?.[greet].any(foobar).str +$env?.String?.[greet].array +$env?.String?.[greet]?.[list] +$env?.String?.[greet]?.f64 +$env?.String?.[greet]?.list +$env?.String?.[i] +$env?.String?.[i].f64 +$env?.String?.[i].f64() +$env?.String?.[i].foo +$env?.String?.[i].list +$env?.String?.[i]?.[array] +$env?.String?.[i]?.[foo] +$env?.String?.[i]?.[greet] +$env?.String?.[i]?.add +$env?.String?.[i]?.array +$env?.String?.[i]?.foo +$env?.String?.[i]?.str() +$env?.String?.[list] +$env?.String?.[list].array +$env?.String?.[list].foo +$env?.String?.[list].list +$env?.String?.[list].ok() +$env?.String?.[list]?.[list] +$env?.String?.[list]?.[str] +$env?.String?.[list]?.add +$env?.String?.[list]?.list(foobar) +$env?.String?.[ok] +$env?.String?.[ok].Bar +$env?.String?.[ok].add +$env?.String?.[ok]?.Bar.str +$env?.String?.[ok]?.[i] +$env?.String?.[ok]?.[ok] +$env?.String?.[ok]?.[str] +$env?.String?.[ok]?.greet +$env?.String?.[ok]?.ok +$env?.String?.[str] +$env?.String?.[str].foo +$env?.String?.[str].str() +$env?.String?.[str]?.[array] +$env?.String?.[str]?.[list] +$env?.String?.[str]?.array +$env?.String?.[str]?.f64 +$env?.String?.[str]?.str(str) +$env?.String?.add +$env?.String?.add() +$env?.String?.add()?.[i] +$env?.String?.add(Bar) +$env?.String?.add(f64 not endsWith nil) +$env?.String?.add.ok() +$env?.String?.add?.[f64] +$env?.String?.add?.[ok] +$env?.String?.add?.array +$env?.String?.add?.greet +$env?.String?.add?.i(f64) +$env?.String?.add?.list +$env?.String?.add?.ok +$env?.String?.add?.str?.array +$env?.String?.all(1.0, true) +$env?.String?.all(foobar) +$env?.String?.all(nil, nil) +$env?.String?.all(ok, nil) +$env?.String?.any(foo) +$env?.String?.array +$env?.String?.array not endsWith str +$env?.String?.array() +$env?.String?.array()?.[f64] +$env?.String?.array(String) +$env?.String?.array(array matches nil) +$env?.String?.array(i) +$env?.String?.array(str not in String) +$env?.String?.array.Bar +$env?.String?.array.String +$env?.String?.array.f64 +$env?.String?.array.foo +$env?.String?.array.list +$env?.String?.array?.String +$env?.String?.array?.array() +$env?.String?.array?.f64 +$env?.String?.array?.f64.list() +$env?.String?.array?.ok +$env?.String?.bitshl(String) +$env?.String?.bitshr(nil, f64) +$env?.String?.bitushr(str, foobar) +$env?.String?.bitxor(String) +$env?.String?.duration(foobar) +$env?.String?.f64 +$env?.String?.f64() +$env?.String?.f64()?.[i] +$env?.String?.f64()?.[str] +$env?.String?.f64(foobar) +$env?.String?.f64(foobar, foobar) +$env?.String?.f64(i) +$env?.String?.f64(list) +$env?.String?.f64(nil == f64) +$env?.String?.f64.f64 +$env?.String?.f64.list +$env?.String?.f64.ok +$env?.String?.f64.str(foobar, foobar)?.[add] +$env?.String?.f64?.[array] +$env?.String?.f64?.[greet] +$env?.String?.f64?.list?.[str] +$env?.String?.f64?.ok +$env?.String?.findIndex($env) +$env?.String?.findIndex(f64, foobar) +$env?.String?.findIndex(foobar) +$env?.String?.findLast(greet, nil) +$env?.String?.foo +$env?.String?.foo($env) +$env?.String?.foo() +$env?.String?.foo()?.[i] +$env?.String?.foo(foo) +$env?.String?.foo(greet) +$env?.String?.foo(list, 1) +$env?.String?.foo(ok) +$env?.String?.foo.i +$env?.String?.foo?.[f64] +$env?.String?.foo?.[i] +$env?.String?.foo?.[ok] +$env?.String?.foo?.[ok].f64() +$env?.String?.foo?.greet +$env?.String?.foobar +$env?.String?.foobar in array +$env?.String?.foobar.f64 +$env?.String?.foobar.foo +$env?.String?.foobar.greet +$env?.String?.foobar?.[add] +$env?.String?.foobar?.[list] +$env?.String?.foobar?.add() +$env?.String?.foobar?.foo() +$env?.String?.get(nil) +$env?.String?.greet +$env?.String?.greet() +$env?.String?.greet().Bar +$env?.String?.greet().foo +$env?.String?.greet()?.[i] +$env?.String?.greet(foobar == String) +$env?.String?.greet(foobar or true) +$env?.String?.greet(foobar) +$env?.String?.greet.add +$env?.String?.greet.i +$env?.String?.greet?.[array] +$env?.String?.greet?.[list] +$env?.String?.greet?.[ok] +$env?.String?.greet?.foo +$env?.String?.greet?.i +$env?.String?.greet?.list +$env?.String?.i +$env?.String?.i() +$env?.String?.i(0).f64 +$env?.String?.i(1) +$env?.String?.i(String?.$env) +$env?.String?.i(array) +$env?.String?.i(f64) +$env?.String?.i(foobar) +$env?.String?.i.add +$env?.String?.i.foo +$env?.String?.i.foobar +$env?.String?.i.str +$env?.String?.i?.String +$env?.String?.i?.[f64] +$env?.String?.i?.ok +$env?.String?.int(add, foobar, greet) +$env?.String?.join(true, f64) +$env?.String?.list +$env?.String?.list() +$env?.String?.list(false) +$env?.String?.list(ok) +$env?.String?.list.array() +$env?.String?.list?.[i] +$env?.String?.list?.[str] +$env?.String?.list?.f64 +$env?.String?.list?.list +$env?.String?.list?.str +$env?.String?.map(nil, String) +$env?.String?.nil endsWith str +$env?.String?.not +$env?.String?.ok +$env?.String?.ok() +$env?.String?.ok(foobar not endsWith add) +$env?.String?.ok(foobar) +$env?.String?.ok(nil) +$env?.String?.ok.Bar() +$env?.String?.ok.array +$env?.String?.ok.f64 +$env?.String?.ok.foo +$env?.String?.ok.greet +$env?.String?.ok.list +$env?.String?.ok?.Bar +$env?.String?.ok?.[array] +$env?.String?.ok?.[list] +$env?.String?.ok?.[ok] +$env?.String?.ok?.str +$env?.String?.round(foobar, foobar) +$env?.String?.sortBy(foobar) +$env?.String?.str +$env?.String?.str() +$env?.String?.str(foobar) +$env?.String?.str.Bar +$env?.String?.str.add() +$env?.String?.str.list +$env?.String?.str.str +$env?.String?.str?.Bar +$env?.String?.str?.String +$env?.String?.str?.[greet] +$env?.String?.str?.[str] +$env?.String?.str?.i +$env?.String?.str?.ok +$env?.String?.sum(1.0) +$env?.String?.toPairs(Bar) +$env?.String?.true.array +$env?.[1.0]?.foobar and false +$env?.[Bar] != 1.0 + 1.0 +$env?.[Bar] != add +$env?.[Bar] != array +$env?.[Bar] != foo +$env?.[Bar] != greet +$env?.[Bar] != i +$env?.[Bar] != list +$env?.[Bar] != ok +$env?.[Bar] != str +$env?.[Bar] != str != true +$env?.[Bar] != string(false) +$env?.[Bar] < i || true +$env?.[Bar] == $env.array +$env?.[Bar] == add +$env?.[Bar] == array +$env?.[Bar] == foo +$env?.[Bar] == greet ? 0 : true +$env?.[Bar] == list +$env?.[Bar] == ok +$env?.[Bar] and true and false +$env?.[Bar] contains last($env) +$env?.[Bar] contains str +$env?.[Bar] endsWith str +$env?.[Bar] in $env?.nil?.add +$env?.[Bar] in array +$env?.[Bar] in list +$env?.[Bar] matches $env?.str +$env?.[Bar] matches str +$env?.[Bar] not contains $env.str +$env?.[Bar] not contains $env?.Bar +$env?.[Bar] not contains str +$env?.[Bar] not in list +$env?.[Bar] not matches str +$env?.[Bar] not startsWith $env?.[String] +$env?.[Bar] not startsWith foo.Bar +$env?.[Bar] not startsWith str +$env?.[Bar] not startsWith str != nil +$env?.[Bar] startsWith str +$env?.[Bar]?.$env?.[f64] +$env?.[Bar]?.$env?.[foo].Bar +$env?.[Bar]?.Bar +$env?.[Bar]?.Bar($env) +$env?.[Bar]?.Bar() +$env?.[Bar]?.Bar(0)?.foo +$env?.[Bar]?.Bar(Bar not contains f64) +$env?.[Bar]?.Bar(foo) +$env?.[Bar]?.Bar(foobar) +$env?.[Bar]?.Bar.add +$env?.[Bar]?.Bar.greet +$env?.[Bar]?.Bar?.list +$env?.[Bar]?.String +$env?.[Bar]?.String() +$env?.[Bar]?.String(f64) +$env?.[Bar]?.String(foobar not contains foobar?.String) +$env?.[Bar]?.String(foobar) +$env?.[Bar]?.String(str) +$env?.[Bar]?.String.greet +$env?.[Bar]?.String.i +$env?.[Bar]?.String?.Bar +$env?.[Bar]?.String?.[f64] +$env?.[Bar]?.String?.[foo] +$env?.[Bar]?.String?.[greet] +$env?.[Bar]?.String?.[str] +$env?.[Bar]?.String?.add +$env?.[Bar]?.String?.add(foobar) +$env?.[Bar]?.String?.array +$env?.[Bar]?.String?.foo +$env?.[Bar]?.String?.greet?.String(foobar)?.greet +$env?.[Bar]?.String?.i() +$env?.[Bar]?.String?.i(false) +$env?.[Bar]?.String?.list +$env?.[Bar]?.String?.ok +$env?.[Bar]?.[$env?.array] +$env?.[Bar]?.[add] +$env?.[Bar]?.[add].Bar() +$env?.[Bar]?.[add].f64 +$env?.[Bar]?.[add].foo +$env?.[Bar]?.[add].greet +$env?.[Bar]?.[add].ok +$env?.[Bar]?.[add].str +$env?.[Bar]?.[add]?.[list] +$env?.[Bar]?.[add]?.[ok] +$env?.[Bar]?.[add]?.i +$env?.[Bar]?.[add]?.list +$env?.[Bar]?.[array] +$env?.[Bar]?.[array].String +$env?.[Bar]?.[array].String() +$env?.[Bar]?.[array].add() +$env?.[Bar]?.[array].f64 +$env?.[Bar]?.[array].foo +$env?.[Bar]?.[array].greet +$env?.[Bar]?.[array].i +$env?.[Bar]?.[array]?.f64 +$env?.[Bar]?.[array]?.foo +$env?.[Bar]?.[count($env)] +$env?.[Bar]?.[count(list)] +$env?.[Bar]?.[f64] +$env?.[Bar]?.[f64] != i +$env?.[Bar]?.[f64].array +$env?.[Bar]?.[f64].f64 +$env?.[Bar]?.[f64].str +$env?.[Bar]?.[f64]?.Bar +$env?.[Bar]?.[f64]?.[add] +$env?.[Bar]?.[f64]?.[ok] +$env?.[Bar]?.[f64]?.array +$env?.[Bar]?.[f64]?.f64() +$env?.[Bar]?.[f64]?.foo() +$env?.[Bar]?.[f64]?.none(foobar) +$env?.[Bar]?.[foo == foo] +$env?.[Bar]?.[foo] +$env?.[Bar]?.[foo].foo() +$env?.[Bar]?.[foo].greet +$env?.[Bar]?.[foo].i +$env?.[Bar]?.[foo]?.[f64] +$env?.[Bar]?.[foo]?.[foo] +$env?.[Bar]?.[foo]?.[list] +$env?.[Bar]?.[foo]?.ok() +$env?.[Bar]?.[foo]?.str +$env?.[Bar]?.[greet] +$env?.[Bar]?.[greet].array +$env?.[Bar]?.[greet].array() +$env?.[Bar]?.[greet].i +$env?.[Bar]?.[greet].i() +$env?.[Bar]?.[greet].str +$env?.[Bar]?.[greet]?.String +$env?.[Bar]?.[greet]?.add() +$env?.[Bar]?.[greet]?.array() +$env?.[Bar]?.[greet]?.i +$env?.[Bar]?.[greet]?.str +$env?.[Bar]?.[groupBy($env, #)]?.[str] +$env?.[Bar]?.[i] +$env?.[Bar]?.[i].Bar +$env?.[Bar]?.[i].Bar() +$env?.[Bar]?.[i].str +$env?.[Bar]?.[i]?.String +$env?.[Bar]?.[i]?.[list] +$env?.[Bar]?.[i]?.[ok] +$env?.[Bar]?.[i]?.array +$env?.[Bar]?.[i]?.i +$env?.[Bar]?.[i]?.str +$env?.[Bar]?.[list] +$env?.[Bar]?.[list] in list +$env?.[Bar]?.[list].String +$env?.[Bar]?.[list].add() +$env?.[Bar]?.[list].array +$env?.[Bar]?.[list].foo +$env?.[Bar]?.[list].greet +$env?.[Bar]?.[list].ok +$env?.[Bar]?.[list].ok() +$env?.[Bar]?.[list]?.String +$env?.[Bar]?.[list]?.[array] +$env?.[Bar]?.[list]?.[greet]?.list +$env?.[Bar]?.[list]?.[i] +$env?.[Bar]?.[list]?.[list] +$env?.[Bar]?.[list]?.f64 +$env?.[Bar]?.[list]?.foo +$env?.[Bar]?.[list]?.i +$env?.[Bar]?.[ok] +$env?.[Bar]?.[ok].f64 +$env?.[Bar]?.[ok].foo() +$env?.[Bar]?.[ok]?.[i] +$env?.[Bar]?.[ok]?.foo() +$env?.[Bar]?.[ok]?.i +$env?.[Bar]?.[ok]?.ok +$env?.[Bar]?.[str] +$env?.[Bar]?.[str].ok +$env?.[Bar]?.[str]?.[array] +$env?.[Bar]?.[str]?.ok() +$env?.[Bar]?.abs(nil, ok)?.[ok] +$env?.[Bar]?.add +$env?.[Bar]?.add() +$env?.[Bar]?.add().str +$env?.[Bar]?.add()?.[f64] +$env?.[Bar]?.add(1) +$env?.[Bar]?.add(Bar) +$env?.[Bar]?.add(add) +$env?.[Bar]?.add(array) +$env?.[Bar]?.add(foo) +$env?.[Bar]?.add(foobar) +$env?.[Bar]?.add.String() +$env?.[Bar]?.add.add +$env?.[Bar]?.add.greet +$env?.[Bar]?.add.i +$env?.[Bar]?.add.not +$env?.[Bar]?.add.ok +$env?.[Bar]?.add.str +$env?.[Bar]?.add?.Bar() +$env?.[Bar]?.add?.[add] +$env?.[Bar]?.add?.[foo] +$env?.[Bar]?.add?.[ok] +$env?.[Bar]?.add?.join(foobar, str) +$env?.[Bar]?.any(foo) +$env?.[Bar]?.any(foobar, foobar) +$env?.[Bar]?.array +$env?.[Bar]?.array() +$env?.[Bar]?.array().ok +$env?.[Bar]?.array()?.list +$env?.[Bar]?.array(Bar, array) +$env?.[Bar]?.array(add) == greet +$env?.[Bar]?.array(foobar) +$env?.[Bar]?.array(foobar, f64, i) +$env?.[Bar]?.array(foobar?.ok) +$env?.[Bar]?.array(sort(foobar)) +$env?.[Bar]?.array.String() +$env?.[Bar]?.array.add +$env?.[Bar]?.array.list() +$env?.[Bar]?.array?.[add] +$env?.[Bar]?.array?.[array] +$env?.[Bar]?.array?.[list] +$env?.[Bar]?.bitxor(ok) +$env?.[Bar]?.concat(i, 0) +$env?.[Bar]?.f64 +$env?.[Bar]?.f64() +$env?.[Bar]?.f64()?.ok +$env?.[Bar]?.f64(add) +$env?.[Bar]?.f64(foobar in foobar)?.[add] +$env?.[Bar]?.f64.String +$env?.[Bar]?.f64.foo +$env?.[Bar]?.f64.foo() +$env?.[Bar]?.f64.greet +$env?.[Bar]?.f64.i +$env?.[Bar]?.f64.i() +$env?.[Bar]?.f64?.[add] +$env?.[Bar]?.f64?.[greet] +$env?.[Bar]?.f64?.list() +$env?.[Bar]?.false.foo +$env?.[Bar]?.find(Bar) +$env?.[Bar]?.findLast(1) +$env?.[Bar]?.findLast(1, i) +$env?.[Bar]?.findLastIndex(nil) +$env?.[Bar]?.foo +$env?.[Bar]?.foo($env) +$env?.[Bar]?.foo() +$env?.[Bar]?.foo().list +$env?.[Bar]?.foo(foobar) +$env?.[Bar]?.foo(foobar, foobar) +$env?.[Bar]?.foo(foobar?.true startsWith foobar contains foobar) +$env?.[Bar]?.foo.i +$env?.[Bar]?.foo.ok() +$env?.[Bar]?.foo.str +$env?.[Bar]?.foo?.Bar +$env?.[Bar]?.foo?.String +$env?.[Bar]?.foo?.[greet].list() +$env?.[Bar]?.foo?.[list] +$env?.[Bar]?.foo?.f64 +$env?.[Bar]?.foo?.foo() +$env?.[Bar]?.foo?.ok +$env?.[Bar]?.foobar +$env?.[Bar]?.foobar not endsWith str +$env?.[Bar]?.foobar.String +$env?.[Bar]?.foobar.array +$env?.[Bar]?.foobar.list(nil) +$env?.[Bar]?.foobar.str +$env?.[Bar]?.foobar?.[f64] +$env?.[Bar]?.foobar?.[i] +$env?.[Bar]?.foobar?.ok +$env?.[Bar]?.fromPairs(foobar, foo) +$env?.[Bar]?.greet +$env?.[Bar]?.greet == ok +$env?.[Bar]?.greet($env endsWith foobar) +$env?.[Bar]?.greet() +$env?.[Bar]?.greet().add +$env?.[Bar]?.greet()?.[i] +$env?.[Bar]?.greet()?.f64 +$env?.[Bar]?.greet(0) +$env?.[Bar]?.greet(foo) +$env?.[Bar]?.greet(foobar) +$env?.[Bar]?.greet(foobar)?.String +$env?.[Bar]?.greet(list) +$env?.[Bar]?.greet(str) +$env?.[Bar]?.greet.f64 +$env?.[Bar]?.greet.f64(foobar) +$env?.[Bar]?.greet?.[add] +$env?.[Bar]?.greet?.[i] +$env?.[Bar]?.greet?.[list] +$env?.[Bar]?.greet?.f64 +$env?.[Bar]?.greet?.ok +$env?.[Bar]?.i +$env?.[Bar]?.i($env not matches foobar, Bar)?.foo +$env?.[Bar]?.i($env) +$env?.[Bar]?.i() +$env?.[Bar]?.i(foobar) +$env?.[Bar]?.i(foobar, str | reduce($env, f64)) +$env?.[Bar]?.i(greet, foobar) +$env?.[Bar]?.i(list, foobar) +$env?.[Bar]?.i.str +$env?.[Bar]?.i?.[foo] +$env?.[Bar]?.i?.[greet] +$env?.[Bar]?.i?.array +$env?.[Bar]?.i?.greet +$env?.[Bar]?.i?.i +$env?.[Bar]?.i?.str +$env?.[Bar]?.keys(Bar, false) +$env?.[Bar]?.list +$env?.[Bar]?.list() +$env?.[Bar]?.list()?.[ok] +$env?.[Bar]?.list()?.str +$env?.[Bar]?.list(foo.String) +$env?.[Bar]?.list(foobar) +$env?.[Bar]?.list(foobar).f64 +$env?.[Bar]?.list(foobar)?.[str] +$env?.[Bar]?.list(foobar?.list) +$env?.[Bar]?.list.Bar +$env?.[Bar]?.list.add +$env?.[Bar]?.list.f64 +$env?.[Bar]?.list.foobar +$env?.[Bar]?.list?.Bar(foo, f64) +$env?.[Bar]?.list?.[greet] +$env?.[Bar]?.list?.[list] +$env?.[Bar]?.list?.foo +$env?.[Bar]?.list?.str +$env?.[Bar]?.lower(nil) +$env?.[Bar]?.map(nil) +$env?.[Bar]?.nil?.i?.f64 +$env?.[Bar]?.none(list) +$env?.[Bar]?.none(ok) +$env?.[Bar]?.not.ok +$env?.[Bar]?.now(foobar, foobar, $env) +$env?.[Bar]?.ok +$env?.[Bar]?.ok() +$env?.[Bar]?.ok().list +$env?.[Bar]?.ok()?.add +$env?.[Bar]?.ok(add) +$env?.[Bar]?.ok.String +$env?.[Bar]?.ok.list +$env?.[Bar]?.ok?.[greet] +$env?.[Bar]?.ok?.foo +$env?.[Bar]?.reduce(1.0) +$env?.[Bar]?.str +$env?.[Bar]?.str($env == foobar) +$env?.[Bar]?.str($env) +$env?.[Bar]?.str() +$env?.[Bar]?.str().add.i +$env?.[Bar]?.str()?.[list] +$env?.[Bar]?.str(f64) +$env?.[Bar]?.str(f64, array) +$env?.[Bar]?.str(list | first(true, foobar)) +$env?.[Bar]?.str(nil) +$env?.[Bar]?.str.Bar +$env?.[Bar]?.str.foo +$env?.[Bar]?.str.ok +$env?.[Bar]?.str?.[add] +$env?.[Bar]?.str?.[array] +$env?.[Bar]?.str?.[list] +$env?.[Bar]?.str?.[str] +$env?.[Bar]?.sum(foobar) +$env?.[Bar]?.true?.[ok] +$env?.[Bar]?.values(foobar, foobar) +$env?.[String] != 1 ? f64 : f64 +$env?.[String] != add +$env?.[String] != array +$env?.[String] != f64 +$env?.[String] != foo +$env?.[String] != foo ? foo : 0 +$env?.[String] != i +$env?.[String] != list +$env?.[String] != ok +$env?.[String] != str +$env?.[String] == $env.i +$env?.[String] == add +$env?.[String] == greet +$env?.[String] == i && $env +$env?.[String] == list +$env?.[String] == str +$env?.[String] contains str +$env?.[String] endsWith $env?.[str] +$env?.[String] in list +$env?.[String] matches str +$env?.[String] not contains str +$env?.[String] not in array +$env?.[String] not in list +$env?.[String] not matches str +$env?.[String] not startsWith str +$env?.[String] startsWith min($env) +$env?.[String] startsWith str +$env?.[String]?.$env.list +$env?.[String]?.$env?.[foo] +$env?.[String]?.$env?.[ok] +$env?.[String]?.$env?.array +$env?.[String]?.Bar +$env?.[String]?.Bar() +$env?.[String]?.Bar().foo +$env?.[String]?.Bar(f64) +$env?.[String]?.Bar(foobar) +$env?.[String]?.Bar.String +$env?.[String]?.Bar.greet +$env?.[String]?.Bar.str +$env?.[String]?.Bar?.Bar() +$env?.[String]?.Bar?.[foo] +$env?.[String]?.Bar?.[greet] +$env?.[String]?.Bar?.[str] +$env?.[String]?.Bar?.add +$env?.[String]?.Bar?.i +$env?.[String]?.Bar?.list() +$env?.[String]?.String +$env?.[String]?.String() +$env?.[String]?.String().list +$env?.[String]?.String(String) +$env?.[String]?.String(add) +$env?.[String]?.String(foobar, $env) +$env?.[String]?.String(foobar?.[list])?.str() +$env?.[String]?.String(greet) +$env?.[String]?.String(ok && foobar) +$env?.[String]?.String.split(false, add).str.array +$env?.[String]?.String?.Bar +$env?.[String]?.String?.[foo] +$env?.[String]?.String?.[greet] +$env?.[String]?.String?.[list] +$env?.[String]?.String?.array +$env?.[String]?.String?.foo?.foo +$env?.[String]?.String?.list +$env?.[String]?.[$env == true] +$env?.[String]?.[$env.foo] +$env?.[String]?.[$env?.[greet]] +$env?.[String]?.[$env?.array] +$env?.[String]?.[add] +$env?.[String]?.[add].str +$env?.[String]?.[add]?.[list] +$env?.[String]?.[add]?.add +$env?.[String]?.[add]?.greet +$env?.[String]?.[array] +$env?.[String]?.[array] == list +$env?.[String]?.[array].Bar +$env?.[String]?.[array].ok +$env?.[String]?.[array]?.Bar() +$env?.[String]?.[array]?.[ok] +$env?.[String]?.[array]?.add +$env?.[String]?.[array]?.f64 +$env?.[String]?.[array]?.list?.[add] +$env?.[String]?.[f64] +$env?.[String]?.[f64].list +$env?.[String]?.[f64].list() +$env?.[String]?.[f64]?.Bar +$env?.[String]?.[f64]?.Bar() +$env?.[String]?.[f64]?.[f64] +$env?.[String]?.[f64]?.array() +$env?.[String]?.[f64]?.greet +$env?.[String]?.[f64]?.ok +$env?.[String]?.[foo != nil] +$env?.[String]?.[foo] +$env?.[String]?.[foo].String +$env?.[String]?.[foo].f64 +$env?.[String]?.[foo].i +$env?.[String]?.[foo]?.String +$env?.[String]?.[foo]?.[ok] +$env?.[String]?.[foo]?.[ok]?.[f64] +$env?.[String]?.[foo]?.add +$env?.[String]?.[foo]?.f64() +$env?.[String]?.[greet] +$env?.[String]?.[greet].String +$env?.[String]?.[greet].str +$env?.[String]?.[greet]?.[ok] +$env?.[String]?.[greet]?.i +$env?.[String]?.[greet]?.list(foobar) +$env?.[String]?.[greet]?.str +$env?.[String]?.[i] +$env?.[String]?.[i].Bar +$env?.[String]?.[i].f64 +$env?.[String]?.[i].foo +$env?.[String]?.[i].list +$env?.[String]?.[i].ok +$env?.[String]?.[i]?.array +$env?.[String]?.[list] +$env?.[String]?.[list].array() +$env?.[String]?.[list].greet +$env?.[String]?.[list].ok +$env?.[String]?.[list]?.String() +$env?.[String]?.[list]?.[add] +$env?.[String]?.[list]?.greet +$env?.[String]?.[ok and ok] +$env?.[String]?.[ok not in $env] +$env?.[String]?.[ok] +$env?.[String]?.[ok].add +$env?.[String]?.[ok].ok +$env?.[String]?.[ok]?.Bar +$env?.[String]?.[ok]?.[f64] +$env?.[String]?.[ok]?.greet +$env?.[String]?.[ok]?.i +$env?.[String]?.[str] +$env?.[String]?.[str].f64 +$env?.[String]?.[str]?.[f64] +$env?.[String]?.[str]?.foo +$env?.[String]?.add +$env?.[String]?.add() +$env?.[String]?.add()?.[foo] +$env?.[String]?.add()?.f64() +$env?.[String]?.add(1) +$env?.[String]?.add(foobar) +$env?.[String]?.add.Bar +$env?.[String]?.add.String +$env?.[String]?.add?.[add] +$env?.[String]?.add?.[greet] +$env?.[String]?.add?.greet +$env?.[String]?.add?.greet() +$env?.[String]?.all(ok) +$env?.[String]?.any(foobar, ok) +$env?.[String]?.array +$env?.[String]?.array() +$env?.[String]?.array()?.f64(list) +$env?.[String]?.array(String) +$env?.[String]?.array(add) +$env?.[String]?.array(f64) +$env?.[String]?.array(foobar not startsWith foo) +$env?.[String]?.array(foobar) +$env?.[String]?.array(i) +$env?.[String]?.array(str) +$env?.[String]?.array.String +$env?.[String]?.array.array(String, foo) +$env?.[String]?.array.i +$env?.[String]?.array.i() +$env?.[String]?.array.ok +$env?.[String]?.array?.Bar +$env?.[String]?.array?.[greet] +$env?.[String]?.array?.f64 +$env?.[String]?.array?.foo +$env?.[String]?.array?.list(i) +$env?.[String]?.bitshl(foobar) +$env?.[String]?.bitushr(foobar) +$env?.[String]?.ceil(nil) +$env?.[String]?.f64 +$env?.[String]?.f64() +$env?.[String]?.f64().Bar +$env?.[String]?.f64()?.f64 +$env?.[String]?.f64(String?.[array]) +$env?.[String]?.f64(foobar) +$env?.[String]?.f64.Bar() +$env?.[String]?.f64.i +$env?.[String]?.f64.ok +$env?.[String]?.f64?.String +$env?.[String]?.f64?.[add] +$env?.[String]?.f64?.[ok]?.str +$env?.[String]?.f64?.foo() +$env?.[String]?.f64?.greet() +$env?.[String]?.f64?.i +$env?.[String]?.f64?.ok() +$env?.[String]?.false?.str +$env?.[String]?.find(foobar) +$env?.[String]?.foo +$env?.[String]?.foo() +$env?.[String]?.foo()?.str +$env?.[String]?.foo(f64, foobar) +$env?.[String]?.foo(foobar) +$env?.[String]?.foo.String +$env?.[String]?.foo.foo +$env?.[String]?.foo.greet +$env?.[String]?.foo.ok +$env?.[String]?.foo.str +$env?.[String]?.foo?.Bar +$env?.[String]?.foo?.String +$env?.[String]?.foo?.[add] +$env?.[String]?.foo?.[array] +$env?.[String]?.foo?.[f64] +$env?.[String]?.foo?.[foo] +$env?.[String]?.foo?.array +$env?.[String]?.foo?.i +$env?.[String]?.foo?.list +$env?.[String]?.foo?.str +$env?.[String]?.foo?.str() +$env?.[String]?.foobar +$env?.[String]?.foobar.f64 +$env?.[String]?.foobar.str() +$env?.[String]?.foobar?.[list] +$env?.[String]?.foobar?.[ok] +$env?.[String]?.foobar?.array +$env?.[String]?.foobar?.foo +$env?.[String]?.foobar?.i +$env?.[String]?.foobar?.i() +$env?.[String]?.fromJSON(foobar) +$env?.[String]?.fromPairs(false) +$env?.[String]?.get(str) +$env?.[String]?.greet +$env?.[String]?.greet != str +$env?.[String]?.greet() +$env?.[String]?.greet().Bar +$env?.[String]?.greet()?.[list] +$env?.[String]?.greet()?.[str] +$env?.[String]?.greet(add) +$env?.[String]?.greet(foobar) +$env?.[String]?.greet(greet) +$env?.[String]?.greet.add +$env?.[String]?.greet.array() +$env?.[String]?.greet.foo +$env?.[String]?.greet.i +$env?.[String]?.greet.list +$env?.[String]?.greet?.Bar +$env?.[String]?.greet?.[array] +$env?.[String]?.greet?.[str] +$env?.[String]?.greet?.list.str +$env?.[String]?.groupBy(1.0) +$env?.[String]?.groupBy(foobar) +$env?.[String]?.groupBy(str) +$env?.[String]?.hasPrefix(nil)?.String +$env?.[String]?.i +$env?.[String]?.i() +$env?.[String]?.i()?.[array] +$env?.[String]?.i()?.[greet] +$env?.[String]?.i(foo) +$env?.[String]?.i(foobar) +$env?.[String]?.i(ok) +$env?.[String]?.i(str) +$env?.[String]?.i(true) +$env?.[String]?.i.String +$env?.[String]?.i.greet +$env?.[String]?.i.list +$env?.[String]?.i?.[greet] +$env?.[String]?.i?.[ok] +$env?.[String]?.i?.foo +$env?.[String]?.i?.foo() +$env?.[String]?.i?.greet +$env?.[String]?.i?.list +$env?.[String]?.i?.ok.f64 +$env?.[String]?.int(foo) +$env?.[String]?.len(false) +$env?.[String]?.list +$env?.[String]?.list() +$env?.[String]?.list(1.0) +$env?.[String]?.list(Bar) +$env?.[String]?.list(foobar) +$env?.[String]?.list(foobar).greet +$env?.[String]?.list(greet) +$env?.[String]?.list(nil in foobar or foobar) +$env?.[String]?.list(ok) +$env?.[String]?.list(true, true) +$env?.[String]?.list.add() +$env?.[String]?.list.foo +$env?.[String]?.list.list +$env?.[String]?.list?.[ok] +$env?.[String]?.list?.add?.list +$env?.[String]?.list?.array +$env?.[String]?.list?.foobar +$env?.[String]?.list?.i +$env?.[String]?.nil.String +$env?.[String]?.not +$env?.[String]?.ok +$env?.[String]?.ok() +$env?.[String]?.ok()?.list +$env?.[String]?.ok(f64, foobar) +$env?.[String]?.ok(foobar?.[1.0]) +$env?.[String]?.ok(toJSON(foo)).f64 +$env?.[String]?.ok.add +$env?.[String]?.ok.foo +$env?.[String]?.ok.i +$env?.[String]?.ok.str +$env?.[String]?.ok?.[f64] +$env?.[String]?.ok?.[foo] +$env?.[String]?.ok?.[list] +$env?.[String]?.ok?.[ok] +$env?.[String]?.ok?.add +$env?.[String]?.ok?.f64 +$env?.[String]?.ok?.ok +$env?.[String]?.one($env) +$env?.[String]?.one(foobar)?.[f64] +$env?.[String]?.reduce(1.0) +$env?.[String]?.reduce(foobar) +$env?.[String]?.splitAfter(true) +$env?.[String]?.str +$env?.[String]?.str not startsWith str +$env?.[String]?.str() +$env?.[String]?.str().list +$env?.[String]?.str()?.array +$env?.[String]?.str(foo) +$env?.[String]?.str(foobar) +$env?.[String]?.str(foobar?.array) +$env?.[String]?.str.add +$env?.[String]?.str.array +$env?.[String]?.str?.Bar +$env?.[String]?.str?.String +$env?.[String]?.str?.[add] +$env?.[String]?.str?.add +$env?.[String]?.str?.f64() +$env?.[String]?.str?.f64(false)?.greet +$env?.[String]?.sum(add) +$env?.[String]?.take(String)?.str +$env?.[String]?.trimPrefix(add) +$env?.[String]?.true not in array +$env?.[add] != 1.0 && false +$env?.[add] * f64 && false +$env?.[foo] != 1.0 || true +$env?.[foobar] != $env.i +$env?.[foobar] != foo +$env?.[foobar] != greet +$env?.[foobar] != i +$env?.[foobar] != list +$env?.[foobar] == array +$env?.[foobar] == f64 +$env?.[foobar] == foo +$env?.[foobar] == list != $env +$env?.[foobar] == ok +$env?.[foobar] contains str +$env?.[foobar] in $env?.[String] +$env?.[foobar] in list +$env?.[foobar] not in array +$env?.[foobar] not in list +$env?.[foobar] not matches str +$env?.[foobar] not startsWith foo?.String() +$env?.[foobar] not startsWith trim(str) +$env?.[foobar] startsWith $env or $env +$env?.[foobar]?.$env == nil +$env?.[foobar]?.Bar +$env?.[foobar]?.Bar() +$env?.[foobar]?.Bar()?.foobar +$env?.[foobar]?.Bar(foobar) +$env?.[foobar]?.Bar(list) +$env?.[foobar]?.Bar.foo() +$env?.[foobar]?.Bar.str(foobar) +$env?.[foobar]?.Bar?.[str] +$env?.[foobar]?.Bar?.f64 +$env?.[foobar]?.Bar?.foo +$env?.[foobar]?.String +$env?.[foobar]?.String() +$env?.[foobar]?.String(Bar) +$env?.[foobar]?.String(add).String +$env?.[foobar]?.String.ok +$env?.[foobar]?.String?.[i] +$env?.[foobar]?.String?.[str]?.[f64]?.ok +$env?.[foobar]?.String?.array +$env?.[foobar]?.String?.i +$env?.[foobar]?.[add] +$env?.[foobar]?.[add].f64 +$env?.[foobar]?.[add].greet +$env?.[foobar]?.[add]?.[foo] +$env?.[foobar]?.[add]?.[greet] +$env?.[foobar]?.[array] +$env?.[foobar]?.[array]?.Bar +$env?.[foobar]?.[array]?.f64 +$env?.[foobar]?.[array]?.list()?.[add] +$env?.[foobar]?.[f64] +$env?.[foobar]?.[f64].f64 +$env?.[foobar]?.[f64].f64() +$env?.[foobar]?.[f64].greet +$env?.[foobar]?.[f64].ok() +$env?.[foobar]?.[foo] +$env?.[foobar]?.[foo].Bar +$env?.[foobar]?.[foo].String() +$env?.[foobar]?.[foo]?.[str] +$env?.[foobar]?.[foo]?.i +$env?.[foobar]?.[greet] +$env?.[foobar]?.[greet].array.array +$env?.[foobar]?.[greet].f64 +$env?.[foobar]?.[greet]?.[i].array +$env?.[foobar]?.[greet]?.[ok] +$env?.[foobar]?.[greet]?.str +$env?.[foobar]?.[i] +$env?.[foobar]?.[i].Bar +$env?.[foobar]?.[i].greet +$env?.[foobar]?.[i].str +$env?.[foobar]?.[i]?.[list] +$env?.[foobar]?.[i]?.[ok] +$env?.[foobar]?.[i]?.ok +$env?.[foobar]?.[list] +$env?.[foobar]?.[list].foo +$env?.[foobar]?.[list]?.[f64] +$env?.[foobar]?.[list]?.[str] +$env?.[foobar]?.[list]?.f64() +$env?.[foobar]?.[list]?.ok +$env?.[foobar]?.[ok] +$env?.[foobar]?.[ok].Bar +$env?.[foobar]?.[ok]?.[add] +$env?.[foobar]?.[ok]?.[f64] +$env?.[foobar]?.[ok]?.ok +$env?.[foobar]?.[sortBy($env, f64)] +$env?.[foobar]?.[str] +$env?.[foobar]?.[str].i +$env?.[foobar]?.[str]?.[f64] +$env?.[foobar]?.add +$env?.[foobar]?.add() +$env?.[foobar]?.add()?.[array] +$env?.[foobar]?.add(foobar) +$env?.[foobar]?.add?.greet +$env?.[foobar]?.add?.i +$env?.[foobar]?.all(foobar, greet, $env) +$env?.[foobar]?.any(1, foobar) +$env?.[foobar]?.any(f64, nil) +$env?.[foobar]?.any(i).f64 +$env?.[foobar]?.array +$env?.[foobar]?.array() +$env?.[foobar]?.array.f64 +$env?.[foobar]?.array?.[i] +$env?.[foobar]?.array?.add() +$env?.[foobar]?.array?.i +$env?.[foobar]?.f64 +$env?.[foobar]?.f64() +$env?.[foobar]?.f64()?.[ok] +$env?.[foobar]?.f64()?.array +$env?.[foobar]?.f64(String) +$env?.[foobar]?.f64.ok +$env?.[foobar]?.f64?.Bar +$env?.[foobar]?.f64?.ok +$env?.[foobar]?.filter(foo) +$env?.[foobar]?.foo +$env?.[foobar]?.foo() +$env?.[foobar]?.foo()?.array +$env?.[foobar]?.foo()?.f64 +$env?.[foobar]?.foo(foobar) +$env?.[foobar]?.foo(foobar, foobar) +$env?.[foobar]?.foo.foobar +$env?.[foobar]?.foo?.[array] +$env?.[foobar]?.foo?.[foo] +$env?.[foobar]?.foo?.[i] +$env?.[foobar]?.foo?.foo +$env?.[foobar]?.foo?.foo?.array +$env?.[foobar]?.foobar +$env?.[foobar]?.foobar.str +$env?.[foobar]?.greet +$env?.[foobar]?.greet() +$env?.[foobar]?.greet()?.String +$env?.[foobar]?.greet(Bar) +$env?.[foobar]?.greet(String) +$env?.[foobar]?.greet(foobar, foo) +$env?.[foobar]?.greet(greet) +$env?.[foobar]?.greet.foo +$env?.[foobar]?.greet.i +$env?.[foobar]?.i +$env?.[foobar]?.i() +$env?.[foobar]?.i()?.greet +$env?.[foobar]?.i(Bar) +$env?.[foobar]?.i(foo) +$env?.[foobar]?.i(foobar) +$env?.[foobar]?.i.array +$env?.[foobar]?.i.foo +$env?.[foobar]?.i?.[array] +$env?.[foobar]?.i?.[greet] +$env?.[foobar]?.i?.f64 +$env?.[foobar]?.lastIndexOf(nil, foobar) +$env?.[foobar]?.list +$env?.[foobar]?.list() +$env?.[foobar]?.list(f64) +$env?.[foobar]?.list(foobar) +$env?.[foobar]?.list.list +$env?.[foobar]?.list?.[array] +$env?.[foobar]?.list?.[i] +$env?.[foobar]?.list?.[list] +$env?.[foobar]?.max(foo) +$env?.[foobar]?.nil?.[foo] +$env?.[foobar]?.none(foobar) +$env?.[foobar]?.none(nil, foobar) +$env?.[foobar]?.now(1) +$env?.[foobar]?.ok +$env?.[foobar]?.ok() +$env?.[foobar]?.ok(Bar?.[greet])?.greet +$env?.[foobar]?.ok(list) +$env?.[foobar]?.ok.add() +$env?.[foobar]?.ok.i +$env?.[foobar]?.ok?.i +$env?.[foobar]?.str +$env?.[foobar]?.str($env) +$env?.[foobar]?.str() +$env?.[foobar]?.str()?.str +$env?.[foobar]?.str(foobar) +$env?.[foobar]?.str(foobar?.greet(nil)) +$env?.[foobar]?.str.ok +$env?.[foobar]?.str?.[list] +$env?.[foobar]?.str?.foo +$env?.[foobar]?.str?.i() +$env?.[foobar]?.str?.list +$env?.[foobar]?.sum($env) +$env?.[foobar]?.trimSuffix(f64, foobar) +$env?.[greet]?.foobar or true +$env?.[i].i and false +$env?.[list] contains str && false +$env?.[list] || false or true +$env?.[nil] == array?.[0] +$env?.[nil] == ok +$env?.[nil] == str +$env?.[nil]?.Bar +$env?.[nil]?.Bar() +$env?.[nil]?.Bar?.[add] +$env?.[nil]?.String +$env?.[nil]?.String() +$env?.[nil]?.[add] +$env?.[nil]?.[add]?.[add] +$env?.[nil]?.[array] +$env?.[nil]?.[array].count(i) +$env?.[nil]?.[array]?.f64() +$env?.[nil]?.[f64] +$env?.[nil]?.[f64].list +$env?.[nil]?.[f64]?.Bar +$env?.[nil]?.[foo] +$env?.[nil]?.[foo]?.i() +$env?.[nil]?.[greet] +$env?.[nil]?.[greet]?.array() +$env?.[nil]?.[i] +$env?.[nil]?.[list] +$env?.[nil]?.[ok] +$env?.[nil]?.[str] +$env?.[nil]?.[str]?.[array] +$env?.[nil]?.add +$env?.[nil]?.add() +$env?.[nil]?.array +$env?.[nil]?.array(add) +$env?.[nil]?.array(list) +$env?.[nil]?.f64 +$env?.[nil]?.f64.add +$env?.[nil]?.f64.f64 +$env?.[nil]?.f64.i +$env?.[nil]?.foo +$env?.[nil]?.foo() +$env?.[nil]?.foo?.String +$env?.[nil]?.foobar.String() +$env?.[nil]?.greet +$env?.[nil]?.greet() +$env?.[nil]?.greet(foobar) +$env?.[nil]?.greet.f64 +$env?.[nil]?.i +$env?.[nil]?.i() +$env?.[nil]?.i(true or $env >= ok) +$env?.[nil]?.i?.f64 +$env?.[nil]?.list +$env?.[nil]?.list($env?.foo) +$env?.[nil]?.list?.array +$env?.[nil]?.list?.i +$env?.[nil]?.ok +$env?.[nil]?.ok() +$env?.[nil]?.ok?.[str] +$env?.[nil]?.str +$env?.[nil]?.str() +$env?.[nil]?.str(String) +$env?.[nil]?.str(foobar) +$env?.[str] != add +$env?.[str] != f64 +$env?.[str] != greet +$env?.[str] != i +$env?.[str] != ok +$env?.[str] != str +$env?.[str] + str +$env?.[str] < str +$env?.[str] <= str +$env?.[str] == 1.0 == $env +$env?.[str] == array +$env?.[str] == foo +$env?.[str] == greet +$env?.[str] == i +$env?.[str] == ok +$env?.[str] == str +$env?.[str] > str +$env?.[str] >= str +$env?.[str] contains str +$env?.[str] endsWith $env?.str +$env?.[str] endsWith str +$env?.[str] in list +$env?.[str] matches str +$env?.[str] not endsWith str +$env?.[str] not in $env == ok +$env?.[str] not in $env.list +$env?.[str] not in $env?.[Bar] +$env?.[str] not in $env?.array +$env?.[str] not in array +$env?.[str] not matches foo?.String() +$env?.[str] not matches str +$env?.[str] not startsWith str +$env?.[str] startsWith $env?.[String] +$env?.[str] startsWith foo?.Bar +$env?.[str] startsWith str +$env?.[str] | all(false) +$env?.[str] | all(ok) +$env?.[str] | all(true) +$env?.[str] | any(any(list, true)) +$env?.[str] | any(true) +$env?.[str] | count(false) +$env?.[str] | count(i != 0) +$env?.[str] | count(ok) +$env?.[str] | filter(false) +$env?.[str] | find(0 >= #) +$env?.[str] | find(false) +$env?.[str] | find(ok) +$env?.[str] | find(true) +$env?.[str] | findIndex(1 != 0) +$env?.[str] | findIndex(add != #) +$env?.[str] | findIndex(false) +$env?.[str] | findIndex(ok) +$env?.[str] | findIndex(true) +$env?.[str] | findLast(false) +$env?.[str] | findLast(ok) +$env?.[str] | findLastIndex(false) +$env?.[str] | findLastIndex(true) +$env?.[str] | greet() +$env?.[str] | groupBy(#) +$env?.[str] | groupBy(0) +$env?.[str] | groupBy(1.0) +$env?.[str] | groupBy(f64) +$env?.[str] | groupBy(false) +$env?.[str] | groupBy(foo) +$env?.[str] | groupBy(i) +$env?.[str] | groupBy(ok) +$env?.[str] | groupBy(str) +$env?.[str] | groupBy(true) +$env?.[str] | hasPrefix(str) +$env?.[str] | indexOf(str) +$env?.[str] | map(#) +$env?.[str] | map(1) +$env?.[str] | map(1.0) +$env?.[str] | map(add) +$env?.[str] | map(foo) +$env?.[str] | map(greet) +$env?.[str] | map(i) +$env?.[str] | map(str) +$env?.[str] | map(true) +$env?.[str] | none(false) +$env?.[str] | none(ok) +$env?.[str] | none(true) +$env?.[str] | one(false) +$env?.[str] | one(true) +$env?.[str] | reduce(#) +$env?.[str] | reduce(#, array) +$env?.[str] | reduce(#, false) +$env?.[str] | reduce(#, ok) +$env?.[str] | reduce($env) +$env?.[str] | reduce(0) +$env?.[str] | reduce(0, nil) +$env?.[str] | reduce(1, 1.0) +$env?.[str] | reduce(1.0) +$env?.[str] | reduce(1.0, $env) +$env?.[str] | reduce(1.0, nil) +$env?.[str] | reduce(add) +$env?.[str] | reduce(add, nil) +$env?.[str] | reduce(array) +$env?.[str] | reduce(f64) +$env?.[str] | reduce(false) +$env?.[str] | reduce(false, greet) +$env?.[str] | reduce(foo) +$env?.[str] | reduce(foo, true) +$env?.[str] | reduce(greet) +$env?.[str] | reduce(greet, foo) +$env?.[str] | reduce(i) +$env?.[str] | reduce(ok) +$env?.[str] | reduce(ok, $env) +$env?.[str] | reduce(str) +$env?.[str] | reduce(true) +$env?.[str] | reduce(true, f64) +$env?.[str] | repeat(1) +$env?.[str] | sortBy(#) +$env?.[str] | sortBy(0) +$env?.[str] | sortBy(1) +$env?.[str] | sortBy(1.0) +$env?.[str] | sortBy(f64) +$env?.[str] | sortBy(i) +$env?.[str] | sortBy(str) +$env?.[str] | sum(#) +$env?.[str] | sum(1) +$env?.[str] | sum(1.0) +$env?.[str] | sum(f64) +$env?.[str] | sum(i) +$env?.[str] | trimSuffix(str) +$env?.[str]?.[f64] +$env?.[str]?.[f64] * f64 +$env?.[str]?.[i] +$env?.[str][:] +$env?.[str][:i] +$env?.[str][array?.[f64]:] +$env?.[str][f64:] +$env?.add == add +$env?.array != array +$env?.array != array || $env +$env?.array != list +$env?.array == array +$env?.array == list +$env?.array | all(false) +$env?.array | all(ok) +$env?.array | all(true) +$env?.array | any(# == 0) +$env?.array | any(ok) +$env?.array | count(ok) +$env?.array | count(true) +$env?.array | filter(false) +$env?.array | filter(true) +$env?.array | find(false) +$env?.array | find(ok) +$env?.array | find(true) +$env?.array | findIndex(ok) +$env?.array | findIndex(true) +$env?.array | findLast(false) +$env?.array | findLast(ok) +$env?.array | findLast(true) +$env?.array | findLastIndex(false) +$env?.array | findLastIndex(true) +$env?.array | get(1) +$env?.array | groupBy(#) +$env?.array | groupBy(0) +$env?.array | groupBy(1) +$env?.array | groupBy(1.0) +$env?.array | groupBy(false) +$env?.array | groupBy(foo) +$env?.array | groupBy(ok) +$env?.array | groupBy(str) +$env?.array | groupBy(true) +$env?.array | map(#) +$env?.array | map($env) +$env?.array | map(0) +$env?.array | map(1.0) +$env?.array | map(add) +$env?.array | map(array) +$env?.array | map(f64) +$env?.array | map(foo) +$env?.array | map(ok) +$env?.array | map(true) +$env?.array | mean(1.0) +$env?.array | none(ok) +$env?.array | none(true) +$env?.array | one(false) +$env?.array | one(ok) +$env?.array | one(true) +$env?.array | reduce(#) +$env?.array | reduce(#, $env) +$env?.array | reduce(#, 1) +$env?.array | reduce(#, foo) +$env?.array | reduce(#, true) +$env?.array | reduce(#acc) +$env?.array | reduce($env) +$env?.array | reduce($env, add) +$env?.array | reduce($env, nil) +$env?.array | reduce(0, foo) +$env?.array | reduce(1) +$env?.array | reduce(1, 1) +$env?.array | reduce(1, list) +$env?.array | reduce(1.0) +$env?.array | reduce(add) +$env?.array | reduce(add, 1.0) +$env?.array | reduce(add, nil) +$env?.array | reduce(array) +$env?.array | reduce(f64) +$env?.array | reduce(false) +$env?.array | reduce(foo) +$env?.array | reduce(i, 1.0) +$env?.array | reduce(ok) +$env?.array | reduce(true) +$env?.array | sortBy(#) +$env?.array | sortBy(0) +$env?.array | sortBy(1) +$env?.array | sortBy(1.0) +$env?.array | sortBy(f64) +$env?.array | sortBy(i) +$env?.array | sortBy(str) +$env?.array | sum(#) +$env?.array | sum(1) +$env?.array | sum(1.0) +$env?.array | sum(i) +$env?.array | take(0) +$env?.array; i +$env?.array?.[first(array)] +$env?.array?.[i] +$env?.array[:] +$env?.f64 != i +$env?.f64 * 1.0 == 1.0 +$env?.f64 * f64 +$env?.f64 ** 0 / f64 +$env?.f64 ** f64 +$env?.f64 ** i +$env?.f64 ** int(f64) +$env?.f64 + 0 < 1.0 +$env?.f64 + f64 +$env?.f64 + i +$env?.f64 - 1.0 == 1.0 +$env?.f64 - f64 +$env?.f64 / f64 +$env?.f64 / i +$env?.f64 / len($env) +$env?.f64 < 0 % i +$env?.f64 < 1.0 - 1.0 +$env?.f64 < f64 +$env?.f64 < i +$env?.f64 == f64 +$env?.f64 == i +$env?.f64 > f64 +$env?.f64 > i +$env?.f64 >= f64 +$env?.f64 >= round(f64) +$env?.f64 ^ i +$env?.f64 in array +$env?.f64 not in $env?.String +$env?.f64 not in array +$env?.f64 | mean(1.0) +$env?.f64 | median(f64) +$env?.false != add +$env?.false != ok +$env?.false == add +$env?.false contains $env?.String +$env?.false endsWith str +$env?.false?.Bar +$env?.false?.Bar() +$env?.false?.Bar.String +$env?.false?.String +$env?.false?.[add] +$env?.false?.[array] +$env?.false?.[array]?.String +$env?.false?.[f64] +$env?.false?.[foo] +$env?.false?.[greet] +$env?.false?.[i] +$env?.false?.[list] +$env?.false?.[ok] +$env?.false?.[str] +$env?.false?.add +$env?.false?.add() +$env?.false?.add?.[f64] +$env?.false?.array +$env?.false?.array() +$env?.false?.array(f64) +$env?.false?.array(foobar) +$env?.false?.array?.array +$env?.false?.f64 +$env?.false?.f64() +$env?.false?.foo +$env?.false?.foo() +$env?.false?.foo(foobar, i .. f64) +$env?.false?.foobar +$env?.false?.greet +$env?.false?.greet() +$env?.false?.i +$env?.false?.i.str +$env?.false?.list +$env?.false?.list() +$env?.false?.list?.Bar +$env?.false?.ok +$env?.false?.ok() +$env?.false?.str +$env?.false?.str() +$env?.false?.str.foo +$env?.false?.str?.add +$env?.foo in list +$env?.foo not in list +$env?.foo.Bar +$env?.foo.String +$env?.foo.String() +$env?.foo?.Bar +$env?.foo?.String +$env?.foo?.String() +$env?.foobar != f64 +$env?.foobar != str +$env?.foobar == $env.i +$env?.foobar == [1.0] +$env?.foobar == add +$env?.foobar == array +$env?.foobar == foo +$env?.foobar == greet +$env?.foobar == list +$env?.foobar == ok +$env?.foobar == reduce(list, false) +$env?.foobar contains str +$env?.foobar endsWith str +$env?.foobar in array +$env?.foobar in groupBy(array, 1.0) +$env?.foobar matches str +$env?.foobar not contains str +$env?.foobar?.$env?.[f64] +$env?.foobar?.Bar +$env?.foobar?.Bar() +$env?.foobar?.Bar().str +$env?.foobar?.Bar.str +$env?.foobar?.Bar?.[list] +$env?.foobar?.Bar?.list() +$env?.foobar?.String +$env?.foobar?.String() +$env?.foobar?.String(foo) +$env?.foobar?.String(foobar) +$env?.foobar?.[add] +$env?.foobar?.[add]?.[array] +$env?.foobar?.[add]?.[f64] +$env?.foobar?.[add]?.f64 +$env?.foobar?.[add]?.greet() +$env?.foobar?.[array] +$env?.foobar?.[count($env)] +$env?.foobar?.[f64] +$env?.foobar?.[f64]?.Bar +$env?.foobar?.[f64]?.add +$env?.foobar?.[f64]?.f64(foobar) +$env?.foobar?.[foo] +$env?.foobar?.[foo].str +$env?.foobar?.[foo]?.[i] +$env?.foobar?.[foo]?.ok +$env?.foobar?.[greet] +$env?.foobar?.[greet]?.add +$env?.foobar?.[greet]?.array +$env?.foobar?.[i] +$env?.foobar?.[i]?.[ok] +$env?.foobar?.[i]?.foo() +$env?.foobar?.[i]?.i +$env?.foobar?.[i]?.list +$env?.foobar?.[list] +$env?.foobar?.[list] != ok +$env?.foobar?.[list].Bar +$env?.foobar?.[list].list +$env?.foobar?.[list]?.[f64] +$env?.foobar?.[list]?.add +$env?.foobar?.[ok] +$env?.foobar?.[ok]?.str +$env?.foobar?.[str] +$env?.foobar?.[str].String +$env?.foobar?.[str].list(foobar?.[i].ok) +$env?.foobar?.[str]?.f64 +$env?.foobar?.[str]?.list +$env?.foobar?.add +$env?.foobar?.add() +$env?.foobar?.add(1.0) +$env?.foobar?.add(foobar) +$env?.foobar?.add.array +$env?.foobar?.add?.[greet] +$env?.foobar?.add?.[i] +$env?.foobar?.add?.[str] +$env?.foobar?.add?.add +$env?.foobar?.add?.f64 +$env?.foobar?.add?.foo +$env?.foobar?.add?.greet() +$env?.foobar?.add?.i +$env?.foobar?.add?.ok +$env?.foobar?.all(str) +$env?.foobar?.array +$env?.foobar?.array() +$env?.foobar?.array().list +$env?.foobar?.array(Bar) +$env?.foobar?.array(foobar) +$env?.foobar?.array.foo +$env?.foobar?.array.ok +$env?.foobar?.array?.String(i) +$env?.foobar?.array?.array +$env?.foobar?.array?.list +$env?.foobar?.count($env) +$env?.foobar?.count(foo, foo) +$env?.foobar?.f64 +$env?.foobar?.f64() +$env?.foobar?.f64()?.greet +$env?.foobar?.f64(add)?.String(list) +$env?.foobar?.f64.f64 +$env?.foobar?.f64.i +$env?.foobar?.f64?.[array].Bar +$env?.foobar?.f64?.[foo]?.[greet] +$env?.foobar?.f64?.array() +$env?.foobar?.f64?.foo +$env?.foobar?.false?.i() +$env?.foobar?.findIndex(array) +$env?.foobar?.findLast($env, $env) +$env?.foobar?.findLastIndex(foo, f64, array) +$env?.foobar?.findLastIndex(true) +$env?.foobar?.foo +$env?.foobar?.foo() +$env?.foobar?.foo(array) +$env?.foobar?.foo(foobar | string($env)) +$env?.foobar?.foo(foobar)?.[i] +$env?.foobar?.foo.ok +$env?.foobar?.foo?.String +$env?.foobar?.foo?.[add] +$env?.foobar?.foo?.[foo] +$env?.foobar?.foo?.str +$env?.foobar?.foobar +$env?.foobar?.foobar?.[greet] +$env?.foobar?.greet +$env?.foobar?.greet() +$env?.foobar?.greet(array) +$env?.foobar?.greet.Bar +$env?.foobar?.greet.array +$env?.foobar?.greet?.add +$env?.foobar?.greet?.array() +$env?.foobar?.greet?.foo +$env?.foobar?.i +$env?.foobar?.i() +$env?.foobar?.i(foobar) +$env?.foobar?.i(list not endsWith foobar) +$env?.foobar?.i?.f64 +$env?.foobar?.i?.greet +$env?.foobar?.i?.ok +$env?.foobar?.list +$env?.foobar?.list() +$env?.foobar?.list().ok +$env?.foobar?.list()?.f64 +$env?.foobar?.list?.[greet] +$env?.foobar?.list?.foo +$env?.foobar?.min(foobar, 1.0) +$env?.foobar?.none(array) +$env?.foobar?.not +$env?.foobar?.not?.[ok] +$env?.foobar?.ok +$env?.foobar?.ok() +$env?.foobar?.ok(foobar not contains foobar) +$env?.foobar?.ok(ok) +$env?.foobar?.ok.array +$env?.foobar?.ok?.[str] +$env?.foobar?.ok?.i +$env?.foobar?.one(foobar) +$env?.foobar?.replace(str) +$env?.foobar?.split(1.0) +$env?.foobar?.str +$env?.foobar?.str() +$env?.foobar?.str().String +$env?.foobar?.str(String?.[i]) +$env?.foobar?.str(foo) +$env?.foobar?.str.array +$env?.foobar?.str.i +$env?.foobar?.str?.[str] +$env?.foobar?.str?.add +$env?.foobar?.str?.i +$env?.foobar?.string($env) +$env?.foobar?.timezone(str) +$env?.foobar?.true?.str +$env?.greet != greet +$env?.greet == find($env, false) +$env?.greet == greet +$env?.greet($env?.str) +$env?.greet(foo.Bar) +$env?.greet(foo.String()) +$env?.greet(foo?.String()) +$env?.greet(greet(str)) +$env?.greet(str) +$env?.greet(str) startsWith str +$env?.greet(string(0)) +$env?.greet(toJSON(false)) +$env?.greet(type(true)) +$env?.i != f64 +$env?.i != i +$env?.i % i +$env?.i * 1 != $env +$env?.i * f64 +$env?.i * i +$env?.i ** 1.0 >= i +$env?.i ** f64 +$env?.i ** i +$env?.i + f64 +$env?.i + findIndex($env, ok) +$env?.i - ceil(i) +$env?.i - i +$env?.i .. 1 | groupBy(f64) +$env?.i .. i +$env?.i / f64 +$env?.i / i +$env?.i / max(1.0) +$env?.i < f64 +$env?.i < i +$env?.i <= f64 +$env?.i <= i +$env?.i == f64 +$env?.i == first($env) +$env?.i == i +$env?.i == len(list) +$env?.i == max($env) +$env?.i > f64 +$env?.i > i +$env?.i >= $env?.f64 +$env?.i >= 0 or $env +$env?.i >= 1.0 ** 1 +$env?.i >= f64 +$env?.i >= floor(1.0) +$env?.i >= i +$env?.i ^ i +$env?.i ^ i not in array +$env?.i in array +$env?.i not in $env?.[Bar] +$env?.i not in array +$env?.i | bitnand(0) +$env?.i | bitnand(1) +$env?.i | bitor(i) +$env?.i | bitshl(0) +$env?.i | mean(i) +$env?.i | median(f64) +$env?.list != [1.0] +$env?.list != array +$env?.list != list +$env?.list == [foo, 0] +$env?.list == list +$env?.list == nil || $env +$env?.list | all(false) +$env?.list | all(ok) +$env?.list | all(true) +$env?.list | any(false) +$env?.list | any(ok) +$env?.list | concat(list) +$env?.list | count(false) +$env?.list | count(ok) +$env?.list | count(true) +$env?.list | filter(ok) +$env?.list | filter(true) +$env?.list | find(false) +$env?.list | find(ok) +$env?.list | find(true) +$env?.list | findIndex(ok) +$env?.list | findLastIndex(#.Bar in #) +$env?.list | groupBy(#) +$env?.list | groupBy(.Bar) +$env?.list | groupBy(0) +$env?.list | groupBy(1) +$env?.list | groupBy(1.0) +$env?.list | groupBy(f64) +$env?.list | groupBy(false) +$env?.list | groupBy(foo) +$env?.list | groupBy(i) +$env?.list | groupBy(ok) +$env?.list | groupBy(str) +$env?.list | groupBy(true) +$env?.list | map(#) +$env?.list | map(#.Bar) +$env?.list | map(#index) +$env?.list | map($env) +$env?.list | map(.Bar) +$env?.list | map(.String) +$env?.list | map(0) +$env?.list | map(1) +$env?.list | map(1.0) +$env?.list | map(add) +$env?.list | map(array) +$env?.list | map(false) +$env?.list | map(foo) +$env?.list | map(greet) +$env?.list | map(i) +$env?.list | map(list) +$env?.list | map(ok) +$env?.list | map(str) +$env?.list | map(true) +$env?.list | none(.Bar not startsWith #.Bar) +$env?.list | none(ok) +$env?.list | none(true) +$env?.list | one(false) +$env?.list | one(ok) +$env?.list | reduce(#) +$env?.list | reduce(#, false) +$env?.list | reduce(#.Bar) +$env?.list | reduce(#.Bar, 0) +$env?.list | reduce(#acc) +$env?.list | reduce(#acc, 1) +$env?.list | reduce(#acc, true) +$env?.list | reduce(#index) +$env?.list | reduce($env) +$env?.list | reduce($env, greet) +$env?.list | reduce($env, true) +$env?.list | reduce(.Bar) +$env?.list | reduce(.String, $env) +$env?.list | reduce(0) +$env?.list | reduce(1) +$env?.list | reduce(1.0) +$env?.list | reduce(add) +$env?.list | reduce(array) +$env?.list | reduce(array, $env) +$env?.list | reduce(foo) +$env?.list | reduce(foo, nil) +$env?.list | reduce(foo, str) +$env?.list | reduce(greet) +$env?.list | reduce(list) +$env?.list | reduce(ok) +$env?.list | reduce(str) +$env?.list | reduce(true) +$env?.list | reduce(true, i) +$env?.list | sortBy(#.Bar) +$env?.list | sortBy(.Bar) +$env?.list | sortBy(0) +$env?.list | sortBy(1) +$env?.list | sortBy(1.0) +$env?.list | sortBy(str) +$env?.list | sum(1) +$env?.list | sum(1.0) +$env?.list | sum(f64) +$env?.list | sum(i) +$env?.list?.[i] +$env?.list?.[i].String +$env?.list[:] +$env?.nil != array +$env?.nil != greet +$env?.nil == foo.Bar +$env?.nil contains $env?.[nil] +$env?.nil matches str +$env?.nil not in array +$env?.nil?.Bar +$env?.nil?.Bar() +$env?.nil?.Bar(list) +$env?.nil?.Bar?.String(Bar) +$env?.nil?.Bar?.[i] +$env?.nil?.String +$env?.nil?.String() +$env?.nil?.String?.ok() +$env?.nil?.[add] +$env?.nil?.[add]?.[greet] +$env?.nil?.[add]?.str +$env?.nil?.[array] +$env?.nil?.[array].Bar +$env?.nil?.[array]?.String +$env?.nil?.[f64] +$env?.nil?.[foo] +$env?.nil?.[greet] +$env?.nil?.[greet]?.ok +$env?.nil?.[i] +$env?.nil?.[list] +$env?.nil?.[ok] +$env?.nil?.[str] +$env?.nil?.[str]?.str +$env?.nil?.add +$env?.nil?.add() +$env?.nil?.array +$env?.nil?.array() +$env?.nil?.array(str) +$env?.nil?.f64 +$env?.nil?.f64() +$env?.nil?.filter(1.0) +$env?.nil?.foo +$env?.nil?.foo() +$env?.nil?.foo.i +$env?.nil?.foo?.[add].array +$env?.nil?.foo?.[f64] +$env?.nil?.foo?.f64(Bar) +$env?.nil?.foobar +$env?.nil?.greet +$env?.nil?.greet() +$env?.nil?.i +$env?.nil?.list +$env?.nil?.list() +$env?.nil?.ok +$env?.nil?.ok() +$env?.nil?.ok(add) +$env?.nil?.one(foobar, foobar) +$env?.nil?.round(1.0) +$env?.nil?.str +$env?.nil?.str() +$env?.ok && $env?.Bar +$env?.ok && $env?.[str] +$env?.ok && ok +$env?.ok == ok +$env?.ok ? foo == nil : i +$env?.ok ?: foo +$env?.ok and $env?.[String] +$env?.ok and foo != foo +$env?.ok and ok +$env?.ok not in $env && false +$env?.ok or i != 1.0 +$env?.ok or ok +$env?.ok || $env?.Bar() +$env?.ok || ok +$env?.ok || sum($env) +$env?.str + str +$env?.str < type(add) +$env?.str <= foo.Bar +$env?.str <= str +$env?.str <= string(str) +$env?.str == str +$env?.str > str +$env?.str > str == nil +$env?.str > toJSON(nil) +$env?.str >= foo?.Bar +$env?.str contains foo?.Bar +$env?.str contains str +$env?.str endsWith $env and false +$env?.str endsWith str +$env?.str in $env ? 1.0 : nil +$env?.str in foo +$env?.str matches $env?.[String] +$env?.str matches str +$env?.str not contains str +$env?.str not endsWith str +$env?.str not in $env?.[String] +$env?.str not in foo +$env?.str not matches foo.Bar +$env?.str not matches str +$env?.str not startsWith foo?.Bar +$env?.str | date(str) +$env?.str | greet() +$env?.str | trimPrefix(str) +$env?.str[:] +$env?.str[:i] +$env?.str[i:] +$env?.true != ok +$env?.true == foo +$env?.true == i +$env?.true not endsWith str +$env?.true?.Bar +$env?.true?.Bar() +$env?.true?.String +$env?.true?.String() +$env?.true?.[add] +$env?.true?.[array] +$env?.true?.[array].Bar +$env?.true?.[f64] +$env?.true?.[foo] +$env?.true?.[greet] +$env?.true?.[i] +$env?.true?.[list] +$env?.true?.[ok] +$env?.true?.[ok]?.[ok] +$env?.true?.[str] +$env?.true?.[str].foo +$env?.true?.add +$env?.true?.add.foo +$env?.true?.array +$env?.true?.f64 +$env?.true?.f64() +$env?.true?.f64(foobar) +$env?.true?.find(foobar, foobar) +$env?.true?.foo +$env?.true?.foo() +$env?.true?.foo?.[ok] +$env?.true?.foobar +$env?.true?.greet +$env?.true?.greet() +$env?.true?.greet?.ok +$env?.true?.i +$env?.true?.i() +$env?.true?.list +$env?.true?.list() +$env?.true?.list.foo +$env?.true?.ok +$env?.true?.ok() +$env?.true?.str +$env?.true?.str() +$env[$env:] - f64 and false +- + $env || true +- + $env.f64 +- + $env.i +- + $env?.f64 +- + $env?.i +- + 1 != f64 +- + 1 < 1.0 +- + 1 ^ 1 +- + 1.0 != 1.0 +- + abs(i) +- + ceil(0) +- + f64 +- + f64 + f64 +- + f64 - 1.0 +- + f64 > 0 +- + i +- + i < 1 +- + i in $env.array +- + int(0) +- + median(f64) +- + min(f64) +- + sum(array) +- + {foo: 1}.foo +- - $env?.f64 +- - $env?.i +- - 0 <= 1.0 +- - 0 >= 1.0 +- - 0 ^ 0 +- - 0 ^ 1 +- - 1 == 1.0 +- - 1.0 != nil +- - 1.0 ** 1.0 +- - 1.0 < 1 +- - 1.0 == 0 +- - abs(1) +- - array?.[i] +- - ceil(1.0) +- - f64 +- - i +- - i != $env +- - len($env) +- - max(1.0) +- - sum(array) +-.0 ** 0 +-.0 / 1 +0 != $env.f64 +0 != $env.i +0 != $env?.Bar +0 != $env?.Bar?.foo() +0 != $env?.String +0 != $env?.[Bar] +0 != $env?.[String] +0 != $env?.[foobar] +0 != $env?.[str] +0 != $env?.f64 +0 != $env?.foobar?.foo +0 != $env?.i +0 != $env?.not +0 != 0 ?: array +0 != 1.0 * $env.f64 +0 != 1.0 + f64 ** 1.0 +0 != 1.0 / i * 1.0 +0 != 1.0 || $env - i +0 != array?.[i] +0 != f64 / f64 +0 != f64 == $env?.Bar +0 != f64 ^ 1.0 or $env +0 != f64 || ok +0 != i ** i +0 != i ^ f64 +0 != nil != ok +0 != nil || $env?.[String] +0 % $env.i +0 % $env?.i +0 % 1 * i +0 % 1 + i >= 0 +0 % 1 > count(array, false) +0 % 1 >= i +0 % 1 | median(f64) +0 % array?.[i] +0 * $env.f64 +0 * $env.i +0 * $env?.f64 +0 * $env?.i +0 * 0 != f64 +0 * 0 == i +0 * 1 != i +0 * 1 + f64 +0 * 1.0 != nil or ok +0 * 1.0 ** i +0 * array?.[i] +0 * f64 + i +0 * f64 <= f64 +0 * i != i +0 * i ^ f64 +0 ** $env.f64 +0 ** $env.i +0 ** $env?.f64 +0 ** $env?.i +0 ** 0 != $env?.i +0 ** 0 + $env.i +0 ** 1.0 ** f64 +0 ** 1.0 / f64 +0 ** 1.0 < i +0 ** 1.0 == i +0 ** 1.0 > i +0 ** array?.[i] +0 ** f64 >= $env?.f64 +0 ** i != f64 +0 + $env.f64 +0 + $env.i +0 + $env?.[str]?.[i] +0 + $env?.f64 +0 + $env?.i +0 + 0 - f64 +0 + 0 / i +0 + 0 >= f64 <= $env +0 + 1 <= $env.i +0 + 1 <= f64 +0 + 1 | min(0) +0 + 1.0 + i +0 + array?.[i] +0 + f64 > i +0 + i * f64 +0 - $env.f64 +0 - $env.i +0 - $env?.f64 +0 - $env?.i +0 - 0 < f64 +0 - 0 == i +0 - 1 ** f64 +0 - 1 < $env.i +0 - array?.[i] +0 - f64 >= f64 * i +0 .. $env.i +0 .. $env?.i +0 .. 0 | find(ok) +0 .. 0 | map(#) +0 .. 0 | max(1.0) +0 .. 0 | reduce(str) +0 .. 1 | get(1) +0 .. 1 | map(array) +0 .. 1 | map(foo) +0 .. 1 | reduce(#) +0 .. 1 | reduce($env) +0 .. 1 | reduce(add) +0 .. 1 | sortBy(#) +0 .. array?.[i] +0 .. i | groupBy(foo) +0 .. i | map(str) +0 .. i | sortBy(1) +0 / $env != 1 and false +0 / $env.f64 +0 / $env.i +0 / $env?.f64 +0 / $env?.i +0 / 0 * i +0 / 0 + ceil(1.0) +0 / 1 / f64 +0 / 1.0 + $env.i +0 / array?.[i] +0 / f64 <= f64 +0 / i + i +0 < $env.f64 +0 < $env.i +0 < $env?.[str]?.[f64] +0 < $env?.f64 +0 < $env?.i +0 < 0 + len(str) +0 < 1 % i +0 < 1 - i +0 < 1 ^ median(1.0) +0 < 1.0 - f64 +0 < 1.0 / i +0 < 1.0 <= i +0 < array?.[i] +0 < f64 || $env?.ok +0 < i <= reduce(array, #) +0 <= $env.f64 +0 <= $env.i +0 <= $env?.f64 +0 <= $env?.i +0 <= 1 * i +0 <= 1 <= f64 +0 <= 1 ^ f64 +0 <= 1 or $env != 1 +0 <= 1.0 * f64 +0 <= array?.[i] +0 <= i % i +0 == $env || ok +0 == $env.f64 +0 == $env.i +0 == $env?.Bar +0 == $env?.Bar?.foo +0 == $env?.String +0 == $env?.String?.str +0 == $env?.[Bar] +0 == $env?.[String] +0 == $env?.[foobar] +0 == $env?.[str] +0 == $env?.f64 +0 == $env?.i +0 == 0 not in $env?.foobar +0 == 1.0 && f64 + $env +0 == 1.0 / i +0 == array?.[i] +0 == f64 ?: add +0 == i and $env?.[foo] +0 > $env.f64 +0 > $env.i +0 > $env?.[str]?.[f64] +0 > $env?.f64 +0 > $env?.i +0 > 0 * f64 +0 > 0 / i +0 > 0 > ceil($env) +0 > 0 or foo == nil +0 > 1 - i +0 > 1.0 ^ f64 +0 > array?.[i] +0 > f64 > $env?.[Bar] +0 > f64 > f64 +0 >= $env.f64 +0 >= $env.i +0 >= $env?.f64 +0 >= $env?.i +0 >= 0 ** i +0 >= 1 >= i +0 >= 1.0 and ok +0 >= 1.0 or ok +0 >= f64 ** f64 +0 >= f64 + f64 +0 ^ $env.f64 +0 ^ $env.i +0 ^ $env?.f64 +0 ^ $env?.i +0 ^ 1 * i +0 ^ 1 / f64 +0 ^ 1.0 != i +0 ^ 1.0 + f64 +0 ^ 1.0 / f64 +0 ^ 1.0 in array +0 ^ array?.[i] +0 ^ i == i +0 in $env.array +0 in $env?.Bar +0 in $env?.Bar?.greet +0 in $env?.String +0 in $env?.[Bar] +0 in $env?.[String] +0 in $env?.array +0 in array != ok +0 not in $env.array +0 not in $env?.Bar +0 not in $env?.String +0 not in $env?.[Bar] +0 not in $env?.[String] +0 not in $env?.[foobar] +0 not in $env?.array +0 | bitor($env) == 1 and false +0 | bitshl(1) / f64 +0 | bitxor(0) in array +0 | max(0) in array +0 | max(array, 1.0) - floor(i) +0..array?.[i] +0..i | map(list) +0.0 + 0 == $env +0.1 != floor(1.0) +0.1 | mean(f64) +0; $env?.add +1 != $env not in [true] +1 != $env.f64 +1 != $env.i +1 != $env?.Bar +1 != $env?.String +1 != $env?.String?.f64 +1 != $env?.[Bar] +1 != $env?.[Bar]?.f64 +1 != $env?.[String] +1 != $env?.[foobar] +1 != $env?.[str] +1 != $env?.f64 +1 != $env?.foobar +1 != $env?.i +1 != 0 * f64 +1 != 1 - f64 +1 != 1.0 + i +1 != array?.[i] +1 != f64 && $env?.[str] +1 != f64 || ok +1 != i != ok +1 != nil or ok +1 % $env.i +1 % $env?.i +1 % 1 > f64 +1 % array?.[i] +1 * $env.f64 +1 * $env.i +1 * $env.i + f64 +1 * $env?.f64 +1 * $env?.i +1 * 0 / f64 +1 * 0 == {foo: 1.0}?.array +1 * 0 | bitushr(0) +1 * 1 | bitnand(0) +1 * 1 | min(f64) +1 * 1.0 ** $env.i +1 * 1.0 < f64 +1 * array?.[i] +1 * f64 ^ f64 - 1 +1 * f64 | mean(1) +1 * i / i +1 * i | bitxor(i) +1 ** $env.f64 +1 ** $env.i +1 ** $env?.f64 +1 ** $env?.i +1 ** 0 ** i +1 ** 1 != i +1 ** 1 ** i +1 ** 1.0 != f64 +1 ** array?.[i] +1 ** i + f64 +1 + $env.f64 +1 + $env.i +1 + $env?.f64 +1 + $env?.i +1 + 0 ** i +1 + 1 % i +1 + 1 not in array +1 + 1.0 != i +1 + 1.0 - i +1 + 1.0 < f64 +1 + 1.0 ^ i +1 + f64 ^ i ** 1 +1 + f64 in array +1 + f64 | max(array) +1 + f64 | median(array) +1 + i < f64 +1 + i < i +1 + i..i +1 - $env.f64 +1 - $env.i +1 - $env?.f64 +1 - $env?.i +1 - 1.0 in array +1 - 1.0 not in array +1 - array?.[i] +1 - f64 >= 1.0 < 1 +1 - f64 | min(array) +1 - i / f64 1 - i > i -1 - i > i32 -1 - i >= i64 -1 - i not in array -1 - i32 < i32 -1 - i32 < i64 -1 - i32 == i32 -1 - i64 <= i32 -1 .. i != list -1 / 0.5 <= abs(f32) -1 / 0.5 <= i32 -1 / 0.5 == f64 -1 / 0.5 > f32 -1 / 0.5 >= i -1 / 0.5 >= i - i -1 / 0.5 >= i32 -1 / 1 != i32 -1 / 1 * f32 -1 / 1 <= f64 -1 / 1 in array -1 / f32 != f64 -1 / f32 / i64 -1 / f32 <= f32 -1 / f32 <= f64 -1 / f32 == i32 -1 / f32 == i32 / i -1 / f32 > f32 -1 / f32 >= f64 -1 / f64 + f64 -1 / f64 < f32 -1 / f64 == f64 -1 / i * f32 -1 / i / f64 -1 / i < i -1 / i == f64 -1 / i >= i32 -1 / i in map(list, 1) -1 / i32 > f32 -1 / i32 >= i64 -1 / i64 * i -1 / i64 > f32 / f64 -1 / i64 > f64 -1 / i64 >= f64 -1 < 1 == ok -1 < 1 and ok -1 < array[get(array, i32)] -1 < array[i32] -1 < f32 != not true -1 < f64 || ok -1 < i ? array : foo -1 < i32 || 1 >= f32 -1 < i64 == ok -1 < i64 ? ok : list -1 <= 1 == ok -1 <= 1 || add == add -1 <= f32 && ok -1 <= f64 || ok -1 <= i32 ? foo : f32 -1 == 0.5 ? i32 : greet -1 == 0.5 and ok -1 == 1 || ok -1 == f64 && 0.5 != nil -1 == f64 || ok -1 == i32 && ok -1 == i32 == ok -1 == i64 == ok -1 == nil ? ok : half -1 > 0.5 == ok -1 > array[i64] -1 > f32 && ok -1 > f32 == reduce(array, ok) -1 > f64 != ok -1 > i == ok -1 > i64 or i != 1 -1 >= 1 != (nil not in list) -1 >= f32 ? i64 : half -1 >= f64 ? ok : half -1 >= i and ok -1 ^ 0.5 != f32 -1 ^ 0.5 != i -1 ^ 0.5 ** f32 -1 ^ 0.5 ** i32 -1 ^ 0.5 - i32 -1 ^ 0.5 < i32 -1 ^ 0.5 <= f64 -1 ^ 0.5 == i -1 ^ 0.5 ^ f32 -1 ^ 0.5 ^ i64 -1 ^ 1 != f64 -1 ^ 1 != i64 -1 ^ 1 ** i -1 ^ 1 + f64 -1 ^ 1 / i -1 ^ 1 < i -1 ^ 1 < i64 -1 ^ 1 >= i -1 ^ 1 >= i32 -1 ^ f32 < i32 -1 ^ f32 <= f64 -1 ^ f64 / f64 -1 ^ f64 == f32 -1 ^ f64 > f32 -1 ^ f64 >= 1 / f64 -1 ^ i != i * f32 -1 ^ i - i32 -1 ^ i < i -1 ^ i32 * i32 -1 ^ i32 ** i64 -1 ^ i32 / i -1 ^ i32 >= i32 -1 ^ i32 >= i64 -1 ^ i64 * i64 -1 ^ i64 ** reduce(list, 1) -1 ^ i64 - i64 -1 ^ i64 / f64 -1 ^ i64 > i -1 ^ i64 >= i32 + i32 -1 in array ? f32 : foo -[!false] -[!ok] -[!true] -["bar" + "foo"] -["bar" < "bar"] -["bar" not contains "bar"] -[-0.5] -[-1] -[-f32] -[-f64] -[-i64] -[0.5 != f32] -[0.5 != i] -[0.5 * 0.5] -[0.5 * f32] -[0.5 ** i] -[0.5 - 0.5] -[0.5 - i] -[0.5 / i32] -[0.5 <= i32, half] -[0.5 > 1] -[0.5 > f32] -[0.5 > i64] -[0.5 >= f64] -[0.5 ^ 0.5] -[1 != 1] -[1 * 0.5] -[1 ** 0.5] -[1 + i64, add] -[1 == i64] +1 - i ^ i +1 - i | min(1.0) +1 .. $env.i +1 .. $env?.i +1 .. 0 | groupBy(#) +1 .. 0 | groupBy(foo) +1 .. 0 | one($env) +1 .. 0 | sortBy($env) +1 .. 0 | sortBy(str) +1 .. 0 | sum(greet) +1 .. 1 | filter(ok) +1 .. array?.[i] +1 .. i - i +1 .. i | groupBy(#) +1 .. i | groupBy(foo) +1 .. i | groupBy(ok) +1 .. i | reduce(foo) +1 / $env.array?.[i] +1 / $env.f64 +1 / $env.i +1 / $env?.f64 +1 / $env?.i +1 / 1 * f64 +1 / 1 > f64 +1 / 1 ^ i +1 / 1 in [nil] +1 / 1.0 * $env?.f64 +1 / 1.0 ** i +1 / 1.0 == i || ok +1 / array?.[i] +1 / f64 - f64 +1 < $env.f64 +1 < $env.i +1 < $env?.f64 +1 < $env?.f64 && ok +1 < $env?.i +1 < 0 <= $env?.[str] +1 < 0 ^ i ** 1.0 +1 < 1 ?: array +1 < 1.0 < i +1 < 1.0 > $env?.[false] +1 < i or min($env) +1 <= $env.f64 +1 <= $env.i +1 <= $env?.f64 +1 <= $env?.i +1 <= 0 - i +1 <= 0 ?: greet +1 <= 1 / f64 +1 <= 1 == true or true +1 <= 1.0 == $env?.[Bar] +1 <= array?.[i] +1 <= i / i +1 <= i ^ i +1 == $env || ok +1 == $env.f64 +1 == $env.i +1 == $env?.Bar +1 == $env?.Bar?.Bar +1 == $env?.String +1 == $env?.String?.[greet] +1 == $env?.[Bar] +1 == $env?.[String] +1 == $env?.[foobar] +1 == $env?.[foobar]?.[greet] +1 == $env?.[str] +1 == $env?.f64 +1 == $env?.i +1 == $env?.not +1 == 1 ^ i +1 == 1.0 - $env.i +1 == 1.0 - i +1 == array?.[i] +1 == f64 && list == $env +1 == f64 * f64 ** 1.0 +1 == f64 ?: greet +1 == f64 ^ f64 +1 == i - f64 +1 > $env.f64 +1 > $env.i +1 > $env?.f64 +1 > $env?.i +1 > 0 != ok +1 > 0 <= i or $env +1 > 1.0 / i +1 > 1.0 <= i +1 > 1.0 >= $env.i +1 > 1.0 ^ min(array) +1 > array?.[i] +1 > i % i +1 > i - i +1 > i <= f64 +1 >= $env.f64 +1 >= $env.i +1 >= $env?.f64 +1 >= $env?.i +1 >= 0 == ok +1 >= 1 <= f64 +1 >= 1 <= i +1 >= 1.0 > float(1) +1 >= 1.0 or $env.ok +1 >= array?.[i] +1 ^ $env.f64 +1 ^ $env.i +1 ^ $env?.f64 +1 ^ $env?.i +1 ^ 0 ** i +1 ^ 1 > f64 +1 ^ 1.0 + f64 +1 ^ 1.0 == i +1 ^ 1.0 ^ int(1.0) +1 ^ 1.0 ^ round(0) +1 ^ array?.[i] +1 ^ f64 != $env.f64 +1 ^ f64 - ceil(1.0) +1 in $env.array +1 in $env?.Bar +1 in $env?.String +1 in $env?.[Bar] +1 in $env?.[String] +1 in $env?.array +1 in $env?.foobar +1 in array || false ? 1 : foo +1 in array || ok +1 not in $env.array +1 not in $env?.Bar +1 not in $env?.Bar?.[i] +1 not in $env?.String +1 not in $env?.[Bar] +1 not in $env?.[String] +1 not in $env?.[String]?.f64 +1 not in $env?.[foobar] +1 not in $env?.array +1 not in $env?.foobar +1 | bitshl(0) != f64 +1 | bitxor(1) >= i +1 | min(1.0) + i +1..array?.[i] +1..i | map(#) +1..i | map(0) +1..i | reduce(array) +1.0 != $env.f64 +1.0 != $env.i +1.0 != $env?.Bar +1.0 != $env?.Bar?.[array] +1.0 != $env?.Bar?.str +1.0 != $env?.String +1.0 != $env?.String?.[i] +1.0 != $env?.String?.[ok] +1.0 != $env?.[Bar] +1.0 != $env?.[String] +1.0 != $env?.[foobar?.add($env)]?.greet +1.0 != $env?.[foobar?.add] +1.0 != $env?.[foobar] +1.0 != $env?.[foobar]?.[array] +1.0 != $env?.[str] +1.0 != $env?.f64 +1.0 != $env?.foobar +1.0 != $env?.foobar?.list +1.0 != $env?.i +1.0 != $env?.not +1.0 != 0 != ok +1.0 != 0 / abs(1.0) +1.0 != 1 / i +1.0 != 1 ?: foo +1.0 != 1.0 ** i +1.0 != 1.0 ^ $env.f64 +1.0 != 1.0 ^ f64 +1.0 != 1.0 and $env not endsWith $env +1.0 != array?.[i] +1.0 != f64 && ok +1.0 != i % i +1.0 * $env.f64 +1.0 * $env.i +1.0 * $env?.f64 +1.0 * $env?.i +1.0 * 0 >= i +1.0 * 1.0 <= f64 +1.0 * 1.0 > f64 +1.0 * 1.0 > i +1.0 * 1.0 >= 0 == nil +1.0 * 1.0 | mean(array) +1.0 * array?.[i] +1.0 * f64 - max(1, array) +1.0 * f64 == f64 +1.0 * f64 == sum(array) +1.0 * i >= 1.0 ^ 1 +1.0 * i not in array +1.0 ** $env.f64 +1.0 ** $env.i +1.0 ** $env?.f64 +1.0 ** $env?.i +1.0 ** 0 / i +1.0 ** 0 < i +1.0 ** 0 == i +1.0 ** 0 > i +1.0 ** 0 | median(1) +1.0 ** 1.0 != i +1.0 ** 1.0 * i +1.0 ** 1.0 < 0 != false +1.0 ** 1.0 | median(1.0) +1.0 ** array?.[i] +1.0 ** f64 * f64 +1.0 ** f64 | median(i) +1.0 ** f64 | min(1) +1.0 ** i - float(f64) +1.0 + $env.f64 +1.0 + $env.i +1.0 + $env?.f64 +1.0 + $env?.i +1.0 + 0 != i +1.0 + 0 + f64 +1.0 + 1 | median(1.0) +1.0 + 1.0 <= i +1.0 + 1.0 ^ f64 +1.0 + 1.0 ^ i +1.0 + 1.0 | mean(1) +1.0 + 1.0 | median(1.0) +1.0 + array?.[i] +1.0 + f64 / f64 +1.0 + f64 / i +1.0 + f64 >= f64 +1.0 + i < f64 +1.0 - $env.f64 +1.0 - $env.i +1.0 - $env?.f64 +1.0 - $env?.i +1.0 - 0 != f64 +1.0 - 1 + 1.0 == nil +1.0 - 1 - i +1.0 - 1 - min(1.0) +1.0 - 1 / i +1.0 - 1.0 ** f64 +1.0 - 1.0 + f64 +1.0 - 1.0 < f64 +1.0 - 1.0 == i +1.0 - 1.0 > f64 +1.0 - 1.0 >= f64 +1.0 - 1.0 in array +1.0 - array?.[i] +1.0 - f64 - f64 +1.0 - f64 / i +1.0 - i * $env.i +1.0 - i < i +1.0 / $env.f64 +1.0 / $env.i +1.0 / $env?.f64 +1.0 / $env?.i +1.0 / 0 != i +1.0 / 0 * $env?.f64 +1.0 / 0 <= 1 + f64 +1.0 / 0 == i +1.0 / 0 > $env?.f64 +1.0 / 1 * f64 +1.0 / 1 ** i +1.0 / 1.0 + i +1.0 / 1.0 - f64 +1.0 / 1.0 == i +1.0 / 1.0 >= f64 +1.0 / array?.[i] +1.0 / f64 * i +1.0 / f64 <= f64 || true +1.0 / f64 ^ i +1.0 / f64 in array +1.0 / i < f64 +1.0 / i <= i +1.0 < $env.f64 +1.0 < $env.i +1.0 < $env?.f64 +1.0 < $env?.i +1.0 < 1.0 != ok +1.0 < 1.0 && $env?.String(foobar, i) +1.0 < 1.0 && $env?.[ok] +1.0 < 1.0 ** f64 +1.0 < 1.0 / round(1.0) +1.0 < 1.0 <= $env?.String +1.0 < 1.0 ? foo != nil : str +1.0 < 1.0 ^ f64 +1.0 < 1.0 || ok +1.0 < array?.[i] +1.0 < f64 + $env.i +1.0 < f64 ?: i +1.0 < f64 ^ f64 +1.0 < i != ok +1.0 < i > f64 +1.0 < i > i +1.0 < i ?: 1 == i +1.0 < i ?: list +1.0 <= $env.f64 +1.0 <= $env.i +1.0 <= $env?.f64 +1.0 <= $env?.i +1.0 <= 0 % i +1.0 <= 0 / f64 +1.0 <= 0 < f64 <= f64 +1.0 <= 0 >= i +1.0 <= 0 ? f64 : greet +1.0 <= 1 ** i +1.0 <= 1 / $env?.i +1.0 <= 1 / i +1.0 <= 1 or none($env, $env) +1.0 <= 1.0 != ok +1.0 <= 1.0 ** 1 and false +1.0 <= 1.0 - f64 +1.0 <= 1.0 / mean(f64) +1.0 <= 1.0 < f64 +1.0 <= 1.0 >= f64 +1.0 <= 1.0 or ok +1.0 <= 1.0 || ok +1.0 <= array?.[i] +1.0 <= f64 != ok +1.0 <= f64 && ok +1.0 <= f64 <= f64 +1.0 <= f64 >= f64 +1.0 <= i * i +1.0 <= i / i +1.0 == $env && ok != false +1.0 == $env.f64 +1.0 == $env.i +1.0 == $env?.Bar +1.0 == $env?.String +1.0 == $env?.[Bar] +1.0 == $env?.[Bar]?.foo +1.0 == $env?.[String] +1.0 == $env?.[foobar?.[f64]] +1.0 == $env?.[str] +1.0 == $env?.f64 +1.0 == $env?.i +1.0 == $env?.true != $env +1.0 == 0 or $env?.ok +1.0 == 1 != ok +1.0 == 1 % i +1.0 == 1 - f64 +1.0 == 1 - i +1.0 == 1 == ok +1.0 == 1.0 != ok +1.0 == 1.0 * f64 +1.0 == 1.0 - i +1.0 == 1.0 / f64 +1.0 == 1.0 and ok +1.0 == 1.0 || ok +1.0 == array?.[i] +1.0 == f64 != ok +1.0 == i * i +1.0 == i + f64 +1.0 == nil ?: array +1.0 == nil and $env.ok +1.0 == nil or ok +1.0 > $env.f64 +1.0 > $env.i +1.0 > $env?.f64 +1.0 > $env?.i +1.0 > 0 / i +1.0 > 0 < f64 +1.0 > 0 < i +1.0 > 1 ?: {foo: add, foo: ok}?.foo +1.0 > 1.0 * array?.[i] +1.0 > 1.0 > i +1.0 > array?.[i] +1.0 > f64 * f64 +1.0 > f64 + f64 +1.0 > f64 / i +1.0 > f64 < f64 +1.0 > f64 > round(1.0) +1.0 > f64 or none($env, .f64) +1.0 > i && ok +1.0 > i + 1.0 +1.0 > i >= $env?.[String] +1.0 >= $env.f64 +1.0 >= $env.i +1.0 >= $env?.f64 +1.0 >= $env?.i +1.0 >= 0 / i +1.0 >= 1 > i +1.0 >= 1 > i >= i +1.0 >= 1.0 * f64 or ok +1.0 >= 1.0 + f64 +1.0 >= 1.0 / i +1.0 >= 1.0 / sum(array) +1.0 >= 1.0 == {foo: $env, foo: $env}.foo +1.0 >= 1.0 ?: list +1.0 >= 1.0 ^ f64 +1.0 >= array?.[i] +1.0 >= f64 ** $env?.i +1.0 >= f64 ** 0 > 1.0 +1.0 >= f64 / i +1.0 >= i * f64 +1.0 >= i * i +1.0 >= i + 1.0 >= $env +1.0 >= i - i +1.0 >= i < $env?.i +1.0 ^ $env.f64 +1.0 ^ $env.i +1.0 ^ $env?.f64 +1.0 ^ $env?.i +1.0 ^ 0 - i +1.0 ^ 0 > i ? array : foo +1.0 ^ 0 ^ f64 +1.0 ^ 1 * i +1.0 ^ 1 - sum(array) +1.0 ^ 1 == i +1.0 ^ 1 >= 1 || false +1.0 ^ 1.0 + 1.0 in array +1.0 ^ 1.0 == $env?.i +1.0 ^ 1.0 > i +1.0 ^ 1.0 >= f64 +1.0 ^ array?.[i] +1.0 ^ f64 * i +1.0 ^ f64 <= i and $env +1.0 ^ i * i +1.0 ^ i < f64 < 1.0 +1.0 ^ i <= int(1.0) +1.0 ^ i > i +1.0 ^ i in array +1.0 ^ i not in array +1.0 in $env.array +1.0 in $env?.Bar +1.0 in $env?.String +1.0 in $env?.String?.f64 +1.0 in $env?.[Bar] +1.0 in $env?.[Bar]?.[add] +1.0 in $env?.[Bar]?.array +1.0 in $env?.[String] +1.0 in $env?.[String]?.[i] +1.0 in $env?.[String]?.[str] +1.0 in $env?.[foobar?.[foo]] +1.0 in $env?.array +1.0 in $env?.foobar +1.0 in 0 .. i +1.0 in array or ok +1.0 not in $env.array +1.0 not in $env?.Bar +1.0 not in $env?.String +1.0 not in $env?.[Bar] +1.0 not in $env?.[String] +1.0 not in $env?.[String]?.[array] +1.0 not in $env?.[foobar?.str] +1.0 not in $env?.[foobar] +1.0 not in $env?.array +1.0 not in $env?.foobar +1.0 not in $env?.nil?.[list].array() +1.0 | max(1.0, f64) < f64 +1.0 | max(array) <= i +1.0 | mean(f64) != i +1.0 | median(0) ^ i +1.0 | median(array) | get(foo) +1.0 | min(1.0) ** i +1.0; $env.i +1.0; $env?.Bar +1.0; $env?.list +1.0; 1.0 < f64 +[$env != $env] +[$env != 0] +[$env != 1.0] +[$env != 1] +[$env != add] +[$env != f64] +[$env != false] +[$env != foo] +[$env != list] +[$env != nil] +[$env && true] +[$env == $env] +[$env == 0] +[$env == 1.0] +[$env == 1] +[$env == add] +[$env == false] +[$env == foo] +[$env == greet] +[$env == i, f64] +[$env == i] +[$env == list] +[$env == nil] +[$env == ok] +[$env == str] +[$env == true] +[$env and false] +[$env and true] +[$env in list] +[$env not in array] +[$env not in list, f64] +[$env not in list] +[$env or false, list] +[$env or false] +[$env | all(false)] +[$env | all(true)] +[$env | any(false)] +[$env | any(ok)] +[$env | any(true)] +[$env | filter(false), f64] +[$env | findLast(false)] +[$env | findLastIndex(false)] +[$env | map(1.0)] +[$env | map(add)] +[$env | map(array)] +[$env | map(false)] +[$env | map(foo)] +[$env | map(greet)] +[$env | map(i)] +[$env | map(list)] +[$env | map(ok)] +[$env | map(str)] +[$env | none(false)] +[$env | one(false)] +[$env | one(ok)] +[$env | sum(0)] +[$env | sum(1)] +[$env | sum(1.0)] +[$env | sum(f64)] +[$env, $env]?.[i] +[$env, 0] | any(.ok) +[$env, 1.0] | find(true) +[$env, 1.0] | map(true) +[$env, 1.0]?.[i] +[$env, 1] | reduce(i, nil) +[$env, false, i]?.[i] +[$env, false] | reduce(#) +[$env, foo] | groupBy(f64) +[$env, foo] | reduce($env) +[$env, ok]?.[i] +[$env, true] | groupBy(foo) +[$env, true] | map(foo) +[$env.add, foo] +[$env.add, list] +[$env.add] +[$env.array, i] +[$env.array] +[$env.f64, greet] +[$env.f64, round(1.0)] +[$env.f64, string($env)] +[$env.f64] +[$env.foo, foo] +[$env.foo?.String()] +[$env.foo] +[$env.greet, 1 >= 1] +[$env.greet, foo] +[$env.greet] +[$env.i, greet] +[$env.i] +[$env.list, add] +[$env.list] +[$env.ok] +[$env.str, max(1.0)] +[$env.str] +[$env?.$env] +[$env?.Bar] +[$env?.String, add] +[$env?.String, f64] +[$env?.String] +[$env?.[Bar], array] +[$env?.[Bar], foo] +[$env?.[Bar]] +[$env?.[String], str] +[$env?.[String]?.[foo]] +[$env?.[String]] +[$env?.[foobar]?.add?.add] +[$env?.[foobar]] +[$env?.[nil]] +[$env?.[str], f64] +[$env?.[str]] +[$env?.add, foo] +[$env?.add] +[$env?.array | map(str)] +[$env?.array, $env?.list] +[$env?.array, array != $env] +[$env?.array] +[$env?.f64] +[$env?.foo] +[$env?.foobar, $env.add] +[$env?.foobar?.ok] +[$env?.foobar] +[$env?.greet] +[$env?.i, i < f64] +[$env?.i] +[$env?.list | map(#)] +[$env?.list] +[$env?.nil] +[$env?.ok] +[$env?.str] +[$env] != list +[$env] == 0 .. 1 +[$env] | any(#.ok) +[$env] | concat(array) +[$env] | count(#.ok) +[$env] | count(ok) +[$env] | filter(.ok) +[$env] | filter(ok) +[$env] | find(#.ok != .Bar) +[$env] | find(#.ok) +[$env] | findLastIndex(false) +[$env] | groupBy(.add == ok) +[$env] | groupBy(1) +[$env] | groupBy(i) +[$env] | map(#.String) +[$env] | map($env) +[$env] | map(.greet) +[$env] | map(.str) +[$env] | map(1) +[$env] | map(1.0) +[$env] | map(array) +[$env] | map(foo) +[$env] | map(true) +[$env] | reduce(#) +[$env] | reduce(#.add) +[$env] | reduce(#.add?.[false]) +[$env] | reduce(#.f64 | map(#.str)) +[$env] | reduce(#.greet, greet) +[$env] | reduce(#.greet?.[foo]) +[$env] | reduce(#.ok) +[$env] | reduce($env) +[$env] | reduce(.Bar, 0) +[$env] | reduce(1) +[$env] | reduce(1.0) +[$env] | reduce(array) +[$env] | reduce(foo) +[$env] | reduce(i) +[$env] | reduce(list, i) +[$env] | reduce(ok) +[$env] | reduce(str) +[$env] | sortBy(#.list) +[$env] | sortBy(#?.[.String]) +[$env] | sortBy(.array) +[$env] | sortBy(1) +[$env] | sortBy(array) +[$env] | sortBy(false) +[$env] | sortBy(foo) +[$env] | sortBy(greet) +[$env] | sortBy(list) +[$env] | sum(#.f64) +[$env] | sum(.f64) +[$env] | sum(1.0) +[$env][len(list):] +[0 != $env] +[0 != 0] +[0 != 1.0] +[0 != i] +[0 != nil] +[0 * 0] +[0 * 1] +[0 * f64] +[0 ** 1.0] +[0 ** 1] +[0 + 1.0] +[0 + f64] +[0 - 0] +[0 / f64] +[0 / i] +[0 < 0] +[0 < 1.0] +[0 < f64] +[0 <= 0] +[0 <= f64] +[0 <= i] +[0 == $env] +[0 == 0] +[0 == 1.0] +[0 == i] +[0 == nil] +[0 > 0] +[0 > 1] +[0 > f64] +[0 > i] +[0 >= 1.0] +[0 >= 1] +[0 >= f64] +[0 ^ 1] +[0 in array] +[0 not in array] +[0 | median(1.0)] +[0, $env] | count(false || true) +[0, $env] | sortBy(1.0) +[0, 0] | reduce(1.0, $env) +[0, 1.0]?.[i] +[0, add] | findLastIndex(ok) +[0, foo][:] +[0, greet]?.[i] +[0, i] | any(false) +[0, i]?.[i] +[0, list]?.[i] +[0, ok]?.[i] +[0, str] | map(#) +[0, true]?.[i] +[0.0] +[0.1] +[0] | all(false) +[0] | any(false) +[0] | count(ok) +[0] | findIndex(ok) +[0] | groupBy(i) +[0] | groupBy(true) +[0] | map(#) +[0] | map(array) +[0] | map(f64) +[0] | map(foo) +[0] | reduce(#) +[0] | reduce(0, nil) +[0] | reduce(i) +[0] | sortBy(#) +[0] | sortBy(1.0) +[0] | sortBy(foo) +[0] | sortBy(str) +[0] | sum(i) +[1 != $env] +[1 != 1.0] +[1 != f64] +[1 != nil] +[1 * 0] +[1 * 1.0] +[1 * 1] +[1 * f64] +[1 ** f64] +[1 + 0] +[1 + 1.0] +[1 + 1] +[1 + f64] +[1 - 0] +[1 - 1.0] +[1 - f64] +[1 .. 1] +[1 / 1.0] +[1 / i] +[1 < 0] +[1 < 1.0, foo] +[1 < 1.0] +[1 < 1] +[1 <= 1.0] +[1 <= 1] +[1 == $env] +[1 == 1.0] +[1 == 1] +[1 == f64] [1 == i] -[[f32]] +[1 > 1.0] +[1 >= 1.0] +[1 >= i] +[1 ^ f64] +[1 | max(1.0)] +[1 | median(1.0)] +[1, $env]?.[i] +[1, 1]?.[i] +[1, false] | all(false) +[1, false] | groupBy(true) +[1, foo]?.[i] +[1, greet] | reduce(#acc, 0) +[1, nil] | reduce(add, array) +[1, str, 0] | findLastIndex($env?.ok) +[1, true] | findLastIndex(#) +[1.0 != $env] +[1.0 != 0] +[1.0 != 1.0] +[1.0 != 1] +[1.0 != f64] +[1.0 != i] +[1.0 != nil] +[1.0 * 0] +[1.0 * 1.0] +[1.0 * 1] +[1.0 * i] +[1.0 ** 1.0] +[1.0 ** f64] +[1.0 ** i] +[1.0 + 0] +[1.0 + 1.0] +[1.0 + f64] +[1.0 + i] +[1.0 - 0] +[1.0 - 1.0] +[1.0 - 1] +[1.0 - i] +[1.0 / 0] +[1.0 / 1] +[1.0 / f64] +[1.0 / i] +[1.0 < 1.0] +[1.0 < f64] +[1.0 < i] +[1.0 <= 1.0, foo] +[1.0 <= 1.0] +[1.0 <= 1] +[1.0 <= f64] +[1.0 <= i] +[1.0 == $env] +[1.0 == 0] +[1.0 == 1.0] +[1.0 == 1] +[1.0 == f64] +[1.0 == i] +[1.0 == nil] +[1.0 > 0] +[1.0 > 1.0] +[1.0 > 1] +[1.0 >= 1.0] +[1.0 >= 1] +[1.0 >= f64] +[1.0 >= i] +[1.0 ^ 0] +[1.0 ^ 1] +[1.0 ^ f64] +[1.0 ^ i] +[1.0 in array, list] +[1.0 | max(f64)] +[1.0 | mean(f64)] +[1.0, $env] | map(str) +[1.0, $env] | reduce(array) +[1.0, 0] | map(#) +[1.0, 1.0] | sortBy(#) +[1.0, f64] | reduce(#) +[1.0, foo]?.[i] +[1.0, greet] | reduce($env, list) +[1.0, nil] | reduce(true) +[1.0, nil] | sum(f64) +[1.0, ok] | findLastIndex(true) +[1.0, ok]?.[i] +[1.0] +[1.0] == list +[1.0] | all(true) +[1.0] | any(true) +[1.0] | filter(ok) +[1.0] | find(false) +[1.0] | findLastIndex(false) +[1.0] | groupBy(#) +[1.0] | groupBy(0) +[1.0] | groupBy(1) +[1.0] | groupBy(f64) +[1.0] | groupBy(foo) +[1.0] | map(#index) +[1.0] | map($env) +[1.0] | map(1.0) +[1.0] | map(add) +[1.0] | map(foo) +[1.0] | map(i) +[1.0] | map(str) +[1.0] | median(1.0) +[1.0] | one(false) +[1.0] | one(ok) +[1.0] | one(true) +[1.0] | reduce(#) +[1.0] | reduce(#acc) +[1.0] | reduce(#acc, foo) +[1.0] | reduce($env) +[1.0] | reduce(1.0) +[1.0] | reduce(array) +[1.0] | reduce(f64) +[1.0] | sortBy(1) +[1.0] | sortBy(false) +[1.0] | sortBy(greet) +[1.0] | sum(0) +[1.0] | sum(1.0) +[1.0][:] +[1.1] +[1] | filter(false) +[1] | findIndex(true) +[1] | groupBy(#) +[1] | groupBy(foo) +[1] | map(#) +[1] | map(1.0) +[1] | map(foo) +[1] | reduce(#, foo) +[1] | sortBy(#) +[1] | sortBy(1.0) +[1] | sortBy(array) +[1] | sortBy(true) +[1] | sum(#) +[1] | sum(1.0) +[[$env]] +[[0]] +[[1, ok]] +[[1, true, true]] +[[1.0, foo]] +[[1.0], 1 / 1.0] +[[1.0]] +[[1]] +[[add]] +[[array]] +[[f64, foo]] +[[f64]] +[[false, add]] +[[false]] +[[foo, 1]] +[[foo, array]] +[[foo], i] +[[foo]] +[[greet], $env?.String] +[[greet]] +[[i]] +[[list, ok, foo]] +[[list]] +[[nil], i] +[[nil]] +[[ok, 0]] +[[ok]] +[[str]] +[[true]] +[[{foo: false, foo: add}]] +[abs(0)] +[abs(1)] +[abs(1.0)] +[abs(f64)] +[abs(i)] +[add != $env] [add != nil] +[add == $env] +[add == nil] +[add(1, i)] +[add(i, 1)] +[add, $env != 1] +[add, $env.foo] +[add, $env?.[String]] +[add, $env?.[str]] +[add, $env?.greet] +[add, 0] | map(add) +[add, 1.0]?.[i] +[add, [$env]] [add, add] -[add, f32] +[add, array] +[add, f64] +[add, false]?.[i] +[add, foo] +[add, foo] | groupBy(foo) +[add, greet] [add, i] +[add, list] +[add, ok] +[add, ok] | none(ok) +[add, ok]?.[i] +[add, str] +[add, true]?.[i] [add] -[all(list, false)] -[any(list, ok)] +[add] | all(true) +[add] | findLastIndex(false) +[add] | groupBy(true) +[add] | map(#) +[add] | map($env) +[add] | map(1.0) +[add] | map(add) +[add] | map(ok) +[add] | none(ok) +[add] | reduce(#) +[add] | reduce(#, add) +[add] | reduce(#acc) +[add] | reduce(foo, foo) +[add] | sortBy($env) +[add] | sum(1.0) +[all($env, ok)] +[all($env, true)] +[all(list, ok)] +[any(list, false)] +[array != $env] +[array != array] +[array != nil] +[array == $env] +[array | findLast(false)] +[array | groupBy(#)] +[array | map(#)] +[array | map(1)] +[array | map(1.0)] +[array | map(ok)] +[array | one(false)] +[array | one(true)] +[array | reduce(#)] +[array | reduce(#, false)] +[array | reduce(#index)] +[array | reduce(0)] +[array | reduce(add)] +[array | reduce(f64)] +[array | reduce(foo, true)] +[array | reduce(ok)] +[array | sortBy(#)] +[array | sortBy(1.0)] +[array | sortBy(f64)] +[array | sum(#), foo] +[array | sum(1)] +[array, $env.array] +[array, $env?.[Bar]] +[array, 0 == $env] +[array, 1.0]?.[i] [array, add] [array, array] -[array, f32] +[array, f64] +[array, f64] | findIndex(ok) +[array, f64] | reduce(str) +[array, f64]?.[i] +[array, false, ok] | findLastIndex(#) +[array, foo] [array, greet] -[array, i64] [array, i] +[array, i]?.[i] [array, list] -[array, ok, add] -[array, string(nil)] +[array, nil] | sum(0) +[array, ok] +[array, ok] | reduce(true) +[array, ok]?.[i] +[array, str, ok] +[array, str] +[array?.[i]] +[array[i:]] [array] +[array] | map(#) +[array] | reduce(#) +[array] | reduce(#, 1.0) +[array] | reduce(0) +[array] | reduce(1.0) +[array] | sortBy(#) +[array] | sortBy(i) +[array] | sum(0) +[array] | sum(1.0) +[array][:i] +[bitnot(0)] [bitnot(1)] -[ceil(i32)] -[div(1, 1)] -[div, add] -[div, foo] -[div, i32] -[div, i64, array] -[div] -[f32 * i] -[f32 + f64] -[f32 >= i] -[f32, f64] -[f32, foo, greet] -[f32, greet] -[f32, i32] -[f32, list] -[f32, ok] -[f32, score] -[f32] -[f64 + f64] +[bitnot(i)] +[ceil(0)] +[ceil(1.0)] +[ceil(f64)] +[ceil(i)] +[concat(array)] +[concat(list)] +[count($env, false)] +[count(list, false)] +[f64 != 0] +[f64 != 1.0] +[f64 != nil] +[f64 * 1] +[f64 * f64] +[f64 * i] +[f64 ** 0] +[f64 ** 1] +[f64 ** i] +[f64 + 1.0] +[f64 - 1] +[f64 / 1] [f64 / f64] -[f64 < 0.5] -[f64 < f32] -[f64 < i64] -[f64 <= 1] -[f64 in array] +[f64 < 0] +[f64 < 1.0] +[f64 < f64] +[f64 < i] +[f64 <= f64] +[f64 == $env] +[f64 == 0] +[f64 == f64] +[f64 == i] +[f64 == nil] +[f64 > 1.0] +[f64 > f64] +[f64 >= 0] +[f64 >= 1.0] +[f64 ^ 1] +[f64 not in array] +[f64 | median(1.0)] +[f64, $env == 1.0] +[f64, $env.add] +[f64, $env.list] +[f64, $env?.String] +[f64, 1.0 ^ i] +[f64, 1.0] | map(0) [f64, add] +[f64, array] [f64, f64] -[f64, half] -[f64, i64] +[f64, foo] +[f64, foo] | reduce(#) +[f64, greet] +[f64, i] +[f64, i] | take(i) +[f64, list] +[f64, nil != foo] +[f64, nil]?.[i] +[f64, ok] +[f64, str] +[f64, str] | findLast(ok) +[f64, {foo: 0}] [f64] -[f64] == array +[f64] | map(#) +[f64] | map(1.0) +[f64] | map(false) +[f64] | map(foo) +[f64] | map(greet) +[f64] | reduce(1) +[f64] | reduce(1.0) +[f64] | reduce(f64) +[f64] | reduce(false) +[f64] | reduce(greet, true) +[f64] | sortBy($env) +[f64] | sortBy(0) +[f64] | sum(#) +[f64] | sum(1.0) +[f64][:] +[false != $env] +[false != false] +[false != nil] +[false != true] +[false && $env] +[false && false] +[false && true] +[false == $env] +[false == false] +[false == nil] +[false == ok] +[false == true] +[false ? 1.0 : foo] +[false ?: 1.0] +[false ?: foo] +[false and $env] +[false and ok] +[false and true] +[false or $env] +[false or false] +[false || $env] +[false || false, list] +[false, $env] | findIndex(true) +[false, $env] | groupBy(1.0) +[false, 1] != nil ? 1.0 : $env[add(false) == greet():] +[false, 1]?.[i] +[false, array] | reduce(0) +[false, f64]?.[i] +[false, greet]?.[i] +[false, str] | groupBy(foo) +[false] == $env?.Bar +[false] | all(#) +[false] | count(false) +[false] | find(#) +[false] | findLast(true) +[false] | groupBy(#) +[false] | groupBy(i) +[false] | map(foo) +[false] | map(list) +[false] | none(#) +[false] | reduce(false, add) +[false] | reduce(list, foo) +[false] | sortBy(false) +[false] | sortBy(true) +[false][:] +[false][i:] +[filter($env, false)] +[filter(array, false)] +[find(array, false)] [find(array, true)] -[findIndex(list, false)] -[findLast(list, ok)] -[float(0.5)] +[find(list, false)] +[find(list, true)] +[findIndex($env, true)] +[findIndex(list, ok)] +[findIndex(list, true)] +[findLast(array, true)] +[findLast(list, false), i] +[findLastIndex($env, ok)] +[findLastIndex(array, true)] +[findLastIndex(list, true)] +[first($env)] +[first(array)] +[first(list)] +[flatten(array)] +[flatten(list)] +[float(0)] [float(1)] +[float(1.0)] +[float(f64)] +[float(i)] +[floor(0)] +[floor(1), f64] +[floor(1)] +[floor(1.0)] +[floor(f64)] +[floor(i)] +[foo != $env] +[foo != foo, add] +[foo != foo] +[foo != nil] +[foo == $env, list] +[foo == $env] +[foo == foo] +[foo == nil] +[foo not in list] +[foo, $env] | map(1.0) +[foo, $env]?.[i] +[foo, 1.0, $env]?.[i] +[foo, 1.0] | groupBy(1) +[foo, 1.0] | one(ok) +[foo, 1.0]?.[i] +[foo, 1]?.[i] +[foo, add, $env] | findLastIndex(ok) +[foo, add, f64] [foo, add] +[foo, add]?.[i] [foo, array] -[foo, half] +[foo, array] | reduce(i) +[foo, array]?.[i] +[foo, f64] +[foo, f64] | count(false) +[foo, false] | map(#) +[foo, false]?.[i] +[foo, foo != $env] +[foo, foo] +[foo, foo] | reduce(1.0) +[foo, foo]?.[i] +[foo, greet(str)] +[foo, greet] [foo, i] +[foo, i]?.[i] +[foo, list] +[foo, list]?.[i] +[foo, mean(1)] +[foo, nil, list] | map(#) +[foo, nil]?.[i] [foo, ok] -[foo, reduce(array, #)] +[foo, str] +[foo, true]?.[i] +[foo, values($env)] +[foo.Bar, ok] [foo.Bar] -[foo.Qux] -[foo?.Bar, f32, f64] -[foo?.Bar, i32] +[foo.String()] +[foo.String, f64] +[foo.String] [foo?.Bar] -[foo?.Qux] [foo?.String()] +[foo?.String, $env?.String] +[foo?.String] [foo] +[foo] in [nil] +[foo] | all(ok) +[foo] | all(true) +[foo] | any(ok) +[foo] | count(false) +[foo] | filter(ok) +[foo] | filter(true) +[foo] | find(ok) +[foo] | findLast(false) +[foo] | findLastIndex(ok) +[foo] | groupBy(#) +[foo] | groupBy(#.Bar) +[foo] | groupBy(foo) +[foo] | map(#) +[foo] | map(.String) +[foo] | map(i) +[foo] | map(list) +[foo] | map(ok) +[foo] | none(true) +[foo] | reduce(#) +[foo] | reduce(#, ok) +[foo] | reduce(#index) +[foo] | reduce(.Bar, 0) +[foo] | reduce(0) +[foo] | reduce(1) +[foo] | reduce(1.0) +[foo] | reduce(foo) +[foo] | reduce(foo, list) +[foo] | reduce(greet) +[foo] | sortBy(#) +[foo] | sortBy(#.String) +[foo] | sortBy(.Bar) +[foo] | sortBy(add) +[foo] | sortBy(greet) +[foo] | sortBy(i) +[foo] | sortBy(str) +[foo] | sum(i) +[foo][:] +[get($env, nil)] +[get($env, str)] [greet != nil] +[greet == $env] +[greet == nil, array] +[greet == nil] +[greet(str), array] +[greet(str)] +[greet, $env.array] +[greet, $env.greet] +[greet, 1.0]?.[i] +[greet, [array]] +[greet, abs(1.0)] +[greet, add] +[greet, add] | reduce($env) [greet, array] -[greet, div] +[greet, f64] +[greet, foo == $env] [greet, foo] +[greet, foo] | none(true) +[greet, foo]?.[i] [greet, greet] -[greet, half] -[greet, i64] +[greet, i] [greet, list] +[greet, nil]?.[i] +[greet, ok] +[greet, str] +[greet, true]?.[i] [greet] -[greet] == list -[groupBy(array, "bar")] -[groupBy(array, #), half] +[greet] | any(false) +[greet] | count(false) +[greet] | groupBy(1) +[greet] | groupBy(foo) +[greet] | groupBy(true) +[greet] | map($env) +[greet] | map(i) +[greet] | map(str) +[greet] | reduce(#, array) +[greet] | reduce(greet) +[greet] | reduce(ok) +[greet] | sum(f64) +[greet][:i] [groupBy(array, #)] -[groupBy(array, f64)] -[groupBy(list, #)?.Qux] -[half(0.5)] -[half(f64)] -[half(i64 ^ 1)] -[half, array] -[half, div] -[half, f64] -[half, i64 < f64] -[half, list] -[half] -[i != i64] -[i .. 1] -[i / i] -[i < i64, score] -[i <= 0.5] -[i == i32] -[i >= i32] +[groupBy(list, #)] +[groupBy(list, 1.0)?.[i]] +[groupBy(list, false)] +[groupBy(list, foo)] +[i != $env] +[i != 0] +[i != 1.0] +[i != 1] +[i != f64] +[i % 1] +[i % i] +[i * 0] +[i * 1] +[i ** 0] +[i ** 1.0] +[i + 1.0] +[i - f64] +[i .. i] +[i / 1] +[i < 1.0] +[i <= 1.0] +[i <= 1] +[i == $env] +[i == 0] +[i == 1] +[i == f64] +[i == nil] +[i > f64] +[i >= 1] +[i ^ 1.0] [i ^ 1] -[i, array, list] +[i | max(array, i)] +[i, $env?.String] +[i, $env?.foobar] +[i, 1.0]?.[i] +[i, add] [i, array] -[i, greet("bar")] +[i, f64 > i] +[i, f64] +[i, f64] != array +[i, foo?.String] +[i, foo] [i, greet] -[i, i32] [i, i] [i, list] -[i32 < i] -[i32 > 1] -[i32, -1] -[i32, div] -[i32, f64] -[i32, i32] -[i32, list] -[i32, type(greet)] -[i32] -[i64 != f64] -[i64 + 0.5] -[i64 / f64] -[i64 <= i64] -[i64 >= 1] -[i64 ^ 1] -[i64, div] -[i64, foo] -[i64, half] -[i64, score] -[i64] +[i, nil in $env] +[i, nil] | groupBy(1.0) +[i, ok] +[i, str] +[i, sum(array)] +[i, toJSON(0)] +[i, true] | groupBy(true) +[i..i] [i] +[i] != list +[i] == array +[i] == list +[i] | any(ok) +[i] | find(false) +[i] | groupBy(1) +[i] | groupBy(1.0) +[i] | map(#) +[i] | map(false) +[i] | reduce(add, i) +[i] | reduce(str) +[i] | sortBy(#) +[i] | sortBy($env) +[i] | sortBy(1.0) +[i] | sum(#) +[if false { $env } else { 1.0 }] +[if false { $env } else { greet }] +[if false { 1.0 } else { true }] +[if false { foo } else { 1 }] +[if false { foo } else { true }] +[if ok { 1.0 } else { foo }] +[if ok { false } else { 1.0 }] +[if ok { nil } else { nil }] +[if ok { true } else { 1.0 }, $env.f64] +[if true { 0 } else { ok }] +[if true { 1 } else { 0 }] +[if true { f64 } else { 1 }] +[if true { foo } else { 1 }] +[if true { foo } else { add }] +[if true { foo } else { ok }] +[if true { nil } else { array }] +[int(0)] +[int(1)] +[int(1.0)] +[int(f64), foo] +[int(f64)] +[int(i)] +[keys($env)] +[last($env)] +[last(array)] +[last(list)] +[len($env)] +[len(array)] +[len(list)] +[len(str)] +[len({foo: list})] +[let foobar = 1.0; foobar] +[list != list] [list != nil] -[list, div] -[list, f32] +[list | findLast(false)] +[list | groupBy(#)] +[list | groupBy(1.0)] +[list | groupBy(f64)] +[list | map(#)] +[list | map(foo)] +[list | reduce(#)] +[list | reduce(#, 0)] +[list | reduce(#.String)] +[list | reduce(#index, greet)] +[list | reduce($env)] +[list | reduce($env, foo)] +[list | reduce(1.0, greet)] +[list | reduce(array)] +[list | reduce(foo)] +[list | reduce(i)] +[list | sortBy(1)] +[list | sortBy(1.0)] +[list, $env.foo] +[list, $env?.String] +[list, $env?.list] +[list, 0 * i] +[list, 0 ^ 1.0] +[list, 0] | find(false) +[list, 1.0 + 1.0] +[list, 1.0]?.[i] +[list, add] +[list, add] | map(#) +[list, add]?.[i] +[list, array] +[list, f64] +[list, f64]?.[i] +[list, false, 1] | reduce(foo) +[list, foo] +[list, foo] | groupBy(foo) [list, greet] -[list, half] +[list, i ^ 1.0] [list, i] +[list, list] [list, ok] +[list, str, str] +[list, str] +[list, toJSON(nil)] +[list, true != $env] +[list?.[0]] +[list?.[i]] [list] +[list] != list +[list] == array +[list] | filter(ok) +[list] | findIndex(ok) +[list] | findLast(false) +[list] | groupBy($env.foo) +[list] | map(add) +[list] | map(i) +[list] | map(true) +[list] | none(ok) +[list] | one(true) +[list] | reduce(1) +[list] | reduce(foo) +[list] | reduce(foo, false) +[list] | sortBy(#) +[list] | sortBy(add) +[list] | sortBy(foo) +[list] | sortBy(i) +[list] | sortBy(str) +[lower(str)] +[map($env, $env)] +[map($env, list)] +[map($env, str)] [map(array, #)] -[map(array, add)] -[map(array, f64)] -[map(array, foo)] -[max(1)] -[nil != 0.5] -[not false] +[map(array, $env)] +[map(array, 1)] +[map(array, 1.0), foo] +[map(array, false)] +[map(array, str), ok] +[map(array, str)] +[map(list, #)] +[map(list, $env)] +[map(list, 0)] +[map(list, ok)] +[map(list, str)] +[max($env), f64] +[max($env)] +[max(0)] +[max(1.0)] +[max(array) ^ f64] +[max(array)] +[max(array, 1.0)] +[max(f64)] +[mean(0)] +[mean(1)] +[mean(1.0)] +[mean(array)] +[mean(f64)] +[mean(i)] +[median(0)] +[median(1)] +[median(1.0)] +[median(array)] +[median(f64)] +[median(floor(0))] +[median(i)] +[min($env)] +[min(0)] +[min(1)] +[min(1.0)] +[min(array)] +[min(f64)] +[nil != $env] +[nil != 0] +[nil != 1.0] +[nil != f64] +[nil != foo] +[nil != greet] +[nil != list] +[nil != nil] +[nil != ok] +[nil != str] +[nil != true] +[nil == $env, foo] +[nil == 0] +[nil == 1.0] +[nil == add] +[nil == array] +[nil == f64] +[nil == false, str] +[nil == false] +[nil == foo] +[nil == greet] +[nil == list] +[nil == nil] +[nil == ok] +[nil == str] +[nil == true] +[nil in $env] +[nil in list] +[nil not in $env] +[nil not in list] +[nil, 0]?.[i] +[nil, 1.0] | none(true) +[nil, 1.0] | reduce(#) +[nil, 1.0]?.[i] +[nil, 1]?.[i] +[nil, add] | none(false) +[nil, add]?.[i] +[nil, f64] | groupBy(str) +[nil, foo] | findLast(ok) +[nil, foo]?.[i] +[nil, nil, $env]?.[i] +[nil, nil, array]?.[i] +[nil, str, 1.0] | map(#) +[nil, true]?.[i] +[nil] == list +[nil] | count(ok) +[nil] | findIndex(true) +[nil] | findLast(false) +[nil] | groupBy(0) +[nil] | groupBy(str) +[nil] | map(1.0) +[nil] | map(f64) +[nil] | one(ok) +[nil] | reduce(0) +[nil] | reduce(array) +[nil] | reduce(array, array) +[nil] | reduce(false) +[nil] | reduce(i) +[nil] | reduce(ok) +[nil] | reduce(true) +[nil] | sortBy(0) +[nil] | sortBy(false) +[nil] | sortBy(foo) +[nil] | sortBy(true) +[nil] | sum(1) +[nil] | sum(1.0) +[none($env, true)] +[none(array, false)] +[ok != $env] +[ok != nil] +[ok && ok] +[ok == $env] +[ok == false] +[ok == nil] +[ok == true] [ok ? 1 : greet] -[ok, f32] -[ok, half] -[ok, i64] +[ok ? str : i, add] +[ok ?: 0] +[ok and $env] +[ok and ok, ok] +[ok and true] +[ok or $env] +[ok or false] +[ok or ok] +[ok or true] +[ok || $env] +[ok || false] +[ok, $env?.[str]] +[ok, $env?.str] +[ok, $env] | find(#) +[ok, $env] | map(false) +[ok, 1.0 == 1.0] +[ok, 1] | map(1.0) +[ok, add] +[ok, array] +[ok, array]?.[i] +[ok, f64] +[ok, floor(0)] +[ok, foo not in list] +[ok, foo?.String] +[ok, foo] +[ok, foo] | map(f64) +[ok, foo]?.[i] +[ok, greet] [ok, i] -[ok, list, 0.5] == list +[ok, int(f64)] +[ok, list] +[ok, list] | findIndex(false) +[ok, list]?.[i] +[ok, nil] | find(#) [ok, ok] +[ok, reduce(list, str)] +[ok, str] +[ok, str] | reduce(foo) +[ok, string(add)] [ok] +[ok] != array +[ok] | all(#) +[ok] | any(#) +[ok] | count(#) +[ok] | findLast(false) +[ok] | reduce(1.0) +[ok] | reduce(foo) +[ok] | sortBy(f64) +[ok] | sum(f64) +[one($env, false)] +[one($env, ok)] +[reduce(array, #)] +[reduce(array, $env)] +[reduce(array, $env, f64)] +[reduce(array, array)] +[reduce(array, false)] [reduce(array, foo)] -[reduce(list, #)] -[reduce(list, div)] -[score == nil] -[score, div] -[score, f32] -[score, f64] -[score, greet] -[score, half] -[score, one(array, # > i32)] -[score, score] -[score] -[string(0.5)] +[reduce(array, true)] +[reduce(list, .String)] +[reduce(list, add)] +[reduce(list, foo)] +[reduce(list, i)] +[reduce(list, list)] +[reverse(array)] +[round(0)] +[round(1)] +[round(1.0)] +[round(f64)] +[round(i)] +[sort($env)?.[i], foo] +[sort($env)] +[sort(array)] +[sortBy(array, 1.0)] +[sortBy(array, i)] +[sortBy(list, 1)] +[str != nil] +[str < str] +[str <= str] +[str contains str] +[str in $env] +[str in foo] +[str not contains str] +[str not in $env] +[str not in foo] +[str not matches str] +[str not startsWith str] +[str | greet()] +[str, $env == false] +[str, $env?.[Bar]] +[str, $env?.ok] +[str, 0] | reduce(false, foo) +[str, 1]?.[i] +[str, add] +[str, array] +[str, f64 ** 1] +[str, f64 > i] +[str, f64] +[str, false != nil] +[str, false]?.[i] +[str, foo.Bar] +[str, foo] +[str, greet] +[str, i] +[str, list | findLastIndex(true)] +[str, list] +[str, list] | any(false) +[str, map(list, $env)] +[str, nil]?.[i] +[str, ok] +[str, str, 0]?.[i] +[str, str] +[str[1:]] +[str] +[str] == array +[str] | all(false) +[str] | any(ok) +[str] | count(true) +[str] | filter(ok) +[str] | findLastIndex(false) +[str] | groupBy(#) +[str] | one(ok) +[str] | one(true) +[str] | reduce(#) +[str] | reduce(#acc) +[str] | reduce(false) +[str] | sortBy($env) +[str] | sortBy(1.0) +[str] | sortBy(foo) +[str] | sum(abs(0)) +[str][i:] +[string($env)] +[string($env.f64)] +[string(0)] [string(1)] +[string(1.0)] +[string(add)] +[string(array)] +[string(f64)] +[string(false)] +[string(foo), add] [string(foo)] +[string(greet)] [string(i)] -[string(i64)] +[string(list) not in $env?.foobar] +[string(list)] +[string(nil)] +[sum(array)] +[sum(array, #)] +[sum(array, 1)] +[sum(array, i)] +[toBase64(str)] +[toBase64(string(1.0))] +[toJSON($env.foo)] +[toJSON(0)] +[toJSON(1)] +[toJSON(1.0)] +[toJSON(array)] +[toJSON(false), str] +[toJSON(false)] +[toJSON(foo)] +[toJSON(i)] [toJSON(list)] -[trimPrefix("bar")] -[true ? add : f64] -[true and ok] -[true || ok] -[type(1)] +[toJSON(nil), foo.Bar] +[toJSON(nil)] +[toJSON(ok)] +[toJSON(true)] +[toPairs($env)] +[trim(str)] +[trimPrefix(str)] +[true != false] +[true != nil] +[true && $env, list] +[true && $env] +[true && false, array] +[true == $env] +[true == nil] +[true ? $env : 1.0] +[true ?: 1] +[true ?: array] +[true ?: list] +[true and $env] +[true and true] +[true or true] +[true || $env] +[true || true] +[true, 1] == $env?.array +[true, add] | findLast(true) +[true, add] | reduce(array, greet) +[true, add]?.[i] +[true, foo] | find(#) +[true, foo]?.[i] +[true, list]?.[i] +[true, nil]?.[i] +[true, ok] | find(true) +[true, ok]?.[i] +[true] != [array] +[true] in $env?.foobar +[true] | all(#) +[true] | any(#) +[true] | any(false) +[true] | findIndex(#) +[true] | findLastIndex(false) +[true] | groupBy(1.0) +[true] | map(1.0) +[true] | none(true) +[true] | one(false) +[true] | reduce($env) +[true] | reduce($env, str) +[true] | reduce(1.0) +[true] | sortBy(#) +[true] | sortBy(greet) +[true] | sortBy(true) +[true] | sum(1) +[true] | sum(1.0) +[type($env)] +[type(0)] +[type(1.0)] [type(add)] -[type(div)] +[type(array)] +[type(f64)] +[type(false)] +[type(foo)] [type(greet)] -[type(nil)] -abs(-0.5) -abs(-1) -abs(-f32) -abs(-f64) -abs(-i) -abs(-i32) -abs(-i64) -abs(0.5 * 0.5) -abs(0.5 * 1) -abs(0.5 * i) -abs(0.5 * i64) -abs(0.5 ** 0.5) -abs(0.5 ** 1) -abs(0.5 ** i32) -abs(0.5 + 0.5) -abs(0.5 + 1) -abs(0.5 + f32) -abs(0.5 + i) -abs(0.5 + i64) -abs(0.5 - 0.5) -abs(0.5 - 1) -abs(0.5 - i) -abs(0.5 - i32) -abs(0.5 - i64) -abs(0.5 / 0.5) -abs(0.5 / 1) -abs(0.5 / f64) -abs(0.5 ^ 0.5) -abs(0.5 ^ 1) -abs(0.5 ^ f32) -abs(0.5) - i32 -abs(0.5) / f32 -abs(0.5) < f64 -abs(0.5) < i32 -abs(0.5) <= i64 -abs(0.5) == -0.5 -abs(0.5) == half(1) -abs(0.5) > i32 -abs(0.5) >= f64 -abs(0.5) ^ i64 -abs(0.5) not in array -abs(1 * f32) +[type(list), array] +[type(list)] +[type(ok)] +[type(str), foo]?.[i] +[type(str)] +[type(true)] +[uniq(array)] +[uniq(list)] +[upper(str)] +[values($env)] +[{foo: $env, foo: nil}] +[{foo: $env}] +[{foo: 0, foo: 1.0}] +[{foo: 0, foo: nil}] +[{foo: 0, foo: true}] +[{foo: 0}] +[{foo: 1.0}.add] +[{foo: 1.0}] +[{foo: 1}] +[{foo: add, foo: i}] +[{foo: add, foo: str}] +[{foo: add}] +[{foo: array}] +[{foo: f64}] +[{foo: false, foo: 0}] +[{foo: false}] +[{foo: foo, foo: false}] +[{foo: foo}] +[{foo: greet, foo: f64, foo: 0}] +[{foo: greet}] +[{foo: i, foo: $env}] +[{foo: i}] +[{foo: list, foo: foo}] +[{foo: list}] +[{foo: nil, foo: 1.0}] +[{foo: nil, foo: i}] +[{foo: nil, foo: str}] +[{foo: nil}] +[{foo: ok}?.foo] +[{foo: ok}] +[{foo: str}] +[{foo: true}] +abs($env | count(true)) +abs($env | sum(1)) +abs($env | sum(1.0)) +abs($env.f64) +abs($env.i) +abs($env?.f64) +abs($env?.i) +abs(0 * 1.0) +abs(0 ** f64) +abs(0 + 0) +abs(0 + 1.0) +abs(0 + i) +abs(0 - 1.0) +abs(0 - f64) +abs(0 - i) +abs(0 / 0) +abs(0 ^ 1.0) +abs(0 | mean(i, i)) +abs(0) * f64 +abs(0) - i +abs(0) / f64 +abs(0) in array +abs(0.1) +abs(1 % 1) +abs(1 % i) abs(1 * f64) -abs(1 * i32) -abs(1 ** 0.5) abs(1 ** 1) -abs(1 ** i) -abs(1 + 1) -abs(1 + i) -abs(1 + i64) -abs(1 - 0.5) +abs(1 ** 1.0) +abs(1 ** f64) +abs(1 + 0) abs(1 - 1) -abs(1 - i64) -abs(1 / 0.5) -abs(1 / 1) +abs(1 - 1.0) +abs(1 - f64) abs(1 / i) -abs(1 / i32) -abs(1 ^ f32) +abs(1 ^ 0) +abs(1 ^ 1) abs(1 ^ i) -abs(1 ^ i32) -abs(1) - i32 -abs(1) .. i -abs(1) / f64 -abs(1) / i64 -abs(1) < i64 -abs(1) <= i32 -abs(1) == i32 +abs(1 | max(array)) +abs(1) + f64 +abs(1) < f64 +abs(1) < i abs(1) >= i -abs(1) ^ f64 -abs(abs(0.5)) -abs(abs(1)) +abs(1) | mean(i) +abs(1.0 * 0) +abs(1.0 * 1) +abs(1.0 * 1.0) +abs(1.0 * i) +abs(1.0 ** 0) +abs(1.0 ** 1) +abs(1.0 ** 1.0) +abs(1.0 ** i) +abs(1.0 + 1) +abs(1.0 + 1.0) +abs(1.0 + f64) +abs(1.0 - 1) +abs(1.0 - 1.0) +abs(1.0 - i) +abs(1.0 / 0) +abs(1.0 / 1) +abs(1.0 / 1.0) +abs(1.0 ^ 0) +abs(1.0 ^ 1) +abs(1.0 ^ 1.0) +abs(1.0 ^ f64) +abs(1.0 ^ i) +abs(1.0 | mean(array)) +abs(1.0) != f64 +abs(1.0) * i +abs(1.0) ** f64 +abs(1.0) + count(list, false) +abs(1.0) - f64 +abs(1.0) / 0 in array +abs(1.0) / f64 +abs(1.0) <= reduce(array, #) +abs(1.0) == i +abs(1.0) ^ f64 > 0 +abs(1.0) ^ i +abs(1.0) in $env?.[String] +abs(1.0) in array +abs(abs(1.0)) abs(abs(f64)) -abs(abs(i32)) -abs(abs(i64)) -abs(add(i, 1)) -abs(bitand(i64, i32)) -abs(bitnand(i64, i)) +abs(add(1, 1)) +abs(array | count(true)) +abs(array | find(ok)) +abs(array | findLast(true)) +abs(array | reduce(#)) +abs(array | reduce(#acc)) +abs(array | reduce(#index)) +abs(array | reduce(0)) +abs(array | reduce(0, array)) +abs(array | reduce(1.0)) +abs(array | reduce(1.0, foo)) +abs(array?.[i]) +abs(bitnot(0)) abs(bitnot(1)) abs(bitnot(i)) -abs(bitnot(i32)) -abs(bitnot(i64)) -abs(bitushr(1, 1)) -abs(ceil(0.5)) +abs(bitor(0, 0)) +abs(ceil(0)) abs(ceil(1)) -abs(ceil(f32)) -abs(ceil(i)) -abs(ceil(i32)) -abs(ceil(i64)) -abs(count(array, ok)) -abs(count(array, true)) -abs(count(list, false)) -abs(div(i, i)) -abs(f32 * 0.5) -abs(f32 ** 1) -abs(f32 ** f32) -abs(f32 ** i32) -abs(f32 + 0.5) -abs(f32 + 1) -abs(f32 + i) -abs(f32 + i32) -abs(f32 - 0.5) -abs(f32 - 1) -abs(f32 - i32) -abs(f32 - i64) -abs(f32 / 0.5) -abs(f32 / 1) -abs(f32 / f32) -abs(f32 / f64) -abs(f32 / i32) -abs(f32 ^ i) -abs(f32 ^ i64) -abs(f32) -abs(f32) ** f32 -abs(f32) ** i -abs(f32) + i64 -abs(f32) - i32 -abs(f32) / f64 -abs(f32) < f64 -abs(f32) >= 0.5 / 1 -abs(f32) ^ f32 -abs(f64 * f32) +abs(count($env, false)) +abs(count($env, true)) +abs(f64 * 1) +abs(f64 * 1.0) abs(f64 * f64) +abs(f64 * i) +abs(f64 ** 0) abs(f64 ** 1) -abs(f64 + 0.5) -abs(f64 + 1) +abs(f64 ** 1.0) +abs(f64 + 0) +abs(f64 + 1.0) abs(f64 + f64) abs(f64 - 1) -abs(f64 - f32) -abs(f64 / 0.5) -abs(f64 / 1) +abs(f64 - i) abs(f64 / f64) -abs(f64 / i) -abs(f64 ^ 0.5) -abs(f64 ^ f32) +abs(f64 ^ 0) +abs(f64 ^ 1.0) abs(f64 ^ i) -abs(f64 ^ i64) abs(f64) -abs(f64) + f32 -abs(f64) + f64 -abs(f64) + i32 -abs(f64) + i64 / i -abs(f64) - i -abs(f64) < i32 -abs(f64) <= f64 -abs(f64) > i64 -abs(f64) ^ f32 -abs(f64) ^ i64 -abs(f64) in array -abs(false ? f32 : 1) -abs(false ? half : 0.5) -abs(false ? list : 1) -abs(find(array, ok)) -abs(find(array, true)) -abs(findIndex(list, ok)) -abs(findIndex(list, true)) -abs(findLastIndex(array, ok)) +abs(f64) != f64 +abs(f64) != i +abs(f64) + i +abs(f64) - f64 +abs(f64) / i +abs(findIndex($env, true)) abs(first(array)) -abs(float(0.5)) -abs(float(1)) -abs(float(f32)) +abs(float(0)) +abs(float(1.0)) abs(float(f64)) -abs(float(i)) -abs(float(i32)) -abs(floor(0.5)) -abs(floor(f32)) -abs(floor(i32)) -abs(get(array, 1)) -abs(get(array, i)) -abs(get(array, i32)) -abs(get(array, i64)) -abs(half(0.5)) -abs(half(1)) -abs(half(f64)) -abs(i * 1) -abs(i * f32) -abs(i ** 1) -abs(i ** f32) -abs(i ** i32) -abs(i + 0.5) -abs(i + f64) -abs(i - 0.5) -abs(i - 1) -abs(i - f32) -abs(i - f64) -abs(i - i32) -abs(i / 0.5) -abs(i / f64) +abs(floor(1)) +abs(floor(1.0)) +abs(i % i) +abs(i * 0) +abs(i * f64) +abs(i ** 0) +abs(i ** 1.0) +abs(i + 0) +abs(i + i) +abs(i - 1.0) +abs(i / 1.0) abs(i / i) -abs(i / i32) -abs(i / i64) -abs(i ^ 0.5) -abs(i ^ f64) -abs(i ^ i) -abs(i ^ i32) -abs(i ^ i64) +abs(i ^ 1.0) +abs(i | bitshl(0)) abs(i) -abs(i) % i -abs(i) * i32 -abs(i) ** f32 abs(i) + f64 -abs(i) - f32 -abs(i) .. i -abs(i) .. i32 -abs(i) / f32 -abs(i) < f64 -abs(i) <= i64 -abs(i) == 0.5 / i -abs(i) > i64 -abs(i) ^ f64 -abs(i) ^ half(1) abs(i) ^ i -abs(i) ^ i32 -abs(i32 % i32) -abs(i32 % i64) -abs(i32 * f64) -abs(i32 * i32) -abs(i32 ** 0.5) -abs(i32 ** 1) -abs(i32 ** i32) -abs(i32 + 0.5) -abs(i32 + 1) -abs(i32 + f64) -abs(i32 + i) -abs(i32 + i32) -abs(i32 - 0.5) -abs(i32 - i64) -abs(i32 / 0.5) -abs(i32 / i) -abs(i32 / i64) -abs(i32) -abs(i32) != f64 -abs(i32) * f32 -abs(i32) * i -abs(i32) ** i -abs(i32) - i32 -abs(i32) / -1 -abs(i32) / i32 ** f64 -abs(i32) < i64 == false -abs(i32) <= i -abs(i32) <= i32 -abs(i32) == i32 -abs(i32) ^ i64 -abs(i32) in array -abs(i64 * 0.5) -abs(i64 * f32) -abs(i64 * i32) -abs(i64 ** 0.5) -abs(i64 ** f64) -abs(i64 ** i64) -abs(i64 + 0.5) -abs(i64 + 1) -abs(i64 + f32) -abs(i64 + f64) -abs(i64 + i) -abs(i64 - 0.5) -abs(i64 - i) -abs(i64 / f32) -abs(i64 / i32) -abs(i64 ^ f64) -abs(i64 ^ i) -abs(i64 ^ i32) -abs(i64) -abs(i64) * i32 -abs(i64) ** i -abs(i64) + f32 -abs(i64) / i -abs(i64) > i32 -abs(i64) ^ i32 -abs(i64) not in array -abs(int(0.5)) +abs(i) not in array +abs(i) | bitshr(0) +abs(if false { array } else { 1 }) +abs(if false { array } else { i }) +abs(if true { i } else { i }) +abs(int(0)) abs(int(1)) +abs(int(1.0)) abs(int(i)) -abs(int(i32)) -abs(int(i64)) abs(last(array)) -abs(len("foo")) -abs(len(list)) -abs(max(0.5)) -abs(max(f32)) +abs(len($env)) +abs(len(str)) +abs(list | findIndex(ok)) +abs(list | findIndex(true)) +abs(list | reduce(1)) +abs(list | sum(1.0)) +abs(max(0)) +abs(max(1)) +abs(max(1.0)) +abs(max(array)) abs(max(f64)) -abs(max(i32)) -abs(max(i64)) +abs(max(f64, f64)) +abs(max(i)) +abs(mean(0)) +abs(mean(1)) +abs(mean(1.0)) abs(mean(array)) +abs(mean(f64)) +abs(mean(i)) +abs(median(0)) +abs(median(1)) +abs(median(1.0)) abs(median(array)) -abs(min(0.5)) -abs(min(1)) -abs(min(f32)) -abs(min(f64)) +abs(median(f64)) +abs(median(f64, array)) +abs(median(i)) +abs(min(0)) +abs(min(1.0)) +abs(min(array)) abs(min(i)) -abs(min(i32)) -abs(ok ? 1 : "foo") -abs(ok ? f32 : 0.5) -abs(ok ? f32 : nil) -abs(ok ? f64 : ok) -abs(ok ? i32 : foo) abs(reduce(array, #)) +abs(reduce(array, #, nil)) abs(reduce(array, i)) +abs(reduce(list, 0)) abs(reduce(list, 1)) -abs(reduce(list, i32)) -abs(round(0.5)) +abs(round(0)) abs(round(1)) -abs(round(f32)) -abs(round(i)) -abs(round(i64)) -abs(score(1)) -abs(score(i)) +abs(round(1.0)) +abs(sum($env, 1.0)) abs(sum(array)) -abs(true ? 1 : ok) +abs(sum(array, #)) +abs(sum(array, 0)) +abs(sum(array, f64)) +abs(sum(list, 1.0)) add +add != $env && $env?.ok +add != $env == $env +add != $env or ok +add != $env.add +add != $env?.Bar +add != $env?.String +add != $env?.[Bar] +add != $env?.[String] +add != $env?.[foobar?.[foobar]] +add != $env?.[foobar] +add != $env?.[str] +add != $env?.add +add != $env?.add ?: foo +add != $env?.foobar +add != $env?.foobar?.[array] add != add -add != add == nil -add != div -add != div != false -add != div == true -add != nil ? f64 : i64 -add != reduce(list, add) +add != nil && $env +add != nil ?: false +add != nil || true +add == $env ? 0 : 1 +add == $env ? array : ok +add == $env.add +add == $env?.Bar +add == $env?.Bar?.[str] +add == $env?.String +add == $env?.String?.ok() +add == $env?.[Bar] +add == $env?.[String] +add == $env?.[foobar] +add == $env?.[str] +add == $env?.add +add == $env?.foobar add == add -add == add != nil -add == add == nil -add == add ? 1 : i64 -add == div -add == div ? f64 : list -add == nil ? false : i32 -add == nil ? greet : i32 -add == nil ? nil : nil -add in sort(array) -add(1, i) < i -add(i, 1) ** f32 +add == last($env) +add == max($env) +add == nil != $env?.[Bar] +add == nil && $env[foobar:foobar] +add == nil || $env +add == nil || false +add in $env?.Bar +add in $env?.String +add in $env?.[Bar] +add in $env?.[String] +add in $env?.[String]?.add +add in $env?.[String]?.array +add in $env?.[foobar] +add in $env?.foobar +add in $env?.foobar?.str()?.greet +add in [$env, $env] +add in keys($env) +add in values($env) +add in {foo: add}?.add +add not in $env?.Bar +add not in $env?.String +add not in $env?.[Bar] +add not in $env?.[String] +add not in $env?.[foobar] +add not in $env?.foobar +add not in $env?.foobar == false +add not in $env?.foobar?.[str] +add not in $env?.true?.[greet] +add not in first($env) +add not in keys($env) +add not in reverse(list) +add not in {foo: 1}?.array +add($env.i, i) +add(0, 1) * f64 +add(i, 1) >= f64 > i +add(i, array?.[i]) add(i, i) -add(i, i32 + 1) -all(1 .. i64, ok) -all(["bar"], # >= #) -all(["foo"], # not matches #) -all([false], # && false) -all([false], #) -all(array, !(# >= f64)) -all(array, !ok) -all(array, !true) -all(array, "foo" < "bar") -all(array, # != #) -all(array, # != 1) -all(array, # != f32) -all(array, # != f64) -all(array, # != i32) -all(array, # != nil) +add(i, list | sum(i)) +add(min(0, i), i) +add(sum(array), i) +add; $env.array +add; add +add; greet +add; list +add; ok +add; {foo: f64} +all($env | filter(false), #[.ok:$env]) +all($env, true) and ok +all($env.array, 1 > #) +all($env.list, $env == #) +all($env?.list, nil == $env) +all([$env], ok) +all([list], 1.0 < 1.0) all(array, # < #) -all(array, # < 0.5) -all(array, # < 1) -all(array, # < f64) -all(array, # < i) -all(array, # < i64) all(array, # <= #) -all(array, # <= 0.5) -all(array, # <= i) -all(array, # == # + #) all(array, # == #) -all(array, # == 0.5) -all(array, # == 1) -all(array, # == f64) -all(array, # == i) -all(array, # == i32) -all(array, # == i64) +all(array, # == $env) +all(array, # == 0) all(array, # > #) -all(array, # > 0.5) -all(array, # > 1) -all(array, # > f64) -all(array, # > i) -all(array, # > i32) -all(array, # > i64) all(array, # >= #) -all(array, # >= 0.5) -all(array, # >= f32) -all(array, # >= f64) -all(array, # >= i32) -all(array, # >= i64) -all(array, # in array) -all(array, 0.5 != #) -all(array, 0.5 < #) -all(array, 0.5 < f32) -all(array, 0.5 <= #) -all(array, 0.5 <= f32) -all(array, 0.5 <= i) -all(array, 0.5 > f32) -all(array, 0.5 > f64) -all(array, 0.5 > i32) -all(array, 0.5 >= #) -all(array, 0.5 >= 0.5) -all(array, 0.5 in array) -all(array, 1 != #) -all(array, 1 != f32) -all(array, 1 < #) -all(array, 1 < f32) -all(array, 1 == #) -all(array, 1 > #) -all(array, 1 > i64) -all(array, 1 >= #) -all(array, 1 >= 1) -all(array, 1 >= i64) -all(array, f32 < #) -all(array, f32 <= #) -all(array, f32 <= f32) -all(array, f32 > i) -all(array, f32 >= #) -all(array, f64 != #) -all(array, f64 <= #) -all(array, f64 <= f32) -all(array, f64 == #) -all(array, f64 == 0.5) -all(array, f64 == i64) -all(array, f64 >= i64) -all(array, false && true) -all(array, false ? 1 : true) -all(array, i != 0.5) -all(array, i <= 0.5) -all(array, i <= f32) -all(array, i <= i32) -all(array, i == #) -all(array, i32 != #) -all(array, i32 != i64) -all(array, i32 < i) -all(array, i32 >= #) -all(array, i64 != #) -all(array, i64 != i64) -all(array, i64 == i32) -all(array, i64 > #) -all(array, i64 > 0.5) -all(array, i64 >= #) -all(array, nil != "bar") -all(array, nil != #) -all(array, nil != list) -all(array, nil != ok) -all(array, nil == "foo") -all(array, nil == i32) -all(array, nil == list) -all(array, none(list, true)) -all(array, not false) -all(array, not true) +all(array, $env != #) +all(array, $env == #) +all(array, 1.0 > 0) +all(array, i >= 1) +all(array, list | one(true)) +all(array, nil != nil) +all(array, nil == true) all(array, ok) -all(false ? add : "bar", ok) -all(filter(array, true), ok) -all(groupBy(array, f32).score, 0.5 in #?.f64) -all(groupBy(list, #).i, #?.half() not in # + #) -all(i32 .. 1, ok) -all(list, !false) -all(list, "bar" in #) -all(list, "bar" not in #) -all(list, "foo" > "foo") +all(array, ok) || $env?.Bar +all(array, str == nil) +all(array, str startsWith str) +all(array, true or $env) +all(list | map(true), #) all(list, # != #) -all(list, # != nil) -all(list, # == # || f64 != i64) -all(list, # == #) -all(list, # == foo) all(list, # in list) -all(list, # not in list) -all(list, 0.5 < f64) -all(list, 0.5 < i64) -all(list, 0.5 <= i64) -all(list, 0.5 >= i) -all(list, 0.5 >= i32) -all(list, 1 != 1) -all(list, 1 <= 1) -all(list, 1 > i32) -all(list, 1 >= f64) -all(list, add == div) -all(list, all(array, ok)) -all(list, div != nil) -all(list, f64 != 0.5) -all(list, f64 != f32) -all(list, f64 < i32) -all(list, f64 > i64) -all(list, false ? i : true) -all(list, i < f32) -all(list, i <= 1) -all(list, i <= i32) -all(list, i > f64) -all(list, i > i32) -all(list, i >= 1) -all(list, i32 < 1) -all(list, i32 <= 0.5) -all(list, i32 == f32) -all(list, i64 != nil) -all(list, i64 <= 0.5) -all(list, i64 > 1) -all(list, list != nil) -all(list, nil != 1) -all(list, nil != i64) -all(list, nil != nil) -all(list, nil != score) -all(list, nil == #) -all(list, nil == score) -all(list, nil in array) -all(list, none(array, 1 > #)) -all(list, not true) +all(list, #.Bar >= str) +all(list, $env != 0) +all(list, 0 < 1.0) +all(list, array | any(ok)) +all(list, f64 <= 1.0) +all(list, foo == #) +all(list, nil == nil) +all(list, nil not in $env) all(list, ok) -all(list, reduce(array, true)) -all(list, type(i) not endsWith .Bar) -all(map(array, #), ok && false) -all(map(array, #), ok) -all(map(array, f32), !ok) -all(map(array, false), #) -all(map(array, score), # != #) -all(map(array, score), ok) -all(map(list, "bar" not in #), #) -all(map(list, 0.5), 0.5 <= #) -all(map(list, i), # == 0.5) -all(map(list, list), 1 == 0.5) -all(map(list, ok), #) -all(reduce(array, array), # > #) -all(reduce(array, list), ok) -all(true ? list : false, not true) -any(["bar"], # not endsWith #) -any([greet], ok) -any(array, !(i32 <= #)) -any(array, "foo" >= "foo") -any(array, "foo" not endsWith "bar") -any(array, # != # or # > #) +all(list, true and ok) +all(sort($env), #) +all(sort($env), .f64 | reduce(#, foo)) +all(sort($env), .f64) +all(sort($env), .ok?.array) +all(sort($env), 1.0 >= #) +all(sort($env), sortBy(#, ok)) +all(toPairs($env), ok) +any($env, ok) || $env == foo +any($env, true) || $env?.[str] +any($env.list, ok) +any($env?.[str], true and true) +any($env?.array, # == #) +any($env?.list, ok) any(array, # != #) -any(array, # != 0.5) -any(array, # != f32) -any(array, # != f64) -any(array, # != i32) -any(array, # != i64) -any(array, # != nil) -any(array, # < #) -any(array, # < 0.5) -any(array, # < 1) -any(array, # < f32) -any(array, # < f64) -any(array, # < i) -any(array, # < i32) +any(array, # != $env) +any(array, # < 0) any(array, # <= #) -any(array, # <= 0.5) -any(array, # <= 1) -any(array, # <= f32) -any(array, # <= i) -any(array, # <= i32) -any(array, # <= i64) -any(array, # == #) -any(array, # == 0.5) -any(array, # == 1) -any(array, # == i32) -any(array, # == i64) -any(array, # > #) -any(array, # > 0.5) -any(array, # > 1) -any(array, # > f64) -any(array, # > i32) -any(array, # >= #) -any(array, # >= 0.5) -any(array, # >= 1) -any(array, # >= f32) -any(array, # >= i32) -any(array, # >= i64) -any(array, # in array) -any(array, 0.5 != #) -any(array, 0.5 == #) -any(array, 0.5 == i32) -any(array, 0.5 > #) -any(array, 0.5 > f64) -any(array, 0.5 >= #) -any(array, 1 != i64) -any(array, 1 < #) -any(array, 1 < 0.5) -any(array, 1 <= #) -any(array, 1 == #) -any(array, 1 > #) -any(array, 1 > 1) -any(array, 1 >= #) -any(array, 1 >= f64) -any(array, all(list, false)) -any(array, f32 < i) -any(array, f32 > #) -any(array, f32 > 0.5) -any(array, f32 >= #) -any(array, f64 != #) -any(array, f64 < i) -any(array, f64 <= #) -any(array, f64 == #) -any(array, f64 > #) -any(array, f64 > 0.5) -any(array, false && false) -any(array, greet == greet) +any(array, $env != #) +any(array, $env != add) +any(array, $env | all(true)) +any(array, $env?.ok) +any(array, 0 == #) +any(array, 1 == 1.0) +any(array, array == array) +any(array, foo == nil) any(array, i != #) -any(array, i < #) -any(array, i > #) -any(array, i >= #) -any(array, i32 > i64) -any(array, i64 < #) -any(array, i64 == f64) -any(array, i64 >= #) -any(array, nil != #) -any(array, nil != 1) -any(array, nil != i) -any(array, nil != ok) -any(array, nil == "foo") -any(array, nil == #) -any(array, nil == 1) -any(array, ok != true) +any(array, i <= i) +any(array, ok != ok) +any(array, ok or $env) any(array, ok) -any(array, one(array, # <= 0.5)) -any(array, one(array, ok)) -any(array, score == nil) -any(i32 .. i, half == half) -any(list, !ok) -any(list, !true) -any(list, "bar" < "foo") -any(list, "bar" not in #) -any(list, "bar" not startsWith "foo") -any(list, "foo" not in foo) +any(array, str >= str) +any(keys($env), ok) any(list, # != #) any(list, # == #) -any(list, # == foo) -any(list, # == nil) -any(list, 0.5 != 1) -any(list, 0.5 < 1) -any(list, 0.5 < f64) -any(list, 0.5 == i64) -any(list, 1 >= f64) -any(list, 1 >= i32) -any(list, any(list, false)) -any(list, any(list, ok)) -any(list, array == nil) -any(list, f32 < 1) -any(list, f32 <= i64) -any(list, f32 > 1) -any(list, f32 > i64) -any(list, f32 >= i32) -any(list, f64 != i64) -any(list, f64 >= 1) -any(list, false) == (foo not in list) -any(list, false) || false ? nil : add -any(list, i > i64) -any(list, i >= 0.5) -any(list, i32 != 0.5) -any(list, i64 <= 1) -any(list, i64 == 0.5) -any(list, i64 == i) -any(list, i64 >= i32) -any(list, i64 not in array) -any(list, nil == false) +any(list, # in list) +any(list, $env != false) +any(list, $env && false) +any(list, $env == 1.0) +any(list, $env == list) +any(list, $env == str) +any(list, $env?.ok) +any(list, i ^ i == 1.0) +any(list, list != array) +any(list, nil != 1) any(list, nil == nil) -any(list, none(array, false)) -any(list, not ok) -any(list, ok || # == #) any(list, ok) -any(list, reduce(list, true)) -any(list, true ? false : f64) -any(map(array, #), # >= #) -any(map(array, #), ok) -any(map(array, false), #) -any(map(array, ok), # and #) -any(map(array, ok), #) -any(map(list, #), nil == #) -any(map(list, false), nil == i32) -any(map(list, ok), #) -any(ok ? "foo" : 1, ok) -any(ok ? "foo" : f32, i > #) -any(reduce(array, array), 1 == #) +any(map(array, add), ok) +any(sortBy(list, i), ok) +any(values($env), # != 1.0) array +array != $env && false +array != $env == false +array != $env == ok +array != $env and $env +array != $env and $env?.[Bar] +array != $env or true +array != $env.array +array != $env.list +array != $env?.Bar +array != $env?.Bar?.i +array != $env?.String +array != $env?.String?.foo() +array != $env?.[Bar] +array != $env?.[String] +array != $env?.[String]?.[greet] +array != $env?.[str] +array != $env?.array +array != $env?.foobar +array != $env?.list +array != [1.0 + f64] +array != [f64] +array != [foo] array != array -array != array ? 1 : false -array != array ? score : i32 +array != array && true +array != array or ok +array != flatten(array) array != list -array != list ? list : f64 -array != map(array, #) -array != map(array, 1) +array != list != false +array != list && 1.0 > 0 +array != list || ok +array != map($env, 1.0) array != map(list, #) -array != map(list, true) -array != nil ? add : 0.5 +array != map(list, 1.0) +array != min($env) +array != nil == $env +array != nil ? list : greet +array != nil and ok +array != values($env) +array != {foo: $env}?.str +array == $env != ok +array == $env && false +array == $env and $env +array == $env.array +array == $env.list +array == $env?.Bar +array == $env?.String +array == $env?.[Bar] +array == $env?.[String] +array == $env?.[foobar] +array == $env?.[str] +array == $env?.array +array == $env?.foobar +array == $env?.list +array == [1.0] +array == [1] +array == [foo] +array == [nil] +array == [ok, 1.0] +array == [str] array == array -array == array ? half : false +array == array != ok +array == keys($env) array == list -array == map(array, score) -array == map(list, #) -array == nil ? list : float(f32) -array not in sort(array) -array[-i32] -array[-i64] -array[-i] -array[1 % i64] -array[1 + 1] -array[1] * i32 -array[1] * i64 -array[1] - f64 -array[1] / i32 -array[1] == -i -array[1] > i -array[1] ^ i -array[abs(1)] -array[array[i32]] -array[bitnot(1)] -array[bitor(1, i)] -array[count(list, ok)] -array[get(array, 1)] -array[i32 * 1] -array[i32:i] -array[i32] -array[i32] != i -array[i32] % i32 -array[i32] * f64 -array[i32] ** i32 -array[i32] + i64 -array[i32] - f64 -array[i32] / f32 -array[i32] == i32 -array[i32] == i64 -array[i32] > f64 -array[i32] >= f32 -array[i64:i64] -array[i64] -array[i64] .. i32 -array[i64] == floor(0.5) -array[i64] == i -array[i64] > half(f64) -array[i64] ^ f64 -array[i:i32] -array[i:i64] -array[i] -array[i] * f64 -array[i] + f32 -array[i] - f32 -array[i] / f64 -array[i] < round(i) -array[i] == i32 -array[i] > f64 -array[i] >= 0.5 ** i -array[max(1)] -array[reduce(list, 1)] -array[score(1):i] -array[score(1)] -array[score(i)] -bitand(1 * i64, i) -bitand(1, 1) != i -bitand(1, i64) == f64 +array == list != false +array == list[:] +array == map(array, #) +array == max($env)?.greet +array == min(array) +array == nil && $env +array in $env?.Bar +array in $env?.String +array in $env?.String?.array +array in $env?.[Bar] +array in $env?.[String] +array in $env?.[String]?.[greet] +array in $env?.[foobar]?.[i] +array in $env?.foobar +array in [array] +array in [f64, list] +array in [list] +array in [str, $env] +array in flatten(array) +array in last($env) +array in reverse(list) +array in uniq(array) +array not in $env?.Bar +array not in $env?.String +array not in $env?.[Bar] +array not in $env?.[String] +array not in $env?.[String]?.f64 +array not in $env?.[String]?.list +array not in $env?.[foobar?.String] +array not in $env?.[foobar] +array not in $env?.foobar +array not in [array] +array not in map(array, array) +array not in toPairs($env) +array not in uniq(array) +array not in {foo: foo}.add +array | all(# != nil) +array | all(# == f64) +array | all(# >= i) +array | all($env == #) +array | all($env == foo) +array | all(0 < 1.0) +array | all(0 == #) +array | all(false) +array | all(foo == foo) +array | all(i != f64) +array | all(i > #) +array | all(ok) +array | all(true && true) +array | all(true) +array | any(# < #) +array | any(# <= #) +array | any(# == $env.i) +array | any($env != #) +array | any($env == foo) +array | any($env?.ok) +array | any(1 < #) +array | any(1.0 <= 1) +array | any(false) +array | any(i <= #) +array | any(ok ?: nil) +array | any(ok) +array | any(true) +array | concat(array) +array | concat(array) | find(ok) +array | concat(list) +array | count(# != #) +array | count(# != $env) +array | count(# != nil) +array | count(# <= 0) +array | count($env != foo) +array | count($env == #) +array | count($env == array) +array | count($env?.ok) +array | count(0 <= #) +array | count(1.0 == #) +array | count(false) +array | count(i >= #) +array | count(ok) +array | count(true) +array | count(true) ** i +array | filter(# < 1.0) +array | filter(# <= #) +array | filter(# <= f64) +array | filter($env == #) +array | filter($env == i) +array | filter($env.ok) +array | filter(1 != #) +array | filter(false) +array | filter(false) | sortBy(#) +array | filter(foo != foo) +array | filter(nil == #) +array | filter(nil == foo) +array | filter(ok) +array | filter(ok) | sum(1) +array | filter(true) +array | filter(true) | groupBy(#) +array | find(# >= 1.0) +array | find($env != $env) +array | find($env not in list) +array | find(0 < 1) +array | find(1.0 < #) +array | find(1.0 == 0) +array | find(false) +array | find(foo in list) +array | find(ok) +array | find(true) +array | find(true) >= float(f64) +array | findIndex(# != 0) +array | findIndex(# == #) +array | findIndex(# > f64) +array | findIndex(# >= 1.0) +array | findIndex($env != false) +array | findIndex($env?.ok) +array | findIndex(1.0 < 1.0) +array | findIndex(1.0 <= #) +array | findIndex(f64 == $env) +array | findIndex(f64 >= 1.0) +array | findIndex(false and false) +array | findIndex(false) +array | findIndex(i != $env) +array | findIndex(ok) +array | findIndex(true) +array | findIndex(true) + i +array | findLast(# > #) +array | findLast(1.0 < #) +array | findLast(1.0 >= i) +array | findLast(f64 >= #) +array | findLast(false) +array | findLast(greet != nil) +array | findLast(nil != #) +array | findLast(nil not in $env) +array | findLast(ok) +array | findLast(true ?: add) +array | findLast(true) +array | findLastIndex(# != $env) +array | findLastIndex(# < #) +array | findLastIndex(# <= #) +array | findLastIndex($env | any(false)) +array | findLastIndex(0 <= 0) +array | findLastIndex(1 <= i) +array | findLastIndex(1.0 <= #) +array | findLastIndex(1.0 <= 1.0) +array | findLastIndex(false ?: ok) +array | findLastIndex(false) +array | findLastIndex(foo in list) +array | findLastIndex(ok) +array | findLastIndex(ok) < f64 +array | findLastIndex(true) +array | findLastIndex(true) - i +array | get(0) +array | get(1) +array | get(i) +array | groupBy(# != #) +array | groupBy(# - #) +array | groupBy(# / 1.0) +array | groupBy(# == #) +array | groupBy(# > #) +array | groupBy(# >= #) +array | groupBy(# ^ #) +array | groupBy(#) +array | groupBy($env != 0) +array | groupBy($env && false) +array | groupBy($env.foo) +array | groupBy($env?.[str]) +array | groupBy($env?.foo) +array | groupBy($env?.str) +array | groupBy(0 ** 1.0) +array | groupBy(0) +array | groupBy(1) +array | groupBy(1.0 != #) +array | groupBy(1.0 ** 1) +array | groupBy(1.0 ** f64) +array | groupBy(1.0) +array | groupBy(f64) +array | groupBy(false != false) +array | groupBy(false) +array | groupBy(foo) +array | groupBy(foo.Bar) +array | groupBy(i) +array | groupBy(list?.[i]) +array | groupBy(ok) +array | groupBy(round(#)) +array | groupBy(round(1.0)) +array | groupBy(str) +array | groupBy(string(1)) +array | groupBy(trimPrefix(str)) +array | groupBy(true) +array | map(# != 0) +array | map(# ** i) +array | map(# - #) +array | map(# .. #index) +array | map(# > #) +array | map(# >= #) +array | map(# >= i) +array | map(# ^ #) +array | map(#) +array | map(#) | any(ok) +array | map(#) | map(1.0) +array | map(#) | one(ok) +array | map(#) | one(true) +array | map(#) | reduce(#) +array | map(#) | reduce(ok) +array | map(#) | sum(1.0) +array | map(#) | take(0) +array | map(#index % i) +array | map(#index - 1.0) +array | map(#index) +array | map(#index) | map(false) +array | map($env != str) +array | map($env) +array | map($env) | any(.ok) +array | map($env.list) +array | map($env.ok) +array | map($env?.Bar) +array | map($env?.list) +array | map(0) +array | map(0) | reduce(#) +array | map(0) | sum(#) +array | map(0) | sum(f64) +array | map(1 >= 1) +array | map(1) +array | map(1) | find(ok) +array | map(1) | groupBy(#) +array | map(1) | reduce($env, array) +array | map(1.0 + #index) +array | map(1.0 - 1.0) +array | map(1.0 <= #) +array | map(1.0 > #) +array | map(1.0) +array | map(1.0) | map(0) +array | map(1.0) | reduce(foo) +array | map(1.0) | sortBy(#) +array | map([#]) +array | map([$env]) +array | map(add(#, #)) +array | map(add) +array | map(array) +array | map(array) == array +array | map(array) | any(false) +array | map(f64 ^ #) +array | map(f64) +array | map(f64) | one(array == $env) +array | map(f64) | sortBy(i) +array | map(false) +array | map(false) != list +array | map(false) | none(#) +array | map(foo) +array | map(foo) != array +array | map(foo) | map(#) +array | map(foo) | reduce(#) +array | map(foo) | reduce(1.0) +array | map(foo?.Bar) +array | map(greet) +array | map(greet) | groupBy(true) +array | map(i <= 1) +array | map(i) +array | map(i) | filter(ok) +array | map(i) | groupBy(f64) +array | map(if false { 0 } else { foo }) +array | map(let foobar = greet; foobar) +array | map(list) +array | map(mean(#)) +array | map(median(#)) +array | map(nil == greet) +array | map(ok) +array | map(ok) | any(#) +array | map(ok) | groupBy(ok) +array | map(str) +array | map(str) | groupBy(#) +array | map(str) | map(#) +array | map(toJSON(f64)) +array | map(true) +array | map(true) | reduce(foo) +array | max(0) +array | max(0, 1) +array | max(0, 1.0) +array | max(1) +array | max(1, 0) +array | max(1, 1.0) +array | max(1.0) +array | max(array) +array | max(f64) +array | max(f64, 1.0) +array | max(f64, f64) +array | max(i) +array | max(i, i) +array | max(map($env, #index)) +array | mean(0 / 1) +array | mean(0) +array | mean(0, 1.0, array) +array | mean(1) +array | mean(1, 0) +array | mean(1.0) +array | mean(1.0, 1) +array | mean(1.0, 1.0) +array | mean(array) +array | mean(array, 0) <= i +array | mean(array, array) +array | mean(f64) +array | mean(f64, 1) +array | mean(i) +array | mean(i, f64) +array | median($env.array) +array | median($env?.array) +array | median(0) +array | median(1 - 1.0) +array | median(1) +array | median(1.0) +array | median(1.0, 1.0) +array | median(1.0, f64) +array | median([array]) +array | median(array) +array | median(f64) +array | median(i) +array | min(0) +array | min(0, array) +array | min(0, f64) +array | min(1) +array | min(1.0) +array | min(array) +array | min(f64) +array | min(i) +array | min(i, i) +array | none(# != $env) +array | none(# != 1) +array | none(# < #) +array | none(# == #) +array | none(# == $env) +array | none(# == nil) +array | none($env != 1.0) +array | none($env.ok) +array | none(1.0 < #) +array | none(1.0 > #) +array | none(false) +array | none(ok) +array | none(true == $env) +array | none(true) +array | one(# == #) +array | one(# > #) +array | one(# > 1.0) +array | one(# not in array) +array | one($env != $env) +array | one($env != foo) +array | one($env.ok) +array | one(false) +array | one(i == nil) +array | one(nil == 1) +array | one(nil == foo) +array | one(ok) +array | one(true) +array | reduce(# != #) +array | reduce(# * #) +array | reduce(# + #) +array | reduce(# - f64) +array | reduce(# > #index) +array | reduce(#) +array | reduce(#, $env) +array | reduce(#, 0) +array | reduce(#, 1) +array | reduce(#, 1.0) +array | reduce(#, add) +array | reduce(#, array) +array | reduce(#, f64) +array | reduce(#, false) +array | reduce(#, foo) +array | reduce(#, greet) +array | reduce(#, i) +array | reduce(#, list) +array | reduce(#, nil) +array | reduce(#, ok) +array | reduce(#, str) +array | reduce(#, true) +array | reduce(#acc) +array | reduce(#acc) == greet +array | reduce(#acc, 0) +array | reduce(#acc, 1.0) in [str, foo] +array | reduce(#acc, add) +array | reduce(#acc, array) +array | reduce(#acc, foo) +array | reduce(#acc, greet) +array | reduce(#acc, i) +array | reduce(#acc, nil) +array | reduce(#index) +array | reduce(#index, false) +array | reduce(#index, foo) +array | reduce(#index, i) +array | reduce(#index, list) +array | reduce(#index, ok) +array | reduce(#index, str) +array | reduce($env != array) +array | reduce($env) +array | reduce($env) | findLastIndex(true) +array | reduce($env) | reduce($env, nil) +array | reduce($env, $env) +array | reduce($env, 0) +array | reduce($env, 1) +array | reduce($env, 1.0) +array | reduce($env, add) +array | reduce($env, array) +array | reduce($env, f64) +array | reduce($env, false) +array | reduce($env, foo) +array | reduce($env, greet) +array | reduce($env, list) +array | reduce($env, nil) +array | reduce($env, ok) +array | reduce($env.ok) +array | reduce($env?.Bar) +array | reduce($env?.[Bar]) +array | reduce($env?.[String]?.foo()) +array | reduce($env?.list, foo?.String) +array | reduce(0 + i) +array | reduce(0 .. #) +array | reduce(0 == #) +array | reduce(0) +array | reduce(0, 0) +array | reduce(0, 1.0) +array | reduce(0, foo) +array | reduce(0, i) +array | reduce(0, list) +array | reduce(0, true) +array | reduce(1) +array | reduce(1, 0) +array | reduce(1, 1.0) +array | reduce(1, add) +array | reduce(1, false) +array | reduce(1, foo) +array | reduce(1, nil) +array | reduce(1, ok) +array | reduce(1, str) +array | reduce(1.0 * 1) +array | reduce(1.0 > 1.0) +array | reduce(1.0) +array | reduce(1.0) != f64 +array | reduce(1.0) / f64 +array | reduce(1.0) < i <= f64 +array | reduce(1.0, $env) +array | reduce(1.0, 0) +array | reduce(1.0, 1) +array | reduce(1.0, 1.0) +array | reduce(1.0, array) +array | reduce(1.0, f64) +array | reduce(1.0, false) +array | reduce(1.0, foo) +array | reduce(1.0, list) +array | reduce(1.0, nil) +array | reduce(1.0, ok) +array | reduce(1.0, true) +array | reduce(add) +array | reduce(add, $env) +array | reduce(add, 0) +array | reduce(add, 1.0) +array | reduce(add, array) +array | reduce(add, f64) +array | reduce(add, false) +array | reduce(add, list) +array | reduce(add, nil) +array | reduce(add, ok) +array | reduce(add, str) +array | reduce(array) +array | reduce(array) | reduce(false) +array | reduce(array, $env) +array | reduce(array, 0) +array | reduce(array, 1.0) +array | reduce(array, f64) +array | reduce(array, foo) +array | reduce(array, greet) +array | reduce(array, list) +array | reduce(array, nil) +array | reduce(array, ok) +array | reduce(f64) +array | reduce(f64, 0) +array | reduce(f64, 1) +array | reduce(f64, 1.0) +array | reduce(f64, array) +array | reduce(f64, f64) +array | reduce(f64, false) +array | reduce(f64, foo) +array | reduce(f64, i) +array | reduce(f64, list) +array | reduce(f64, nil) +array | reduce(f64, true) +array | reduce(false) +array | reduce(false, $env) +array | reduce(false, 1) +array | reduce(false, 1.0) +array | reduce(false, add) +array | reduce(false, false) +array | reduce(false, foo) +array | reduce(false, i) +array | reduce(false, list) +array | reduce(false, nil) +array | reduce(false, true) +array | reduce(foo) +array | reduce(foo, $env) +array | reduce(foo, 0) +array | reduce(foo, 1) +array | reduce(foo, 1.0) +array | reduce(foo, add) +array | reduce(foo, array) +array | reduce(foo, f64) +array | reduce(foo, foo) +array | reduce(foo, i) +array | reduce(foo, list) +array | reduce(foo, nil) +array | reduce(foo, ok) +array | reduce(foo, str) +array | reduce(foo, true) +array | reduce(greet) +array | reduce(greet, 1.0) +array | reduce(greet, array) +array | reduce(greet, false) +array | reduce(greet, foo) +array | reduce(greet, greet) +array | reduce(greet, i) +array | reduce(greet, str) +array | reduce(greet, true) +array | reduce(i > 1) +array | reduce(i) +array | reduce(i, $env) +array | reduce(i, 0) +array | reduce(i, 1) +array | reduce(i, 1.0) +array | reduce(i, false) +array | reduce(i, foo) +array | reduce(i, list) +array | reduce(i, nil) +array | reduce(i, ok) +array | reduce(list) +array | reduce(list, $env) +array | reduce(list, 0) +array | reduce(list, 1.0) +array | reduce(list, foo) +array | reduce(list, i) +array | reduce(list, list) +array | reduce(list, nil) +array | reduce(list, ok) +array | reduce(list, ok) | all(true) +array | reduce(list, true) +array | reduce(median(0)) +array | reduce(nil != #) +array | reduce(ok) +array | reduce(ok, $env) +array | reduce(ok, 0) +array | reduce(ok, 1.0) +array | reduce(ok, add) +array | reduce(ok, false) +array | reduce(ok, foo) +array | reduce(ok, greet) +array | reduce(ok, list) +array | reduce(ok, nil) +array | reduce(ok, true) +array | reduce(str) +array | reduce(str) | greet() +array | reduce(str, $env) +array | reduce(str, 1) +array | reduce(str, 1.0) +array | reduce(str, abs(1)) +array | reduce(str, add) +array | reduce(str, foo) +array | reduce(str, greet) +array | reduce(str, i) +array | reduce(str, list) +array | reduce(str, nil) +array | reduce(string(add)) +array | reduce(true and true) +array | reduce(true) +array | reduce(true, $env) +array | reduce(true, 1) +array | reduce(true, 1.0) +array | reduce(true, array) +array | reduce(true, foo) +array | reduce(true, i) +array | reduce(true, nil) +array | reduce(true, ok) +array | reduce(true, true) +array | sortBy(# + #) +array | sortBy(# + i) +array | sortBy(# / #) +array | sortBy(# ^ 1.0) +array | sortBy(# ^ f64) +array | sortBy(#) +array | sortBy(#) | all(ok) +array | sortBy(#) | map(#) +array | sortBy(#) | map(foo) +array | sortBy($env?.[str]) +array | sortBy($env?.i) +array | sortBy(0 ^ #) +array | sortBy(0) +array | sortBy(0) | median(1.0) +array | sortBy(1) +array | sortBy(1.0) +array | sortBy(1.0) != list +array | sortBy(1.0) | one(true) +array | sortBy(1.0) | sortBy(#) +array | sortBy(array | reduce(1.0)) +array | sortBy(array?.[i]) +array | sortBy(bitnot(i)) +array | sortBy(f64) +array | sortBy(f64) | map(#) +array | sortBy(f64) | sortBy(1.0) +array | sortBy(f64) | sortBy(i) +array | sortBy(floor(#)) +array | sortBy(foo.String()) +array | sortBy(i) +array | sortBy(i) | sortBy(#) +array | sortBy(reduce(array, str, foo)) +array | sortBy(str + str) +array | sortBy(str) +array | sum(# ** #) +array | sum(# - #) +array | sum(# ^ 1) +array | sum(# ^ i) +array | sum(#) +array | sum(#) < 1.0 ^ 1.0 +array | sum(0) +array | sum(0.1) +array | sum(1 + 1.0) +array | sum(1) +array | sum(1.0 * #) +array | sum(1.0 ** #) +array | sum(1.0 - 1.0) +array | sum(1.0) +array | sum(bitshl(#, #)) +array | sum(f64) +array | sum(float(f64)) +array | sum(i + 0) +array | sum(i) +array | sum(int(#)) +array | sum(max(#, 1)) +array | sum(median(#)) +array | sum(round(1.0)) +array | take(0) +array | take(1) +array | take(i) +array; $env.ok +array; add +array; array +array; foo.String +array; greet +array; i +array; list +array?.[$env.i] +array?.[$env?.i] +array?.[0 % i] +array?.[1] % i +array?.[1] .. i +array?.[1] / f64 +array?.[array?.[i]] +array?.[bitnot(i)] +array?.[i] +array?.[i] != 1.0 ?: 1.0 +array?.[i] != f64 +array?.[i] != i * 1.0 +array?.[i] * i +array?.[i] ** i +array?.[i] - f64 +array?.[i] - i +array?.[i] .. i +array?.[i] / i +array?.[i] < 0 + 1.0 +array?.[i] < f64 +array?.[i] <= f64 +array?.[i] == f64 +array?.[i] > f64 +array?.[i] >= f64 +array?.[i] >= i +array?.[i] ^ f64 +array?.[i] ^ i +array?.[i] not in array +array?.[i] | add(i) +array?.[i] | bitshr(0) +array?.[i] | min(0) +array?.[int(1.0)] +array?.[len(list)] +array?.[list | count(ok)] +array?.[mean(1)] +array?.[mean(i)] +array?.[median(1)] +array[$env?.i:] +array[0:] | reduce(#) +array[0:] | reduce(str) +array[0:] | sortBy(#) +array[0:]?.[i] +array[1:] == list +array[1:] | any(ok) +array[1:] | findLast(false) +array[1:] | reduce(foo) +array[1:] | sum(#) +array[1:]?.[i] +array[:$env.i] +array[:0] | sortBy(#) +array[:0] | sum(str) +array[:1] | findLastIndex(false) +array[:1] | sum(#) +array[:] +array[:] | reduce(f64) +array[:]?.[i] +array[:i] +array[:i] | map(f64) +array[:i] | reduce($env) +array[:i] | sortBy(array) +array[:int(1.0)] +array[:reduce(array, 1)] +array[array?.[i]:] +array[bitnot(1):] +array[i % 1:] +array[i:] +array[i:] | findIndex(false) +array[i:] | groupBy(1) +array[len($env):] +array[sum(array):] +bitand(1, i) * i +bitand(i, 0) + f64 bitand(i, i) -bitand(i, i32) -bitand(i, i64) -bitand(i32, 1) != f32 -bitand(i32, i) -bitand(i32, i) - i32 -bitand(i32, i32 * i) -bitand(i32, i32) -bitand(i32, i64) -bitand(i64, 1) <= i32 -bitand(i64, i + i64) -bitand(i64, i) -bitand(i64, i) ^ f64 -bitand(i64, i32) -bitand(i64, i64) -bitand(int(i32), i64) -bitnand(1, i64) != int(i64) +bitand(i, sum(array)) +bitnand($env.i, i) bitnand(i, i) -bitnand(i, i32 + i32) -bitnand(i, i32) -bitnand(i, i64) -bitnand(i32, bitnot(1)) -bitnand(i32, i) -bitnand(i32, i32) -bitnand(i32, i64) -bitnand(i64 + i, i32) -bitnand(i64 + i64, i64) -bitnand(i64, -1) -bitnand(i64, 1) + i64 + 1 -bitnand(i64, i) -bitnand(i64, i32) -bitnand(i64, i32) > f64 -bitnand(i64, i64) -bitnot(-1) -bitnot(-i) -bitnot(-i32) -bitnot(-i64) -bitnot(1 % 1) -bitnot(1 % i32) -bitnot(1 % i64) -bitnot(1 * 1) -bitnot(1 * i64) -bitnot(1 + 1) +bitnot($env | findIndex(true)) +bitnot($env | findLastIndex(ok)) +bitnot($env.i) +bitnot($env?.[str]?.[i]) +bitnot($env?.i) +bitnot(0 * 1) +bitnot(0 * i) +bitnot(0 - 0) +bitnot(0 - 1) +bitnot(0 | min(0)) +bitnot(0) < f64 +bitnot(0) == $env?.[Bar] +bitnot(0) in array +bitnot(0) | min(array, 0) +bitnot(1 % i) +bitnot(1 * 0) bitnot(1 - i) -bitnot(1 - i32) -bitnot(1) * i % 1 -bitnot(1) ** f32 -bitnot(1) ** i -bitnot(1) + i32 -bitnot(1) - i -bitnot(1) - i32 -bitnot(1) / min(i) -bitnot(1) < i32 -bitnot(1) < i64 -bitnot(1) == i32 -bitnot(1) > f64 -bitnot(1) >= i -bitnot(1) >= i64 -bitnot(abs(1)) -bitnot(abs(i32)) -bitnot(abs(i64)) -bitnot(array[1]) -bitnot(array[i64]) -bitnot(array[i]) +bitnot(1 | min(i)) +bitnot(1) != i && false +bitnot(1) == f64 +bitnot(abs(i)) +bitnot(array | count(false)) +bitnot(array | count(ok)) +bitnot(array | sum(#)) +bitnot(array | sum(i)) +bitnot(array?.[0]) +bitnot(array?.[i]) +bitnot(bitand(1, 0)) +bitnot(bitnot(0)) +bitnot(bitnot(1)) bitnot(bitnot(i)) -bitnot(bitushr(1, 1)) -bitnot(bitushr(i32, 1)) -bitnot(bitxor(i, i64)) bitnot(count(array, false)) -bitnot(findLast(array, ok)) +bitnot(count(list, ok)) +bitnot(false ? nil : 1) +bitnot(false ?: 1) +bitnot(findIndex($env, ok)) +bitnot(findIndex(array, ok)) +bitnot(findLastIndex(array, true)) bitnot(first(array)) -bitnot(get(array, 1)) -bitnot(get(array, i)) -bitnot(i % i64) -bitnot(i * i) -bitnot(i * i32) -bitnot(i + 1) -bitnot(i - 1) -bitnot(i - i64) +bitnot(i % i) +bitnot(i * 0) +bitnot(i * 1) +bitnot(i + 0) +bitnot(i | add(i)) +bitnot(i | min(1.0)) bitnot(i) -bitnot(i) % i32 -bitnot(i) * i -bitnot(i) + f64 -bitnot(i) .. i64 -bitnot(i) == 1 - i -bitnot(i) > i -bitnot(i) >= i32 -bitnot(i) ^ f32 -bitnot(i) ^ f64 -bitnot(i) in array -bitnot(i32 % 1) -bitnot(i32 % i64) -bitnot(i32 + i) -bitnot(i32 + i32) -bitnot(i32 - 1) -bitnot(i32 - i32) -bitnot(i32) -bitnot(i32) != f64 -bitnot(i32) != i32 -bitnot(i32) * i -bitnot(i32) * i64 -bitnot(i32) ** f32 -bitnot(i32) - i32 -bitnot(i32) / f64 -bitnot(i32) == i64 -bitnot(i32) > 1 != true -bitnot(i32) >= f32 -bitnot(i64 % 1) -bitnot(i64 % i) -bitnot(i64 % i32) -bitnot(i64 * 1) -bitnot(i64 * i) -bitnot(i64 * i32) -bitnot(i64 * i64) -bitnot(i64 - 1) -bitnot(i64 - i) -bitnot(i64 - i64) -bitnot(i64) -bitnot(i64) % i32 -bitnot(i64) * f32 -bitnot(i64) < f32 -bitnot(i64) > f64 -bitnot(i64) > i % i -bitnot(i64) >= i32 ^ f32 -bitnot(i64) ^ f64 -bitnot(i64) not in array -bitnot(int(f32)) +bitnot(i) + i +bitnot(i) - i +bitnot(if false { f64 } else { 0 }) +bitnot(if true { 1 } else { foo }) +bitnot(int(1)) +bitnot(int(1.0)) bitnot(int(f64)) -bitnot(int(i)) -bitnot(int(i32)) -bitnot(int(i64)) bitnot(last(array)) -bitnot(len("bar")) -bitnot(len("foo")) -bitnot(len(list)) +bitnot(len($env)) +bitnot(len(array)) +bitnot(len(str)) +bitnot(list | findLastIndex(ok)) +bitnot(list | findLastIndex(true)) +bitnot(max(0)) bitnot(max(1)) -bitnot(max(1, i64)) +bitnot(max(1, 0)) +bitnot(max(array, 0)) bitnot(max(i)) -bitnot(max(i32)) -bitnot(min(1)) -bitnot(min(i32)) -bitnot(min(i64)) -bitnot(ok ? 1 : array) -bitnot(ok ? 1 : ok) -bitnot(ok ? i : add) +bitnot(min(0)) +bitnot(min(array)) +bitnot(min(i)) +bitnot(min(i, 0)) bitnot(reduce(array, #)) -bitnot(reduce(array, 1)) -bitnot(reduce(list, 1)) -bitnot(score(1)) -bitnot(score(i)) +bitnot(reduce(array, 0)) +bitnot(reduce(list, i)) bitnot(sum(array)) -bitor(1, 1) < i -bitor(1, 1) == i -bitor(1, i32) != i64 -bitor(i, -i64) +bitnot(sum(array, #)) +bitnot(sum(list, 0)) +bitor($env.i, i) +bitor(i, array?.[i]) bitor(i, i) -bitor(i, i64) -bitor(i32, i) -bitor(i32, i32) -bitor(i32, i64) -bitor(i64 % 1, i32) -bitor(i64, i) -bitor(i64, i32) -bitor(i64, i64) -bitor(min(i64), i) -bitor(score(i), i64) -bitshl(bitnot(i), i) +bitor(i, len(list)) +bitshl(i, $env?.i) bitshl(i, i) -bitshl(i, i32) -bitshl(i, i64) -bitshl(i32, i) -bitshl(i32, i32) -bitshl(i32, i64) -bitshl(i64, i32) -bitshl(i64, i64) -bitshl(len(array), i) -bitshl(score(i), i32) -bitshr(i % 1, i32) -bitshr(i, 1) - i64 -bitshr(i, i32) -bitshr(i, i64) -bitshr(i32, i) -bitshr(i32, i) - f32 -bitshr(i32, i32) -bitshr(i32, i64) -bitshr(i64, i32) -bitshr(i64, i64) -bitushr(-i64, i64) -bitushr(1 % i, i) -bitushr(1, i) * i -bitushr(abs(1), i32) +bitshr(i, $env?.i) +bitshr(i, i) +bitshr(i, sum(array)) bitushr(i, i) -bitushr(i, i) % i64 -bitushr(i, i32) -bitushr(i, i64) -bitushr(i32, i) -bitushr(i32, i32) -bitushr(i32, i64) -bitushr(i64, i) -bitushr(i64, i32) -bitushr(i64, i64) -bitxor(-i, i64) -bitxor(1, i) * i -bitxor(bitnot(1), -i) -bitxor(i, i32) -bitxor(i, i64) -bitxor(i32, 1) > i64 -bitxor(i32, i) -bitxor(i32, i) ** f64 -bitxor(i32, i32) -bitxor(i32, i64) -bitxor(i32, i64) ** i32 -bitxor(i64, i) -bitxor(i64, i32) -bitxor(i64, i64) -bitxor(score(1), i) -ceil(-0.5) -ceil(-1) -ceil(-f32) -ceil(-f64) -ceil(-i) -ceil(-i32) -ceil(-i64) -ceil(0.5 * 0.5) -ceil(0.5 * 1) -ceil(0.5 * f64) -ceil(0.5 * i) -ceil(0.5 ** 1) -ceil(0.5 ** f64) -ceil(0.5 ** i) -ceil(0.5 + 0.5) -ceil(0.5 + 1) -ceil(0.5 + f32) -ceil(0.5 + f64) -ceil(0.5 + i) -ceil(0.5 + i32) -ceil(0.5 + i64) -ceil(0.5 - 0.5) -ceil(0.5 - f64) -ceil(0.5 - i) -ceil(0.5 / 0.5) -ceil(0.5 / 1) -ceil(0.5 / f32) -ceil(0.5 / i) -ceil(0.5 / i32) -ceil(0.5 ^ 1) -ceil(0.5 ^ f32) -ceil(0.5 ^ i32) -ceil(0.5 ^ i64) -ceil(0.5) != 0.5 * 0.5 -ceil(0.5) != i -ceil(0.5) != nil ? score : "foo" -ceil(0.5) ** round(f32) -ceil(0.5) - i -ceil(0.5) < i -ceil(0.5) == f32 -ceil(0.5) == i ? div : half -ceil(0.5) == i64 -ceil(0.5) > f64 -ceil(0.5) >= i -ceil(0.5) >= i64 -ceil(0.5) ^ i64 -ceil(1 % i64) -ceil(1 * 0.5) -ceil(1 * 1) -ceil(1 ** 1) -ceil(1 + 0.5) -ceil(1 + 1) +bitxor(i, i) +ceil($env | sum(0)) +ceil($env | sum(f64)) +ceil($env | sum(i)) +ceil($env.f64) +ceil($env.i) +ceil($env?.[str] | sum(1.0)) +ceil($env?.array | findLast(ok)) +ceil($env?.f64) +ceil($env?.i) +ceil($env?.i) < f64 +ceil(0 * 1) +ceil(0 * 1.0) +ceil(0 ** 1) +ceil(0 ** 1.0) +ceil(0 ** f64) +ceil(0 + 1) +ceil(0 + 1.0) +ceil(0 + i) +ceil(0 - 0) +ceil(0 - 1.0) +ceil(0 - i) +ceil(0 / 1) +ceil(0 / 1.0) +ceil(0 ^ 0) +ceil(0 ^ 1.0) +ceil(0 ^ f64) +ceil(0 ^ i) +ceil(0 | add(i)) +ceil(0 | bitshl(i)) +ceil(0 | median(1.0)) +ceil(0) != f64 +ceil(0) <= f64 +ceil(0.0) +ceil(1 % 1) +ceil(1 * f64) +ceil(1 ** 1.0) +ceil(1 ** f64) ceil(1 + f64) ceil(1 + i) -ceil(1 - 0.5) -ceil(1 - f64) -ceil(1 / 0.5) -ceil(1 / 1) -ceil(1 / f64) -ceil(1 / i64) -ceil(1 ^ f64) -ceil(1 ^ i) -ceil(1 ^ i64) -ceil(1) ** f32 -ceil(1) + i32 -ceil(1) / i -ceil(1) < f32 ^ i -ceil(1) <= f32 -ceil(1) <= i64 -ceil(1) == f32 -ceil(1) > f32 -ceil(1) >= f32 -ceil(1) >= i64 ** 0.5 +ceil(1 - 1.0) +ceil(1 ^ 1.0) +ceil(1 | bitor(0)) +ceil(1) != i +ceil(1) > f64 ceil(1) ^ i -ceil(abs(0.5)) -ceil(abs(1)) -ceil(abs(f32)) +ceil(1) | median(1.0, 1) +ceil(1) | min(array) +ceil(1.0 * 0) +ceil(1.0 * 1) +ceil(1.0 * 1.0) +ceil(1.0 * i) +ceil(1.0 ** i) +ceil(1.0 + 0) +ceil(1.0 + 1) +ceil(1.0 + 1.0) +ceil(1.0 + i) +ceil(1.0 - 0) +ceil(1.0 - 1) +ceil(1.0 - 1.0) +ceil(1.0 - f64) +ceil(1.0 - i) +ceil(1.0 / 1) +ceil(1.0 / 1.0) +ceil(1.0 / f64) +ceil(1.0 ^ 0) +ceil(1.0 ^ 1.0) +ceil(1.0 ^ f64) +ceil(1.0 | min(1)) +ceil(1.0) == nil ? foo : str +ceil(1.0) >= f64 +ceil(1.0) not in array +ceil(1.0) | mean(1) +ceil(abs(0)) ceil(abs(f64)) -ceil(abs(i32)) -ceil(abs(i64)) -ceil(add(1, 1)) -ceil(array[1]) -ceil(array[i64]) -ceil(array[i]) +ceil(abs(i)) +ceil(array?.[i]) +ceil(bitnot(0)) ceil(bitnot(1)) -ceil(bitnot(i)) -ceil(ceil(0.5)) +ceil(ceil(0)) +ceil(ceil(1)) +ceil(ceil(1.0)) ceil(ceil(f64)) -ceil(ceil(i)) -ceil(ceil(i32)) -ceil(count(list, ok)) -ceil(f32 * 0.5) -ceil(f32 * i) -ceil(f32 * i32) -ceil(f32 ** i) -ceil(f32 ** i32) -ceil(f32 + 1) -ceil(f32 + i64) -ceil(f32 - f32) -ceil(f32 - i) -ceil(f32 - i32) -ceil(f32 - i64) -ceil(f32 / 0.5) -ceil(f32 / f64) -ceil(f32 / i32) -ceil(f32 ^ 0.5) -ceil(f32 ^ 1) -ceil(f32 ^ i64) -ceil(f32) -ceil(f32) != i64 -ceil(f32) * i64 -ceil(f32) ** -1 -ceil(f32) ** i -ceil(f32) + i -ceil(f32) + i64 -ceil(f32) - i32 -ceil(f32) / i64 -ceil(f32) < i -ceil(f32) < i32 -ceil(f64 * 1) -ceil(f64 * i) +ceil(count($env, false)) +ceil(f64 * 0) +ceil(f64 ** 0) +ceil(f64 ** 1) +ceil(f64 ** 1.0) ceil(f64 ** i) -ceil(f64 ** i64) -ceil(f64 + 1) -ceil(f64 + f32) -ceil(f64 - 0.5) -ceil(f64 - f32) -ceil(f64 - f64) -ceil(f64 - i32) -ceil(f64 / 0.5) +ceil(f64 + 1.0) +ceil(f64 + f64) +ceil(f64 - 1) +ceil(f64 / 1) +ceil(f64 / 1.0) ceil(f64 / f64) -ceil(f64 / i32) -ceil(f64 / i64) -ceil(f64 ^ 0.5) -ceil(f64 ^ f32) -ceil(f64 ^ f64) -ceil(f64 ^ i32) -ceil(f64 ^ i64) +ceil(f64 / i) +ceil(f64 ^ 1.0) +ceil(f64 ^ i) +ceil(f64 | min(1.0)) ceil(f64) ceil(f64) != i -ceil(f64) != i64 -ceil(f64) * f32 -ceil(f64) ** f32 -ceil(f64) - i32 -ceil(f64) / f64 -ceil(f64) / i / i64 -ceil(f64) in array -ceil(false ? add : 0.5) -ceil(find(array, ok)) -ceil(findLast(array, true)) -ceil(findLastIndex(list, ok)) -ceil(findLastIndex(list, true)) +ceil(f64) * f64 +ceil(f64) * i +ceil(f64) == f64 +ceil(f64) == i +ceil(f64) ^ i +ceil(f64) | median(1.0, i, i) +ceil(false ?: 0) +ceil(false ?: 1) +ceil(findIndex($env, true)) +ceil(findIndex(array, true)) +ceil(findLastIndex($env, true)) ceil(first(array)) -ceil(float(0.5)) -ceil(float(1)) +ceil(float(1.0)) ceil(float(f64)) ceil(float(i)) -ceil(float(i32)) -ceil(float(i64)) -ceil(floor(0.5)) +ceil(floor(0)) ceil(floor(1)) +ceil(floor(1.0)) ceil(floor(f64)) ceil(floor(i)) -ceil(floor(i32)) -ceil(floor(i64)) -ceil(get(array, 1)) -ceil(get(array, i)) -ceil(half(0.5)) -ceil(half(1)) -ceil(half(f64)) ceil(i % i) -ceil(i * 0.5) -ceil(i * i) -ceil(i ** f64) -ceil(i ** i) -ceil(i + 0.5) +ceil(i * 1) +ceil(i * 1.0) +ceil(i ** 0) +ceil(i ** 1) +ceil(i ** 1.0) ceil(i + 1) -ceil(i + f32) -ceil(i + i64) +ceil(i + i) +ceil(i - 0) +ceil(i - 1.0) ceil(i - i) -ceil(i / f32) +ceil(i / 1) +ceil(i / 1.0) +ceil(i / f64) ceil(i / i) -ceil(i / i64) +ceil(i ^ 0) +ceil(i ^ f64) ceil(i ^ i) -ceil(i ^ i32) +ceil(i | min(0)) +ceil(i | min(1.0)) ceil(i) -ceil(i) != i32 -ceil(i) * f64 -ceil(i) * i64 -ceil(i) ** f64 -ceil(i) + i -ceil(i) - f32 -ceil(i) / f32 -ceil(i) <= f64 -ceil(i) == i32 -ceil(i) > i64 -ceil(i32 * i) -ceil(i32 * i32) -ceil(i32 ** i32) -ceil(i32 + 0.5) -ceil(i32 + i32) -ceil(i32 - 0.5) -ceil(i32 - 1) -ceil(i32 - i) -ceil(i32 - i64) -ceil(i32 / 0.5) -ceil(i32 / f32) -ceil(i32 / i) -ceil(i32 / i32) -ceil(i32 ^ 0.5) -ceil(i32 ^ i64) -ceil(i32) -ceil(i32) * 1 ^ i32 -ceil(i32) * i32 -ceil(i32) ** max(i) -ceil(i32) + f32 -ceil(i32) + i -ceil(i32) + i32 -ceil(i32) <= i64 -ceil(i32) not in array -ceil(i64 % 1) -ceil(i64 % i32) -ceil(i64 * f32) -ceil(i64 * f64) -ceil(i64 ** i32) -ceil(i64 ** i64) -ceil(i64 + 0.5) -ceil(i64 + f64) -ceil(i64 + i32) -ceil(i64 - 0.5) -ceil(i64 - f64) -ceil(i64 / 0.5) -ceil(i64 / 1) -ceil(i64 / f64) -ceil(i64 ^ 0.5) -ceil(i64 ^ i) -ceil(i64 ^ i32) -ceil(i64 ^ i64) -ceil(i64) -ceil(i64) - -1 -ceil(i64) - f32 -ceil(i64) - i32 -ceil(i64) / (0.5 - f32) -ceil(i64) >= f32 -ceil(i64) ^ i32 -ceil(int(0.5)) -ceil(int(f32)) +ceil(i) != 0 ?: 1.0 +ceil(i) == i +ceil(i) > i +ceil(i) >= f64 +ceil(if false { false } else { f64 }) +ceil(if true { 1.0 } else { 1.0 }) +ceil(if true { 1.0 } else { f64 }) +ceil(if true { i } else { foo }) +ceil(indexOf(str, str)) +ceil(int(0)) +ceil(int(1)) +ceil(int(1.0)) ceil(int(f64)) ceil(int(i)) -ceil(int(i64)) -ceil(len("bar")) +ceil(last(array)) +ceil(len($env)) ceil(len(array)) ceil(len(list)) -ceil(max(1, i)) -ceil(max(f32, 0.5)) +ceil(len(str)) +ceil(let foobar = 1.0; foobar) +ceil(list | reduce(0)) +ceil(list | reduce(0, 1.0)) +ceil(list | reduce(f64)) +ceil(list | sum(i)) +ceil(max(0)) +ceil(max(1)) +ceil(max(1.0)) +ceil(max(array)) ceil(max(f64)) ceil(max(i)) +ceil(mean(1)) +ceil(mean(1.0 ^ 1.0)) +ceil(mean(1.0)) ceil(mean(array)) +ceil(mean(f64)) +ceil(mean(f64, 1)) +ceil(mean(i)) +ceil(mean(i, i, 0)) +ceil(median(0)) +ceil(median(1.0)) +ceil(median(1.0, 0)) +ceil(median(1.0, i)) ceil(median(array)) -ceil(min(0.5, f32)) +ceil(median(f64)) +ceil(median(i)) +ceil(median(i, 1.0)) +ceil(min(0)) ceil(min(1)) -ceil(min(f32)) +ceil(min(1.0)) +ceil(min(1.0, f64)) +ceil(min(1.0, i)) +ceil(min(array)) ceil(min(f64)) -ceil(min(i)) -ceil(min(i64)) -ceil(ok ? f32 : nil) -ceil(ok ? i32 : "bar") -ceil(ok ? i32 : i64) ceil(reduce(array, #)) -ceil(reduce(array, 0.5)) -ceil(reduce(list, 1)) -ceil(round(0.5)) -ceil(round(1)) -ceil(round(f32)) -ceil(round(f64)) +ceil(reduce(array, #acc)) +ceil(reduce(array, 1.0)) +ceil(reduce(list, 0)) +ceil(round(0)) +ceil(round(1.0)) ceil(round(i)) -ceil(round(i32)) -ceil(round(i64)) -ceil(score(1)) -ceil(score(i)) -ceil(true ? 1 : half) -ceil(true ? 1 : nil) -ceil(true ? f64 : nil) -count(["bar", score, i], 1 != #) -count(["bar"], # startsWith #) -count([0.5], ok) -count([greet], ok) -count([i32], f32 != #) -count([list, 0.5], # not in list) -count([nil], ok) -count(array, !ok) -count(array, !true) -count(array, "bar" <= "bar") -count(array, "bar" not endsWith "bar") -count(array, "foo" matches "foo") -count(array, # != #) -count(array, # != 0.5) +ceil(sum(array)) +ceil(sum(list, 1.0)) +concat($env | map(1.0)) +concat($env | map(1.0))[:i] +concat($env | map(add)) +concat($env | map(array)) +concat($env | map(foo)) +concat($env.array) +concat($env.list) +concat($env?.array) +concat($env?.list) +concat(0 .. i) +concat(1 .. 0) +concat(1 .. 1) +concat(1..i) +concat([$env, 1]) +concat([$env, nil]) +concat([$env]) +concat([0]) +concat([1, foo]) +concat([1.0 - 1.0]) +concat([1.0, $env]) +concat([1.0]) +concat([1]) +concat([array]) +concat([f64, foo]) +concat([false, $env]) +concat([false]) +concat([foo, array]) +concat([foo]) +concat([greet, 0]) +concat([greet]) +concat([i, 1.0]) +concat([list]) +concat([nil]) +concat([ok, $env]) +concat([ok]) +concat([str]) +concat([true]) +concat([true], array) +concat(array | map(#)) +concat(array | map(foo)) +concat(array | sortBy(#)) +concat(array | sortBy(f64)) +concat(array | sortBy(i)) +concat(array | take(0)) +concat(array) +concat(array) | groupBy(1.0) +concat(array) | map(list) +concat(array) | reduce(#) +concat(array) | reduce(str) +concat(array) | sortBy(f64) +concat(array)?.[i] +concat(array, [greet]) +concat(array, array) +concat(array, array)?.[i] +concat(array, list) +concat(array[0:]) +concat(array[:1]) +concat(array[:]) +concat(array[i:]) +concat(concat(array)) +concat(concat(array, array)) +concat(false ?: array) +concat(false ?: list) +concat(filter($env, false)) +concat(flatten(array)) +concat(flatten(list)) +concat(keys($env)) +concat(list | filter(ok)) +concat(list | map(#)) +concat(list | map(1)) +concat(list | map(1.0)) +concat(list) +concat(list) | count(false) +concat(list) | groupBy(#) +concat(list) | groupBy(1.0) +concat(list) | map(0) +concat(list) | map(add) +concat(list) | map(foo) +concat(list) | none(ok) +concat(list) | reduce(#) +concat(list) | reduce(1.0, foo) +concat(list) | reduce(i, str) +concat(list) | sum(1) +concat(list) | sum(i) +concat(list)?.[i] +concat(list, array) +concat(list, list | sortBy(i)) +concat(list, list) +concat(list, list) | any(true) +concat(map($env, #index)) +concat(map($env, $env)) +concat(map($env, array), list) +concat(map($env, foo)) +concat(map(array, #)) +concat(map(array, $env)) +concat(map(array, 1)) +concat(map(array, 1.0)) +concat(map(array, f64)) +concat(map(list, #)) +concat(map(list, $env)) +concat(map(list, 0)) +concat(map(list, 1.0)) +concat(map(list, greet)) +concat(map(list, i)) +concat(reduce(list, array)) +concat(reverse(array)) +concat(reverse(list)) +concat(sort($env)) +concat(sort(array)) +concat(sortBy(array, #)) +concat(toPairs($env)) +concat(toPairs({foo: false, foo: add})) +concat(uniq(array)) +concat(values($env)) +count($env | filter(false)) +count($env | map(foo), ok) +count($env | map(ok)) +count($env | map(true)) +count($env, false) ^ i +count($env, true) ** i +count($env.list, foo != foo) +count($env.list, ok) +count($env?.[str], true != nil) +count($env?.array, ok) +count($env?.list, ok) +count(1 .. 0) +count([$env && false]) +count([false, false]) +count([false]) +count([false], #) +count([ok]) +count([true]) +count(array | map(false)) +count(array | map(ok)) count(array, # != i) -count(array, # != i64) -count(array, # != nil) -count(array, # < #) -count(array, # < i) -count(array, # < i32) -count(array, # <= #) -count(array, # <= 0.5) -count(array, # <= 1) -count(array, # <= i) -count(array, # <= i32) -count(array, # == #) -count(array, # == 0.5) -count(array, # == 1) -count(array, # == f32) -count(array, # == i) -count(array, # == i64) -count(array, # == nil) count(array, # > #) -count(array, # > 0.5) -count(array, # > i) -count(array, # > i64) -count(array, # >= #) -count(array, # >= 0.5) -count(array, # >= 1) -count(array, # >= f32) count(array, # >= i) -count(array, # in array) count(array, # not in array) -count(array, 0.5 != #) -count(array, 0.5 < #) -count(array, 0.5 <= #) -count(array, 0.5 <= f32) -count(array, 0.5 <= f64) -count(array, 0.5 == #) -count(array, 0.5 == f32) -count(array, 0.5 == i) -count(array, 0.5 > #) -count(array, 1 != #) -count(array, 1 != 0.5) -count(array, 1 < #) -count(array, 1 <= #) -count(array, 1 == #) -count(array, 1 >= #) -count(array, any(array, true)) -count(array, div(#, 1) >= #) -count(array, f32 <= #) -count(array, f32 == #) -count(array, f64 < #) -count(array, f64 < f32) -count(array, f64 <= #) -count(array, f64 <= 1) -count(array, f64 == #) -count(array, false) ** i32 -count(array, false) + f32 -count(array, false) - i64 -count(array, false) / f64 -count(array, false) > i64 * i64 +count(array, $env != #) +count(array, $env.ok) +count(array, $env?.false != nil and ok) +count(array, 1 != nil) +count(array, 1.0 != #) +count(array, array | none(true)) +count(array, false and $env) +count(array, false) <= 1 ^ i +count(array, false) ^ f64 count(array, foo in list) -count(array, foo not in list) -count(array, i != #) -count(array, i < #) -count(array, i < 0.5) -count(array, i <= #) -count(array, i == #) -count(array, i > i64) count(array, i >= #) -count(array, i32 != #) -count(array, i32 != i) -count(array, i32 < #) -count(array, i32 < 1) -count(array, i32 <= #) -count(array, i32 <= f32) -count(array, i32 == #) -count(array, i32 == 0.5) -count(array, i32 > #) -count(array, i32 >= #) -count(array, i32 >= f32) -count(array, i32 >= i32) -count(array, i64 != i32) -count(array, i64 != i64) -count(array, i64 < #) -count(array, i64 <= #) -count(array, i64 == #) -count(array, i64 == i64) -count(array, i64 > 1) -count(array, list != array) -count(array, list != nil) -count(array, nil != "foo") -count(array, nil != f64) -count(array, nil == 1) -count(array, nil == list) -count(array, nil == nil) -count(array, none(array, false)) -count(array, not false) -count(array, ok or false) +count(array, nil == $env) count(array, ok) -count(array, ok) * i32 -count(array, ok) ^ i -count(array, reduce(list, false)) -count(array, true == ok) -count(array, true) / f64 -count(filter(list, true), ok) -count(groupBy(list, #).String, .div?.array) -count(i .. 1, # == i) -count(i .. i, ok) -count(i32 .. i, # >= #) -count(i64 .. 1, nil != f32) -count(list, !false) -count(list, !true) -count(list, "bar" not matches "bar") -count(list, "foo" in #) -count(list, # != #) -count(list, # == #) -count(list, # == nil) -count(list, # in list) -count(list, 0.5 < f32) -count(list, 0.5 <= 0.5) -count(list, 0.5 <= i64) -count(list, 0.5 > 0.5) -count(list, 0.5 > 1) -count(list, 0.5 > f32) -count(list, 1 != i) -count(list, 1 >= 0.5) -count(list, 1 >= f32) -count(list, f32 == i64) -count(list, f32 >= f32) -count(list, false && false) -count(list, false) + -1 -count(list, false) / f64 -count(list, false) > f32 -count(list, foo == #) -count(list, i != i64) -count(list, i < 0.5) -count(list, i <= i64) -count(list, i > 1) -count(list, i32 < f32) -count(list, i32 < i64) -count(list, i64 not in array) -count(list, nil != #) -count(list, nil != false) -count(list, nil == list) -count(list, not false) +count(array, ok) ^ f64 +count(array, true) in array +count(array[:0]) +count(filter($env, false)) +count(filter(list, # != #)) +count(i .. 0) +count(list | filter(false)) +count(list | map(false)) +count(list | map(true)) +count(list, # != foo) +count(list, # != nil) +count(list, #.Bar == nil) +count(list, $env == $env) +count(list, $env in array) +count(list, 0 != nil) +count(list, 0 <= f64) +count(list, 0 == i) +count(list, 1 < i) +count(list, 1.0 < 1.0) +count(list, [#] | all(true)) +count(list, add == $env) +count(list, f64 == nil) +count(list, foo != $env) +count(list, nil != 1.0) +count(list, nil != true) count(list, ok) -count(list, ok) % i64 -count(list, ok) / half(1) -count(list, ok) / i -count(list, ok) >= i32 -count(list, ok) ^ i -count(list, ok) ^ i64 -count(list, true or ok) -count(list, true || true) -count(list, true) * f32 -count(list, true) == i -count(map(array, #), # == i32) -count(map(array, #), not true) -count(map(array, #), ok) -count(map(array, false), #) -count(map(array, i), ok) -count(map(array, i32), 1 == #) -count(map(array, i64), f64 != nil) -count(map(array, ok), !#) -count(map(list, 0.5), "bar" == "foo") -count(map(list, div), ok) -count(map(list, f32), # == #) -count(map(list, greet), ok) -count(map(list, i32), # != i64) -count(map(list, ok), #) -count(map(list, ok), 0.5 <= i64) -count(ok ? array : i64, # > 0.5) -count(sort(array), 1 <= #) -div -div != add -div != add != nil -div != add == ok -div != div -div != div != ok -div != div && ok -div != div ? "bar" : "foo" -div != nil == ok -div != nil || f32 < 0.5 -div != reduce(array, div) -div == add -div == add ? 1 : ok -div == div -div == nil ? f32 : half -div == nil ? false : 1 -div(-i, array[i64]) -div(-i, i) -div(1, i) + i -div(findLast(array, true), i) -div(i, -1) -div(i, i) -div(last(array), 1 * i32) -div(score(1), bitnot(1)) -f32 -f32 != -0.5 -f32 != -1 -f32 != -f32 -f32 != 0.5 != false -f32 != 0.5 * 1 -f32 != 0.5 * i64 -f32 != 0.5 ** f32 -f32 != 0.5 + 1 -f32 != 0.5 - i64 -f32 != 0.5 / 0.5 -f32 != 0.5 / i32 -f32 != 0.5 == ok -f32 != 0.5 == true -f32 != 0.5 ? array : score -f32 != 0.5 ? foo : f64 -f32 != 0.5 ? true : i32 -f32 != 0.5 ^ 1 -f32 != 0.5 ^ f32 -f32 != 1 && ok -f32 != 1 * i -f32 != 1 + i64 -f32 != f32 -f32 != f32 / 0.5 -f32 != f32 / f32 -f32 != f64 -f32 != findLast(array, ok) -f32 != findLastIndex(array, ok) -f32 != floor(0.5) -f32 != half(0.5) -f32 != i -f32 != i != true -f32 != i % 1 -f32 != i % i -f32 != i ** i64 -f32 != i / f64 -f32 != i32 -f32 != i32 % i -f32 != i32 * i32 -f32 != i32 + 0.5 -f32 != i64 -f32 != i64 != nil -f32 != i64 != true -f32 != i64 ? 0.5 : f64 -f32 != i64 ^ i32 -f32 != int(f32) -f32 != int(i32) -f32 != len(array) -f32 != nil ? true : score -f32 != nil || ok -f32 != round(i) -f32 != score(1) -f32 != score(1, i) -f32 * (0.5 + f64) -f32 * (0.5 + i32) -f32 * (0.5 - f32) -f32 * (f64 + f64) -f32 * (f64 + i64) -f32 * (f64 - i) -f32 * -0.5 -f32 * -1 -f32 * -f64 -f32 * -i -f32 * -i64 -f32 * -len(array) -f32 * 0.5 * 0.5 -f32 * 0.5 * i -f32 * 0.5 * i32 -f32 * 0.5 - i32 -f32 * 0.5 / i -f32 * 0.5 <= i -f32 * 0.5 ^ f32 -f32 * 0.5 not in array -f32 * 1 != f32 -f32 * 1 * f64 -f32 * 1 * i32 -f32 * 1 ** 0.5 -f32 * 1 + f64 -f32 * 1 < i64 -f32 * 1 >= i64 -f32 * 1 ^ i64 -f32 * ceil(i) -f32 * f32 -f32 * f32 * 0.5 -f32 * f32 < i32 -f32 * f32 <= i64 -f32 * f32 > f32 - 1 -f32 * f32 ^ 0.5 -f32 * f32 in array -f32 * f64 -f32 * f64 + f64 -f32 * f64 + i32 -f32 * f64 / i64 -f32 * f64 >= 1 - i -f32 * float(i) -f32 * float(i32) -f32 * floor(0.5) -f32 * floor(i) -f32 * half(0.5) -f32 * half(1) -f32 * half(f64) -f32 * i -f32 * i != i32 -f32 * i - i -f32 * i / f64 -f32 * i == i64 -f32 * i32 -f32 * i32 != max(i) -f32 * i32 * i32 -f32 * i32 ** 0.5 -f32 * i32 >= i -f32 * i64 -f32 * i64 != f64 -f32 * i64 ** i -f32 * int(i64) -f32 * min(i64) -f32 * reduce(array, 1) -f32 * reduce(list, 1) -f32 * round(f64) -f32 ** (0.5 + 0.5) -f32 ** (0.5 - 1) -f32 ** (0.5 / f32) -f32 ** (1 / f64) -f32 ** (f32 - 0.5) -f32 ** (f64 - i64) -f32 ** (i % 1) -f32 ** (i64 * i32) -f32 ** (i64 + 0.5) -f32 ** (i64 - 1) -f32 ** -0.5 -f32 ** -f32 -f32 ** -f64 -f32 ** -i -f32 ** 0.5 != f32 -f32 ** 0.5 + f32 -f32 ** 0.5 >= -i64 -f32 ** 0.5 ^ (f32 / f64) -f32 ** 0.5 ^ i64 -f32 ** 1 + i64 -f32 ** 1 / i -f32 ** 1 < f64 -f32 ** 1 < i64 -f32 ** 1 <= i64 -f32 ** ceil(i64) -f32 ** f32 -f32 ** f32 * f32 -f32 ** f32 ** f32 -f32 ** f32 < f64 -f32 ** f32 ^ f32 -f32 ** f32 ^ f64 -f32 ** f64 -f32 ** f64 ** 1 -f32 ** f64 <= f64 -f32 ** f64 >= i -f32 ** float(f32) -f32 ** float(f64) -f32 ** half(0.5) -f32 ** half(1) -f32 ** i -f32 ** i != half(1) -f32 ** i ** f64 -f32 ** i ** i32 -f32 ** i <= i64 -f32 ** i32 -f32 ** i32 / i32 -f32 ** i32 == f64 -f32 ** i32 ^ f32 -f32 ** i64 -f32 ** i64 / f32 -f32 ** i64 == i32 -f32 ** i64 > i32 -f32 ** int(f64) -f32 ** len("foo") -f32 ** max(f32) -f32 ** max(i32) -f32 ** median(array) -f32 ** reduce(array, 0.5) -f32 ** round(f64) -f32 + -0.5 -f32 + -1 -f32 + -f32 -f32 + -i -f32 + 0.5 ** f32 -f32 + 0.5 + i32 -f32 + 0.5 - i -f32 + 0.5 - i32 -f32 + 0.5 / f32 -f32 + 0.5 == i -f32 + 0.5 > i64 -f32 + 0.5 ^ 0.5 -f32 + 1 * 0.5 -f32 + 1 * 1 -f32 + 1 + i -f32 + 1 - f64 -f32 + 1 - i64 -f32 + 1 / f64 -f32 + 1 < f32 -f32 + 1 < i -f32 + 1 >= ceil(0.5) -f32 + bitnot(i64) -f32 + ceil(-1) -f32 + ceil(1) -f32 + ceil(f32) -f32 + f32 -f32 + f32 * 0.5 -f32 + f32 ** i64 -f32 + f32 - i32 -f32 + f32 / 1 -f32 + f32 > i32 -f32 + f32 ^ 0.5 -f32 + f64 -f32 + f64 in array -f32 + findIndex(array, true) -f32 + first(array) -f32 + float(i) -f32 + floor(1) -f32 + floor(i64) -f32 + half(1) -f32 + half(f64) -f32 + i -f32 + i != i64 -f32 + i + 1 -f32 + i + i -f32 + i - i32 -f32 + i == f64 -f32 + i32 -f32 + i32 != f32 -f32 + i32 % i -f32 + i32 / f32 -f32 + i32 <= i -f32 + i32 ^ 0.5 -f32 + i64 -f32 + i64 != f32 -f32 + i64 + 0.5 -f32 + i64 < f32 -f32 + i64 <= i32 -f32 + i64 >= i -f32 + i64 >= i32 -f32 + int(1) -f32 + int(f64) -f32 + max(0.5) -f32 + max(f64) -f32 + reduce(array, #) -f32 + round(1) -f32 + round(i32) -f32 + score(1) -f32 + score(i) -f32 - -1 -f32 - -f64 -f32 - -i -f32 - 0.5 ** i64 -f32 - 0.5 + 0.5 -f32 - 0.5 + f64 -f32 - 0.5 - i64 -f32 - 0.5 < i -f32 - 0.5 <= i32 -f32 - 0.5 <= i64 -f32 - 0.5 > f64 -f32 - 1 % i64 -f32 - 1 * i64 -f32 - 1 + 1 -f32 - 1 / 0.5 -f32 - 1 < i32 -f32 - 1 <= i32 -f32 - 1 == f32 -f32 - 1 >= f64 -f32 - abs(i32) -f32 - abs(i64) -f32 - bitshl(i, i32) -f32 - ceil(f64) -f32 - f32 -f32 - f32 ** i32 -f32 - f32 + i -f32 - f32 == i -f32 - f64 -f32 - f64 + f64 -f32 - f64 - i -f32 - f64 <= f32 -f32 - i -f32 - i >= f32 -f32 - i32 -f32 - i32 * 0.5 -f32 - i32 * f64 -f32 - i32 ** 1 -f32 - i32 <= f32 -f32 - i32 <= i32 -f32 - i32 >= abs(0.5) -f32 - i64 -f32 - i64 ** 0.5 -f32 - len(array) -f32 - max(1) -f32 - min(0.5) -f32 - min(0.5, 0.5) -f32 - reduce(array, #) -f32 - score(1) -f32 - score(i) -f32 / (0.5 - i32) -f32 / (1 + i) -f32 / (f64 - 0.5) -f32 / (i - i32) -f32 / (i32 + 1) -f32 / -1 -f32 / -f64 -f32 / -i64 -f32 / 0.5 ** f64 -f32 / 0.5 / i -f32 / 0.5 <= i64 -f32 / 0.5 ^ f64 -f32 / 1 * i32 -f32 / 1 <= f32 -f32 / 1 >= 0.5 ? f64 : foo -f32 / 1 >= f32 -f32 / 1 >= i32 -f32 / array[1] -f32 / array[i32] -f32 / bitnot(i) -f32 / ceil(1) -f32 / ceil(f32) -f32 / count(list, false) -f32 / f32 -f32 / f32 / 0.5 -f32 / f32 ^ 1 -f32 / f64 -f32 / f64 * i32 -f32 / f64 + f32 -f32 / f64 - i32 -f32 / f64 / 1 -f32 / f64 / f64 -f32 / f64 / i64 -f32 / f64 < i -f32 / float(1) -f32 / float(i32) -f32 / float(i64) -f32 / floor(i) -f32 / half(0.5) -f32 / half(1) -f32 / half(f64) -f32 / i -f32 / i * 0.5 -f32 / i / 0.5 -f32 / i <= i -f32 / i == i32 -f32 / i > f64 -f32 / i32 -f32 / i32 * 1 -f32 / i32 * f32 -f32 / i32 ** f32 -f32 / i32 + i -f32 / i32 + i64 -f32 / i32 < f64 + 0.5 -f32 / i32 >= i32 -f32 / i64 -f32 / i64 - f64 -f32 / i64 ^ 0.5 -f32 / int(0.5) -f32 / int(1 * i64) -f32 / max(0.5) -f32 / min(i32) -f32 / reduce(array, #) -f32 / reduce(list, 1) -f32 / score(i) -f32 < -0.5 -f32 < -f64 -f32 < -i -f32 < -i64 -f32 < 0.5 + 0.5 -f32 < 0.5 + 1 -f32 < 0.5 ^ f32 -f32 < 0.5 ^ i64 -f32 < 1 % 1 -f32 < 1 + f64 -f32 < 1 ? f64 : i -f32 < 1 and ok -f32 < abs(0.5) -f32 < ceil(0.5) -f32 < ceil(f64) -f32 < count(array, ok) -f32 < count(list, ok) -f32 < f32 -f32 < f32 / 1 -f32 < f32 ^ f64 -f32 < f64 -f32 < f64 ** 1 -f32 < f64 + 0.5 -f32 < f64 + i -f32 < f64 / i64 -f32 < f64 ? 0.5 : array -f32 < f64 ? div : i32 -f32 < f64 and ok -f32 < floor(0.5) -f32 < floor(i) -f32 < half(0.5) -f32 < half(1) -f32 < i -f32 < i != ok -f32 < i / 1 -f32 < i ? 1 : i -f32 < i32 -f32 < i32 ** i64 -f32 < i32 ? f64 : i -f32 < i32 ? greet : i32 -f32 < i32 or ok -f32 < i64 -f32 < i64 - i32 -f32 < i64 / 0.5 -f32 < i64 ? foo : i32 -f32 < i64 ? foo?.Bar : div -f32 < i64 ^ 0.5 -f32 < max(i) -f32 < max(i32, 1) -f32 < min(0.5) -f32 < reduce(array, #) -f32 < reduce(list, 1) -f32 < round(i64) -f32 <= -0.5 -f32 <= -1 -f32 <= -f64 -f32 <= -i64 -f32 <= 0.5 != true -f32 <= 0.5 * 0.5 -f32 <= 0.5 + i -f32 <= 0.5 / i64 -f32 <= 0.5 ? i64 : i -f32 <= 1 - 0.5 -f32 <= 1 == nil -f32 <= 1 ? f64 : add -f32 <= 1 ? i64 : i64 % 1 -f32 <= 1 ? list : div -f32 <= 1 || ok -f32 <= f32 -f32 <= f32 * 1 -f32 <= f32 + f64 -f32 <= f32 + i -f32 <= f32 ? greet : half -f32 <= f64 -f32 <= findIndex(list, ok) * f64 -f32 <= float(1) -f32 <= float(i) -f32 <= float(i64) -f32 <= float(toJSON(1)) -f32 <= floor(0.5) -f32 <= half(0.5) -f32 <= half(1) -f32 <= half(f64) -f32 <= i -f32 <= i == nil -f32 <= i and i32 <= f32 -f32 <= i32 -f32 <= i32 ** i32 -f32 <= i32 + 1 -f32 <= i32 / 1 -f32 <= i64 -f32 <= i64 ** i64 -f32 <= i64 - f32 -f32 <= i64 ? f64 : f64 -f32 <= i64 ^ i32 -f32 <= i64 || nil in array -f32 <= last(array) -f32 <= min(0.5) -f32 <= min(1) -f32 <= min(f64) -f32 <= round(0.5) -f32 <= score(1) -f32 == -0.5 -f32 == -1 -f32 == -f32 -f32 == -i32 -f32 == -i64 -f32 == 0.5 != ok -f32 == 0.5 * 0.5 -f32 == 0.5 * 1 -f32 == 0.5 ** i32 -f32 == 0.5 + 1 -f32 == 0.5 / i32 -f32 == 0.5 / i64 -f32 == 0.5 ? array : greet -f32 == 0.5 ? true : score -f32 == 0.5 ^ 0.5 -f32 == 0.5 || f64 >= 1 -f32 == 1 != nil -f32 == 1 + f32 -f32 == 1 - 1 -f32 == 1 - i -f32 == 1 == ok -f32 == 1 ? foo : f32 -f32 == 1 ? ok : add != nil -f32 == add(i, 1) -f32 == array[i32] -f32 == bitnot(i) -f32 == ceil(1) -f32 == ceil(i32) -f32 == ceil(i64) -f32 == f32 -f32 == f32 ? f32 : list -f32 == f32 and ok -f32 == f64 -f32 == f64 + f64 -f32 == f64 ^ 1 -f32 == findLastIndex(array, ok) -f32 == first(array) -f32 == float(0.5) -f32 == float(1) -f32 == floor(f64) -f32 == half(1) -f32 == half(f64) -f32 == i -f32 == i != nil -f32 == i - 0.5 -f32 == i - i64 -f32 == i32 -f32 == i32 + i32 -f32 == i32 ? 0.5 : array -f32 == i32 ? i64 : i64 -f32 == i32 ? true : half -f32 == i32 ^ i32 -f32 == i32 or ok -f32 == i64 -f32 == i64 * i64 -f32 == i64 + 0.5 -f32 == i64 - 0.5 -f32 == i64 - 1 -f32 == i64 ? div : 0.5 -f32 == last(array) -f32 == max(f64) -f32 == min(0.5) -f32 == min(f32) -f32 == nil ? array : add -f32 == nil ? i : div -f32 == round(1) -f32 == score(1) -f32 == score(i) -f32 > -(0.5 / 1) -f32 > -0.5 -f32 > -f32 -f32 > -i32 -f32 > 0.5 / f32 -f32 > 0.5 / i32 -f32 > 0.5 == true ? i32 : array -f32 > 0.5 ? half : false -f32 > 0.5 ^ f64 -f32 > 1 ** i -f32 > 1 ? 1 : false -f32 > 1 ? list : "foo" -f32 > abs(1) -f32 > abs(f32) -f32 > abs(f64) -f32 > count(array, ok) -f32 > f32 -f32 > f32 + f32 -f32 > f32 - f32 -f32 > f32 == nil -f32 > f64 -f32 > f64 * i -f32 > f64 ** 0.5 -f32 > float(0.5) -f32 > float(i32) -f32 > floor(1) -f32 > half(1) -f32 > half(f64) -f32 > i -f32 > i != ok -f32 > i * 1 -f32 > i ? array : 1 -f32 > i ? foo : list -f32 > i32 -f32 > i32 != nil -f32 > i32 * f64 -f32 > i32 ? 0.5 : greet -f32 > i32 and ok -f32 > i64 -f32 > i64 % i64 -f32 > i64 ** i -f32 > i64 + 0.5 -f32 > i64 - i64 -f32 > i64 ? i : 0.5 -f32 > mean(array) -f32 > min(f32) -f32 > min(i64) -f32 > reduce(array, #) -f32 > reduce(array, i64) -f32 > reduce(list, f32) -f32 > round(0.5) -f32 > score(1, 1) -f32 >= -0.5 -f32 >= -f32 -f32 >= -f64 -f32 >= 0.5 * f64 -f32 >= 0.5 / i64 -f32 >= 0.5 ? i64 : nil -f32 >= 0.5 ^ i64 -f32 >= 1 == false -f32 >= 1 == ok ? add : array -f32 >= 1 ? i : 1 -f32 >= abs(0.5) -f32 >= abs(f32) -f32 >= abs(i) -f32 >= array[1] -f32 >= array[i32] -f32 >= bitnot(i32) -f32 >= count(list, false) -f32 >= f32 -f32 >= f32 ** 1 -f32 >= f32 - i64 -f32 >= f32 ? half : greet -f32 >= f32 or nil != ok -f32 >= f64 -f32 >= f64 && ok -f32 >= f64 ** 0.5 -f32 >= f64 ** i32 -f32 >= f64 - f64 -f32 >= f64 / i64 -f32 >= f64 or ok -f32 >= float(0.5) -f32 >= half(f64) -f32 >= i -f32 >= i - f32 -f32 >= i ? 1 : nil -f32 >= i ^ i -f32 >= i32 -f32 >= i32 % i -f32 >= i32 - f32 -f32 >= i32 / i64 -f32 >= i32 ? f32 : 0.5 -f32 >= i32 or not ok -f32 >= i64 -f32 >= i64 * i32 -f32 >= i64 + f64 -f32 >= i64 / 1 -f32 >= len("bar") -f32 >= max(i) -f32 >= max(i64) -f32 >= reduce(array, #) -f32 >= score(1) -f32 >= sum(array) -f32 ^ (0.5 * f64) -f32 ^ (0.5 / 1) -f32 ^ (0.5 / i) -f32 ^ (1 * i) -f32 ^ (1 + f64) -f32 ^ (f32 * i64) -f32 ^ (f64 * f64) -f32 ^ (f64 - 1) -f32 ^ (f64 / i) -f32 ^ (i64 * f64) -f32 ^ (i64 * i32) -f32 ^ (i64 * i64) -f32 ^ (i64 + i64) -f32 ^ (i64 - f32) -f32 ^ -0.5 -f32 ^ -1 -f32 ^ -i32 -f32 ^ 0.5 ** i32 -f32 ^ 0.5 - f32 -f32 ^ 0.5 - i32 -f32 ^ 0.5 == i64 -f32 ^ 0.5 ^ 0.5 -f32 ^ 1 != i64 -f32 ^ 1 / f32 -f32 ^ 1 >= -0.5 -f32 ^ abs(1) -f32 ^ abs(f32) -f32 ^ array[i64] -f32 ^ array[i] -f32 ^ bitnot(1) -f32 ^ bitor(1, i32) -f32 ^ f32 -f32 ^ f32 ^ 0.5 -f32 ^ f32 in array -f32 ^ f64 -f32 ^ f64 ** f64 -f32 ^ f64 / 1 * 1 -f32 ^ f64 / f64 -f32 ^ f64 == i64 -f32 ^ f64 not in array -f32 ^ floor(0.5) -f32 ^ floor(1) -f32 ^ half(1) -f32 ^ half(f64) -f32 ^ i -f32 ^ i - f64 -f32 ^ i <= i -f32 ^ i >= f64 -f32 ^ i ^ f32 -f32 ^ i32 -f32 ^ i32 ** i64 -f32 ^ i64 -f32 ^ i64 ** 1 -f32 ^ i64 + i64 -f32 ^ i64 - f32 -f32 ^ i64 >= f64 -f32 ^ i64 ^ f32 -f32 ^ int(i32) -f32 ^ len("foo") -f32 ^ len(array) -f32 ^ min(1) -f32 ^ min(f64) -f32 ^ min(i) -f32 ^ reduce(array, 1) -f32 ^ round(i) -f32 ^ round(i32) -f32 ^ score(i) -f32 ^ score(reduce(array, #)) -f32 in [i] -f32 in [nil] -f32 in array -f32 in array == nil -f32 in array ? 1 : i -f32 in array ? false : 0.5 -f32 in array ? nil : "bar" -f32 in groupBy(array, #) -f32 in groupBy(list, #) -f32 in groupBy(list, ok) -f32 in map(array, #) -f32 not in [f32, "bar"] -f32 not in array -f32 not in array ? foo : i -f32 not in array ? i32 : div +count(list, ok) .. 1 | take(1) +count(list, str != $env) +count(list, true != nil) +count(list[:0]) +count(map($env, $env), ok == $env) +count(map($env, false)) +count(map($env, ok)) +count(map($env, true)) +count(map($env, true)) >= f64 +count(map(array, false)) +count(map(list, false)) +count(map(list, ok)) +count(sort($env)) +count(sort($env), # < #.str) +count(sort($env), #) +count(sort($env), #.str && #) +count(toPairs($env), 0 in #) +date(str, str) +duration(string(0)) +duration(toJSON(0)) f64 -f64 != -0.5 -f64 != -1 -f64 != -f32 -f64 != -i -f64 != -i64 -f64 != 0.5 != false -f64 != 0.5 ** 1 -f64 != 0.5 ** f64 -f64 != 0.5 + f32 -f64 != 0.5 ^ 0.5 -f64 != 1 - 1 -f64 != 1 / 0.5 -f64 != 1 ? half : div -f64 != 1 ^ i -f64 != abs(i32) -f64 != bitnot(i64) -f64 != ceil(i) -f64 != f32 -f64 != f32 != nil -f64 != f32 + 0.5 -f64 != f32 + i32 -f64 != f32 - i32 -f64 != f32 ? array : nil -f64 != f32 ? i32 : "bar" -f64 != f32 ? ok : i -f64 != f32 or greet == nil +f64 != $env == false +f64 != $env ?: false +f64 != $env or $env +f64 != $env or ok +f64 != $env || $env +f64 != $env || false +f64 != $env.f64 +f64 != $env.i +f64 != $env?.$env +f64 != $env?.Bar +f64 != $env?.Bar?.[ok] +f64 != $env?.Bar?.list() +f64 != $env?.String +f64 != $env?.[Bar] +f64 != $env?.[Bar]?.String +f64 != $env?.[Bar]?.add +f64 != $env?.[String] +f64 != $env?.[foobar] +f64 != $env?.[str] +f64 != $env?.f64 +f64 != $env?.foobar +f64 != $env?.i +f64 != $env?.nil +f64 != $env?.true +f64 != 0 != true +f64 != 0 + i +f64 != 0 - i +f64 != 0 == $env +f64 != 0 == nil +f64 != 1 / i +f64 != 1 and $env +f64 != 1 || $env +f64 != 1.0 != $env +f64 != 1.0 != nil +f64 != 1.0 - 0 +f64 != 1.0 - 1 +f64 != 1.0 - i +f64 != 1.0 == true +f64 != 1.0 ?: add +f64 != 1.0 and false +f64 != 1.0 or $env +f64 != array?.[i] f64 != f64 -f64 != f64 * f32 -f64 != f64 ? f64 : true -f64 != first(array) -f64 != floor(1) -f64 != half(0.5) -f64 != half(1) +f64 != f64 && $env +f64 != f64 and true +f64 != float(i) +f64 != floor(f64) +f64 != floor(i) f64 != i -f64 != i * 0.5 -f64 != i / 1 -f64 != i / f32 -f64 != i ^ f64 -f64 != i32 -f64 != i32 * f32 -f64 != i32 == ok -f64 != i32 ? f64 : ok -f64 != i32 ? foo : ok -f64 != i32 ^ i32 -f64 != i64 -f64 != i64 * f64 -f64 != i64 - i32 -f64 != i64 or ok -f64 != int(i64) -f64 != min(f64) -f64 != nil != ok -f64 != nil && f64 > 0.5 -f64 != nil == true -f64 != nil ? array : foo -f64 != nil ? f64 : half -f64 != nil ? i64 : 0.5 -f64 != nil ? nil : half -f64 != round(1) -f64 * (0.5 - 1) -f64 * (i64 + 0.5) -f64 * -1 -f64 * -f32 -f64 * -f64 -f64 * 0.5 * 1 -f64 * 0.5 * i64 -f64 * 0.5 ** 0.5 -f64 * 0.5 / 0.5 -f64 * 0.5 / f32 -f64 * 0.5 / i32 -f64 * 0.5 < f32 -f64 * 0.5 <= i -f64 * 0.5 == f64 -f64 * 0.5 ^ 1 -f64 * 1 * f64 -f64 * 1 * i32 -f64 * 1 ** 1 -f64 * 1 + f64 -f64 * 1 - i32 -f64 * 1 <= 1 + 1 -f64 * 1 == i64 -f64 * 1 > f32 -f64 * 1 > f64 -f64 * 1 >= f64 -f64 * bitnot(i64) -f64 * ceil(i) -f64 * ceil(i64) -f64 * f32 -f64 * f32 != i -f64 * f32 / i64 -f64 * f32 > f64 -f64 * f32 > i +f64 != i != false +f64 != i && $env +f64 != i * f64 +f64 != i and $env +f64 != i and nil not in array +f64 != i and true +f64 != int(1.0) +f64 != last($env) +f64 != len($env) +f64 != mean(0) +f64 != mean(1.0) +f64 != mean(array) +f64 != median(1.0) +f64 != nil != false +f64 != nil && $env +f64 != nil or $env +f64 != round(1.0) +f64 * $env.f64 +f64 * $env.i +f64 * $env?.f64 +f64 * $env?.i +f64 * 0 * 1.0 +f64 * 0 + 1 +f64 * 0 - 1.0 +f64 * 1 != nil +f64 * 1 * 0 +f64 * 1 * i +f64 * 1 <= i +f64 * 1 == nil +f64 * 1 in array +f64 * 1.0 +f64 * 1.0 != i +f64 * 1.0 * 1.0 +f64 * 1.0 * f64 +f64 * 1.0 ** f64 +f64 * 1.0 < 0 +f64 * 1.0 < 1 +f64 * 1.0 | max(0) +f64 * abs(1.0) +f64 * array?.[1] +f64 * array?.[i] +f64 * bitnot(0) f64 * f64 -f64 * f64 * f64 -f64 * f64 / 1 -f64 * f64 <= f64 -f64 * f64 > f64 -f64 * f64 in array -f64 * float(f32) -f64 * floor(0.5) -f64 * get(array, 1) -f64 * half(f64) +f64 * f64 * i +f64 * f64 / i +f64 * f64 > 1 +f64 * float(0) +f64 * float(f64) +f64 * float(i) f64 * i -f64 * i / f64 -f64 * i32 -f64 * i32 != i64 * f64 -f64 * i32 - i32 -f64 * i64 -f64 * i64 ** i -f64 * i64 == i -f64 * i64 > i32 -f64 * i64 ^ i32 -f64 * median(array) -f64 * min(1) -f64 * min(f64) -f64 * min(i) -f64 * round(1) -f64 * round(i64) -f64 ** (0.5 - i) -f64 ** (0.5 / i64) -f64 ** (1 * i) -f64 ** (f64 * i32) -f64 ** (f64 / 1) -f64 ** (i * 1) -f64 ** (i * i64) -f64 ** (i32 * i) -f64 ** (i32 + i32) -f64 ** (i32 - f64) -f64 ** (i32 / i64) -f64 ** (i64 % 1) -f64 ** (i64 + 0.5) -f64 ** (i64 + i64) -f64 ** (i64 - i32) -f64 ** (i64 / 0.5) -f64 ** -0.5 -f64 ** -1 -f64 ** -i -f64 ** 0.5 ** f32 -f64 ** 0.5 == i32 -f64 ** 1 + f64 -f64 ** 1 / i -f64 ** 1 < f32 -f64 ** 1 > i32 -f64 ** 1 ^ f32 -f64 ** abs(i) -f64 ** bitand(1, 1) -f64 ** ceil(0.5) -f64 ** ceil(f64) -f64 ** f32 -f64 ** f32 != f64 -f64 ** f32 ** f64 -f64 ** f32 > f64 +f64 * i != $env?.i +f64 * i != sum(array) +f64 * i ** 1.0 +f64 * i == nil +f64 * i > $env?.f64 +f64 * int(1) +f64 * int(1.0) +f64 * len($env) +f64 * len(foo.Bar) +f64 * len(str) +f64 * min(array) +f64 * sum(array | sortBy(#)) +f64 ** $env.f64 +f64 ** $env.i +f64 ** $env?.f64 +f64 ** $env?.i +f64 ** 0 ** f64 +f64 ** 0 >= 1.0 +f64 ** 1 != nil +f64 ** 1 - i +f64 ** 1 / 0 +f64 ** 1 < f64 +f64 ** 1.0 != $env +f64 ** 1.0 != f64 +f64 ** 1.0 * 1.0 +f64 ** 1.0 + 0 +f64 ** 1.0 / i +f64 ** 1.0 > 1 +f64 ** 1.0 ^ 1.0 +f64 ** 1.0 not in array +f64 ** abs(mean(1.0)) +f64 ** array?.[i] +f64 ** bitnot(0) f64 ** f64 -f64 ** f64 - f32 -f64 ** f64 / min(1) -f64 ** f64 <= f32 -f64 ** f64 <= i64 -f64 ** f64 ^ 0.5 -f64 ** half(0.5) +f64 ** f64 * 0 +f64 ** f64 * i +f64 ** f64 + 1.0 +f64 ** f64 - 1.0 +f64 ** f64 ^ i +f64 ** f64 | median(0) +f64 ** float(1.0) f64 ** i -f64 ** i * f64 -f64 ** i ** i -f64 ** i + -i32 -f64 ** i + f32 -f64 ** i32 -f64 ** i32 != f64 -f64 ** i32 > f64 -f64 ** i64 -f64 ** i64 + f32 -f64 ** i64 <= f32 -f64 ** i64 not in map(array, 0.5) -f64 ** last(array) -f64 ** len("bar") -f64 ** max(i) -f64 ** min(f32) -f64 ** reduce(array, #) -f64 ** reduce(list, i32) -f64 ** score(i) -f64 + -0.5 -f64 + -1 -f64 + -f64 -f64 + -i -f64 + -i32 -f64 + 0.5 / f32 -f64 + 0.5 < i32 -f64 + 0.5 <= f64 -f64 + 0.5 <= float(f32) -f64 + 0.5 <= i -f64 + 0.5 > f64 -f64 + 0.5 ^ i -f64 + 0.5 ^ i64 -f64 + 1 % i -f64 + 1 * 0.5 -f64 + 1 * 1 -f64 + 1 * f64 -f64 + 1 ** 0.5 -f64 + 1 + i32 -f64 + 1 / i64 -f64 + 1 ^ i -f64 + 1 not in map(array, #) -f64 + ceil(0.5) -f64 + count(list, true) -f64 + f32 -f64 + f32 == i != true +f64 ** i >= i +f64 ** i ^ i +f64 ** mean(1.0) +f64 ** mean(f64) +f64 ** min(1.0) +f64 ** min(f64) +f64 ** round(f64) +f64 ** sum(array) +f64 + $env.f64 +f64 + $env.i +f64 + $env?.f64 +f64 + $env?.i +f64 + 0 * f64 +f64 + 0 ^ 1.0 +f64 + 0 ^ f64 +f64 + 1 * 0 +f64 + 1 * i +f64 + 1 / 1.0 +f64 + 1 < 1.0 +f64 + 1 > $env and false +f64 + 1 ^ f64 +f64 + 1.0 != f64 +f64 + 1.0 < 1.0 +f64 + 1.0 < int(0) +f64 + 1.0 <= $env.i +f64 + 1.0 <= 0 +f64 + 1.0 == 0 +f64 + 1.0 == nil +f64 + 1.0 ^ 0 +f64 + 1.0 ^ 1.0 +f64 + 1.0 not in array +f64 + 1.0 | max(1.0) +f64 + abs(i) +f64 + array?.[i] +f64 + bitnot(i) +f64 + ceil(1) +f64 + count($env, true) f64 + f64 -f64 + f64 < f32 -f64 + f64 <= i32 -f64 + f64 ^ i32 -f64 + float(f64) -f64 + floor(f64) -f64 + get(array, i32) -f64 + half(0.5) -f64 + half(1) +f64 + f64 ** 1.0 +f64 + f64 ^ i f64 + i -f64 + i + 0.5 -f64 + i / 0.5 -f64 + i / i32 -f64 + i > 0.5 != true -f64 + i > f64 -f64 + i >= f64 -f64 + i32 -f64 + i32 != i64 -f64 + i32 % i32 -f64 + i32 ** 1 -f64 + i32 > i64 -f64 + i64 -f64 + i64 + i64 -f64 + i64 / f64 -f64 + i64 > i32 / i -f64 + i64 > i64 -f64 + i64 ^ i32 -f64 + reduce(array, #) -f64 + reduce(list, f32) -f64 + score(1) -f64 - -0.5 -f64 - -1 -f64 - -f64 -f64 - -i -f64 - -i64 -f64 - 0.5 - 0.5 -f64 - 0.5 - 1 -f64 - 0.5 - i32 -f64 - 0.5 >= f64 -f64 - 0.5 ^ i64 -f64 - 1 * i32 -f64 - 1 + i64 -f64 - 1 - f64 -f64 - 1 / i64 -f64 - 1 < f32 -f64 - 1 < f32 ? i64 : false -f64 - 1 >= len(array) -f64 - 1 ^ i64 -f64 - f32 -f64 - f32 != i64 -f64 - f32 + f32 -f64 - f32 < f64 -f64 - f32 ^ f32 +f64 + i != 0 +f64 + i ** 1 +f64 + i - 1 +f64 + i / i +f64 + i == i +f64 + i > 1.0 +f64 + i in array +f64 + int(i) +f64 + min(f64) +f64 + sum(array) +f64 + sum(list, 1) +f64 - $env.f64 +f64 - $env.i +f64 - $env?.f64 +f64 - $env?.i +f64 - 0 / 1 +f64 - 0 / f64 +f64 - 0 < 0 +f64 - 0 < 1 +f64 - 0 > 0 +f64 - 0 > f64 +f64 - 1 != $env +f64 - 1 <= 1 + f64 +f64 - 1 > i +f64 - 1 not in $env?.[Bar] +f64 - 1 | mean(1.0) +f64 - 1.0 - 0 +f64 - 1.0 - 1.0 +f64 - 1.0 / i +f64 - 1.0 == f64 +f64 - 1.0 > 1 +f64 - array?.[i] +f64 - bitxor(i, i) +f64 - ceil(f64) f64 - f64 -f64 - f64 + -1 -f64 - f64 < f64 -f64 - float(f32) -f64 - floor(1) -f64 - half(1) +f64 - f64 < i +f64 - f64 <= f64 +f64 - floor(0) f64 - i -f64 - i + 0.5 -f64 - i + 1 -f64 - i + i32 -f64 - i / i -f64 - i ^ f32 -f64 - i32 -f64 - i32 / 0.5 -f64 - i32 >= i64 -f64 - i32 ^ 0.5 -f64 - i64 -f64 - i64 ** i32 -f64 - int(i) -f64 - int(i32) -f64 - reduce(array, -#) -f64 - round(1) -f64 - score(i) -f64 / (0.5 - 1) -f64 / (0.5 - i64) -f64 / (f32 + 1) -f64 / (i + 0.5) -f64 / (i32 + i64) -f64 / -0.5 -f64 / -1 -f64 / -f64 -f64 / -i -f64 / -i32 -f64 / -i64 -f64 / 0.5 != f64 -f64 / 0.5 * f32 -f64 / 0.5 + f64 -f64 / 0.5 / 1 -f64 / 0.5 < i32 -f64 / 0.5 == i32 -f64 / 0.5 >= i64 -f64 / 1 != i -f64 / 1 * i32 -f64 / 1 ** 1 +f64 - i >= 1 +f64 - i >= i +f64 - i | median(1.0) +f64 - last(array) +f64 - len(str) +f64 - max(array) +f64 - max(f64) +f64 - median(1.0) +f64 - median(array) +f64 - min(1.0, array) +f64 / $env.f64 +f64 / $env.i +f64 / $env?.f64 +f64 / $env?.i +f64 / 0 != 1.0 +f64 / 0 + i +f64 / 0 - 1.0 +f64 / 1 / 1.0 f64 / 1 / i -f64 / 1 <= i64 -f64 / 1 ^ i -f64 / abs(f64) -f64 / array[1] -f64 / array[i64] -f64 / ceil(i32) -f64 / f32 -f64 / f32 * i -f64 / f32 * i64 -f64 / f32 / 0.5 -f64 / f32 == f32 -f64 / f32 ^ 0.5 +f64 / 1 <= 0 +f64 / 1.0 != 1 +f64 / 1.0 != f64 +f64 / 1.0 ** 1.0 +f64 / 1.0 - 1 +f64 / 1.0 <= 1.0 +f64 / 1.0 >= 0 +f64 / 1.0 ^ 1.0 +f64 / 1.0 ^ f64 +f64 / abs(1.0) +f64 / abs(i) +f64 / add(i, 1) +f64 / array?.[i] +f64 / ceil(1.0) f64 / f64 -f64 / f64 / 0.5 -f64 / f64 >= f64 -f64 / f64 >= i32 -f64 / f64 >= i64 -f64 / float(1) -f64 / float(f64) -f64 / floor(i64) -f64 / get(array, 1) -f64 / get(array, i32) -f64 / half(0.5) -f64 / half(1) +f64 / f64 ** i +f64 / f64 / 1.0 +f64 / f64 <= f64 +f64 / first(array) +f64 / float(1.0) f64 / i -f64 / i != f64 -f64 / i ** 0.5 -f64 / i ** f32 -f64 / i + i32 -f64 / i == i64 -f64 / i >= i -f64 / i32 -f64 / i32 != 0.5 - i64 -f64 / i32 == f64 ** i -f64 / i32 == i32 -f64 / i32 >= f32 -f64 / i64 -f64 / i64 < f64 -f64 / int(f32) -f64 / last(array) -f64 / max(i) -f64 / reduce(array, #) -f64 / reduce(array, f64) -f64 / reduce(list, f32) -f64 / round(1) -f64 / round(i64) -f64 / score(1) -f64 < -0.5 -f64 < -i32 -f64 < -i64 -f64 < 0.5 + i64 -f64 < 0.5 / 0.5 -f64 < 0.5 / i -f64 < 0.5 == true -f64 < 0.5 ? f64 : array +f64 / i >= 1.0 +f64 / len($env) +f64 / max(1) +f64 / max(f64, f64) +f64 / mean(1) +f64 / mean(array) +f64 < $env.f64 +f64 < $env.i +f64 < $env?.f64 +f64 < $env?.i +f64 < 0 % 1 +f64 < 0 ** f64 +f64 < 0 + 1.0 +f64 < 0 + i +f64 < 0 < $env > $env +f64 < 0 <= $env?.[array] +f64 < 0 == false +f64 < 0 or true f64 < 1 % 1 -f64 < 1 * 0.5 -f64 < 1 ** i32 -f64 < 1 / f32 -f64 < 1 == false -f64 < 1 ? i : "foo" +f64 < 1 / 0 +f64 < 1 <= f64 +f64 < 1 or ok +f64 < 1 or true +f64 < 1.0 && $env +f64 < 1.0 - 1.0 +f64 < 1.0 - f64 +f64 < 1.0 / 1 +f64 < 1.0 / 1.0 +f64 < 1.0 / f64 +f64 < 1.0 < 1.0 +f64 < 1.0 <= i +f64 < 1.0 == false +f64 < 1.0 >= 1.0 == true +f64 < 1.0 ?: true f64 < abs(1) -f64 < abs(f32) -f64 < array[i64] -f64 < bitnot(1) -f64 < ceil(f64) -f64 < count(array, false) -f64 < f32 -f64 < f32 * i -f64 < f32 / i64 -f64 < f32 ^ 1 -f64 < f32 ^ f64 +f64 < array?.[i] +f64 < ceil(1.0) +f64 < count(list, true) f64 < f64 -f64 < f64 == ok -f64 < floor(i64) -f64 < get(array, i) +f64 < f64 > 0 +f64 < f64 ?: ok +f64 < f64 in $env?.String +f64 < float(1) +f64 < floor(1) +f64 < floor(f64) f64 < i -f64 < i && "bar" < "bar" -f64 < i && ok -f64 < i ** i32 -f64 < i + 1 -f64 < i ? 0.5 : "bar" -f64 < i ? div : nil -f64 < i32 -f64 < i32 * f64 -f64 < i32 * i -f64 < i32 ** f32 -f64 < i32 ** i64 -f64 < i32 + f32 -f64 < i32 + f64 -f64 < i32 + i64 -f64 < i32 ? false : ok -f64 < i32 ? true : 1 -f64 < i32 ^ 1 -f64 < i32 ^ i32 -f64 < i64 -f64 < i64 * f64 -f64 < i64 ^ i -f64 < int(0.5) -f64 < max(1) -f64 < max(f64, i32) -f64 < min(0.5, i64) -f64 < min(f32) -f64 < min(f64, f32) -f64 < min(i32) -f64 < round(0.5) -f64 < score(1) -f64 <= -0.5 -f64 <= -1 -f64 <= -i -f64 <= -i32 -f64 <= 0.5 != false -f64 <= 0.5 + 0.5 -f64 <= 0.5 / f32 -f64 <= 0.5 ? greet : f64 -f64 <= 0.5 ? score : array -f64 <= 1 * i32 -f64 <= 1 + 0.5 -f64 <= 1 / i -f64 <= 1 == nil -f64 <= 1 ? "bar" : array -f64 <= 1 ? half : list -f64 <= 1 ^ f64 -f64 <= abs(0.5) -f64 <= abs(i) -f64 <= array[i64] -f64 <= ceil(i) -f64 <= f32 -f64 <= f32 ** 0.5 -f64 <= f32 - i64 -f64 <= f32 ? f64 : div -f64 <= f32 ^ f32 +f64 < i != nil +f64 < i % i +f64 < i >= f64 +f64 < i || true +f64 < max(array) +f64 < max(f64) +f64 < mean(f64) +f64 < median(array) +f64 < min(0) +f64 < min(1.0) +f64 < min(i) +f64 < round(1.0) +f64 < sum(array) +f64 <= $env.f64 +f64 <= $env.i +f64 <= $env?.f64 +f64 <= $env?.i +f64 <= 0 ** 1.0 +f64 <= 0 > i +f64 <= 0.1 +f64 <= 1 - i +f64 <= 1 / f64 +f64 <= 1 >= f64 +f64 <= 1 ^ 0 +f64 <= 1 or true +f64 <= 1 || $env +f64 <= 1.0 != nil +f64 <= 1.0 && $env +f64 <= 1.0 && true +f64 <= 1.0 * $env?.i +f64 <= 1.0 * min(i) +f64 <= 1.0 <= f64 +f64 <= 1.0 <= mean(1.0) +f64 <= 1.0 > 1 +f64 <= 1.0 ^ 1.0 +f64 <= 1.0 and $env +f64 <= 1.0 and ok +f64 <= 1.1 <= 1 +f64 <= abs(0) +f64 <= abs(f64) +f64 <= add(i, i) +f64 <= array?.[i] +f64 <= bitnand(i, 1) f64 <= f64 -f64 <= f64 != ok -f64 <= f64 + f64 -f64 <= f64 + i32 -f64 <= f64 - 1 -f64 <= f64 ^ i -f64 <= float(i) -f64 <= float(i64) -f64 <= half(0.5) -f64 <= half(1) +f64 <= f64 && $env +f64 <= f64 - 0 +f64 <= f64 and $env +f64 <= floor(1.0) f64 <= i -f64 <= i * i64 -f64 <= i - 1 -f64 <= i - f32 -f64 <= i ^ f64 -f64 <= i32 -f64 <= i32 ** 1 -f64 <= i32 ? div : foo -f64 <= i32 or all(list, ok) -f64 <= i64 -f64 <= i64 + 1 -f64 <= i64 - 0.5 -f64 <= int(f32) -f64 <= max(i) -f64 <= max(i64, i32) -f64 <= min(i32) -f64 <= min(i64) -f64 <= reduce(array, #) -f64 == -0.5 -f64 == -1 -f64 == -f32 -f64 == -f64 -f64 == -i -f64 == -i64 -f64 == 0.5 ** 0.5 -f64 == 0.5 - i -f64 == 0.5 ? 0.5 : i64 -f64 == 0.5 ? 1 : 1 +f64 <= i + f64 +f64 <= i == $env?.Bar +f64 <= i > i +f64 <= int(1.0) +f64 <= len(list) +f64 <= mean(i) +f64 <= median(1.0) +f64 <= min(f64) +f64 <= sum(array) +f64 <= sum(array, #) +f64 == $env && true +f64 == $env == $env +f64 == $env ? add : $env +f64 == $env or $env +f64 == $env.f64 +f64 == $env.i +f64 == $env?.Bar +f64 == $env?.String +f64 == $env?.[Bar] +f64 == $env?.[String] +f64 == $env?.[str] +f64 == $env?.f64 +f64 == $env?.foobar +f64 == $env?.foobar?.str +f64 == $env?.i +f64 == 0 && $env?.[add] +f64 == 0 && sum($env) +f64 == 0 or ok f64 == 1 != ok -f64 == 1 % 1 -f64 == 1 * i64 -f64 == 1 ** 0.5 -f64 == 1 == false -f64 == abs(0.5) -f64 == abs(i64) -f64 == ceil(i) -f64 == f32 -f64 == f32 && ok -f64 == f32 + len(array) -f64 == f32 ? 0.5 : i -f64 == f32 ^ i32 +f64 == 1 * i +f64 == 1 - 1.0 +f64 == 1 - f64 +f64 == 1.0 ** 0 +f64 == 1.0 + f64 +f64 == 1.0 == ok +f64 == 1.0 ?: nil +f64 == 1.0 and true +f64 == 1.0 || $env +f64 == abs(1.0) +f64 == array?.[i] +f64 == bitor(i, 1) +f64 == count(array, ok) f64 == f64 -f64 == f64 ** i -f64 == f64 - f64 -f64 == float(0.5) -f64 == floor(0.5) -f64 == half(0.5) -f64 == half(f64) +f64 == f64 ^ i +f64 == findLastIndex($env, true) f64 == i -f64 == i != false -f64 == i * 1 -f64 == i ? i32 : score -f64 == i32 -f64 == i32 == ok ? 1 : list -f64 == i32 == true -f64 == i32 || ok -f64 == i64 -f64 == i64 / i -f64 == i64 ? 1 : 0.5 -f64 == i64 ? greet : i32 -f64 == int(f32) -f64 == max(0.5) -f64 == max(i) -f64 == min(i32) -f64 == nil && ok -f64 == nil ? 0.5 : add -f64 == nil ? foo : "foo" -f64 == reduce(list, i32) -f64 == round(i) -f64 == score(i, 1) -f64 > -0.5 -f64 > -1 -f64 > -f64 -f64 > -i -f64 > -i32 -f64 > 0.5 ** f32 -f64 > 0.5 / i -f64 > 0.5 ^ i -f64 > 0.5 or i <= 0.5 -f64 > 1 + f32 -f64 > 1 + i32 -f64 > 1 ? div : i32 -f64 > 1 ^ i32 -f64 > array[i64] -f64 > ceil(0.5) -f64 > ceil(1) -f64 > ceil(f32) -f64 > f32 -f64 > f32 / 1 +f64 == i / i +f64 == int(f64) +f64 == mean(1.0) +f64 == median(i) +f64 == min($env) +f64 == min(1.0) +f64 == nil != nil +f64 == nil != ok +f64 == nil ?: list +f64 == nil || max(array) +f64 == nil || true +f64 > $env.f64 +f64 > $env.i +f64 > $env?.[str]?.[f64] +f64 > $env?.f64 +f64 > $env?.i +f64 > 0 + 1.0 +f64 > 0 >= 0 +f64 > 0 >= 1.0 +f64 > 0 ? 1 : 1.0 +f64 > 0 and $env?.String +f64 > 0 or true +f64 > 1 ** i +f64 > 1 / f64 +f64 > 1 / i +f64 > 1 <= i +f64 > 1 >= f64 +f64 > 1 >= i +f64 > 1 ? array : false +f64 > 1 or true +f64 > 1.0 * i +f64 > 1.0 ** f64 +f64 > 1.0 / 0 +f64 > 1.0 <= f64 +f64 > 1.0 == true +f64 > 1.0 > $env +f64 > 1.0 > median(list, 1) +f64 > 1.0 ? i : false +f64 > 1.0 and true +f64 > array?.[i] +f64 > ceil(0) f64 > f64 -f64 > f64 - 0.5 -f64 > float(0.5 * i64) -f64 > floor(f64) -f64 > get(array, 1) -f64 > half(0.5) -f64 > half(1) -f64 > half(f64) +f64 > f64 != true +f64 > f64 * f64 +f64 > f64 - 1 +f64 > f64 >= 1.0 +f64 > float(1.0) f64 > i -f64 > i - 0.5 -f64 > i32 -f64 > i32 == ok -f64 > i32 ? f32 : array -f64 > i32 ? list : half -f64 > i32 ^ i32 -f64 > i32 ^ i64 -f64 > i64 -f64 > i64 - 1 -f64 > i64 ? array : half -f64 > i64 ? list : div -f64 > i64 || ok or ok -f64 > int(f32) -f64 > last(array) -f64 > max(0.5) -f64 > max(0.5, i64) -f64 > max(f32) -f64 > median(array) -f64 > min(f32) -f64 >= -0.5 -f64 >= -1 -f64 >= -i64 -f64 >= 0.5 + i32 -f64 >= 0.5 - 1 -f64 >= 0.5 - f32 -f64 >= 0.5 / i64 -f64 >= 0.5 ? list : i32 -f64 >= 0.5 ^ i64 -f64 >= array[1] -f64 >= f32 -f64 >= f32 - i32 -f64 >= f32 ^ 1 +f64 > i < f64 ?: $env +f64 > i == $env +f64 > i ^ 1 +f64 > max(array) +f64 > mean(1.0) +f64 > median(f64) +f64 > round(1) +f64 > round(i) +f64 > sum($env | filter(false)) +f64 > sum($env, f64) +f64 >= $env && false +f64 >= $env || true +f64 >= $env.f64 +f64 >= $env.i +f64 >= $env?.f64 +f64 >= $env?.i +f64 >= 0 != $env +f64 >= 0 >= f64 +f64 >= 0 ? greet : 1 +f64 >= 0 || ok +f64 >= 1 != true +f64 >= 1 < i +f64 >= 1 ? 0 : foo +f64 >= 1 ? foo : str +f64 >= 1.0 != nil +f64 >= 1.0 ** i < f64 +f64 >= 1.0 + 1.0 +f64 >= 1.0 > i +f64 >= 1.0 ?: list +f64 >= 1.0 and $env in str +f64 >= 1.0 and $env?.[str] +f64 >= array?.[i] +f64 >= bitnot(i) +f64 >= ceil(0) +f64 >= ceil(i) f64 >= f64 -f64 >= f64 != nil -f64 >= f64 != ok -f64 >= findIndex(array, ok) -f64 >= floor(f32) -f64 >= floor(i) -f64 >= half(0.5) -f64 >= half(1) +f64 >= f64 == ok +f64 >= f64 ^ f64 +f64 >= float(0) +f64 >= float(1) +f64 >= float(1.0) f64 >= i -f64 >= i * 0.5 -f64 >= i ** 0.5 -f64 >= i ** i32 -f64 >= i / i32 -f64 >= i ^ 1 -f64 >= i32 -f64 >= i32 - f64 -f64 >= i32 ? ok : add -f64 >= i32 ^ 1 -f64 >= i64 -f64 >= i64 + f64 -f64 >= i64 ? 0.5 : score -f64 >= i64 ? 1 : f32 -f64 >= max(1) -f64 >= median(array) -f64 >= reduce(array, #) -f64 >= reduce(array, i32) -f64 >= score(i) -f64 ^ (0.5 * i) -f64 ^ (0.5 + 1) -f64 ^ (1 * f64) -f64 ^ (1 - 1) -f64 ^ (f32 + 1) -f64 ^ (f32 - 0.5) -f64 ^ (f32 - i) -f64 ^ (f32 / -f64) -f64 ^ (i32 - 1) -f64 ^ (i32 / f32) -f64 ^ (i64 - 1) -f64 ^ -0.5 -f64 ^ -i32 -f64 ^ 0.5 * f64 -f64 ^ 0.5 ** f32 -f64 ^ 0.5 ** i32 -f64 ^ 0.5 > ceil(f32) -f64 ^ 0.5 > i -f64 ^ 0.5 >= f64 -f64 ^ 0.5 >= i32 -f64 ^ 0.5 ^ i32 -f64 ^ 0.5 not in array -f64 ^ 1 ** i -f64 ^ 1 ** i64 -f64 ^ 1 ^ i -f64 ^ abs(0.5) -f64 ^ array[i64] -f64 ^ f32 -f64 ^ f32 ** 1 -f64 ^ f32 < score(1) -f64 ^ f32 >= i32 +f64 >= i != $env +f64 >= i * f64 +f64 >= i + 1.0 +f64 >= mean(1) +f64 >= mean(1.0) +f64 >= sum(array) +f64 ^ $env.f64 +f64 ^ $env.i +f64 ^ $env?.f64 +f64 ^ $env?.i +f64 ^ 0 - 1.0 +f64 ^ 0 / i +f64 ^ 0 < 0 +f64 ^ 0 >= 1.0 ?: greet +f64 ^ 1 + 1.0 +f64 ^ 1.0 +f64 ^ 1.0 != 1.0 +f64 ^ 1.0 != f64 +f64 ^ 1.0 ** 1.0 +f64 ^ 1.0 > 1 +f64 ^ 1.0 >= i +f64 ^ array?.[i] f64 ^ f64 -f64 ^ f64 - -i -f64 ^ f64 == i32 -f64 ^ f64 > f64 -f64 ^ f64 ^ i -f64 ^ f64 ^ i64 -f64 ^ findIndex(array, true) -f64 ^ float(abs(i)) -f64 ^ floor(f64) -f64 ^ half(1) -f64 ^ half(f64) +f64 ^ f64 != $env +f64 ^ f64 ** i +f64 ^ f64 + 1.0 +f64 ^ find(array, ok) +f64 ^ float(i) f64 ^ i -f64 ^ i ** 1 -f64 ^ i + f32 -f64 ^ i + i32 -f64 ^ i <= i32 -f64 ^ i ^ i64 -f64 ^ i32 -f64 ^ i32 / f64 -f64 ^ i32 <= i32 -f64 ^ i32 >= i -f64 ^ i64 -f64 ^ i64 ** i64 -f64 ^ int(0.5) -f64 ^ int(f64) -f64 ^ last(array) -f64 ^ len(list) -f64 ^ min(1) -f64 ^ reduce(array, #) -f64 ^ round(i) -f64 ^ score(1) +f64 ^ i ** 1.0 +f64 ^ i ** i +f64 ^ i >= 0 || $env +f64 ^ i not in array +f64 ^ len($env) +f64 ^ median(0) +f64 ^ sum(array) +f64 in $env && false +f64 in $env.array +f64 in $env?.Bar +f64 in $env?.String +f64 in $env?.[$env?.[String]] +f64 in $env?.[Bar] +f64 in $env?.[String] +f64 in $env?.[foobar] +f64 in $env?.array +f64 in $env?.foobar +f64 in $env?.foobar?.[add] +f64 in $env?.nil +f64 in [1.0] +f64 in [foo, 1.0] +f64 in [foo, i] +f64 in [list, 1.0] +f64 in [nil] f64 in array -f64 in array != nil -f64 in groupBy(list, i64) +f64 in array or false +f64 in reverse(array) +f64 not in $env or true +f64 not in $env.array +f64 not in $env?.Bar +f64 not in $env?.String +f64 not in $env?.[Bar] +f64 not in $env?.[String] +f64 not in $env?.[String]?.foo +f64 not in $env?.[foobar] +f64 not in $env?.array +f64 not in $env?.foobar +f64 not in [$env] +f64 not in [1.0] +f64 not in [array | groupBy(#), i] f64 not in array -f64 not in array != ok -f64 not in array != true -f64 not in array == true -f64 not in groupBy(array, #) -f64 not in groupBy(array, bitnand(#, 1)) -f64 not in i .. i32 -f64 not in map(array, #) -false != false ? foo : greet -false && i not in array -false && nil not in array -false && nil not in list -false == nil ? i32 : f64 -false == nil ? i32 : i32 -false ? "bar" : 0.5 - i -false ? "foo" : f32 * i -false ? "foo" : f32 / i32 -false ? "foo" : foo.Qux -false ? add : 1 / i ^ 0.5 -false ? add : i64 - i -false ? div : i64 ** i -false ? f32 : foo.Qux -false ? f64 : 0.5 != i32 -false ? f64 : 0.5 ** i32 -false ? f64 : 1 >= i -false ? f64 : foo?.Qux -false ? f64 : i ^ f32 -false ? false : foo?.Qux -false ? foo : i32 - i -false ? half : 0.5 == f32 -false ? half : i ^ i64 -false ? i : foo?.Qux -false ? i : nil in list -false ? i32 : 1 <= i32 -false ? i32 : foo.Qux -false ? i64 : 1 <= f32 -false ? i64 : foo.Qux -false ? i64 : i64 ** i64 -false ? list : list == list -false ? nil : foo?.Qux -false ? nil : i32 > i32 -false ? ok : foo.String() -false ? ok : i64 < i64 -false and false || 0.5 > f32 -false or 1 not in array -false or true or ok -false or true || ok -filter(1 .. 1, # > i) -filter(1 .. i, i >= #) -filter([0.5], # > 0.5) -filter([nil], # != false) -filter(array, !true) -filter(array, "bar" != "foo") -filter(array, "foo" == nil) +f64 not in i .. i +f64 not in keys($env) +f64 not in map($env, $env) +f64 not in map(array, 1) +f64 | max(0) +f64 | max(0, 1) +f64 | max(1) +f64 | max(1.0) +f64 | max(array) +f64 | max(array, 1) +f64 | max(bitnot(1)) +f64 | max(f64) +f64 | max(i) +f64 | max(i, 1.0) +f64 | mean(0) +f64 | mean(0, 0) +f64 | mean(0, 1.0) +f64 | mean(0, array) +f64 | mean(1) +f64 | mean(1.0) +f64 | mean(1.0, 1.0) +f64 | mean(1.0, array) +f64 | mean(array) +f64 | mean(array, 0) +f64 | mean(f64) +f64 | mean(f64, array) != add +f64 | mean(f64, f64) +f64 | mean(i) +f64 | median(0) +f64 | median(0, 0) +f64 | median(0, array) +f64 | median(0, i) +f64 | median(1) +f64 | median(1.0) +f64 | median(array) +f64 | median(array) >= f64 +f64 | median(array, 1.0) +f64 | median(f64) +f64 | median(i) +f64 | min($env?.array) +f64 | min($env?.f64) +f64 | min(0) +f64 | min(0, i) +f64 | min(1) +f64 | min(1, f64) +f64 | min(1.0) +f64 | min(1.0, 0) +f64 | min(array) +f64 | min(array, 1) +f64 | min(array, i) +f64 | min(f64) +f64 | min(f64, 1.0) +f64 | min(i) +f64; $env?.list +f64; f64 +f64; foo?.String +f64; i +f64; str +false != $env and ok +false != $env.ok +false != $env?.Bar +false != $env?.String +false != $env?.[Bar] +false != $env?.[String] +false != $env?.[foobar] +false != $env?.[str] +false != $env?.foobar +false != $env?.ok +false != nil == ok +false && $env == count(array) +false && $env > findLastIndex($env, #) +false && $env >= sum($env)?.[array] +false && $env in str +false && $env not in list +false && $env or ok +false && $env.ok +false && $env?.Bar +false && $env?.String +false && $env?.String() +false && $env?.String(foobar.Bar) +false && $env?.[Bar] +false && $env?.[String] +false && $env?.[add] +false && $env?.[add].array +false && $env?.[array] +false && $env?.[array]?.[ok] +false && $env?.[f64 > str] +false && $env?.[f64] +false && $env?.[f64]?.array +false && $env?.[foo] +false && $env?.[foobar - foobar] +false && $env?.[foobar.add] +false && $env?.[foobar] +false && $env?.[greet] +false && $env?.[greet].i +false && $env?.[i] +false && $env?.[list] +false && $env?.[ok] +false && $env?.[ok].add +false && $env?.[str] +false && $env?.[str].String +false && $env?.foobar +false && $env?.ok +false && $env[:Bar < 0] +false && $env[:ok()] +false && $env[foobar:Bar] +false && $env[foobar:foobar?.[String]] +false && $env[foobar?.ok(foobar):] +false && $env[i:] +false && $env[ok.String:all(foobar, #.foo)] +false && 0 >= i +false && 0 not in map($env, i) +false && 1 == 1 ** $env +false && 1.0 == i +false && 1.0 == int(1) +false && 1.0 > $env[:ok] +false && 1.0 > i +false && f64 < i +false && i < f64 +false && i in array +false && nil != greet +false && nil == ok +false && nil in reduce($env, #) +false && ok || ok +false == $env && ok +false == $env.ok +false == $env?.Bar +false == $env?.String +false == $env?.[Bar] +false == $env?.[String] +false == $env?.[String]?.[f64] +false == $env?.[String]?.greet +false == $env?.[foobar]?.[str] +false == $env?.[str] +false == $env?.ok +false == nil && ok +false ? $env : $env.greet +false ? $env : $env.list +false ? $env : $env?.[str] +false ? $env : $env?.add +false ? $env : foo.Bar +false ? $env : foo?.Bar +false ? 0 : array?.[i] +false ? 0 : foo?.Bar +false ? 1 : $env?.f64 +false ? 1 : $env?.i +false ? 1 : $env?.ok +false ? 1.0 : $env.greet +false ? 1.0 : $env?.[Bar] +false ? 1.0 : $env?.greet +false ? 1.0 : $env?.list +false ? 1.0 : $env?.ok +false ? 1.0 : foo?.Bar +false ? 1.0 : foo?.String() +false ? 1.0 : str contains str +false ? add : $env.array +false ? add : list | reduce(true) +false ? add : nil not in array +false ? array : $env.f64 +false ? array : $env?.f64 +false ? array : $env?.list +false ? array : 1 * f64 +false ? array : nil != str +false ? f64 : $env.array +false ? f64 : $env.f64 +false ? f64 : $env.list +false ? f64 : $env.ok +false ? f64 : $env?.[String] +false ? f64 : $env?.greet +false ? f64 : $env?.str +false ? f64 : list | groupBy(#) +false ? false : $env?.list +false ? foo : $env?.String +false ? foo : $env?.[Bar] +false ? foo : $env?.[String] +false ? foo : $env?.add +false ? foo : $env?.f64 +false ? foo : $env?.i +false ? foo : $env?.ok +false ? foo : array | map(0) +false ? foo : foo.Bar +false ? foo : foo?.Bar +false ? foo : foo?.String +false ? greet : $env | map(1.0) +false ? greet : $env?.greet +false ? i : $env.str +false ? i : $env?.[String] +false ? list : $env.array +false ? list : $env?.foo +false ? list : foo.Bar +false ? nil : $env.foo +false ? nil : $env?.greet +false ? nil : $env?.str +false ? nil : foo.String +false ? ok : $env.str +false ? ok : $env?.[Bar] +false ? ok : $env?.array +false ? ok : list | groupBy(i) +false ? str : $env != str +false ? str : $env.add +false ? str : $env.f64 +false ? str : $env.list +false ? str : $env?.Bar +false ? str : foo?.Bar +false ? true : $env.add +false ? true : $env?.String +false ? true : foo.Bar +false ? true : foo?.Bar +false ?: $env.add +false ?: $env.greet +false ?: $env.i +false ?: $env.ok +false ?: $env.str +false ?: $env?.Bar +false ?: $env?.String +false ?: $env?.[foobar] +false ?: $env?.add +false ?: $env?.i +false ?: $env?.list +false ?: $env?.str +false ?: array | sum(1.0) +false ?: f64 - i +false ?: foo.Bar +false ?: foo?.String +false ?: foo?.String() +false ?: i | mean(1) +false ?: list | map(foo) +false and $env != f64 +false and $env <= $env[foobar:foobar] +false and $env == add +false and $env >= str +false and $env not contains str +false and $env not in array +false and $env not in foo || true +false and $env || ok +false and $env.ok +false and $env?.$env?.ok +false and $env?.Bar +false and $env?.Bar != foo +false and $env?.Bar(array, foobar) +false and $env?.String +false and $env?.String() +false and $env?.String?.greet(str) +false and $env?.[Bar] +false and $env?.[Bar]?.[add] +false and $env?.[String] +false and $env?.[add] +false and $env?.[array] +false and $env?.[array]?.[array] +false and $env?.[f64()] not matches str +false and $env?.[f64] +false and $env?.[findLast(String, $env)] +false and $env?.[foo.list] +false and $env?.[foo] +false and $env?.[foobar] +false and $env?.[greet] +false and $env?.[i] +false and $env?.[i].array +false and $env?.[list] +false and $env?.[list].array +false and $env?.[ok(foobar)] +false and $env?.[ok] +false and $env?.[str] +false and $env?.[str]?.list(filter(String / foobar, f64 >= 1.0)) +false and $env?.all(foobar, foo) +false and $env?.none(foobar) +false and $env?.ok +false and $env?.repeat(nil) +false and $env[$env .. add:foo ? true : foobar]?.greet +false and $env[$env[array:foo]:] +false and $env[:foobar?.Bar] +false and $env[Bar(foo):] +false and $env[array():] +false and $env[foobar:] +false and $env[greet(str):true in list] +false and $env[i():] +false and 0 == i +false and 1 != f64 +false and 1 <= f64 +false and 1 not in $env?.array +false and 1.0 ** 1.0 == nil +false and 1.0 <= f64 / f64 +false and 1.0 == i +false and f64 in array +false and i == median(list) +false and nil == str +false and ok and ok +false and str >= foo?.Bar +false and true ?: add +false in $env?.Bar +false in $env?.String +false in $env?.[Bar] +false in $env?.[String] +false in $env?.[foobar]?.[array] +false not in $env?.Bar +false not in $env?.String +false not in $env?.[Bar] +false not in $env?.[String] +false not in $env?.[String]?.Bar +false not in $env?.[first(foobar)] +false not in $env?.[foobar] +false or $env in $env?.[foobar] +false or $env startsWith $env?.[Bar] +false or $env.ok +false or $env?.Bar +false or $env?.Bar?.[i] +false or $env?.String +false or $env?.[Bar] +false or $env?.[Bar]?.list +false or $env?.[String] +false or $env?.[String]?.[list] +false or $env?.[foobar | toJSON(nil)] +false or $env?.[foobar?.[0]] +false or $env?.[str] +false or $env?.foobar +false or $env?.ok +false or 0 not in array +false or 1.0 >= i +false or array == list +false or false ?: ok +false or greet == greet +false or i == i +false or nil != array +false or nil != f64 +false or nil == foo +false or ok == ok +false or str != str +false or str not matches str +false || $env != f64 and $env +false || $env == i +false || $env in list +false || $env.ok +false || $env?.Bar +false || $env?.Bar?.foo +false || $env?.String +false || $env?.String?.foo() +false || $env?.[Bar] +false || $env?.[String] +false || $env?.[str] +false || $env?.false?.array +false || $env?.ok +false || 1 == array?.[i] +false || 1 > f64 +false || 1 in array +false || 1.0 <= 1.0 ?: 1 +false || 1.0 <= i +false || add != add +false || array != list +false || foo in list +false || i >= i +false || nil != i +false || nil == greet +false || str not endsWith str +false || true == ok +false; $env?.Bar +false; $env?.String +false; $env?.[Bar] +filter($env, #.list) | filter(false) +filter($env, .f64) | filter(false) +filter($env, .ok) | filter(false) +filter($env, false) | all(#) +filter($env, false) | all(#.str not matches .str) +filter($env, false) | all(false) +filter($env, false) | find(true) +filter($env, false) | groupBy(#) +filter($env, false) | reduce(#.list, str) +filter($env, false) | reduce(true, nil) +filter($env, false) | sortBy(foo) +filter($env, false) | sum(greet) +filter($env, ok) | map(foo) +filter($env.array, foo != foo) +filter($env.array, i == 1) +filter($env.list, ok) +filter($env.list, true || true) +filter($env?.[str], ok) +filter($env?.array, ok) +filter($env?.list, ok) +filter([0], ok) +filter([1], # != 1.0) +filter([true, $env], 1 < 1) filter(array, # != #) -filter(array, # != f32) -filter(array, # != f64) -filter(array, # != i) -filter(array, # != i64) -filter(array, # < #) -filter(array, # < f64) filter(array, # <= #) -filter(array, # <= 1) -filter(array, # <= bitshr(#, #)) -filter(array, # <= i) -filter(array, # <= i64) -filter(array, # == #) -filter(array, # == 0.5) -filter(array, # == f32) -filter(array, # == f64) -filter(array, # == i) -filter(array, # == i32) -filter(array, # == i64) -filter(array, # == nil) -filter(array, # > #) -filter(array, # > 0.5) -filter(array, # > 1) -filter(array, # > i) -filter(array, # > i32) -filter(array, # >= #) -filter(array, # >= 0.5) -filter(array, # >= 1) -filter(array, # >= f32) -filter(array, # >= i) -filter(array, # >= i32) -filter(array, # >= i64) -filter(array, 0.5 != #) -filter(array, 0.5 != f64) -filter(array, 0.5 != i) -filter(array, 0.5 < #) -filter(array, 0.5 < f64) -filter(array, 0.5 < i32) -filter(array, 0.5 <= #) -filter(array, 0.5 <= i) -filter(array, 0.5 <= i32) -filter(array, 0.5 == #) -filter(array, 0.5 == f64) -filter(array, 0.5 > #) -filter(array, 0.5 >= #) -filter(array, 1 != #) -filter(array, 1 < i) -filter(array, 1 == #) -filter(array, 1 == 0.5) -filter(array, 1 == i) -filter(array, 1 > i) +filter(array, $env != $env) +filter(array, $env and false) filter(array, 1 >= #) -filter(array, add == add) -filter(array, add == nil) -filter(array, any(list, ok)) -filter(array, f32 != #) -filter(array, f32 < #) -filter(array, f32 <= #) -filter(array, f32 == #) -filter(array, f32 == i64) -filter(array, f32 > #) -filter(array, f32 >= #) -filter(array, f64 < #) +filter(array, 1.0 <= f64) +filter(array, 1.0 == $env) +filter(array, 1.0 > 1.0) filter(array, f64 <= #) -filter(array, f64 == i32) -filter(array, f64 >= #) -filter(array, half != nil) -filter(array, half == half) -filter(array, half(1) >= # ^ i) -filter(array, i != #) -filter(array, i != f64) -filter(array, i <= i32) -filter(array, i == #) -filter(array, i > #) -filter(array, i > f32) -filter(array, i32 != i64) -filter(array, i32 < 0.5) -filter(array, i32 > #) -filter(array, i64 < #) -filter(array, i64 < i64) -filter(array, i64 == #) -filter(array, i64 == i32) -filter(array, i64 >= #) -filter(array, nil != #) -filter(array, nil != greet) -filter(array, nil == #) -filter(array, nil == 1) -filter(array, nil == i32) -filter(array, not false) -filter(array, not ok) -filter(array, not true) -filter(array, ok && true) +filter(array, false) | all($env[1.0:]) +filter(array, false) | sortBy($env) +filter(array, false) | sortBy(add) filter(array, ok) -filter(array, ok)[i64] -filter(array, score == nil) -filter(array, true == true) -filter(array, true and true) -filter(false ? ok : array, # == nil) -filter(filter(list, true), ok) -filter(groupBy(list, #).f64, # not matches #?.foo) -filter(i .. i64, ok) -filter(list, !ok) -filter(list, !true) -filter(list, "bar" < "foo") -filter(list, "bar" not matches "foo") -filter(list, "foo" == "foo") -filter(list, "foo" in #) -filter(list, "foo" not endsWith "bar") -filter(list, "foo" startsWith "bar") -filter(list, # != #) -filter(list, # != foo) -filter(list, # != nil) -filter(list, # == #) -filter(list, # == foo) -filter(list, # in list) -filter(list, 0.5 < 1) -filter(list, 0.5 <= 0.5) -filter(list, 0.5 >= 1) -filter(list, 0.5 >= i) -filter(list, 0.5 >= i64) -filter(list, 1 < 1) -filter(list, 1 <= f32) -filter(list, any(array, ok)) -filter(list, any(list, true)) -filter(list, div != div) -filter(list, f32 <= 1) -filter(list, f32 == f64) -filter(list, f32 > i) -filter(list, f64 <= 1) -filter(list, f64 == 0.5) -filter(list, false != false) -filter(list, false or ok) -filter(list, foo == #) -filter(list, i < 0.5) -filter(list, i < f32) -filter(list, i >= 0.5) -filter(list, i64 > 0.5) -filter(list, nil != "foo") -filter(list, nil != #) -filter(list, nil != #?.Bar) -filter(list, nil != add) -filter(list, nil != greet) -filter(list, nil != i64) -filter(list, nil == #) -filter(list, nil == 0.5) -filter(list, nil == f32) -filter(list, nil == half) -filter(list, nil == i32) -filter(list, nil == score) -filter(list, ok == nil) -filter(list, ok and false) +filter(array, ok) | findIndex(false) +filter(array, ok) | sortBy(0) +filter(array, ok)?.[i] +filter(array, str in foo) +filter(array, true) | findLast(ok) +filter(array, true) | none(true) +filter(array, true)?.[i] +filter(concat(array), #.greet || true) +filter(keys($env), ok) +filter(list, # == $env) +filter(list, # not in list) +filter(list, #.Bar in #) +filter(list, #.Bar not in foo) +filter(list, $env != #) +filter(list, $env != str) +filter(list, $env == #) +filter(list, $env?.ok) +filter(list, 1.0 == nil) +filter(list, f64 <= 1.0) +filter(list, false) | sum($env) +filter(list, false) | sum(foo) +filter(list, foo != nil) filter(list, ok) -filter(list, ok)[i] -filter(list, true == ok) -filter(list, true || true) -filter(list, true) == list -filter(map(array, #), # == 1) -filter(map(array, #), # > #) -filter(map(array, 1), ok) -filter(map(array, greet), ok) -filter(map(array, i32), ok) -filter(map(array, i64), nil == div) -filter(map(array, ok), true || ok) -filter(map(array, score), # != nil) -filter(map(list, #), # == #) -filter(map(list, #), half != nil) -filter(map(list, #), ok) -filter(map(list, array), # == #) -filter(map(list, f32), # == #) -filter(map(list, f32), ok) -filter(map(list, false), #) -filter(map(list, i32), i64 <= i32) -filter(map(list, ok), #) -filter(map(list, true), #) -filter(ok ? "foo" : 0.5, # <= i64) -filter(true ? list : score, # != #) -find(1 .. i, ok) -find([ok], #) -find([score, score], # == #) -find(array, !(# <= i32)) -find(array, !ok) -find(array, !true) -find(array, "bar" not startsWith "foo") -find(array, "foo" not contains "bar") -find(array, # != #) -find(array, # != 1) -find(array, # != i) -find(array, # != i32) -find(array, # != nil) -find(array, # - i != #) -find(array, # < #) -find(array, # < 0.5) -find(array, # < 1) -find(array, # < f32) -find(array, # < i) -find(array, # < i32) -find(array, # < i64) -find(array, # <= #) -find(array, # <= 0.5) -find(array, # <= 1) -find(array, # <= i32) -find(array, # == #) -find(array, # == 0.5) +filter(list, ok) | findIndex(true) +filter(list, ok)?.[i] +filter(list, str != $env) +filter(list, true) | all(true) +filter(list, true) | reduce(#acc) +filter(list, true) | reduce(i) +filter(map($env, foo), # != #) +filter(sort($env), #.foo?.String) +filter(sort($env), #.i || #) +filter(sort($env), nil not in .list) +find($env | filter(false), # endsWith .Bar) +find($env, false)?.Bar +find($env, false)?.String +find($env, false)?.[add] +find($env, false)?.[array] +find($env, false)?.[f64] +find($env, false)?.[foo] +find($env, false)?.[greet].i() +find($env, false)?.[greet].str +find($env, false)?.[i]?.foo +find($env, false)?.[list] +find($env, false)?.[ok] +find($env, false)?.[{foo: false}] +find($env, false)?.add +find($env, false)?.array +find($env, false)?.bitxor(ok, nil, 1) +find($env, false)?.f64 +find($env, false)?.foo +find($env, false)?.foo() +find($env, false)?.greet +find($env, false)?.greet(foobar) +find($env, false)?.i +find($env, false)?.i() +find($env, false)?.list +find($env, false)?.ok +find($env.array, i != 1.0) +find($env.array, ok) +find($env.list, ok) +find($env?.[str], 1 > 0) +find($env?.[str], ok or .ok) +find($env?.[str], ok) +find($env?.list, f64 != 0) +find($env?.list, ok) +find([str], ok) +find(array, # != 0) +find(array, # < 0) +find(array, # <= 0) +find(array, # <= i) find(array, # == 1) -find(array, # == i) -find(array, # == i64) -find(array, # == nil) -find(array, # > #) -find(array, # > 1) -find(array, # > i32) -find(array, # > i64) -find(array, # >= #) -find(array, # >= 1) -find(array, # >= f64) -find(array, # >= i) -find(array, # not in array) -find(array, 0.5 != 1) -find(array, 0.5 / i64 <= #) -find(array, 0.5 < #) -find(array, 0.5 < f64) -find(array, 0.5 <= #) -find(array, 0.5 >= #) -find(array, 0.5 >= 0.5) -find(array, 0.5 >= f64) -find(array, 1 != #) -find(array, 1 < #) -find(array, 1 < i32) -find(array, 1 < i64) -find(array, 1 <= #) -find(array, 1 <= i) -find(array, 1 == #) -find(array, 1 > #) -find(array, 1 >= #) -find(array, div != nil) -find(array, f32 != #) -find(array, f32 != f32) -find(array, f32 < #) -find(array, f32 <= #) -find(array, f32 == #) -find(array, f32 == i32) -find(array, f32 > #) -find(array, f32 >= #) -find(array, f64 != #) -find(array, f64 < #) -find(array, f64 < 1) -find(array, f64 <= #) -find(array, f64 == #) -find(array, f64 == i64) -find(array, false ? # : false) -find(array, false) != f64 -find(array, floor(#) > #) -find(array, greet != greet) -find(array, i % # != f64) -find(array, i < 0.5) -find(array, i <= #) -find(array, i > 0.5) -find(array, i >= #) -find(array, i >= 1) -find(array, i32 != #) -find(array, i32 != i32) -find(array, i32 == #) -find(array, i32 > #) -find(array, i32 >= #) -find(array, i64 != #) -find(array, i64 != 1) -find(array, i64 < #) -find(array, i64 <= #) -find(array, i64 == #) -find(array, i64 > #) -find(array, nil != nil) -find(array, nil == #) -find(array, nil == 0.5) -find(array, nil == i32) -find(array, none(array, true)) -find(array, not (# == #)) -find(array, ok == nil) -find(array, ok and false) +find(array, $env == foo) +find(array, $env | any(false)) +find(array, 0 != f64) +find(array, 0 <= 1) +find(array, 1.0 != #) +find(array, 1.0 != nil) +find(array, 1.0 == nil) +find(array, array | one(true)) +find(array, nil != true) +find(array, ok or false) find(array, ok) -find(array, ok) % i32 -find(array, ok) ** i -find(array, ok) >= i32 -find(array, true) > f64 -find(array, true) > i64 -find(filter(list, false), i64 not in array) -find(groupBy(array, #).Qux, .String?.f32) -find(groupBy(array, #).ok, first(#[1])) -find(i .. i64, ok) -find(i64 .. i32, # != #) -find(list, !false) -find(list, !ok) -find(list, "bar" not in #) -find(list, "foo" contains "foo") find(list, # != #) -find(list, # != nil) -find(list, # == #) -find(list, # == foo) -find(list, # == nil) -find(list, 0.5 != 1) -find(list, 0.5 <= 0.5) -find(list, 1 != 0.5) -find(list, 1 < 1) -find(list, 1 < i64) -find(list, 1 == f64) -find(list, 1 > 0.5) -find(list, 1 > i) -find(list, 1 > i64) -find(list, f32 < 1) -find(list, f32 <= 0.5) -find(list, f32 <= i32) -find(list, f32 == i64) -find(list, f32 > f64) -find(list, f32 not in array) -find(list, f64 < f64) -find(list, false && true) +find(list, #.String == .String) +find(list, $env != list) +find(list, $env == nil) +find(list, $env not in array) +find(list, 0 > i) +find(list, 1 == 1.0) +find(list, array != $env) +find(list, array == list) find(list, false)?.Bar find(list, foo != #) -find(list, foo == #) -find(list, i != 1) -find(list, i != f64) -find(list, i != i32) -find(list, i32 != 1) -find(list, i32 != f64) -find(list, i32 < i) -find(list, i32 == i32) -find(list, nil != #) -find(list, nil != ok) -find(list, nil == array) -find(list, nil == div) -find(list, not false) -find(list, ok != false) +find(list, foo != nil) +find(list, nil == str) find(list, ok) -find(list, ok).String -find(list, ok).String() +find(list, ok).Bar find(list, ok)?.Bar -find(list, ok)?.Qux find(list, ok)?.String -find(list, score == score) -find(list, true != nil) -find(list, true == true) -find(list, true or false) +find(list, str == $env) find(list, true).Bar -find(list, true).Qux find(list, true).String -find(list, true)?.Bar find(list, true)?.String -find(map(array, #), # != f32) -find(map(array, #), # <= 1) -find(map(array, #), # == 0.5) -find(map(array, #), ok) -find(map(array, false), #) -find(map(array, foo), ok) -find(map(array, ok), #) -find(map(list, #), # != #) -find(map(list, #), ok) -find(map(list, 0.5), # != #) -find(map(list, add), 0.5 >= i64) -find(map(list, div), # == #) -find(map(list, f32), # > 0.5) -find(map(list, false), #) -find(map(list, i), # == i64) -find(map(list, ok), #) -find(map(list, true), #) -find(ok ? "foo" : f64, f32 >= #) -findIndex(array, !ok) -findIndex(array, "bar" == "foo") -findIndex(array, "foo" > "foo") -findIndex(array, "foo" in foo) +find(max($env), $env == i) +find(sort($env), #.f64 not startsWith .String) +find(sort($env), .str?.ok)?.[ok] +find(toPairs($env), $env.ok) +findIndex($env?.[str], 1.0 == nil) +findIndex($env?.array, # < #) +findIndex($env?.list, ok) +findIndex([0], # <= 1) +findIndex([1.0], # > 1.0) +findIndex([add], ok) +findIndex([array], ok) +findIndex([f64], ok) +findIndex([false], #) +findIndex([foo], ok) +findIndex([list], $env == add) +findIndex([str], $env?.ok) +findIndex([true], #) +findIndex(array | sortBy(1.0), ok) findIndex(array, # != #) -findIndex(array, # != 0.5) -findIndex(array, # != f32) -findIndex(array, # != f64) -findIndex(array, # != i) -findIndex(array, # != i64) findIndex(array, # != nil) -findIndex(array, # < #) -findIndex(array, # < 1) -findIndex(array, # < i32) -findIndex(array, # <= #) -findIndex(array, # <= 0.5) -findIndex(array, # <= 1) -findIndex(array, # == #) -findIndex(array, # == 0.5) -findIndex(array, # == 1) -findIndex(array, # == i32) -findIndex(array, # == nil) findIndex(array, # > #) -findIndex(array, # > 0.5) -findIndex(array, # > 1) -findIndex(array, # > f64) -findIndex(array, # > i) -findIndex(array, # > i64) findIndex(array, # >= #) -findIndex(array, # >= 0.5) -findIndex(array, # >= 1) -findIndex(array, # >= f32) -findIndex(array, # >= f64) -findIndex(array, # >= i) -findIndex(array, # >= i32) -findIndex(array, # >= i64) -findIndex(array, 0.5 != #) -findIndex(array, 0.5 != 1) -findIndex(array, 0.5 < 1) -findIndex(array, 0.5 <= #) -findIndex(array, 0.5 == #) -findIndex(array, 0.5 == i64) -findIndex(array, 0.5 > #) -findIndex(array, 0.5 > 0.5) -findIndex(array, 0.5 > i) -findIndex(array, 0.5 > i32) -findIndex(array, 0.5 >= 0.5) -findIndex(array, 0.5 >= 1) -findIndex(array, 0.5 not in array) -findIndex(array, 1 != #) -findIndex(array, 1 != i64) -findIndex(array, 1 != nil) -findIndex(array, 1 < #) +findIndex(array, $env != true) +findIndex(array, $env.ok) +findIndex(array, $env?.ok) +findIndex(array, 0 == #) findIndex(array, 1 <= #) -findIndex(array, 1 > #) -findIndex(array, 1 > i) -findIndex(array, 1 >= #) -findIndex(array, add != div) -findIndex(array, add != nil) -findIndex(array, f32 != #) -findIndex(array, f32 != 1) -findIndex(array, f32 < #) -findIndex(array, f32 == #) -findIndex(array, f32 >= #) -findIndex(array, f32 >= i32) -findIndex(array, f64 >= #) -findIndex(array, f64 >= i32) -findIndex(array, false) == -f64 -findIndex(array, i != f64) -findIndex(array, i < #) -findIndex(array, i < i32) -findIndex(array, i <= #) -findIndex(array, i <= 0.5) -findIndex(array, i == #) -findIndex(array, i >= i) -findIndex(array, i >= i32) -findIndex(array, i32 != #) -findIndex(array, i32 < #) -findIndex(array, i32 == #) -findIndex(array, i32 > f32) -findIndex(array, i64 != #) -findIndex(array, i64 != nil) -findIndex(array, i64 < 0.5) -findIndex(array, i64 <= #) -findIndex(array, i64 <= i64) -findIndex(array, i64 > #) -findIndex(array, i64 >= #) -findIndex(array, i64 >= f64) -findIndex(array, i64 >= i32) -findIndex(array, nil != half) -findIndex(array, nil != ok) -findIndex(array, nil == #) -findIndex(array, nil == 1) -findIndex(array, nil == nil) -findIndex(array, not false) +findIndex(array, 1.0 != $env) +findIndex(array, 1.0 < #) +findIndex(array, 1.0 >= #) +findIndex(array, add == nil) +findIndex(array, false || ok) +findIndex(array, foo == nil) +findIndex(array, nil != foo) findIndex(array, ok) -findIndex(array, ok) / f64 -findIndex(array, ok) / i -findIndex(array, ok) <= f32 -findIndex(array, one(list, false)) -findIndex(array, true) + f64 -findIndex(array, true) - f64 -findIndex(array, true) .. i -findIndex(filter(array, false), # > 1) -findIndex(filter(array, true), # not in array) -findIndex(filter(list, false), 1 <= i64) -findIndex(groupBy(array, #).f64, .Bar(half(add, half, div, greet, f64))) -findIndex(groupBy(array, false).String, #?.i64()) -findIndex(groupBy(array, foo).String, #) -findIndex(groupBy(list, #).Qux, #) -findIndex(i32 .. 1, # >= #) -findIndex(list, !false) -findIndex(list, !ok) -findIndex(list, !true) -findIndex(list, "bar" > "foo") -findIndex(list, "bar" in #) -findIndex(list, "bar" not in #) -findIndex(list, # != #) -findIndex(list, # != nil) +findIndex(array, true) | min(array) +findIndex(filter($env, false), #.list(foobar)) +findIndex(flatten(list), .String != ok) findIndex(list, # == #) -findIndex(list, # == foo) -findIndex(list, # in list) -findIndex(list, #?.Bar not in #) -findIndex(list, 0.5 != i) -findIndex(list, 0.5 > 1) -findIndex(list, 0.5 >= i) -findIndex(list, 1 != i32) -findIndex(list, 1 < f64) -findIndex(list, 1 < i32) -findIndex(list, 1 == f32) -findIndex(list, 1 > 0.5) -findIndex(list, 1 > i32) -findIndex(list, 1 >= 1) -findIndex(list, 1 >= i) -findIndex(list, f32 != f32) -findIndex(list, f32 != i) -findIndex(list, f32 < i32) -findIndex(list, f32 == bitshl(i, i64)) -findIndex(list, f32 > 1) -findIndex(list, f64 != 0.5) -findIndex(list, f64 < 1) -findIndex(list, f64 < i) -findIndex(list, f64 > 1) -findIndex(list, f64 >= f64) -findIndex(list, false != nil) -findIndex(list, false || ok) -findIndex(list, foo != #) +findIndex(list, # == nil) +findIndex(list, $env != .String) +findIndex(list, $env == false) +findIndex(list, .Bar == $env) +findIndex(list, f64 == 1.0) +findIndex(list, foo != $env) findIndex(list, greet == nil) -findIndex(list, i < 0.5) -findIndex(list, i <= i32) -findIndex(list, i32 == 1) -findIndex(list, i32 >= i64) -findIndex(list, i64 != f32) -findIndex(list, nil != 0.5) -findIndex(list, nil != f32) -findIndex(list, nil != i64) -findIndex(list, nil == "foo") -findIndex(list, nil == f64) -findIndex(list, not ok) -findIndex(list, not true) +findIndex(list, nil != $env) findIndex(list, ok) -findIndex(list, ok) * i -findIndex(list, ok) ** i -findIndex(list, ok) >= f64 -findIndex(list, ok) ^ i32 -findIndex(list, true ? ok : #) -findIndex(list, true) % i64 -findIndex(map(array, #), # < #) -findIndex(map(array, #), # >= #) -findIndex(map(array, #), i > #) -findIndex(map(array, f32), i32 == #) -findIndex(map(array, i), # != #) -findIndex(map(array, i), ok) -findIndex(map(list, #), # != #) -findIndex(map(list, #), # == #) -findIndex(map(list, i64), # == 0.5) -findIndex(map(list, i64), i64 < #) -findIndex(map(list, true), #) -findIndex(map(list, true), ok) -findIndex(ok ? "foo" : greet, !ok) -findIndex(ok ? "foo" : i, # == #) -findIndex(sort(array), i32 == #) -findIndex(true ? "foo" : ok, # == greet) -findLast(1 .. i, # <= #) -findLast(1 .. i32, 1 >= #) -findLast(1 .. i64, ok) -findLast([false], #) -findLast(array, !false) -findLast(array, !ok) -findLast(array, "foo" > "bar") -findLast(array, # != #) -findLast(array, # != 0.5) -findLast(array, # != 1) -findLast(array, # != f32) -findLast(array, # != f64) -findLast(array, # != i) -findLast(array, # < #) -findLast(array, # < 0.5) -findLast(array, # < f32) +findIndex(list, ok) * f64 +findIndex(list, str in #) +findIndex(list, str not contains str) +findIndex(sort($env), #.String?.list(foobar)) +findIndex(sort($env), .array) +findIndex(sort($env), list not in .Bar) +findLast($env, false) == greet +findLast($env, false)?.Bar +findLast($env, false)?.String +findLast($env, false)?.[add] +findLast($env, false)?.[foo] +findLast($env, false)?.[greet] +findLast($env, false)?.[greet]?.Bar +findLast($env, false)?.[i] +findLast($env, false)?.[list] +findLast($env, false)?.[ok] +findLast($env, false)?.[str] +findLast($env, false)?.add() +findLast($env, false)?.array +findLast($env, false)?.f64 +findLast($env, false)?.f64() +findLast($env, false)?.f64?.[str] +findLast($env, false)?.foo +findLast($env, false)?.greet() +findLast($env, false)?.i +findLast($env, false)?.i() +findLast($env, false)?.list() +findLast($env, false)?.ok +findLast($env, false)?.ok() +findLast($env, false)?.str +findLast($env.array, # >= #) +findLast($env.array, str in $env) +findLast($env.list, ok) +findLast($env?.[str], # not in array) +findLast($env?.[str], false == #) +findLast($env?.array, $env.ok) +findLast($env?.array, i in array) +findLast($env?.array, ok) +findLast($env?.list, ok) +findLast([$env], $env != nil).array +findLast([1.0], ok) +findLast([false], $env | none(true)) +findLast([ok], ok) +findLast([true], ok) +findLast(array | map(#index), ok) findLast(array, # < f64) -findLast(array, # < i + #) findLast(array, # <= #) -findLast(array, # <= 0.5) -findLast(array, # <= 1) -findLast(array, # <= f32) -findLast(array, # <= i64) -findLast(array, # == #) -findLast(array, # == 0.5) -findLast(array, # == nil) -findLast(array, # > #) -findLast(array, # > 0.5) -findLast(array, # > 1) -findLast(array, # > i) -findLast(array, # > i32) -findLast(array, # > i64) -findLast(array, # >= #) -findLast(array, # >= 0.5) -findLast(array, # >= 1) -findLast(array, # >= f32) -findLast(array, # >= i32) -findLast(array, 0.5 <= #) -findLast(array, 0.5 <= i64) -findLast(array, 0.5 > #) -findLast(array, 0.5 >= #) -findLast(array, 0.5 >= 1) +findLast(array, # > 1.0) +findLast(array, $env?.ok) findLast(array, 1 != #) -findLast(array, 1 <= #) -findLast(array, 1 == #) -findLast(array, f32 >= #) -findLast(array, f64 != #) -findLast(array, f64 != nil) -findLast(array, f64 <= #) -findLast(array, f64 <= 1) -findLast(array, f64 == #) -findLast(array, f64 == nil) -findLast(array, f64 >= 1) -findLast(array, f64 >= i64) -findLast(array, false != true) -findLast(array, false or true) -findLast(array, greet != nil) -findLast(array, i < #) -findLast(array, i == i32) -findLast(array, i > #) -findLast(array, i >= 0.5) -findLast(array, i32 < #) -findLast(array, i32 == 0.5) -findLast(array, i32 > #) -findLast(array, i32 >= #) -findLast(array, i32 >= i32) -findLast(array, i64 != #) -findLast(array, i64 < #) -findLast(array, i64 <= #) -findLast(array, i64 == #) -findLast(array, i64 > 0.5) -findLast(array, list != nil) -findLast(array, nil != array) -findLast(array, not (array == array)) -findLast(array, not false) -findLast(array, not ok) -findLast(array, ok and true) +findLast(array, 1 < 1) +findLast(array, 1.0 >= 1.0) +findLast(array, f64 < 0) +findLast(array, f64 < f64) +findLast(array, f64 > #) +findLast(array, f64 >= 1.0) +findLast(array, f64 >= i) +findLast(array, false || true) +findLast(array, nil != #) +findLast(array, nil != nil) +findLast(array, ok ?: 1.0) findLast(array, ok) -findLast(array, ok) == i64 -findLast(array, reduce(list, ok)) -findLast(array, score != nil) -findLast(array, true) % i64 -findLast(groupBy(array, #).i32, #) -findLast(groupBy(list, "bar").div, #?.f32?.half()) -findLast(groupBy(list, #)[ok], .ok) -findLast(groupBy(list, f64).foo, .f32(#, #)?.Qux(#?.i64(add, nil))) -findLast(i .. 1, # < #) -findLast(i .. i32, # != i64) -findLast(i .. i32, ok) -findLast(i32 .. i64, # >= i) -findLast(i64 .. 1, # < #) -findLast(list, !false) -findLast(list, !ok) -findLast(list, "foo" in #) -findLast(list, # != #) -findLast(list, # != nil) -findLast(list, # == #) +findLast(array, ok) >= f64 +findLast(array, ok) in array +findLast(array, str not in foo) +findLast(filter(list, false), $env?.[array]) +findLast(keys($env), foo == foo) +findLast(list | sortBy(0), # == #) findLast(list, # == foo) -findLast(list, # in list) -findLast(list, # not in list) -findLast(list, 0.5 != i64) -findLast(list, 0.5 <= 1) -findLast(list, 0.5 == i64) -findLast(list, 1 != f32) -findLast(list, 1 != nil) -findLast(list, 1 <= 1) -findLast(list, 1 > f32) -findLast(list, 1 >= f64) -findLast(list, f32 != i) -findLast(list, f32 > f32) -findLast(list, f32 >= 1) -findLast(list, f64 <= i) -findLast(list, f64 in array) +findLast(list, #.Bar in #) +findLast(list, #.String != nil) +findLast(list, $env != true) +findLast(list, $env == false) +findLast(list, $env == foo.String()) +findLast(list, $env or true) +findLast(list, $env.ok) +findLast(list, 0 != 1.0) +findLast(list, 1 >= 1.0) +findLast(list, 1.0 <= f64) +findLast(list, 1.0 == 1) +findLast(list, 1.0 >= 1.0) +findLast(list, f64 == f64) findLast(list, false)?.Bar -findLast(list, foo != #) -findLast(list, foo in list) -findLast(list, i != i) -findLast(list, i <= 1) -findLast(list, i <= i) -findLast(list, i == i32) -findLast(list, i >= i) -findLast(list, i32 != f32) -findLast(list, i64 > f32) -findLast(list, i64 > i) -findLast(list, i64 >= 1) -findLast(list, nil != #) -findLast(list, nil not in array) -findLast(list, nil not in list) -findLast(list, none(array, ok)) -findLast(list, not false) -findLast(list, not true) -findLast(list, ok or true) +findLast(list, foo == #) +findLast(list, i > 0) +findLast(list, nil == #) +findLast(list, nil == greet) findLast(list, ok) -findLast(list, ok) not in list findLast(list, ok).Bar -findLast(list, ok).Qux -findLast(list, ok).String -findLast(list, ok)?.Bar -findLast(list, ok)?.Qux -findLast(list, ok)?.String -findLast(list, true or ok) -findLast(list, true).Bar -findLast(list, true).Qux +findLast(list, ok).String() +findLast(list, true && false) findLast(list, true).String findLast(list, true)?.Bar -findLast(list, true)?.Qux -findLast(list, true)?.String -findLast(map(array, #), # < #) -findLast(map(array, #), # < i32) -findLast(map(array, #), # <= 1) -findLast(map(array, #), # == f64) -findLast(map(array, #), 0.5 != 0.5) -findLast(map(array, #), i32 == #) -findLast(map(array, #), ok) -findLast(map(array, f64 * #), # + # > f32) -findLast(map(array, score), ok) -findLast(map(list, #), # == #) -findLast(map(list, #), greet == nil) -findLast(map(list, #), ok) -findLast(map(list, ok), # ? # : #) -findLastIndex(1 .. 1, i64 < #) -findLastIndex([i64, half], ok) -findLastIndex(array, "bar" not matches "foo") -findLastIndex(array, "bar" startsWith "foo") -findLastIndex(array, "foo" == nil) -findLastIndex(array, "foo" >= "foo") -findLastIndex(array, "foo" contains "foo") -findLastIndex(array, # != #) -findLastIndex(array, # != 1) -findLastIndex(array, # != f32) -findLastIndex(array, # != f64) -findLastIndex(array, # != i32) -findLastIndex(array, # != i64) -findLastIndex(array, # != nil) +findLast(min($env), .array and false) +findLast(sort($env), .array) +findLast(sort($env), .f64 != #.i) +findLast(sort($env), .list?.list) +findLast(sort($env), 1.0 != #.list) +findLastIndex($env, ok) > i +findLastIndex($env, ok) ^ f64 +findLastIndex($env, true) <= f64 +findLastIndex($env, true) | bitor(1) +findLastIndex($env, true) | bitshl(1) +findLastIndex($env?.[str], 1.0 > #) +findLastIndex($env?.array, ok) +findLastIndex([false, true, $env], #.greet != true) +findLastIndex([list], foo not in #) +findLastIndex([true], str < str) findLastIndex(array, # < #) -findLastIndex(array, # < 1) -findLastIndex(array, # < f64) findLastIndex(array, # < i) -findLastIndex(array, # < i64) findLastIndex(array, # <= #) -findLastIndex(array, # <= 0.5) -findLastIndex(array, # <= i64) -findLastIndex(array, # == #) -findLastIndex(array, # == 0.5) -findLastIndex(array, # == 1) -findLastIndex(array, # == f64) -findLastIndex(array, # == i64) -findLastIndex(array, # == nil) findLastIndex(array, # > #) -findLastIndex(array, # > 0.5) -findLastIndex(array, # > f32) -findLastIndex(array, # > f64) -findLastIndex(array, # > i) -findLastIndex(array, # >= #) -findLastIndex(array, # >= 0.5) -findLastIndex(array, # >= 1) -findLastIndex(array, # >= f32) -findLastIndex(array, # >= i32) -findLastIndex(array, # ^ # >= #) -findLastIndex(array, # not in array) -findLastIndex(array, 0.5 != #) -findLastIndex(array, 0.5 != i64) -findLastIndex(array, 0.5 < #) -findLastIndex(array, 0.5 < i32) -findLastIndex(array, 0.5 <= #) -findLastIndex(array, 0.5 > #) -findLastIndex(array, 0.5 >= 0.5) -findLastIndex(array, 0.5 >= f64) -findLastIndex(array, 1 != #) -findLastIndex(array, 1 <= #) -findLastIndex(array, 1 == #) -findLastIndex(array, 1 == f64) -findLastIndex(array, 1 >= i32) -findLastIndex(array, array == nil) -findLastIndex(array, f32 != #) -findLastIndex(array, f32 != f32) -findLastIndex(array, f32 < #) -findLastIndex(array, f32 == #) -findLastIndex(array, f32 == nil) -findLastIndex(array, f32 > #) -findLastIndex(array, f64 != #) -findLastIndex(array, f64 < #) -findLastIndex(array, f64 <= #) -findLastIndex(array, f64 <= i32) -findLastIndex(array, f64 == #) -findLastIndex(array, f64 == 0.5) -findLastIndex(array, f64 > #) -findLastIndex(array, false ? # : false) -findLastIndex(array, foo != foo) -findLastIndex(array, greet == greet) -findLastIndex(array, i - # >= #) -findLastIndex(array, i < #) -findLastIndex(array, i <= #) -findLastIndex(array, i > 0.5) -findLastIndex(array, i32 <= #) -findLastIndex(array, i32 <= 1) -findLastIndex(array, i32 <= f32) -findLastIndex(array, i32 > 0.5) -findLastIndex(array, i32 >= #) -findLastIndex(array, i64 <= # + #) -findLastIndex(array, i64 > #) -findLastIndex(array, min(1, #) <= i32 + #) -findLastIndex(array, nil != #) -findLastIndex(array, nil != add) -findLastIndex(array, nil != i32) -findLastIndex(array, nil == #) -findLastIndex(array, not (i32 != 0.5)) -findLastIndex(array, not ok) -findLastIndex(array, ok && true) +findLastIndex(array, $env == 1.0) +findLastIndex(array, $env.ok) +findLastIndex(array, 0 == $env) +findLastIndex(array, 1 >= 1.0) +findLastIndex(array, add == nil) +findLastIndex(array, any($env, false)) +findLastIndex(array, false) != 1.0 + 1.0 +findLastIndex(array, nil == ok) findLastIndex(array, ok) -findLastIndex(array, ok) % i64 -findLastIndex(array, ok) + f64 -findLastIndex(array, one(list, ok)) -findLastIndex(array, score == nil) -findLastIndex(array, true == false) -findLastIndex(array, true) / f32 -findLastIndex(array, true) not in array -findLastIndex(filter(array, false), ok) -findLastIndex(groupBy(list, #).ok, #) -findLastIndex(groupBy(list, 0.5).Bar, #?.String endsWith .f32(list)) -findLastIndex(i32 .. i32, ok) -findLastIndex(i64 .. 1, ok) -findLastIndex(list, !(nil != #)) -findLastIndex(list, !false) -findLastIndex(list, !ok) -findLastIndex(list, !true) -findLastIndex(list, "bar" in #) -findLastIndex(list, "bar" matches "foo") -findLastIndex(list, "bar" not endsWith "foo") -findLastIndex(list, "bar" not matches "bar") -findLastIndex(list, "foo" <= "bar") -findLastIndex(list, "foo" not in #) -findLastIndex(list, # != #) -findLastIndex(list, # != foo) +findLastIndex(array, str in foo) +findLastIndex(array, str not in $env) +findLastIndex(array, true) * f64 +findLastIndex(false ? nil : $env, ok) +findLastIndex(flatten(array), ok) findLastIndex(list, # == #) -findLastIndex(list, # == foo) -findLastIndex(list, # == nil) -findLastIndex(list, # in list) -findLastIndex(list, # not in list) -findLastIndex(list, 1 != f32) -findLastIndex(list, 1 != nil) -findLastIndex(list, 1 > 1) -findLastIndex(list, 1 >= 0.5) -findLastIndex(list, array != nil) -findLastIndex(list, div != nil) -findLastIndex(list, f32 != 1) -findLastIndex(list, f32 != f64) -findLastIndex(list, f64 > 0.5) -findLastIndex(list, foo == #) -findLastIndex(list, i <= 1) -findLastIndex(list, i32 > 1) -findLastIndex(list, i32 > f32) -findLastIndex(list, i64 == i64) -findLastIndex(list, i64 >= 0.5) -findLastIndex(list, i64 not in array) -findLastIndex(list, nil != "bar") -findLastIndex(list, nil != #) -findLastIndex(list, nil != f64) -findLastIndex(list, nil == #) +findLastIndex(list, #.Bar == nil) +findLastIndex(list, $env.ok) +findLastIndex(list, 0 != 1) +findLastIndex(list, 0 > 1.0) +findLastIndex(list, foo != #) +findLastIndex(list, foo != $env) +findLastIndex(list, foo not in list) +findLastIndex(list, nil != nil) findLastIndex(list, nil == 1) -findLastIndex(list, nil == half) -findLastIndex(list, not false) -findLastIndex(list, not true) -findLastIndex(list, ok ? ok : 0.5) -findLastIndex(list, ok and false) findLastIndex(list, ok) -findLastIndex(list, ok) != i64 -findLastIndex(list, ok) > f32 -findLastIndex(list, ok) > i64 -findLastIndex(list, one(array, true)) -findLastIndex(list, true && ok) -findLastIndex(list, true) * i32 -findLastIndex(list, true) - i32 -findLastIndex(list, true) < i64 -findLastIndex(list, true) > i64 -findLastIndex(list, true) ^ f64 -findLastIndex(map(array, "bar"), # not endsWith #) -findLastIndex(map(array, #), # < f64) -findLastIndex(map(array, #), # <= #) -findLastIndex(map(array, #), ok) -findLastIndex(map(array, div), 0.5 <= 0.5) -findLastIndex(map(array, f32), nil == nil) -findLastIndex(map(array, list), ok) -findLastIndex(map(array, ok), # and #) -findLastIndex(map(list, "bar"), # >= #) -findLastIndex(map(list, #), !true) -findLastIndex(map(list, #), nil == 0.5) -findLastIndex(map(list, false), #) -findLastIndex(map(list, foo), ok) -findLastIndex(map(list, i32), # >= #) -findLastIndex(map(list, i64), ok) -findLastIndex(ok ? "bar" : add, not false) -findLastIndex(true ? "foo" : 1, # and false) -first(1 .. 1) -first(1 .. i64) -first([f32]) +findLastIndex(list, ok) < i +findLastIndex(list, str == $env) +findLastIndex(list, str not in #) +findLastIndex(list, true) > f64 +findLastIndex(map(array, ok), #) +findLastIndex(map(list, add), ok) +findLastIndex(sort($env), #.foo?.greet) +findLastIndex(sort($env), $env ?: #.i) +first($env | findLast(false)) +first($env | map($env)) +first($env | map($env))?.foo +first($env) != foo +first($env) != i +first($env) == str +first($env) not contains str +first($env) not in array +first($env) not matches str +first($env) not startsWith str +first($env) startsWith str +first($env)?.$env?.array() +first($env)?.Bar +first($env)?.Bar() +first($env)?.Bar(add) +first($env)?.String +first($env)?.String() +first($env)?.String?.array +first($env)?.[add] +first($env)?.[add]?.[foo] +first($env)?.[array] +first($env)?.[f64] +first($env)?.[f64]?.String +first($env)?.[foo] +first($env)?.[foo]?.[greet].String +first($env)?.[greet] +first($env)?.[greet]?.[greet] +first($env)?.[greet]?.str +first($env)?.[i] +first($env)?.[i]?.add +first($env)?.[i]?.str +first($env)?.[list] +first($env)?.[ok] +first($env)?.[ok].add() +first($env)?.[str] +first($env)?.[str]?.f64 +first($env)?.[str]?.ok +first($env)?.add +first($env)?.add() +first($env)?.add?.[greet] +first($env)?.array +first($env)?.array() +first($env)?.array(foobar) +first($env)?.f64 +first($env)?.f64() +first($env)?.f64(f64) +first($env)?.f64(foobar) +first($env)?.f64.String +first($env)?.findIndex(add) +first($env)?.foo +first($env)?.foo() +first($env)?.foo(foobar not contains foobar) +first($env)?.foo(foobar) +first($env)?.foo?.[greet] +first($env)?.foobar not in $env +first($env)?.foobar.greet +first($env)?.foobar?.[greet] +first($env)?.greet +first($env)?.greet() +first($env)?.greet(foobar not startsWith foobar) +first($env)?.greet(foobar, foobar) +first($env)?.greet(true) +first($env)?.greet?.[i] +first($env)?.greet?.str +first($env)?.i +first($env)?.i() +first($env)?.i?.add +first($env)?.list +first($env)?.list() +first($env)?.list(foo) +first($env)?.list(foobar?.[Bar]) +first($env)?.list.str +first($env)?.list?.add +first($env)?.map(add) +first($env)?.ok +first($env)?.ok() +first($env)?.ok(foobar) +first($env)?.str +first($env)?.str() +first($env)?.str(f64) +first($env.array) +first($env.list) +first($env?.$env) +first($env?.Bar) +first($env?.Bar)?.array +first($env?.Bar?.[array]) +first($env?.Bar?.f64) +first($env?.String) +first($env?.String)?.String() +first($env?.[Bar]) +first($env?.[Bar])?.[i] +first($env?.[Bar])?.str +first($env?.[Bar]?.String) +first($env?.[Bar]?.f64) +first($env?.[String]) +first($env?.[String]?.foo) +first($env?.[foobar]) +first($env?.[foobar])?.Bar +first($env?.[nil]?.ok) +first($env?.[str]) +first($env?.array) +first($env?.false) +first($env?.foobar) +first($env?.foobar)?.Bar() +first($env?.foobar)?.i() +first($env?.list) +first($env?.nil) +first($env?.nil)?.f64 +first(0..i) +first(1 .. i) +first(1 | median(array)) +first(1.0 | min(array)) +first([$env?.array]) +first([$env]) +first([0]) +first([1.0]) +first([1]) +first([add, $env, greet]) +first([add]) +first([array]) +first([f64]) +first([false]) first([foo]) +first([greet]) +first([i]) +first([list]) +first([nil]) first([ok]) +first([str]) +first([true]) +first(array | map($env)) +first(array | map(0)) +first(array | map(foo)) +first(array | sortBy(#)) +first(array | sortBy(1.0)) +first(array | take(1)) first(array) -first(array) * i -first(array) * i64 -first(array) + f32 -first(array) <= i -first(array) == f32 -first(array) == f64 -first(array) == i64 -first(array) > 0.5 ** i -first(array) > i64 -first(array) ^ f64 -first(array[1:1]) -first(false ? foo : 1) -first(false ? greet : foo) -first(get(groupBy(array, #), i)) -first(groupBy(array, #).greet) -first(groupBy(list, #)?.div) -first(i .. i) -first(i64 .. i32) -first(i64 .. i64) +first(array) != i +first(array) == i +first(array) > 1.0 > $env +first(array) | bitand(1) +first(array[:0]) +first(array[:1]) +first(concat(array)) +first(concat(list)) +first(filter(list, ok)) +first(first($env)) +first(flatten(array)) +first(flatten(list)) +first(i .. 1) +first(i..i) +first(if false { 0 } else { foo }) +first(if true { 0 } else { foo })?.add +first(if true { ok } else { 1 }) +first(if true { ok } else { 1.0 }) +first(keys($env)) +first(last($env)) +first(let foobar = list; foobar) +first(list | map(#)) +first(list | map(0)) +first(list | map(add)) +first(list | map(true)) +first(list | reduce(list)) +first(list | sortBy(#.Bar)) first(list) -first(list) not in list +first(list) == $env?.String first(list).Bar -first(list).Qux first(list).String first(list).String() first(list)?.Bar -first(list)?.Qux first(list)?.String first(list)?.String() +first(list[:i]) +first(map($env, $env)) +first(map($env, 0)) +first(map($env, array)) +first(map($env, f64)) +first(map($env, i)) first(map(array, #)) -first(map(array, 0.5)) -first(map(array, 1)) -first(map(array, add)) -first(map(array, array)) -first(map(array, div)) -first(map(array, half)) -first(map(array, i)) -first(map(array, i32)) -first(map(array, i64)) -first(map(array, ok)) +first(map(array, 0)) +first(map(array, 1.0)) +first(map(array, false)) +first(map(array, greet)) +first(map(array, str)) +first(map(array, true)) first(map(list, #)) -first(map(list, 0.5)) -first(map(list, f32)) -first(map(list, greet)) -first(map(list, i)) -first(map(list, list)) -first(map(list, score)) -first(ok ? 0.5 : false) -first(ok ? array : add) -first(ok ? greet : i64) -first(ok ? list : ok) -first(reduce(list, array)) -first(sort(array)) -first(true ? f32 : div) -first(true ? greet : div) -first(true ? score : div) -float(-0.5) -float(-1) -float(-f32) -float(-f64) -float(-i) -float(-i32) -float(-i64) -float(0.5 * 0.5) -float(0.5 * 1) -float(0.5 * f32) -float(0.5 * i64) -float(0.5 ** 0.5) -float(0.5 ** f32) -float(0.5 + 1) -float(0.5 + i32) -float(0.5 + i64) -float(0.5 - 0.5) -float(0.5 - 1) -float(0.5 - i64) -float(0.5 / 0.5) -float(0.5 / i32) -float(0.5 / i64) -float(0.5 ^ 1) -float(0.5 ^ i) -float(0.5) != f32 -float(0.5) != i32 -float(0.5) * f32 -float(0.5) * i32 -float(0.5) * i64 -float(0.5) ** f64 -float(0.5) ** i -float(0.5) ** i32 -float(0.5) - i -float(0.5) - i64 -float(0.5) / f32 -float(0.5) / f64 -float(0.5) / i32 -float(0.5) == i32 * 0.5 -float(0.5) ^ i64 -float(0.5) in array -float(1 % i64) -float(1 * 0.5) -float(1 * f32) -float(1 * i) -float(1 * i64) -float(1 ** 0.5) +first(map(list, 0)) +first(map(list, foo)) +first(max($env)) +first(max(array)) +first(mean(array)) +first(median(array)) +first(min($env)) +first(min(array)) +first(ok ? 0 : 1.0) +first(ok ?: $env) +first(ok ?: add) +first(ok ?: list) +first(reduce(array, $env)) +first(reverse(list)) +first(sort($env)) +first(sortBy(array, #)) +first(sortBy(array, f64)) +first(sortBy(list, .Bar)) +first(toPairs($env)) +first(true ? 1.0 : foo) +first(true ?: 1.0)?.str +first(uniq(array)) +first(uniq(list)) +first(values($env)) +first({foo: 1.0}.f64) +first({foo: greet, foo: nil}.ok) +flatten($env | map(array)) +flatten($env | map(foo)) +flatten($env | map(i)) +flatten($env.array) +flatten($env.list) +flatten($env?.array) +flatten($env?.list) +flatten($env?.list)?.[i] +flatten(0 .. i) +flatten(1 .. 1) +flatten(1 .. i) +flatten([$env]) +flatten([0 <= 1]) +flatten([0, 1.0]) +flatten([0]) +flatten([1.0, foo]) +flatten([1.0]) +flatten([1]) +flatten([add, greet]) +flatten([add]) +flatten([array, ok]) +flatten([array]) +flatten([f64]) +flatten([false, list]) +flatten([false]) +flatten([foo, 1.0]) +flatten([foo]) +flatten([greet]) +flatten([i, list]) +flatten([i]) +flatten([list]) +flatten([nil]) +flatten([ok, true]) +flatten([ok]) +flatten([str]) +flatten(array | map(#)) +flatten(array | map(1.0)) +flatten(array | map(false)) +flatten(array | sortBy(#)) +flatten(array | sortBy(1.0)) +flatten(array) +flatten(array) | groupBy(#) +flatten(array) | map(#) +flatten(array) | one(true) +flatten(array) | reduce(1.0) +flatten(array) | sum(#) +flatten(array)?.[i] +flatten(array)[i:] +flatten(array[0:]) +flatten(array[:1]) +flatten(concat(array)) +flatten(concat(list)) +flatten(filter(list, false)) +flatten(flatten(array)) +flatten(groupBy(list, #).i) +flatten(i .. 0) +flatten(i..i) +flatten(if true { array } else { add }) +flatten(keys($env)) +flatten(list | map(#)) +flatten(list | map(i)) +flatten(list | sortBy(f64)) +flatten(list | sortBy(str)) +flatten(list) +flatten(list) == list +flatten(list) | filter(true) +flatten(list) | findLastIndex(false) +flatten(list) | groupBy(foo) +flatten(list) | map(f64) +flatten(list) | map(false) +flatten(list) | map(foo) +flatten(list) | map(ok) +flatten(list) | reduce(#) +flatten(list) | reduce($env, $env) +flatten(list) | sortBy(0) +flatten(list) | sortBy(str) +flatten(list)?.[i] +flatten(list)[:] +flatten(map($env, $env)) +flatten(map($env, 0)) +flatten(map($env, 1.0)) +flatten(map(array, true)) +flatten(map(list, #)) +flatten(map(list, $env)) +flatten(map(list, .Bar)) +flatten(map(list, ok)) +flatten(reduce(array, array)) +flatten(reverse(array)) +flatten(reverse(list)) +flatten(sort(array)) +flatten(sortBy(array, #)) +flatten(sortBy(array, 1)) +flatten(sortBy(array, 1.0)) +flatten(sortBy(array, f64)) +flatten(toPairs($env)) +flatten(uniq(array)) +flatten(uniq(list)) +flatten(values($env)) +float($env | findLastIndex(ok)) +float($env | findLastIndex(true)) +float($env | sum(1.0)) +float($env | sum(f64)) +float($env.f64) +float($env.i) +float($env?.f64) +float($env?.i) +float(0 % 1) +float(0 % i) +float(0 * 1) +float(0 * 1.0) +float(0 * f64) +float(0 ** 1.0) +float(0 ** f64) +float(0 ** i) +float(0 + 1) +float(0 + i) +float(0 - 1.0) +float(0 - i) +float(0 / 0) +float(0 / 1.0) +float(0 / i) +float(0 ^ 1.0) +float(0 ^ i) +float(0) > f64 +float(0) > i +float(0) ^ f64 +float(1 % i) +float(1 * 1.0) float(1 ** 1) float(1 ** f64) float(1 ** i) -float(1 + f64) -float(1 + i32) -float(1 - 0.5) -float(1 / 0.5) -float(1 ^ f64) -float(1) * f32 -float(1) * i64 -float(1) ** i -float(1) ** i64 +float(1 + 1) +float(1 + 1.0) +float(1 + i) +float(1 - 1.0) +float(1 - f64) +float(1 / 1) +float(1 / 1.0) +float(1 ^ 0) +float(1 ^ 1.0) +float(1 ^ i) float(1) - f64 -float(1) <= i64 -float(1) == i64 -float(1) > -0.5 -float(1) > i64 -float(1) >= f64 -float(1) >= i -float(abs(f32)) +float(1) < f64 +float(1) == i +float(1) in [add, true] +float(1.0 * 0) +float(1.0 * 1) +float(1.0 * 1.0) +float(1.0 * f64) +float(1.0 * i) +float(1.0 ** 1) +float(1.0 ** 1.0) +float(1.0 ** f64) +float(1.0 + 0) +float(1.0 + 1.0) +float(1.0 + f64) +float(1.0 + i) +float(1.0 - 0) +float(1.0 - 1) +float(1.0 - 1.0) +float(1.0 - f64) +float(1.0 - i) +float(1.0 / 1.0) +float(1.0 / f64) +float(1.0 / i) +float(1.0 ^ 1) +float(1.0 ^ 1.0) +float(1.0 ^ f64) +float(1.0 ^ i) +float(1.0 | min(f64)) +float(1.0) != $env?.[str] +float(1.0) * max(f64) +float(1.0) - f64 +float(1.0) / i +float(1.0) == 0 % 1 +float(1.0) == i +float(1.0) == i != false +float(1.0) > f64 +float(1.0) >= last(array) +float(abs(0)) +float(abs(1.0)) float(abs(f64)) float(abs(i)) -float(abs(i32)) -float(add(1, 1)) -float(array[i32]) -float(array[i64]) -float(array[i]) -float(bitnot(1)) +float(add(0, i)) +float(array | max(1)) +float(array | reduce(#index, 1.0)) +float(array | sum(#)) +float(array | sum(1.0)) +float(array?.[i]) +float(bitand(0, i)) +float(bitnot(0)) float(bitnot(i)) -float(bitnot(i32)) -float(bitnot(i64)) -float(ceil(0.5)) -float(ceil(f32)) +float(bitor(0, i)) +float(bitshl(i, 0)) +float(bitshr(0, 0)) +float(bitshr(i, 1)) +float(ceil(0)) +float(ceil(1)) +float(ceil(1.0)) float(ceil(f64)) -float(ceil(i32)) -float(ceil(i64)) -float(count(array, false)) -float(count(array, ok)) -float(count(list, i32 == 0.5)) -float(f32 * f64) -float(f32 * i) -float(f32 * i32) -float(f32 ** 1) -float(f32 ** f32) -float(f32 ** i) -float(f32 ** i64) -float(f32 + 0.5) -float(f32 + 1) -float(f32 + f64) -float(f32 + i32) -float(f32 + i64) -float(f32 - 0.5) -float(f32 - f64) -float(f32 - i64) -float(f32 / 0.5) -float(f32 / 1) -float(f32 / i) -float(f32 ^ 0.5) -float(f32 ^ 1) -float(f32 ^ f32) -float(f32 ^ i) -float(f32 ^ i32) -float(f32) -float(f32) < i32 -float(f32) <= f32 -float(f32) <= f64 / f32 -float(f32) <= i -float(f32) > i -float(f32) >= i64 -float(f32) ^ f64 -float(f32) ^ i64 -float(f64 * 0.5) -float(f64 * 1) -float(f64 * f32) -float(f64 * f64) -float(f64 * i32) -float(f64 ** f32) -float(f64 + 1) +float(ceil(i)) +float(count($env, false)) +float(count(list, false)) +float(count(list, ok)) +float(f64 * 1.0) +float(f64 ** 0) +float(f64 ** 1) +float(f64 ** 1.0) +float(f64 + f64) float(f64 + i) -float(f64 + i32) -float(f64 - 1) -float(f64 - i) -float(f64 / 0.5) -float(f64 / 1) -float(f64 / i64) -float(f64 ^ f32) +float(f64 - 1.0) +float(f64 / 1.0) +float(f64 / i) +float(f64 ^ 0) +float(f64 ^ 1.0) float(f64) -float(f64) * f32 -float(f64) * i -float(f64) / -i32 -float(f64) / i -float(f64) == f64 -float(f64) > f64 -float(f64) > i64 -float(f64) >= f32 -float(f64) >= i -float(f64) >= i64 -float(f64) ^ i64 -float(false ? f64 : 0.5) -float(false ? half : f64) -float(false ? list : f64) -float(find(array, ok)) -float(findIndex(array, ok)) -float(findLastIndex(array, ok)) -float(findLastIndex(list, true)) -float(first(array)) -float(float(0.5)) +float(f64) != f64 +float(f64) == i +float(false ? i : 1.0) +float(false ? str : 1.0) +float(false ?: 1.0) +float(false ?: i) +float(findIndex($env, ok)) +float(findIndex(array, true)) +float(findLastIndex($env, true)) float(float(1)) -float(float(f32)) float(float(f64)) -float(float(i)) -float(float(i32)) -float(floor(0.5)) float(floor(1)) -float(floor(f32)) +float(floor(1.0)) float(floor(f64)) -float(floor(i32)) -float(floor(i64)) -float(get(array, 1)) -float(get(array, i)) -float(half(0.5)) -float(half(1)) -float(half(f64)) -float(i % i32) -float(i * 0.5) -float(i * f64) -float(i * i64) -float(i ** f32) -float(i ** i32) -float(i + 0.5) +float(i % 1) +float(i * 1.0) +float(i ** 1.0) float(i + 1) -float(i + i64) +float(i - 0) float(i - 1) float(i - f64) -float(i / 0.5) +float(i - i) float(i / 1) -float(i ^ 0.5) -float(i ^ i32) +float(i / 1.0) float(i) -float(i) != 1 ? nil : foo -float(i) != f64 -float(i) + f32 -float(i) + f64 -float(i) < i -float(i) == f32 -float(i) == i -float(i) > f64 -float(i32 % i) -float(i32 % i64) -float(i32 * f64) -float(i32 * i32) -float(i32 ** 1) -float(i32 + f64) -float(i32 + i64) -float(i32 / 1) -float(i32 / f32) -float(i32 / i32) -float(i32 ^ f64) -float(i32 ^ i32) -float(i32) -float(i32) != f64 -float(i32) ** f32 -float(i32) ** i -float(i32) > i32 -float(i32) >= i -float(i64 % i64) -float(i64 * i64) -float(i64 ** 1) -float(i64 + f32) -float(i64 + i) -float(i64 - 0.5) -float(i64 - 1) -float(i64 - f32) -float(i64 / 1) -float(i64 ^ f32) -float(i64) -float(i64) != i -float(i64) ** max(f64) -float(i64) + i32 -float(i64) - 0.5 ^ f32 -float(i64) - f64 -float(i64) / i32 -float(i64) < i32 -float(i64) == i -float(i64) == i64 -float(i64) > i -float(i64) ^ f32 -float(int(0.5)) +float(i) + first(array) +float(if false { 1.0 } else { 1 }) +float(if false { greet } else { 1 }) +float(if false { greet } else { 1.0 }) +float(if true { 0 } else { $env }) +float(int(0)) float(int(1)) -float(int(f32)) +float(int(1.0)) +float(int(f64)) float(int(i)) -float(int(i32)) -float(last(array)) -float(len("bar")) +float(lastIndexOf(str, str)) +float(len($env)) float(len(array)) float(len(list)) -float(max(0.5)) -float(max(0.5, i64)) -float(max(1)) -float(max(1, 1)) -float(max(f32)) -float(max(f64)) +float(len(str)) +float(let foobar = i; foobar) +float(list | findIndex(ok)) +float(list | reduce(i)) +float(list | sum(f64)) +float(max(0)) +float(max(1.0)) float(max(i)) -float(max(i32)) -float(max(i64)) +float(mean(0)) +float(mean(1)) +float(mean(1.0 - 1.0)) +float(mean(1.0)) float(mean(array)) -float(min(1)) -float(min(f64)) -float(min(f64, i64)) -float(min(i32)) -float(min(i64)) -float(ok ? 0.5 : foo) -float(ok ? 0.5 : list) -float(reduce(array, #)) -float(reduce(array, 0.5)) -float(reduce(array, f64)) -float(reduce(array, i32)) -float(reduce(list, i64)) -float(round(0.5)) +float(mean(f64)) +float(mean(i)) +float(median(0)) +float(median(1.0)) +float(median(1.0, 0, 0)) +float(median(1.0, i)) +float(median(f64)) +float(median(i)) +float(min($env?.array)) +float(min(0)) +float(min(1.0)) +float(min(array)) +float(min(i)) +float(reduce($env, 1.0, 1.0)) +float(reduce(list, 0)) +float(reduce(list, 1)) +float(reduce(list, i)) float(round(1)) -float(round(i32)) -float(round(i64)) -float(score(1)) -float(score(1, 1)) -float(score(i)) -float(string(0.5)) +float(round(1.0)) +float(round(f64)) +float(round(i)) +float(string(0)) float(string(1)) -float(string(f64 - 0.5)) -float(string(i)) -float(string(i32)) -float(string(i64)) +float(string(1.0)) +float(string(f64)) +float(sum($env, 0)) +float(sum($env, 1)) +float(sum($env?.array)) float(sum(array)) -float(toJSON(0.5)) +float(sum(array, #)) +float(sum(array, 1)) +float(sum(array, i)) +float(sum(list, 1)) float(toJSON(1)) -float(toJSON(f32)) -float(toJSON(f64)) -float(toJSON(i32)) -float(toJSON(i64)) -float(true ? f32 : "foo") -floor(-0.5) -floor(-1) -floor(-f32) -floor(-f64) -floor(-i) -floor(-i32) -floor(-i64) -floor(0.5 * 0.5) -floor(0.5 * 1) -floor(0.5 * i32) -floor(0.5 ** 1) -floor(0.5 ** f64) -floor(0.5 ** i) -floor(0.5 + 1) -floor(0.5 + f32) -floor(0.5 + i) -floor(0.5 + i32) -floor(0.5 + i64) -floor(0.5 - 1) -floor(0.5 - f32) -floor(0.5 - i) -floor(0.5 / 0.5) -floor(0.5 / 1) -floor(0.5 / i32) -floor(0.5 ^ 0.5) -floor(0.5 ^ 1) -floor(0.5 ^ f32) -floor(0.5 ^ f64) -floor(0.5 ^ i) -floor(0.5) != i64 -floor(0.5) ** f32 -floor(0.5) - i -floor(0.5) - i64 -floor(0.5) / i -floor(0.5) <= i64 -floor(0.5) > i32 -floor(0.5) > i64 != ok -floor(0.5) >= f32 -floor(0.5) ^ i -floor(1 % 1) -floor(1 % i) -floor(1 * 0.5) +float(toJSON(i)) +float(toJSON(min(1.0))) +float(true ? 1.0 : ok) +float(true ? f64 : foo) +float(true ? f64 : str) +floor($env | findIndex(ok)) +floor($env.f64) +floor($env.i) +floor($env?.f64) +floor($env?.i) +floor(0 % i) +floor(0 * 1) +floor(0 * 1.0) +floor(0 * i) +floor(0 + 1.0) +floor(0 + f64) +floor(0 - 0) +floor(0 - 1) +floor(0 - 1.0) +floor(0 - i) +floor(0 / 1) +floor(0 / f64) +floor(0 ^ 0) +floor(0 ^ 1.0) +floor(0 | min(1.0)) +floor(0) * i +floor(0) <= f64 floor(1 * 1) +floor(1 * 1.0) +floor(1 * f64) +floor(1 * i) +floor(1 ** 0) floor(1 ** 1) -floor(1 ** f64) -floor(1 ** i32) -floor(1 + 0.5) -floor(1 + 1) -floor(1 + f32) -floor(1 + f64) -floor(1 + i32) -floor(1 - 0.5) -floor(1 - 1) +floor(1 ** i) +floor(1 + 1.0) +floor(1 + i) floor(1 - i) -floor(1 - i32) -floor(1 - i64) -floor(1 / 0.5) -floor(1 / 1) -floor(1 / i) -floor(1 / i64) +floor(1 / 0) +floor(1 / 1.0) +floor(1 / f64) +floor(1 ^ 0) +floor(1 ^ 1.0) +floor(1 ^ f64) floor(1 ^ i) -floor(1 ^ i32) -floor(1 ^ i64) -floor(1) * i64 -floor(1) - f32 -floor(1) - i -floor(1) <= f32 -floor(1) >= half(0.5) -floor(abs(0.5)) +floor(1) != f64 +floor(1) * f64 +floor(1) + $env?.f64 +floor(1) <= i +floor(1) in array +floor(1.0 * 1) +floor(1.0 * 1.0) +floor(1.0 * f64) +floor(1.0 ** 1) +floor(1.0 ** 1.0) +floor(1.0 ** f64) +floor(1.0 ** i) +floor(1.0 + 1) +floor(1.0 + 1.0) +floor(1.0 + f64) +floor(1.0 - 0) +floor(1.0 - 1.0) +floor(1.0 - f64) +floor(1.0 - i) +floor(1.0 / 0) +floor(1.0 / 1.0) +floor(1.0 / f64) +floor(1.0 ^ 0) +floor(1.0 ^ 1.0) +floor(1.0 ^ i) +floor(1.0 | max(f64)) +floor(1.0 | mean(array)) +floor(1.0) != $env?.f64 +floor(1.0) + f64 +floor(1.0) - $env.i +floor(1.0) == f64 +floor(1.0) > i +floor(1.0) | median(0) +floor(abs(0)) floor(abs(1)) -floor(abs(f32)) +floor(abs(1.0)) floor(abs(f64)) -floor(abs(i32)) -floor(abs(i64)) -floor(array[1]) -floor(array[i32]) -floor(array[i64]) -floor(array[i]) +floor(abs(i)) +floor(add(i, i)) +floor(array | findLast(ok)) +floor(array | mean(1)) +floor(array | mean(f64)) +floor(array | reduce(#)) +floor(array | sum(f64)) +floor(array?.[i]) +floor(bitnot(0)) floor(bitnot(1)) -floor(bitnot(i)) -floor(bitnot(i32)) -floor(bitnot(i64)) -floor(ceil(0.5)) floor(ceil(1)) -floor(ceil(f64)) +floor(ceil(1.0)) floor(ceil(i)) -floor(ceil(i32)) -floor(ceil(i64)) -floor(count(array, false)) -floor(count(array, ok)) +floor(count($env, true)) floor(count(list, ok)) -floor(f32 ** 1) -floor(f32 ** f64) -floor(f32 ** i32) -floor(f32 + f32) -floor(f32 + i32) -floor(f32 + i64) -floor(f32 - 0.5) -floor(f32 - f64) -floor(f32 / 0.5) -floor(f32 / f64) -floor(f32 / i) -floor(f32 / i32) -floor(f32 / i64) -floor(f32 ^ 0.5) -floor(f32 ^ f64) -floor(f32 ^ i) -floor(f32) -floor(f32) != -i32 -floor(f32) * i32 -floor(f32) + f32 -floor(f32) / f32 -floor(f32) / f64 -floor(f32) == i64 -floor(f32) > i32 -floor(f32) >= f32 -floor(f32) >= i -floor(f32) ^ f32 -floor(f64 * f32) -floor(f64 ** 0.5) -floor(f64 ** 1) -floor(f64 ** i32) -floor(f64 + 0.5) -floor(f64 + 1) -floor(f64 + i32) -floor(f64 - 0.5) -floor(f64 - i32) -floor(f64 / 0.5) -floor(f64 / 1) -floor(f64 / f32) +floor(f64 * 1.0) +floor(f64 ** 1.0) +floor(f64 ** i) +floor(f64 + 0) +floor(f64 + 1.0) +floor(f64 - 1) +floor(f64 - 1.0) +floor(f64 - i) floor(f64 / f64) -floor(f64 / i) -floor(f64 ^ 1) +floor(f64 ^ 1.0) +floor(f64 ^ i) floor(f64) -floor(f64) * i32 -floor(f64) ** f64 -floor(f64) / f32 -floor(f64) < i32 -floor(f64) <= f64 -floor(f64) <= i64 -floor(f64) == f64 ** i -floor(f64) == i -floor(f64) > i32 -floor(f64) >= 1 * 1 -floor(f64) >= f32 -floor(false ? div : 0.5) -floor(find(array, true)) -floor(findIndex(array, ok)) -floor(findLastIndex(array, ok)) -floor(float(0.5)) +floor(f64) < f64 +floor(f64) >= f64 +floor(f64) >= i ^ f64 +floor(f64) in array +floor(false ?: 1) +floor(findIndex($env, ok)) +floor(findIndex(list, true)) +floor(findLast(array, ok)) +floor(findLastIndex(array, true)) +floor(first(array)) +floor(float(0)) floor(float(1)) +floor(float(1.0)) floor(float(f64)) -floor(float(i32)) -floor(floor(0.5)) +floor(floor(0)) floor(floor(1)) -floor(floor(f32)) -floor(floor(f64)) -floor(floor(i)) -floor(floor(i32)) -floor(floor(i64)) -floor(get(array, 1)) -floor(get(array, i)) -floor(get(array, i64)) -floor(half(0.5)) -floor(half(1)) -floor(half(f64)) -floor(i % 1) -floor(i % i) -floor(i % i32) -floor(i % i64) -floor(i * 1) -floor(i * f64) -floor(i ** 0.5) -floor(i ** f32) -floor(i ** i32) -floor(i ** i64) -floor(i + 0.5) -floor(i + f64) -floor(i - 0.5) -floor(i - f32) -floor(i - i32) -floor(i / 0.5) +floor(floor(1.0)) +floor(i * 1.0) +floor(i * i) +floor(i ** 1) +floor(i ** 1.0) +floor(i ** i) +floor(i + 1.0) +floor(i + i) +floor(i - f64) +floor(i / 0) floor(i / 1) +floor(i / 1.0) floor(i / f64) -floor(i ^ i32) +floor(i ^ 0) +floor(i ^ 1.0) +floor(i ^ i) +floor(i | min(0)) floor(i) -floor(i) != i -floor(i) * f64 -floor(i) ^ i -floor(i32 % i32) -floor(i32 * 1) -floor(i32 * f32) -floor(i32 * f64) -floor(i32 * i32) -floor(i32 ** i) -floor(i32 ** i64) -floor(i32 + 0.5) -floor(i32 + f64) -floor(i32 - 1) -floor(i32 - f32) -floor(i32 - i) -floor(i32 - i32) -floor(i32 - i64) -floor(i32 ^ 0.5) -floor(i32 ^ 1) -floor(i32 ^ f64) -floor(i32 ^ i) -floor(i32 ^ i32) -floor(i32 ^ i64) -floor(i32) -floor(i32) != f32 -floor(i32) * f64 -floor(i32) * i -floor(i32) * i64 -floor(i32) > i32 -floor(i32) > i64 -floor(i32) >= i32 -floor(i32) ^ i32 -floor(i64 % i) -floor(i64 * 0.5) -floor(i64 * f32) -floor(i64 * i) -floor(i64 ** 0.5) -floor(i64 ** 1) -floor(i64 ** i) -floor(i64 ** i32) -floor(i64 + 0.5) -floor(i64 + f64) -floor(i64 + i64) -floor(i64 - f64) -floor(i64 - i) -floor(i64 / f32) -floor(i64 ^ 0.5) -floor(i64 ^ f32) -floor(i64 ^ i64) -floor(i64) -floor(i64) * i64 -floor(i64) / (i64 - i) -floor(i64) / f64 -floor(i64) / i32 -floor(i64) < f32 -floor(i64) <= i64 -floor(i64) ^ f32 -floor(int(0.5)) +floor(i) ** 1.0 >= 1.0 +floor(i) ** i +floor(i) - f64 +floor(i) / sum(array) +floor(i) == $env != ok +floor(i) == i +floor(i) ^ f64 +floor(i) | max(1.0) +floor(if ok { i } else { $env }) +floor(int(0)) floor(int(1)) -floor(int(i32)) -floor(int(i64)) -floor(len("foo")) +floor(int(1.0)) +floor(int(f64)) +floor(int(i)) +floor(last(array)) +floor(len($env)) floor(len(array)) floor(len(list)) -floor(max(0.5)) +floor(len(str)) +floor(let foobar = 1.0; foobar) +floor(list | sum(1)) +floor(max(0)) floor(max(1)) -floor(max(f32)) +floor(max(1.0)) floor(max(f64)) -floor(max(i32)) -floor(min(0.5)) -floor(min(f64) ^ i64) -floor(min(i, i64)) -floor(min(i32)) -floor(ok ? 1 : 1) -floor(ok ? f32 : "foo") -floor(ok ? i64 : f64) +floor(max(i)) +floor(mean(0)) +floor(mean(0, 1.0)) +floor(mean(1)) +floor(mean(1.0)) +floor(mean(array)) +floor(mean(f64)) +floor(mean(i)) +floor(median(0)) +floor(median(1)) +floor(median(1.0)) +floor(median(array)) +floor(median(f64)) +floor(median(i)) +floor(min(1)) +floor(min(1.0)) +floor(min(1.0, 0)) +floor(min(array)) +floor(min(i)) +floor(ok ? 1.0 : nil) +floor(ok ? i : greet) floor(reduce(array, #)) -floor(reduce(array, i)) -floor(reduce(array, i64)) -floor(reduce(list, 1)) -floor(reduce(list, f32)) -floor(reduce(list, i64)) -floor(round(0.5)) -floor(round(f32)) +floor(reduce(array, 1)) +floor(round(1)) +floor(round(1.0)) floor(round(f64)) -floor(round(i)) -floor(round(i32)) -floor(score(1)) -floor(score(1, 1)) -floor(score(i)) -floor(true ? 0.5 : false) -floor(true ? 1 : true) -floor(true ? f64 : 0.5) -floor(true ? f64 : array) +floor(sum($env, 1.0)) +floor(sum(array)) +floor(sum(array, #)) +floor(sum(array, 1.0)) +floor(sum(list, 1.0)) foo +foo != $env != ok +foo != $env && ok and ok +foo != $env == true +foo != $env ? $env : nil +foo != $env.foo +foo != $env?.Bar +foo != $env?.Bar?.[i] +foo != $env?.Bar?.array +foo != $env?.Bar?.list +foo != $env?.String +foo != $env?.String?.[greet] +foo != $env?.String?.greet +foo != $env?.[Bar] +foo != $env?.[String] +foo != $env?.[String]?.add +foo != $env?.[foobar] +foo != $env?.[str] +foo != $env?.foo +foo != $env?.foobar +foo != $env?.not +foo != first(list) foo != foo -foo != nil != nil -foo != reduce(list, #) +foo != foo != $env +foo != foo && $env.ok +foo != foo && get($env, 1) +foo != foo == $env || false +foo != foo == false +foo != foo == true +foo != foo or ok +foo != list?.[i] +foo != nil != $env +foo != nil ? 1.0 : $env +foo != nil ? str : foo +foo != nil || sum($env, $env) +foo == $env != nil +foo == $env in $env?.foobar +foo == $env or $env.ok +foo == $env || $env +foo == $env.foo +foo == $env?.Bar +foo == $env?.Bar?.[i] +foo == $env?.String +foo == $env?.[Bar] +foo == $env?.[String] +foo == $env?.[String]?.[f64] +foo == $env?.[foobar?.greet] +foo == $env?.[foobar] +foo == $env?.[str] +foo == $env?.foo +foo == $env?.foobar +foo == $env?.foobar?.array() +foo == $env?.nil +foo == $env?.not foo == foo -foo == foo and 0.5 != f64 -foo == get(list, 1) -foo == list[i] -foo == nil ? i : i32 -foo == nil ? i64 : i -foo == reduce(list, #) -foo in filter(list, false) -foo in groupBy(array, #) -foo in groupBy(list, #) +foo == foo != ok +foo == foo == ok +foo == foo ? $env : $env +foo == foo ?: f64 +foo == foo ?: i +foo == foo or $env?.[greet] +foo == foo or ok +foo == foo || ok +foo == last($env) +foo == last(list) +foo == list?.[i] +foo == nil != $env +foo == nil != nil +foo == nil && $env or $env +foo == nil && f64 >= 1.0 +foo == nil == $env +foo == nil ? foo : i +foo == nil ? true : i +foo == nil and ok +foo == nil || false +foo in $env.list +foo in $env?.Bar +foo in $env?.Bar?.[add]?.[str] +foo in $env?.String +foo in $env?.String?.[ok] +foo in $env?.[Bar] +foo in $env?.[Bar]?.[i] +foo in $env?.[String] +foo in $env?.[String]?.[array] +foo in $env?.[String]?.[foo] +foo in $env?.[foobar?.foo] +foo in $env?.[foobar] +foo in $env?.[foobar]?.list +foo in $env?.foobar +foo in $env?.foobar?.list() +foo in $env?.list +foo in $env?.true?.[greet] +foo in [nil] +foo in flatten(array) +foo in keys($env) foo in list +foo in list != nil && $env foo in list != ok -foo not in groupBy(array, #) -foo not in groupBy(array, f64).foo -foo not in groupBy(list, #).i -foo not in groupBy(list, f32) -foo not in groupBy(list, ok) +foo in list == $env?.ok +foo in list || false +foo in list[0:] +foo in map(list, foo) +foo in toPairs($env) +foo in uniq(list) +foo not in $env.list +foo not in $env?.Bar +foo not in $env?.String +foo not in $env?.[Bar] +foo not in $env?.[Bar]?.String +foo not in $env?.[String] +foo not in $env?.[String]?.[list] +foo not in $env?.[foobar?.f64] +foo not in $env?.[foobar] +foo not in $env?.[nil | last(foobar)] +foo not in $env?.[nil] +foo not in $env?.foobar +foo not in $env?.foobar?.greet(foobar) +foo not in $env?.list +foo not in $env?.nil?.[ok] +foo not in [$env] +foo not in flatten(array) +foo not in keys($env) foo not in list -foo not in list and ok -foo not in list or false -foo not in map(list, #) +foo not in list != false +foo not in list && ok foo.Bar -foo.Bar <= foo.Bar -foo.Bar matches foo.Bar -foo.Bar matches trimPrefix("foo") -foo.Qux -foo.Qux("foo" + "foo") -foo.Qux(foo.Bar) -foo.Qux(foo.String()) -foo.Qux(greet("foo")) -foo.Qux(string("foo")) -foo.Qux(toJSON(i)) -foo.Qux(type("bar")) -foo.Qux(type(f64)) -foo.Qux(type(half)) +foo.Bar != foo?.Bar +foo.Bar != str +foo.Bar + str +foo.Bar < foo.Bar +foo.Bar <= str +foo.Bar == $env?.Bar +foo.Bar == foo?.Bar +foo.Bar == str +foo.Bar > foo.String() +foo.Bar > str +foo.Bar >= str +foo.Bar >= type(ok) +foo.Bar contains $env?.String +foo.Bar contains str +foo.Bar endsWith str +foo.Bar in $env +foo.Bar in foo +foo.Bar matches str +foo.Bar not contains str +foo.Bar not endsWith str +foo.Bar not in foo +foo.Bar not in {foo: nil, foo: 1} +foo.Bar not matches str +foo.Bar not matches toJSON(i) +foo.Bar not startsWith foo?.Bar +foo.Bar not startsWith str +foo.Bar startsWith $env?.String?.f64() +foo.Bar startsWith $env?.[Bar] +foo.Bar startsWith str +foo.Bar | greet() +foo.Bar | hasPrefix(str) +foo.Bar | indexOf(str) +foo.Bar | repeat(0) +foo.Bar | split($env?.str) +foo.Bar | trimSuffix(str) +foo.Bar[:] +foo.Bar[:i] +foo.Bar[i:] foo.String +foo.String != $env?.foobar +foo.String == $env?.[String] foo.String() -foo.String() != foo?.String() -foo.String() in foo +foo.String() != str +foo.String() <= $env.str +foo.String() <= str +foo.String() > foo.Bar +foo.String() >= $env?.[str] +foo.String() >= str +foo.String() contains str +foo.String() endsWith str foo.String() not in foo +foo.String() not in foo == false +foo.String() | greet() +foo.String()[:] +foo.String()[i:] +foo; $env?.foo +foo; $env?.ok +foo; $env?.str +foo; 1.0; $env?.ok +foo; f64 +foo; foo; nil != ok +foo; foo?.Bar +foo; i +foo; list +foo; str foo?.Bar -foo?.Bar != foo?.Bar +foo?.Bar != nil == $env +foo?.Bar != str +foo?.Bar != type(f64) +foo?.Bar + str +foo?.Bar + type(i) +foo?.Bar < str +foo?.Bar < string(0) +foo?.Bar <= str +foo?.Bar == $env.str +foo?.Bar == nil and false +foo?.Bar == str +foo?.Bar > str +foo?.Bar > type(false) +foo?.Bar >= $env.str +foo?.Bar >= str +foo?.Bar >= toJSON(foo) +foo?.Bar contains $env?.Bar +foo?.Bar contains $env?.[Bar] +foo?.Bar endsWith $env?.String +foo?.Bar endsWith first($env) +foo?.Bar endsWith str foo?.Bar in foo -foo?.Bar matches toJSON(f64) -foo?.Bar not endsWith foo.Bar -foo?.Bar not endsWith toJSON(foo) -foo?.Qux -foo?.Qux(foo?.Bar) -foo?.Qux(string(i32)) -foo?.Qux(toJSON(1)) -foo?.Qux(toJSON(i32)) -foo?.Qux(upper("bar")) +foo?.Bar in {foo: array} +foo?.Bar in {foo: str} +foo?.Bar matches str +foo?.Bar matches toJSON(array) +foo?.Bar not contains str +foo?.Bar not endsWith $env?.[String] +foo?.Bar not endsWith $env?.foobar +foo?.Bar not endsWith str +foo?.Bar not in $env +foo?.Bar not in $env?.[Bar] +foo?.Bar not in foo +foo?.Bar not matches $env?.[foobar] +foo?.Bar not matches $env?.[str] +foo?.Bar not matches str +foo?.Bar not startsWith $env.str +foo?.Bar not startsWith $env?.Bar +foo?.Bar not startsWith str +foo?.Bar not startsWith toJSON(nil) +foo?.Bar not startsWith type(str) +foo?.Bar startsWith str +foo?.Bar | greet() +foo?.Bar | hasSuffix(str) +foo?.Bar[:] foo?.String +foo?.String != $env?.[Bar] +foo?.String != $env?.[str] +foo?.String == $env or $env +foo?.String == $env?.[String] foo?.String() -foo?.String() contains string("foo") +foo?.String() != str +foo?.String() < str +foo?.String() == str +foo?.String() > str +foo?.String() >= toJSON(f64) +foo?.String() in foo +foo?.String() matches str +foo?.String() not contains $env?.[str] +foo?.String() not endsWith $env?.Bar +foo?.String() not endsWith $env?.[foobar] +foo?.String() not in foo +foo?.String() not startsWith str +foo?.String() not startsWith type(foo) +foo?.String() | greet() +foo?.String() | hasSuffix(str) +foo?.String()[:] fromBase64(string(ok)) -fromBase64(toBase64("bar")) -fromBase64(type(1 == 0.5)) +fromBase64(toBase64(str)) +fromBase64(toJSON(nil)) +fromBase64(toJSON(ok)) +fromBase64(toJSON(true)) fromBase64(type(add)) -fromBase64(type(div)) -fromBase64(type(false)) fromBase64(type(greet)) -fromBase64(type(half)) fromBase64(type(ok)) -fromBase64(type(score)) -fromBase64(type(true)) +fromJSON(string(0)) fromJSON(string(1)) -fromJSON(string(f32)) +fromJSON(string(1.0)) fromJSON(string(f64)) +fromJSON(string(false)) fromJSON(string(i)) -fromJSON(string(i32)) -fromJSON(string(i64)) fromJSON(string(ok)) fromJSON(string(true)) -fromJSON(toJSON("bar")) -fromJSON(toJSON(0.5)) +fromJSON(toJSON(0)) +fromJSON(toJSON(1)) +fromJSON(toJSON(1.0)) fromJSON(toJSON(array)) fromJSON(toJSON(f64)) fromJSON(toJSON(false)) fromJSON(toJSON(foo)) -fromJSON(toJSON(i)) -fromJSON(toJSON(i32)) +fromJSON(toJSON(foo)).add fromJSON(toJSON(list)) fromJSON(toJSON(nil)) +fromJSON(toJSON(nil))?.[i].i() +fromJSON(toJSON(ok)) +fromJSON(toJSON(str)) +fromJSON(toJSON(str)) contains str fromJSON(toJSON(true)) -fromPairs(filter(array, false)) -fromPairs(filter(list, false)) -fromPairs(groupBy(array, #).String) -get(["foo"], i32) -get(array, -1) -get(array, -i32) -get(array, -i64) -get(array, -score(1)) -get(array, 1 * 1) -get(array, 1 * i) -get(array, 1) ** f32 -get(array, 1) < f32 -get(array, 1) > i32 -get(array, 1) > i64 -get(array, bitnot(1)) -get(array, count(array, ok)) -get(array, false ? "foo" : 0.5) +fromJSON(toJSON(type(ok))) +fromPairs([list]) +fromPairs(list[:0]) +fromPairs(sort($env)) +fromPairs(toPairs($env)) +fromPairs(toPairs($env)).ok +get($env, nil) != array +get($env, nil)?.[add] +get($env, nil)?.[add].add +get($env, nil)?.[f64] +get($env, nil)?.[i] +get($env, nil)?.[ok] +get($env, nil)?.add +get($env, nil)?.f64 +get($env, nil)?.foo +get($env, nil)?.greet().add +get($env, str) | reduce($env) +get($env, str)?.[f64] +get(array, $env.i) get(array, i) -get(array, i) != f32 -get(array, i) != i32 -get(array, i) * i32 -get(array, i) - i -get(array, i) / i64 -get(array, i) > f64 -get(array, i) >= f64 -get(array, i) >= i64 -get(array, i) ^ half(0.5) -get(array, i32 % i32) -get(array, i32) -get(array, i32) / f64 -get(array, i32) < i -get(array, i64 - 1) -get(array, i64) -get(array, i64) > f64 -get(array, last(array)) -get(array, min(i)) -get(array, reduce(array, #)) -get(array, reduce(list, i64)) -get(array, score(1)) -get(array, score(abs(1))) -get(array, score(i)) -get(array, sum(array)) -get(false ? 0.5 : greet, list) -get(false ? add : array, f64) -get(false ? add : score, ok) -get(false ? f64 : 1, ok) -get(false ? f64 : score, add) -get(false ? false : f32, i) -get(false ? i32 : list, i64) -get(false ? i64 : true, f64) -get(false ? score : ok, trimSuffix("bar", "bar")) -get(filter(list, true), i) -get(groupBy(array, "bar"), i) -get(groupBy(array, "bar"), ok) -get(groupBy(array, #), f32) -get(groupBy(array, #), f64) -get(groupBy(array, #), foo) -get(groupBy(array, #), i) -get(groupBy(array, #), i64 * 0.5) -get(groupBy(array, #), i64) -get(groupBy(array, 0.5), ok) -get(groupBy(array, 1), f32) -get(groupBy(array, f64), i64) -get(groupBy(array, false), findIndex(array, ok)) -get(groupBy(array, i), ok) -get(groupBy(array, true), i32) -get(groupBy(list, "bar"), i32) -get(groupBy(list, #), f32 <= f64) -get(groupBy(list, #), f32) -get(groupBy(list, #), foo) -get(groupBy(list, #), i) -get(groupBy(list, #), i32) -get(groupBy(list, #), i64) -get(groupBy(list, #), int(f32)) -get(groupBy(list, #), reduce(array, foo)) -get(groupBy(list, #), score(1)) -get(groupBy(list, 0.5), ok) -get(groupBy(list, 1), i32) -get(groupBy(list, foo), i32) -get(i .. 1, 1 * 1) -get(i .. i32, i) -get(i32 .. i, i64) -get(i64 .. 1, i32) -get(i64 .. i, i32) -get(i64 .. i64, i64) -get(list, -1) -get(list, -i) -get(list, -i64) -get(list, 1 * 1) -get(list, 1 - 1) -get(list, 1 - i) -get(list, 1) != foo -get(list, 1).Bar -get(list, 1).Qux -get(list, 1).String -get(list, 1).String() -get(list, 1)?.Bar -get(list, 1)?.Qux -get(list, 1)?.String -get(list, 1)?.String() -get(list, bitshr(i, i32)) -get(list, first(array)) -get(list, get(array, 1)) -get(list, get(array, i64)) -get(list, i % 1) +get(if ok { i } else { array }, list) get(list, i) -get(list, i).Bar -get(list, i).Qux get(list, i).String -get(list, i)?.Bar -get(list, i)?.Qux -get(list, i)?.String -get(list, i)?.String() -get(list, i32 * i32) -get(list, i32 - i32) -get(list, i32) -get(list, i32).Bar -get(list, i32).Qux -get(list, i32).String -get(list, i32)?.Bar -get(list, i32)?.Qux -get(list, i32)?.String -get(list, i32)?.String() -get(list, i64 * 1) -get(list, i64 * i) -get(list, i64 - 1) -get(list, i64) -get(list, i64).Bar -get(list, i64).Qux -get(list, i64).String -get(list, i64)?.Bar -get(list, i64)?.Qux -get(list, i64)?.String -get(list, i64)?.String() -get(list, int(1)) -get(list, max(i32)) -get(list, min(i32)) -get(list, min(i64)) -get(list, ok ? 0.5 : "foo") -get(list, reduce(list, i64)) -get(list, score(1)) -get(list, score(i)) -get(list, true ? i : i32) -get(list[i64:1], i) -get(map(array, #), i) -get(map(array, #), i32) -get(map(array, #), i64) -get(map(array, add), i32) -get(map(array, array), i) -get(map(array, greet), i64) -get(map(array, half), i64) -get(map(list, "foo"), i64) -get(map(list, #), i) -get(map(list, #), i64) -get(map(list, 1), i32) -get(map(list, array), i) -get(map(list, i32), i64) -get(map(list, i64), i64) -get(ok ? 1 : "bar", f32) -get(ok ? add : f32, array) -get(ok ? f64 : div, i64) -get(ok ? false : list, f32 > i) -get(ok ? half : i32, i) -get(ok ? half : ok, f64) -get(ok ? i : 0.5, half) -get(ok ? i32 : half, f64) -get(ok ? i64 : foo, f32) -get(ok ? list : i32, f32) -get(ok ? ok : div, greet) -get(ok ? score : f64, i) -get(ok ? score : i64, foo) -get(reduce(list, array), i32) -get(sort(array), i32) -get(take(list, i), i64) -get(true ? "bar" : ok, score(i)) -get(true ? 0.5 : i32, array) -get(true ? f32 : 0.5, ok) -get(true ? false : foo, i64 > 0.5) -get(true ? greet : i32, score) -get(true ? half : f32, greet) -get(true ? half : list, add) -get(true ? i64 : greet, i32) -get(true ? score : true, half)?.half -get(true ? true : i, f64) -get({"foo": foo, "bar": false}, type(i)) +get(median(array), true && $env) greet +greet != $env != nil +greet != $env && $env +greet != $env == nil +greet != $env and $env +greet != $env or sum(array, true) +greet != $env.greet +greet != $env?.Bar +greet != $env?.String +greet != $env?.String?.add() +greet != $env?.[Bar] +greet != $env?.[String] +greet != $env?.[foobar] +greet != $env?.[str] +greet != $env?.greet +greet != $env?.true +greet != get($env, str) greet != greet +greet != greet != nil greet != greet != ok -greet != nil ? "bar" : add -greet != nil ? 0.5 : false -greet != nil ? list : false +greet != greet && true +greet != greet || false +greet != nil and $env +greet != {foo: str}.foobar +greet == $env and false +greet == $env.greet +greet == $env?.Bar +greet == $env?.String +greet == $env?.[Bar] +greet == $env?.[String] +greet == $env?.[foobar] +greet == $env?.[str] +greet == $env?.foobar +greet == $env?.foobar?.String +greet == $env?.greet greet == greet -greet == greet ? 0.5 : "bar" -greet == greet and ok -greet == nil == ok -greet == nil ? i64 : ok -greet in groupBy(array, f64).f32 -greet in groupBy(list, #).score -greet not in sort(array) -greet("bar" + "bar") -greet("foo" + "foo") -greet("foo") startsWith type(f64) -greet(false ? i64 : "bar") +greet == greet == ok +greet == greet ? 1.0 : foo +greet == min($env) +greet == nil == true +greet == nil or $env +greet == nil || true +greet in $env?.Bar +greet in $env?.String +greet in $env?.[Bar] +greet in $env?.[Bar] && ok +greet in $env?.[String] +greet in $env?.[foobar?.[i]] +greet in $env?.foobar?.[foo] +greet in $env?.nil +greet in $env?.true +greet in [nil] +greet in sort($env) +greet in toPairs($env) +greet not in $env?.Bar +greet not in $env?.String +greet not in $env?.String?.str +greet not in $env?.[Bar] +greet not in $env?.[String] +greet not in $env?.[foobar] +greet not in last($env) +greet not in toPairs($env) +greet not in {foo: foo}.list and ok +greet($env.greet(str)) +greet($env.str) +greet($env?.[str]) +greet($env?.greet(str)) +greet($env?.str) greet(foo.Bar) -greet(foo.Qux("foo")) greet(foo.String()) greet(foo?.Bar) +greet(foo?.Bar) not endsWith str greet(foo?.String()) -greet(greet("bar")) -greet(greet("foo")) -greet(lower("bar")) -greet(lower("foo")) -greet(ok ? "bar" : 1) -greet(ok ? "bar" : i64) -greet(ok ? "foo" : 0.5) -greet(ok ? "foo" : div) -greet(ok ? "foo" : true) -greet(reduce(array, "bar")) -greet(reduce(array, "foo")) -greet(reduce(list, "foo")) -greet(repeat("bar", 1)) -greet(repeat(foo?.String(), i32)) -greet(string("bar")) -greet(string("foo")) -greet(string(0.5)) +greet(greet($env?.[str])) +greet(greet(foo.String())) +greet(greet(str)) +greet(greet(str[:i])) +greet(greet(type($env))) +greet(greet(type(true))) +greet(if false { 1.0 } else { str }) +greet(if ok { str } else { nil }) +greet(join($env | map(str))) +greet(keys($env)?.[i]) +greet(last(list).Bar) +greet(list | reduce(#.Bar)) +greet(list | reduce(str)) +greet(list | reduce(str, str)) +greet(list?.[i].Bar) +greet(lower(greet(str))) +greet(lower(str)) +greet(ok ? str : 1) +greet(reduce(array, str)) +greet(reduce(list, str)) +greet(str + str) +greet(str | greet()) +greet(str | repeat(0)) +greet(str | trim(str)) +greet(str) +greet(str) != $env && $env +greet(str) != str +greet(str) < str +greet(str) <= str +greet(str) == nil ? foo : nil +greet(str) > type(0) +greet(str) >= str +greet(str) contains str +greet(str) contains string(true) +greet(str) endsWith $env?.[str] +greet(str) endsWith str +greet(str) matches str +greet(str) not contains str +greet(str) not endsWith string(foo) +greet(str) not endsWith type(nil) +greet(str) not in foo +greet(str) not startsWith $env?.Bar +greet(str) | greet() +greet(str)[:] +greet(str)[:i] +greet(str)[i:] +greet(str[0:]) +greet(str[1:0]) +greet(str[1:]) +greet(str[:1]) +greet(str[:]) +greet(str[:i]) +greet(str[i:]) +greet(str[i:i]) +greet(string($env)) +greet(string($env?.Bar)) +greet(string(0)) greet(string(1)) +greet(string(1.0)) greet(string(add)) +greet(string(array | sortBy(str))) greet(string(array)) -greet(string(div)) -greet(string(f32)) greet(string(f64)) greet(string(false)) greet(string(foo)) greet(string(greet)) -greet(string(half)) +greet(string(groupBy(list, ok))) greet(string(i)) -greet(string(i32)) -greet(string(i64)) +greet(string(last(array))) greet(string(list)) greet(string(nil)) greet(string(ok)) -greet(string(score)) +greet(string(str)) greet(string(true)) -greet(toBase64("bar")) -greet(toBase64(trimPrefix("bar"))) -greet(toJSON("bar")) -greet(toJSON("foo")) -greet(toJSON(0.5)) +greet(toBase64(str)) +greet(toJSON(0)) greet(toJSON(1)) +greet(toJSON(1.0 + 1.0)) +greet(toJSON(1.0)) +greet(toJSON(array | sum(#))) greet(toJSON(array)) -greet(toJSON(f32)) greet(toJSON(f64)) greet(toJSON(false)) +greet(toJSON(foo) | greet()) greet(toJSON(foo)) +greet(toJSON(foo?.Bar)) greet(toJSON(i)) -greet(toJSON(i32)) -greet(toJSON(i64)) greet(toJSON(list)) greet(toJSON(nil)) greet(toJSON(ok)) +greet(toJSON(str)) greet(toJSON(true)) -greet(trim("bar")) -greet(trim("foo")) -greet(trimPrefix("bar")) -greet(trimPrefix("foo")) -greet(trimSuffix("bar")) -greet(trimSuffix("foo")) +greet(trim(str)) +greet(trimPrefix(str)) greet(trimSuffix(foo.String())) -greet(trimSuffix(foo?.Bar)) -greet(true ? "bar" : i64) -greet(true ? "bar" : ok) -greet(true ? "foo" : foo) -greet(type("bar")) -greet(type("foo")) -greet(type(0.5)) +greet(trimSuffix(str)) +greet(true ? str : i) +greet(true ? str : nil) +greet(type($env)) +greet(type($env.ok)) +greet(type(0)) greet(type(1)) +greet(type(1.0)) greet(type(add)) greet(type(array)) -greet(type(div)) -greet(type(f32)) greet(type(f64)) greet(type(false)) greet(type(foo)) greet(type(greet)) -greet(type(half)) greet(type(i)) -greet(type(i32)) -greet(type(i64)) greet(type(list)) +greet(type(map(array, ok))) +greet(type(nil == f64)) greet(type(nil)) greet(type(ok)) -greet(type(score)) +greet(type(str)) greet(type(true)) -greet(upper("bar")) -greet(upper("foo")) -groupBy(1 .. 1, #).f64 -groupBy(1 .. i, #) -groupBy(1 .. i, i32)?.score -groupBy(1 .. i32, #) -groupBy(1 .. i32, ok) -groupBy(1 .. i64, i32) -groupBy([0.5, f64], nil == "foo") -groupBy([1], # <= #) -groupBy([f32 ^ i64], #) -groupBy([f32], f64) -groupBy([f64], # >= f32) -groupBy([half], f32) -groupBy([i32], array[#]) -groupBy([nil], foo) -groupBy([true], #) -groupBy(array, !false) -groupBy(array, !true) -groupBy(array, "bar" in foo).String -groupBy(array, "bar").Bar -groupBy(array, "bar").Qux -groupBy(array, "bar").String -groupBy(array, "bar").add -groupBy(array, "bar").array -groupBy(array, "bar").div -groupBy(array, "bar").f32 -groupBy(array, "bar").f64 -groupBy(array, "bar").foo -groupBy(array, "bar").greet -groupBy(array, "bar").half -groupBy(array, "bar").i -groupBy(array, "bar").i32 -groupBy(array, "bar").i64 -groupBy(array, "bar").list -groupBy(array, "bar").ok -groupBy(array, "bar").score -groupBy(array, "bar")?.Bar -groupBy(array, "bar")?.Qux -groupBy(array, "bar")?.String -groupBy(array, "bar")?.add -groupBy(array, "bar")?.array -groupBy(array, "bar")?.div -groupBy(array, "bar")?.f32 -groupBy(array, "bar")?.f64 -groupBy(array, "bar")?.foo -groupBy(array, "bar")?.greet -groupBy(array, "bar")?.half -groupBy(array, "bar")?.i -groupBy(array, "bar")?.i64 -groupBy(array, "bar")?.list -groupBy(array, "bar")?.ok -groupBy(array, "bar")?.score -groupBy(array, "bar")[f32 > f32] -groupBy(array, "foo").Bar -groupBy(array, "foo").Qux -groupBy(array, "foo").String -groupBy(array, "foo").add -groupBy(array, "foo").array -groupBy(array, "foo").div -groupBy(array, "foo").f32 -groupBy(array, "foo").f64 -groupBy(array, "foo").foo -groupBy(array, "foo").greet -groupBy(array, "foo").half -groupBy(array, "foo").i -groupBy(array, "foo").i32 -groupBy(array, "foo").i64 -groupBy(array, "foo").list -groupBy(array, "foo").ok -groupBy(array, "foo").score -groupBy(array, "foo")?.Bar -groupBy(array, "foo")?.String -groupBy(array, "foo")?.add -groupBy(array, "foo")?.array -groupBy(array, "foo")?.div -groupBy(array, "foo")?.f32 -groupBy(array, "foo")?.f64 -groupBy(array, "foo")?.foo -groupBy(array, "foo")?.greet -groupBy(array, "foo")?.half -groupBy(array, "foo")?.i -groupBy(array, "foo")?.i32 -groupBy(array, "foo")?.i64 -groupBy(array, "foo")?.list -groupBy(array, "foo")?.ok -groupBy(array, "foo")?.score -groupBy(array, # != #) -groupBy(array, # != #).Qux -groupBy(array, # != #)?.array -groupBy(array, # != 0.5) -groupBy(array, # != 1) -groupBy(array, # != f32) -groupBy(array, # != f64) -groupBy(array, # != f64)?.String -groupBy(array, # != i64) -groupBy(array, # != nil) +greet(upper(str)) +greet; $env?.[Bar] +greet; add +greet; array +greet; f64 +greet; foo +greet; foo; i +greet; greet +greet; i +greet; ok +groupBy($env | map(i), ok) +groupBy($env.array, #) +groupBy($env.array, 0 * 1.0) +groupBy($env.array, foo) +groupBy($env.array, i / #) +groupBy($env.list, #) +groupBy($env.list, foo) +groupBy($env.list, nil != #.String) +groupBy($env?.[str], #) +groupBy($env?.[str], 1.0 <= i) +groupBy($env?.[str], f64) +groupBy($env?.[str], i) +groupBy($env?.[str], mean(#)) +groupBy($env?.[str], ok) +groupBy($env?.[str], ok)?.add +groupBy($env?.array, #) +groupBy($env?.array, $env?.i) +groupBy($env?.array, f64) +groupBy($env?.array, i) +groupBy($env?.array, str) +groupBy($env?.list, $env?.i) +groupBy($env?.list, 0 == $env) +groupBy(1 .. 1, ok) +groupBy([1.0], # / f64) +groupBy([1.0], foo) +groupBy([1], #) +groupBy([false, str], ok) +groupBy([false], #) +groupBy([foo], 0 >= i) +groupBy([foo], i) +groupBy([i], foo) +groupBy([list], abs(1.0)) +groupBy([str], str) +groupBy(array | filter(false), greet) +groupBy(array | map($env), #.ok) +groupBy(array, # != 1.0) groupBy(array, # % #) -groupBy(array, # % 1) -groupBy(array, # % i32) -groupBy(array, # * #) -groupBy(array, # * #)?.Qux -groupBy(array, # * 0.5) -groupBy(array, # * 1) groupBy(array, # * i) -groupBy(array, # * i32) -groupBy(array, # * i64) -groupBy(array, # ** #) -groupBy(array, # ** #).add -groupBy(array, # ** 0.5) -groupBy(array, # ** 0.5)?.foo -groupBy(array, # ** 0.5)?.greet -groupBy(array, # ** 1) -groupBy(array, # ** f64) -groupBy(array, # ** i) -groupBy(array, # ** i32) -groupBy(array, # ** i64) groupBy(array, # + #) -groupBy(array, # + 1) -groupBy(array, # + f32) -groupBy(array, # + i) -groupBy(array, # - #) -groupBy(array, # - 0.5) -groupBy(array, # - 1) -groupBy(array, # - f32) -groupBy(array, # - f64) -groupBy(array, # - i) -groupBy(array, # - i32) groupBy(array, # / #) -groupBy(array, # / 0.5) -groupBy(array, # / 0.5)?.foo -groupBy(array, # / 1) -groupBy(array, # / i) -groupBy(array, # / i32) -groupBy(array, # / i64) -groupBy(array, # < # || 0.5 > f64) -groupBy(array, # < #) -groupBy(array, # < 0.5) -groupBy(array, # < 1) -groupBy(array, # < i32) -groupBy(array, # < i64) -groupBy(array, # <= #) -groupBy(array, # <= #)?.Bar -groupBy(array, # <= #)?.Qux -groupBy(array, # <= 0.5) -groupBy(array, # <= 1) -groupBy(array, # <= f32) -groupBy(array, # <= f64) -groupBy(array, # <= i) -groupBy(array, # <= i64) groupBy(array, # == #) -groupBy(array, # == #).String -groupBy(array, # == #)?.half -groupBy(array, # == 0.5) -groupBy(array, # == 1) -groupBy(array, # == f32) -groupBy(array, # == f32).half -groupBy(array, # == f64) -groupBy(array, # == i) -groupBy(array, # == i64) -groupBy(array, # == nil) groupBy(array, # > #) -groupBy(array, # > 0.5) -groupBy(array, # > 1) -groupBy(array, # > 1).Bar -groupBy(array, # > i)?.i64 -groupBy(array, # > i64) -groupBy(array, # >= #) -groupBy(array, # >= f64) -groupBy(array, # >= i) -groupBy(array, # >= i32) -groupBy(array, # >= i64) +groupBy(array, # >= #).String +groupBy(array, # >= 0) groupBy(array, # ^ #) -groupBy(array, # ^ 0.5) -groupBy(array, # ^ f32) -groupBy(array, # ^ i) -groupBy(array, # ^ i32) -groupBy(array, # in array) groupBy(array, #) groupBy(array, #).Bar -groupBy(array, #).Qux groupBy(array, #).String groupBy(array, #).add groupBy(array, #).array -groupBy(array, #).div -groupBy(array, #).f32 groupBy(array, #).f64 groupBy(array, #).foo groupBy(array, #).greet -groupBy(array, #).half groupBy(array, #).i -groupBy(array, #).i32 -groupBy(array, #).i64 groupBy(array, #).list groupBy(array, #).ok -groupBy(array, #).score +groupBy(array, #).str groupBy(array, #)?.Bar -groupBy(array, #)?.Qux groupBy(array, #)?.String +groupBy(array, #)?.[f64] +groupBy(array, #)?.[foo] +groupBy(array, #)?.[i] +groupBy(array, #)?.[ok] +groupBy(array, #)?.[str] groupBy(array, #)?.add groupBy(array, #)?.array -groupBy(array, #)?.div -groupBy(array, #)?.f32 groupBy(array, #)?.f64 groupBy(array, #)?.foo +groupBy(array, #)?.foobar groupBy(array, #)?.greet -groupBy(array, #)?.half groupBy(array, #)?.i -groupBy(array, #)?.i32 -groupBy(array, #)?.i64 groupBy(array, #)?.list groupBy(array, #)?.ok -groupBy(array, #)?.score -groupBy(array, #)[1 / i] -groupBy(array, #)[f32] -groupBy(array, #)[f64] -groupBy(array, #)[foo] -groupBy(array, #)[i32] -groupBy(array, #)[i64] -groupBy(array, #)[i] -groupBy(array, #)[ok] -groupBy(array, #)[reduce(list, #)] -groupBy(array, -# * # * 0.5) -groupBy(array, -#) -groupBy(array, -#).Qux -groupBy(array, -0.5) -groupBy(array, -1) -groupBy(array, -f32) -groupBy(array, -i)?.score -groupBy(array, -i32) -groupBy(array, -i64) -groupBy(array, 0.5 != #) -groupBy(array, 0.5 * #) -groupBy(array, 0.5 * 0.5) -groupBy(array, 0.5 * f64) -groupBy(array, 0.5 ** #) -groupBy(array, 0.5 ** 1) -groupBy(array, 0.5 ** i64) -groupBy(array, 0.5 + #)?.score -groupBy(array, 0.5 + f32) -groupBy(array, 0.5 - 1) -groupBy(array, 0.5 / #).array -groupBy(array, 0.5 / f64) -groupBy(array, 0.5 / i64) -groupBy(array, 0.5 < 0.5) -groupBy(array, 0.5 <= f32) -groupBy(array, 0.5 == #) -groupBy(array, 0.5 >= #) -groupBy(array, 0.5 >= i32) -groupBy(array, 0.5 >= i64) -groupBy(array, 0.5 ^ f32) -groupBy(array, 0.5 ^ i64) -groupBy(array, 0.5).Bar -groupBy(array, 0.5).Qux -groupBy(array, 0.5).String -groupBy(array, 0.5).add -groupBy(array, 0.5).array -groupBy(array, 0.5).div -groupBy(array, 0.5).f32 -groupBy(array, 0.5).f64 -groupBy(array, 0.5).foo -groupBy(array, 0.5).greet -groupBy(array, 0.5).half -groupBy(array, 0.5).i -groupBy(array, 0.5).i32 -groupBy(array, 0.5).i64 -groupBy(array, 0.5).list -groupBy(array, 0.5).ok -groupBy(array, 0.5).score -groupBy(array, 0.5)?.Bar -groupBy(array, 0.5)?.Qux -groupBy(array, 0.5)?.String -groupBy(array, 0.5)?.add -groupBy(array, 0.5)?.array -groupBy(array, 0.5)?.div -groupBy(array, 0.5)?.f32 -groupBy(array, 0.5)?.f64 -groupBy(array, 0.5)?.foo -groupBy(array, 0.5)?.greet -groupBy(array, 0.5)?.half -groupBy(array, 0.5)?.i -groupBy(array, 0.5)?.i32 -groupBy(array, 0.5)?.i64 -groupBy(array, 0.5)?.list -groupBy(array, 0.5)?.ok -groupBy(array, 0.5)?.score -groupBy(array, 1 != #)?.String -groupBy(array, 1 != 0.5) -groupBy(array, 1 != f32) -groupBy(array, 1 % #) -groupBy(array, 1 % i) -groupBy(array, 1 * 0.5) -groupBy(array, 1 * i) -groupBy(array, 1 + #) -groupBy(array, 1 + 1) -groupBy(array, 1 - #) -groupBy(array, 1 - 1) -groupBy(array, 1 / #) -groupBy(array, 1 < #) -groupBy(array, 1 < i32)?.array -groupBy(array, 1 < i64)?.ok -groupBy(array, 1 <= #) -groupBy(array, 1 == #) -groupBy(array, 1 == #).add -groupBy(array, 1 == i32) -groupBy(array, 1 == nil) -groupBy(array, 1 > i) -groupBy(array, 1 >= #) -groupBy(array, 1 ^ #) -groupBy(array, 1 not in array) -groupBy(array, 1).Bar -groupBy(array, 1).Qux +groupBy(array, #)?.str +groupBy(array, $env == foo) +groupBy(array, $env | sum(1.0)) +groupBy(array, $env.f64) +groupBy(array, $env.foo) +groupBy(array, $env.ok) +groupBy(array, $env.str) +groupBy(array, $env?.[foobar]) +groupBy(array, $env?.[str]) +groupBy(array, $env?.f64) +groupBy(array, $env?.i) +groupBy(array, $env?.str) +groupBy(array, 0 + #) +groupBy(array, 0 == 1.0) +groupBy(array, 0).Bar +groupBy(array, 0).String +groupBy(array, 0).add +groupBy(array, 0).array +groupBy(array, 0).foo +groupBy(array, 0).str +groupBy(array, 0)?.Bar +groupBy(array, 0)?.String +groupBy(array, 0)?.[f64] +groupBy(array, 0)?.[foo] +groupBy(array, 0)?.[i] +groupBy(array, 0)?.[str] +groupBy(array, 0)?.add +groupBy(array, 0)?.array +groupBy(array, 0)?.foo +groupBy(array, 0)?.foobar +groupBy(array, 0)?.greet +groupBy(array, 0)?.i +groupBy(array, 0)?.list groupBy(array, 1).String groupBy(array, 1).add groupBy(array, 1).array -groupBy(array, 1).div groupBy(array, 1).f64 groupBy(array, 1).foo groupBy(array, 1).greet -groupBy(array, 1).half groupBy(array, 1).i -groupBy(array, 1).i32 -groupBy(array, 1).i64 groupBy(array, 1).list -groupBy(array, 1).ok -groupBy(array, 1).score groupBy(array, 1)?.Bar -groupBy(array, 1)?.Qux -groupBy(array, 1)?.String +groupBy(array, 1)?.[i] +groupBy(array, 1)?.[ok] +groupBy(array, 1)?.[str] groupBy(array, 1)?.add -groupBy(array, 1)?.array -groupBy(array, 1)?.div -groupBy(array, 1)?.f32 groupBy(array, 1)?.f64 -groupBy(array, 1)?.foo -groupBy(array, 1)?.greet -groupBy(array, 1)?.half -groupBy(array, 1)?.i -groupBy(array, 1)?.i32 -groupBy(array, 1)?.i64 groupBy(array, 1)?.list groupBy(array, 1)?.ok -groupBy(array, 1)?.score +groupBy(array, 1.0 != $env) +groupBy(array, 1.0 - 1.0) +groupBy(array, 1.0 < 0)?.ok +groupBy(array, 1.0 ^ #) +groupBy(array, 1.0) == $env?.Bar +groupBy(array, 1.0).Bar +groupBy(array, 1.0).add +groupBy(array, 1.0).array +groupBy(array, 1.0).f64 +groupBy(array, 1.0).foo +groupBy(array, 1.0).greet +groupBy(array, 1.0).i +groupBy(array, 1.0).list +groupBy(array, 1.0).ok +groupBy(array, 1.0).str +groupBy(array, 1.0)?.Bar +groupBy(array, 1.0)?.String +groupBy(array, 1.0)?.[f64] +groupBy(array, 1.0)?.[foo] +groupBy(array, 1.0)?.[ok] +groupBy(array, 1.0)?.[str] +groupBy(array, 1.0)?.add +groupBy(array, 1.0)?.f64 +groupBy(array, 1.0)?.foo +groupBy(array, 1.0)?.greet +groupBy(array, 1.0)?.i +groupBy(array, 1.0)?.list +groupBy(array, 1.0)?.ok +groupBy(array, 1.0)?.str groupBy(array, abs(#)) -groupBy(array, abs(0.5)) -groupBy(array, abs(1)) -groupBy(array, abs(f32)) -groupBy(array, abs(f64)) -groupBy(array, abs(i)) -groupBy(array, abs(i64)) -groupBy(array, add(#, #)) -groupBy(array, add(#, 1))?.i64 -groupBy(array, bitnand(1, #)) -groupBy(array, bitnot(#)) -groupBy(array, bitnot(1)) -groupBy(array, bitor(#, #)) -groupBy(array, bitor(1, #)) -groupBy(array, bitor(i32, #)) -groupBy(array, bitshl(1, #)) -groupBy(array, bitshr(i, #)) -groupBy(array, bitushr(#, #)) -groupBy(array, ceil(#)) -groupBy(array, ceil(i)) -groupBy(array, ceil(i32)) -groupBy(array, div(#, #)) -groupBy(array, f32 != #) -groupBy(array, f32 ** 0.5) -groupBy(array, f32 - #) -groupBy(array, f32 - f64) -groupBy(array, f32 / #) -groupBy(array, f32 < #) -groupBy(array, f32 <= #) -groupBy(array, f32 == #) -groupBy(array, f32 > 0.5) -groupBy(array, f32 > i32) -groupBy(array, f32 ^ i) -groupBy(array, f32) -groupBy(array, f32).Bar -groupBy(array, f32).Qux -groupBy(array, f32).String -groupBy(array, f32).add -groupBy(array, f32).array -groupBy(array, f32).div -groupBy(array, f32).f64 -groupBy(array, f32).greet -groupBy(array, f32).half -groupBy(array, f32).i -groupBy(array, f32).i32 -groupBy(array, f32).i64 -groupBy(array, f32).list -groupBy(array, f32).ok -groupBy(array, f32).score -groupBy(array, f32)?.Bar -groupBy(array, f32)?.Qux -groupBy(array, f32)?.String -groupBy(array, f32)?.add -groupBy(array, f32)?.array -groupBy(array, f32)?.div -groupBy(array, f32)?.f32 -groupBy(array, f32)?.f64 -groupBy(array, f32)?.greet -groupBy(array, f32)?.half -groupBy(array, f32)?.i32 -groupBy(array, f32)?.i64 -groupBy(array, f32)?.list -groupBy(array, f32)?.ok -groupBy(array, f32)?.score -groupBy(array, f32)[foo] -groupBy(array, f64 != #) -groupBy(array, f64 != i64) -groupBy(array, f64 ** #) -groupBy(array, f64 - #) -groupBy(array, f64 - #).i32 +groupBy(array, bitshr(#, 0)) +groupBy(array, f64 - 1) +groupBy(array, f64 / #) groupBy(array, f64 < #) -groupBy(array, f64 == #) -groupBy(array, f64 > #) -groupBy(array, f64 >= #) -groupBy(array, f64 >= 0.5) groupBy(array, f64) groupBy(array, f64).Bar -groupBy(array, f64).Qux groupBy(array, f64).String groupBy(array, f64).add groupBy(array, f64).array -groupBy(array, f64).div -groupBy(array, f64).f32 groupBy(array, f64).f64 -groupBy(array, f64).foo -groupBy(array, f64).greet -groupBy(array, f64).half groupBy(array, f64).i -groupBy(array, f64).i32 -groupBy(array, f64).i64 -groupBy(array, f64).list groupBy(array, f64).ok -groupBy(array, f64).score +groupBy(array, f64).str groupBy(array, f64)?.Bar -groupBy(array, f64)?.Qux -groupBy(array, f64)?.String +groupBy(array, f64)?.[i] +groupBy(array, f64)?.[ok] +groupBy(array, f64)?.[str] groupBy(array, f64)?.add -groupBy(array, f64)?.array -groupBy(array, f64)?.div -groupBy(array, f64)?.f32 -groupBy(array, f64)?.f64 groupBy(array, f64)?.foo -groupBy(array, f64)?.greet -groupBy(array, f64)?.half -groupBy(array, f64)?.i -groupBy(array, f64)?.i32 -groupBy(array, f64)?.i64 groupBy(array, f64)?.list groupBy(array, f64)?.ok -groupBy(array, f64)?.score -groupBy(array, f64)[i32] -groupBy(array, false ? # : #) -groupBy(array, false || ok) +groupBy(array, f64)?.str +groupBy(array, false and $env) +groupBy(array, false or true) groupBy(array, false).Bar -groupBy(array, false).Qux groupBy(array, false).String groupBy(array, false).add -groupBy(array, false).array -groupBy(array, false).div -groupBy(array, false).f32 groupBy(array, false).f64 +groupBy(array, false).foo groupBy(array, false).greet -groupBy(array, false).half -groupBy(array, false).i -groupBy(array, false).i32 -groupBy(array, false).i64 groupBy(array, false).list -groupBy(array, false).ok -groupBy(array, false).score +groupBy(array, false).str groupBy(array, false)?.Bar -groupBy(array, false)?.Qux groupBy(array, false)?.String +groupBy(array, false)?.[f64] +groupBy(array, false)?.[foo] +groupBy(array, false)?.[i] +groupBy(array, false)?.[str] groupBy(array, false)?.add -groupBy(array, false)?.array -groupBy(array, false)?.div -groupBy(array, false)?.f32 groupBy(array, false)?.f64 groupBy(array, false)?.foo groupBy(array, false)?.greet -groupBy(array, false)?.half -groupBy(array, false)?.i -groupBy(array, false)?.i32 -groupBy(array, false)?.i64 -groupBy(array, false)?.list groupBy(array, false)?.ok -groupBy(array, false)?.score -groupBy(array, findLastIndex(list, true)) -groupBy(array, float(#)) -groupBy(array, floor(#)) -groupBy(array, floor(i32)) +groupBy(array, false)?.str +groupBy(array, foo not in list) groupBy(array, foo) groupBy(array, foo).Bar -groupBy(array, foo).Qux groupBy(array, foo).String groupBy(array, foo).add groupBy(array, foo).array -groupBy(array, foo).div -groupBy(array, foo).f32 -groupBy(array, foo).f64 groupBy(array, foo).foo groupBy(array, foo).greet -groupBy(array, foo).half groupBy(array, foo).i -groupBy(array, foo).i32 -groupBy(array, foo).i64 groupBy(array, foo).list groupBy(array, foo).ok -groupBy(array, foo).score -groupBy(array, foo)?.Bar -groupBy(array, foo)?.Qux +groupBy(array, foo).str groupBy(array, foo)?.String +groupBy(array, foo)?.[f64] +groupBy(array, foo)?.[foo] +groupBy(array, foo)?.[i] +groupBy(array, foo)?.[ok] groupBy(array, foo)?.add groupBy(array, foo)?.array -groupBy(array, foo)?.div -groupBy(array, foo)?.f32 groupBy(array, foo)?.f64 -groupBy(array, foo)?.foo groupBy(array, foo)?.greet -groupBy(array, foo)?.half groupBy(array, foo)?.i -groupBy(array, foo)?.i32 -groupBy(array, foo)?.i64 groupBy(array, foo)?.list groupBy(array, foo)?.ok -groupBy(array, foo)?.score +groupBy(array, foo)?.str groupBy(array, foo.Bar) -groupBy(array, foo?.Bar) -groupBy(array, get(array, #)) -groupBy(array, get(list, #)) -groupBy(array, get(list, i32)) -groupBy(array, half(1)) -groupBy(array, half(f64)) -groupBy(array, half(f64))?.i64 -groupBy(array, i != #) -groupBy(array, i % #) -groupBy(array, i * #) -groupBy(array, i * #)?.f64 -groupBy(array, i ** #) -groupBy(array, i + #) -groupBy(array, i - f64).array -groupBy(array, i / #) -groupBy(array, i < #) -groupBy(array, i <= #) -groupBy(array, i <= f64) -groupBy(array, i > i) -groupBy(array, i ^ #) -groupBy(array, i ^ 0.5) +groupBy(array, greet == $env) +groupBy(array, greet(str)) +groupBy(array, i | bitand(#))?.list groupBy(array, i) -groupBy(array, i).Bar -groupBy(array, i).Qux -groupBy(array, i).String groupBy(array, i).add groupBy(array, i).array -groupBy(array, i).div -groupBy(array, i).f32 groupBy(array, i).f64 groupBy(array, i).foo groupBy(array, i).greet -groupBy(array, i).half groupBy(array, i).i -groupBy(array, i).i32 -groupBy(array, i).i64 -groupBy(array, i).list groupBy(array, i).ok -groupBy(array, i).score +groupBy(array, i).str groupBy(array, i)?.Bar -groupBy(array, i)?.String +groupBy(array, i)?.[f64] +groupBy(array, i)?.[ok] +groupBy(array, i)?.[str] groupBy(array, i)?.add groupBy(array, i)?.array -groupBy(array, i)?.div -groupBy(array, i)?.f32 groupBy(array, i)?.f64 -groupBy(array, i)?.foo -groupBy(array, i)?.greet -groupBy(array, i)?.half -groupBy(array, i)?.i -groupBy(array, i)?.i32 -groupBy(array, i)?.i64 -groupBy(array, i)?.list groupBy(array, i)?.ok -groupBy(array, i)?.score -groupBy(array, i)[f64] -groupBy(array, i)[false ? i32 : ok] -groupBy(array, i32 * f64) -groupBy(array, i32 ** # <= i32) -groupBy(array, i32 ** f64) -groupBy(array, i32 ** i) -groupBy(array, i32 ** i64) -groupBy(array, i32 + #) -groupBy(array, i32 - 1)?.foo -groupBy(array, i32 - i64) -groupBy(array, i32 / #) -groupBy(array, i32 / f32) -groupBy(array, i32 < #) -groupBy(array, i32 < f64) -groupBy(array, i32 <= 1) -groupBy(array, i32 == #) -groupBy(array, i32 == i) -groupBy(array, i32 > #) -groupBy(array, i32 >= #).Bar -groupBy(array, i32 ^ #) -groupBy(array, i32) -groupBy(array, i32).Bar -groupBy(array, i32).Qux -groupBy(array, i32).String -groupBy(array, i32).add -groupBy(array, i32).array -groupBy(array, i32).div -groupBy(array, i32).f32 -groupBy(array, i32).f64 -groupBy(array, i32).greet -groupBy(array, i32).half -groupBy(array, i32).i -groupBy(array, i32).i32 -groupBy(array, i32).i64 -groupBy(array, i32).list -groupBy(array, i32).ok -groupBy(array, i32).score -groupBy(array, i32)?.Bar -groupBy(array, i32)?.Qux -groupBy(array, i32)?.String -groupBy(array, i32)?.add -groupBy(array, i32)?.array -groupBy(array, i32)?.div -groupBy(array, i32)?.f32 -groupBy(array, i32)?.f64 -groupBy(array, i32)?.foo -groupBy(array, i32)?.greet -groupBy(array, i32)?.half -groupBy(array, i32)?.i -groupBy(array, i32)?.i32 -groupBy(array, i32)?.i64 -groupBy(array, i32)?.list -groupBy(array, i32)?.ok -groupBy(array, i32)?.score -groupBy(array, i32)[i] -groupBy(array, i64 != i) -groupBy(array, i64 % #) -groupBy(array, i64 * f32) -groupBy(array, i64 ** #) -groupBy(array, i64 ** i) -groupBy(array, i64 + #) -groupBy(array, i64 - #) -groupBy(array, i64 / #)?.Qux -groupBy(array, i64 / 0.5) -groupBy(array, i64 < #) -groupBy(array, i64 <= #).foo -groupBy(array, i64 >= #) -groupBy(array, i64 ^ #) -groupBy(array, i64) -groupBy(array, i64).Bar -groupBy(array, i64).Qux -groupBy(array, i64).String -groupBy(array, i64).add -groupBy(array, i64).array -groupBy(array, i64).div -groupBy(array, i64).f32 -groupBy(array, i64).f64 -groupBy(array, i64).foo -groupBy(array, i64).greet -groupBy(array, i64).half -groupBy(array, i64).i -groupBy(array, i64).i32 -groupBy(array, i64).i64 -groupBy(array, i64).list -groupBy(array, i64).ok -groupBy(array, i64).score -groupBy(array, i64)?.Bar -groupBy(array, i64)?.Qux -groupBy(array, i64)?.String -groupBy(array, i64)?.add -groupBy(array, i64)?.array -groupBy(array, i64)?.div -groupBy(array, i64)?.f32 -groupBy(array, i64)?.f64 -groupBy(array, i64)?.foo -groupBy(array, i64)?.greet -groupBy(array, i64)?.half -groupBy(array, i64)?.i -groupBy(array, i64)?.i32 -groupBy(array, i64)?.i64 -groupBy(array, i64)?.list -groupBy(array, i64)?.ok -groupBy(array, i64)?.score -groupBy(array, int(f64)).i32 -groupBy(array, max(#)) -groupBy(array, max(#, #, #)).ok -groupBy(array, max(0.5, #)) -groupBy(array, max(1)) -groupBy(array, max(f64)) -groupBy(array, min(#)) -groupBy(array, min(0.5)) -groupBy(array, min(f32)) -groupBy(array, min(i, #, i32)) -groupBy(array, nil != #) -groupBy(array, nil != f64) -groupBy(array, nil != foo) -groupBy(array, nil != half) -groupBy(array, nil == #) -groupBy(array, nil == 0.5) -groupBy(array, none(array, false)) -groupBy(array, none(array, ok)) -groupBy(array, not ok)?.Bar -groupBy(array, not true) -groupBy(array, ok == ok) -groupBy(array, ok ? # : #) +groupBy(array, i)?.str +groupBy(array, if true { nil } else { f64 }) +groupBy(array, max(i)) +groupBy(array, mean(1.0)) +groupBy(array, nil == $env) groupBy(array, ok) groupBy(array, ok).Bar -groupBy(array, ok).Qux groupBy(array, ok).String groupBy(array, ok).add -groupBy(array, ok).array -groupBy(array, ok).div -groupBy(array, ok).f32 groupBy(array, ok).f64 groupBy(array, ok).foo groupBy(array, ok).greet -groupBy(array, ok).half -groupBy(array, ok).i -groupBy(array, ok).i32 -groupBy(array, ok).i64 -groupBy(array, ok).list -groupBy(array, ok).ok -groupBy(array, ok).score -groupBy(array, ok)?.Bar -groupBy(array, ok)?.Qux +groupBy(array, ok).str groupBy(array, ok)?.String +groupBy(array, ok)?.[foo] +groupBy(array, ok)?.[i] +groupBy(array, ok)?.[ok] +groupBy(array, ok)?.[str] groupBy(array, ok)?.array -groupBy(array, ok)?.div -groupBy(array, ok)?.f32 -groupBy(array, ok)?.f64 groupBy(array, ok)?.foo -groupBy(array, ok)?.greet -groupBy(array, ok)?.half -groupBy(array, ok)?.i32 -groupBy(array, ok)?.i64 groupBy(array, ok)?.list groupBy(array, ok)?.ok -groupBy(array, ok)?.score -groupBy(array, one(array, ok)) -groupBy(array, reduce(array, #)) -groupBy(array, reduce(array, foo)) -groupBy(array, reduce(list, #)) -groupBy(array, round(#)) -groupBy(array, score(#)) -groupBy(array, score(#, #)) -groupBy(array, score(#, #, #, 1)) -groupBy(array, score(#, 1)).list -groupBy(array, score(1)) -groupBy(array, score(i)) -groupBy(array, string(#)) -groupBy(array, string(div)) -groupBy(array, string(i32)) -groupBy(array, toJSON("bar")) -groupBy(array, toJSON(#)) -groupBy(array, toJSON(1 .. i)) -groupBy(array, toJSON(foo)) -groupBy(array, trimPrefix("foo")) -groupBy(array, true == nil) -groupBy(array, true ? # : #) -groupBy(array, true ? # : 1) -groupBy(array, true ? nil : "foo") +groupBy(array, round(i)) +groupBy(array, str) +groupBy(array, str).Bar +groupBy(array, str).String +groupBy(array, str).add +groupBy(array, str).foo +groupBy(array, str).list +groupBy(array, str).str +groupBy(array, str)?.String +groupBy(array, str)?.[i] +groupBy(array, str)?.[ok] +groupBy(array, str)?.array +groupBy(array, str)?.f64 +groupBy(array, str)?.i +groupBy(array, str)?.list +groupBy(array, str)?.not +groupBy(array, str)?.ok +groupBy(array, str)?.str +groupBy(array, sum(array)) +groupBy(array, toJSON(array)) +groupBy(array, true && true) groupBy(array, true).Bar -groupBy(array, true).Qux groupBy(array, true).add -groupBy(array, true).div +groupBy(array, true).array groupBy(array, true).f64 groupBy(array, true).foo -groupBy(array, true).greet -groupBy(array, true).half groupBy(array, true).i -groupBy(array, true).i32 -groupBy(array, true).i64 groupBy(array, true).list -groupBy(array, true).ok -groupBy(array, true).score -groupBy(array, true)?.Bar -groupBy(array, true)?.Qux -groupBy(array, true)?.String +groupBy(array, true).str +groupBy(array, true)?.[f64] +groupBy(array, true)?.[foo] +groupBy(array, true)?.[i] +groupBy(array, true)?.[ok] +groupBy(array, true)?.[str] groupBy(array, true)?.add -groupBy(array, true)?.array -groupBy(array, true)?.div -groupBy(array, true)?.f32 groupBy(array, true)?.f64 -groupBy(array, true)?.half groupBy(array, true)?.i -groupBy(array, true)?.i32 -groupBy(array, true)?.i64 groupBy(array, true)?.list groupBy(array, true)?.ok -groupBy(array, true)?.score -groupBy(array, true)[i32] -groupBy(array, type(# <= #)) -groupBy(array, type(#)).i64 -groupBy(array, type(-f64)) -groupBy(array, type(f32)) -groupBy(false ? 0.5 : "bar", #) -groupBy(filter(array, false), #) -groupBy(filter(array, false), add) -groupBy(filter(array, false), f32) -groupBy(filter(array, false), nil == #) -groupBy(filter(array, ok), half(1)) -groupBy(filter(array, true), #) -groupBy(filter(array, true), f64) -groupBy(filter(list, ok), #) -groupBy(groupBy(array, "foo").list, #) -groupBy(groupBy(array, #).i32, add) -groupBy(groupBy(array, ok).Bar, #?.array not matches #) -groupBy(groupBy(array, true).f64, #[#]) -groupBy(i .. 1, !ok)?.f64 -groupBy(i .. 1, # % #) -groupBy(i .. i, i64) -groupBy(i .. i32, #) -groupBy(i .. i32, f64 * #) -groupBy(i .. i64, f64)?.score -groupBy(i .. i64, foo) -groupBy(i .. len(array), #) -groupBy(i32 .. 1, # - #) -groupBy(i32 .. 1, #)?.f32 -groupBy(i32 .. i, #) -groupBy(i32 .. i32, i) -groupBy(i32 .. i32, i32) -groupBy(i32 .. i32, i64) -groupBy(i32 .. i32, list[i]) -groupBy(i32 .. i32, ok) -groupBy(i32 .. i64, #) -groupBy(i32 .. i64, get(array, #)) -groupBy(i64 .. 1, -0.5) -groupBy(i64 .. 1, i) -groupBy(i64 .. i, -#) -groupBy(i64 .. i, i32) -groupBy(i64 .. i32, i) -groupBy(i64 .. i64, i32) -groupBy(list, !("foo" in #)) -groupBy(list, !false) -groupBy(list, !ok) -groupBy(list, !true) -groupBy(list, "bar" contains "foo")?.ok -groupBy(list, "bar" endsWith "bar") -groupBy(list, "bar" not in #) -groupBy(list, "bar").Bar -groupBy(list, "bar").Qux -groupBy(list, "bar").String -groupBy(list, "bar").add -groupBy(list, "bar").array -groupBy(list, "bar").div -groupBy(list, "bar").f32 -groupBy(list, "bar").f64 -groupBy(list, "bar").foo -groupBy(list, "bar").greet -groupBy(list, "bar").i -groupBy(list, "bar").i32 -groupBy(list, "bar").i64 -groupBy(list, "bar").list -groupBy(list, "bar").ok -groupBy(list, "bar").score -groupBy(list, "bar")?.Bar -groupBy(list, "bar")?.Qux -groupBy(list, "bar")?.String -groupBy(list, "bar")?.add -groupBy(list, "bar")?.array -groupBy(list, "bar")?.div -groupBy(list, "bar")?.f32 -groupBy(list, "bar")?.f64 -groupBy(list, "bar")?.foo -groupBy(list, "bar")?.greet -groupBy(list, "bar")?.half -groupBy(list, "bar")?.i -groupBy(list, "bar")?.i32 -groupBy(list, "bar")?.i64 -groupBy(list, "bar")?.list -groupBy(list, "bar")?.ok -groupBy(list, "bar")?.score -groupBy(list, "foo" not in #)?.foo -groupBy(list, "foo").Bar -groupBy(list, "foo").Qux -groupBy(list, "foo").String -groupBy(list, "foo").add -groupBy(list, "foo").array -groupBy(list, "foo").div -groupBy(list, "foo").f32 -groupBy(list, "foo").f64 -groupBy(list, "foo").foo -groupBy(list, "foo").greet -groupBy(list, "foo").half -groupBy(list, "foo").i -groupBy(list, "foo").i32 -groupBy(list, "foo").i64 -groupBy(list, "foo").list -groupBy(list, "foo").ok -groupBy(list, "foo").score -groupBy(list, "foo")?.Bar -groupBy(list, "foo")?.Qux -groupBy(list, "foo")?.String -groupBy(list, "foo")?.add -groupBy(list, "foo")?.array -groupBy(list, "foo")?.div -groupBy(list, "foo")?.f32 -groupBy(list, "foo")?.f64 -groupBy(list, "foo")?.foo -groupBy(list, "foo")?.greet -groupBy(list, "foo")?.half -groupBy(list, "foo")?.i -groupBy(list, "foo")?.i32 -groupBy(list, "foo")?.i64 -groupBy(list, "foo")?.list -groupBy(list, "foo")?.ok -groupBy(list, "foo")?.score -groupBy(list, # != #) -groupBy(list, # != foo) -groupBy(list, # != foo)?.i -groupBy(list, # != nil) +groupBy(array, true)?.str +groupBy(array, type(#)) +groupBy(array, type(i)) +groupBy(filter($env, false), .ok.greet()) +groupBy(flatten(array), #) +groupBy(flatten(list), #) +groupBy(groupBy(array, ok).i, #?.[ok][.f64:]) +groupBy(i..i, #) +groupBy(list | map(#), f64) +groupBy(list | map(#), ok) +groupBy(list | map(array), $env?.f64) groupBy(list, # == #) -groupBy(list, # == #).div -groupBy(list, # in list) -groupBy(list, # not in list) groupBy(list, #) groupBy(list, #).Bar -groupBy(list, #).Qux groupBy(list, #).String groupBy(list, #).add groupBy(list, #).array -groupBy(list, #).div -groupBy(list, #).f32 groupBy(list, #).f64 groupBy(list, #).foo groupBy(list, #).greet -groupBy(list, #).half groupBy(list, #).i -groupBy(list, #).i32 -groupBy(list, #).i64 groupBy(list, #).list groupBy(list, #).ok -groupBy(list, #).score +groupBy(list, #).str groupBy(list, #)?.Bar -groupBy(list, #)?.Qux groupBy(list, #)?.String +groupBy(list, #)?.[f64] +groupBy(list, #)?.[foo] +groupBy(list, #)?.[i] +groupBy(list, #)?.[ok] +groupBy(list, #)?.[str] groupBy(list, #)?.add groupBy(list, #)?.array -groupBy(list, #)?.div -groupBy(list, #)?.f32 groupBy(list, #)?.f64 groupBy(list, #)?.foo groupBy(list, #)?.greet -groupBy(list, #)?.half groupBy(list, #)?.i -groupBy(list, #)?.i32 -groupBy(list, #)?.i64 groupBy(list, #)?.list groupBy(list, #)?.ok -groupBy(list, #)?.score -groupBy(list, #)[-i64] -groupBy(list, #)[1 == i32] -groupBy(list, #)[f32] -groupBy(list, #)[foo] -groupBy(list, #)[i == i64] -groupBy(list, #)[i32] -groupBy(list, #)[i64] -groupBy(list, #)[ok] +groupBy(list, #)?.str +groupBy(list, #.Bar) +groupBy(list, #.Bar).Bar +groupBy(list, #.Bar).array +groupBy(list, #.Bar).f64 +groupBy(list, #.Bar).foo +groupBy(list, #.Bar).ok +groupBy(list, #.Bar).str +groupBy(list, #.Bar)?.String +groupBy(list, #.Bar)?.[f64] +groupBy(list, #.Bar)?.[ok] +groupBy(list, #.Bar)?.array +groupBy(list, #.Bar)?.f64 +groupBy(list, #.Bar)?.foo +groupBy(list, #.Bar)?.i groupBy(list, #?.Bar) +groupBy(list, #?.Bar)?.[f64] groupBy(list, #?.String()) -groupBy(list, #?.String())?.score -groupBy(list, -0.5) -groupBy(list, -1) -groupBy(list, -f32) -groupBy(list, -i) +groupBy(list, $env != f64) +groupBy(list, $env == add) +groupBy(list, $env == greet) +groupBy(list, $env.f64) +groupBy(list, $env.foo) +groupBy(list, $env.i) +groupBy(list, $env.str) +groupBy(list, $env?.[String]) +groupBy(list, $env?.f64) +groupBy(list, $env?.foo) +groupBy(list, $env?.foobar) groupBy(list, .Bar) -groupBy(list, .Bar).f32 -groupBy(list, .String()) -groupBy(list, .String())?.score -groupBy(list, 0.5 != f32) -groupBy(list, 0.5 != f64) -groupBy(list, 0.5 * f32) -groupBy(list, 0.5 ** i64) -groupBy(list, 0.5 / i) -groupBy(list, 0.5).Bar -groupBy(list, 0.5).Qux -groupBy(list, 0.5).String -groupBy(list, 0.5).add -groupBy(list, 0.5).array -groupBy(list, 0.5).div -groupBy(list, 0.5).f32 -groupBy(list, 0.5).f64 -groupBy(list, 0.5).greet -groupBy(list, 0.5).half -groupBy(list, 0.5).i -groupBy(list, 0.5).i32 -groupBy(list, 0.5).i64 -groupBy(list, 0.5).list -groupBy(list, 0.5).ok -groupBy(list, 0.5).score -groupBy(list, 0.5)?.Bar -groupBy(list, 0.5)?.Qux -groupBy(list, 0.5)?.String -groupBy(list, 0.5)?.add -groupBy(list, 0.5)?.array -groupBy(list, 0.5)?.div -groupBy(list, 0.5)?.f32 -groupBy(list, 0.5)?.f64 -groupBy(list, 0.5)?.foo -groupBy(list, 0.5)?.greet -groupBy(list, 0.5)?.half -groupBy(list, 0.5)?.i -groupBy(list, 0.5)?.i32 -groupBy(list, 0.5)?.i64 -groupBy(list, 0.5)?.list -groupBy(list, 0.5)?.ok -groupBy(list, 0.5)?.score -groupBy(list, 1 * f64).f32 -groupBy(list, 1 + i) -groupBy(list, 1 - 0.5) -groupBy(list, 1 ^ 0.5) -groupBy(list, 1 ^ 1) -groupBy(list, 1 ^ i) +groupBy(list, .Bar).String +groupBy(list, .Bar).add +groupBy(list, .Bar).greet +groupBy(list, .Bar)?.Bar +groupBy(list, .Bar)?.[f64] +groupBy(list, .Bar)?.[foo] +groupBy(list, .Bar)?.[ok] +groupBy(list, .Bar)?.f64 +groupBy(list, .Bar)?.greet +groupBy(list, .Bar)?.i +groupBy(list, 0 + 1) +groupBy(list, 0 == 1) +groupBy(list, 0).String +groupBy(list, 0).f64 +groupBy(list, 0).foo +groupBy(list, 0).list +groupBy(list, 0)?.Bar +groupBy(list, 0)?.[f64] +groupBy(list, 0)?.[i] +groupBy(list, 0)?.[str] +groupBy(list, 0)?.add +groupBy(list, 0)?.array +groupBy(list, 0)?.f64 +groupBy(list, 0)?.foo +groupBy(list, 0)?.greet +groupBy(list, 0)?.i +groupBy(list, 0.1) +groupBy(list, 1 * i) groupBy(list, 1).Bar -groupBy(list, 1).Qux groupBy(list, 1).String -groupBy(list, 1).add -groupBy(list, 1).array -groupBy(list, 1).div -groupBy(list, 1).f32 groupBy(list, 1).f64 groupBy(list, 1).foo +groupBy(list, 1).foobar groupBy(list, 1).greet -groupBy(list, 1).half -groupBy(list, 1).i -groupBy(list, 1).i32 -groupBy(list, 1).i64 -groupBy(list, 1).list -groupBy(list, 1).ok -groupBy(list, 1).score +groupBy(list, 1).str groupBy(list, 1)?.Bar -groupBy(list, 1)?.Qux groupBy(list, 1)?.String +groupBy(list, 1)?.[f64] +groupBy(list, 1)?.[foo] +groupBy(list, 1)?.[ok] +groupBy(list, 1)?.[str] groupBy(list, 1)?.add groupBy(list, 1)?.array -groupBy(list, 1)?.div -groupBy(list, 1)?.f32 groupBy(list, 1)?.f64 -groupBy(list, 1)?.foo groupBy(list, 1)?.greet -groupBy(list, 1)?.half -groupBy(list, 1)?.i -groupBy(list, 1)?.i32 -groupBy(list, 1)?.i64 -groupBy(list, 1)?.list -groupBy(list, 1)?.ok -groupBy(list, 1)?.score -groupBy(list, 1)[i] -groupBy(list, 1)[reduce(list, "foo")] -groupBy(list, abs(1)) -groupBy(list, abs(i)) -groupBy(list, abs(i64)) -groupBy(list, all(list, ok)) -groupBy(list, ceil(0.5)) -groupBy(list, ceil(f64)) -groupBy(list, f32 ** 0.5) -groupBy(list, f32 ** 1) -groupBy(list, f32 < f32) -groupBy(list, f32 == i64) -groupBy(list, f32 >= 1) -groupBy(list, f32) -groupBy(list, f32).Bar -groupBy(list, f32).Qux -groupBy(list, f32).String -groupBy(list, f32).add -groupBy(list, f32).array -groupBy(list, f32).div -groupBy(list, f32).f32 -groupBy(list, f32).f64 -groupBy(list, f32).foo -groupBy(list, f32).half -groupBy(list, f32).i -groupBy(list, f32).i32 -groupBy(list, f32).i64 -groupBy(list, f32).list -groupBy(list, f32).ok -groupBy(list, f32)?.Bar -groupBy(list, f32)?.Qux -groupBy(list, f32)?.String -groupBy(list, f32)?.add -groupBy(list, f32)?.array -groupBy(list, f32)?.div -groupBy(list, f32)?.f32 -groupBy(list, f32)?.f64 -groupBy(list, f32)?.foo -groupBy(list, f32)?.greet -groupBy(list, f32)?.half -groupBy(list, f32)?.i -groupBy(list, f32)?.i32 -groupBy(list, f32)?.i64 -groupBy(list, f32)?.list -groupBy(list, f32)?.ok -groupBy(list, f32)?.score -groupBy(list, f32)[add == nil] -groupBy(list, f32)[toJSON(true)] -groupBy(list, f64 * 0.5) -groupBy(list, f64 * 1) -groupBy(list, f64 - 1) -groupBy(list, f64 < f64) +groupBy(list, 1.0 > 1.0)?.[f64] +groupBy(list, 1.0 ^ 1.0) +groupBy(list, 1.0) | get(1) +groupBy(list, 1.0).String +groupBy(list, 1.0).add +groupBy(list, 1.0).f64 +groupBy(list, 1.0).foo +groupBy(list, 1.0).foobar +groupBy(list, 1.0).greet +groupBy(list, 1.0).i +groupBy(list, 1.0).list +groupBy(list, 1.0).str +groupBy(list, 1.0)?.Bar +groupBy(list, 1.0)?.String +groupBy(list, 1.0)?.[f64] +groupBy(list, 1.0)?.[foo] +groupBy(list, 1.0)?.[i] +groupBy(list, 1.0)?.[ok] +groupBy(list, 1.0)?.[str] +groupBy(list, 1.0)?.add +groupBy(list, 1.0)?.array +groupBy(list, 1.0)?.f64 +groupBy(list, 1.0)?.foo +groupBy(list, 1.0)?.greet +groupBy(list, 1.0)?.i +groupBy(list, 1.0)?.ok +groupBy(list, 1.0)?.str +groupBy(list, add != add) +groupBy(list, array | sum(1)) groupBy(list, f64) -groupBy(list, f64).Bar -groupBy(list, f64).Qux groupBy(list, f64).String -groupBy(list, f64).add groupBy(list, f64).array -groupBy(list, f64).div -groupBy(list, f64).f32 groupBy(list, f64).f64 groupBy(list, f64).foo groupBy(list, f64).greet -groupBy(list, f64).half groupBy(list, f64).i -groupBy(list, f64).i32 -groupBy(list, f64).i64 -groupBy(list, f64).list groupBy(list, f64).ok -groupBy(list, f64).score groupBy(list, f64)?.Bar -groupBy(list, f64)?.Qux -groupBy(list, f64)?.String -groupBy(list, f64)?.add +groupBy(list, f64)?.[f64] +groupBy(list, f64)?.[foo] +groupBy(list, f64)?.[i] +groupBy(list, f64)?.[ok] +groupBy(list, f64)?.[str] groupBy(list, f64)?.array -groupBy(list, f64)?.div -groupBy(list, f64)?.f32 groupBy(list, f64)?.f64 groupBy(list, f64)?.foo -groupBy(list, f64)?.greet -groupBy(list, f64)?.half -groupBy(list, f64)?.i -groupBy(list, f64)?.i32 -groupBy(list, f64)?.i64 -groupBy(list, f64)?.list groupBy(list, f64)?.ok -groupBy(list, f64)?.score -groupBy(list, false == ok) -groupBy(list, false ? score : #) +groupBy(list, f64)?.str groupBy(list, false).Bar +groupBy(list, false).String groupBy(list, false).add -groupBy(list, false).array -groupBy(list, false).div -groupBy(list, false).f32 +groupBy(list, false).f64 groupBy(list, false).foo -groupBy(list, false).greet -groupBy(list, false).half +groupBy(list, false).foobar groupBy(list, false).i -groupBy(list, false).i32 -groupBy(list, false).i64 groupBy(list, false).list -groupBy(list, false).ok -groupBy(list, false)?.Bar -groupBy(list, false)?.Qux +groupBy(list, false).str groupBy(list, false)?.String +groupBy(list, false)?.[i] +groupBy(list, false)?.[ok] groupBy(list, false)?.add -groupBy(list, false)?.div -groupBy(list, false)?.f32 +groupBy(list, false)?.array groupBy(list, false)?.f64 groupBy(list, false)?.greet -groupBy(list, false)?.half -groupBy(list, false)?.i -groupBy(list, false)?.i32 -groupBy(list, false)?.i64 -groupBy(list, false)?.list groupBy(list, false)?.ok -groupBy(list, false)?.score -groupBy(list, findLastIndex(array, ok)) -groupBy(list, findLastIndex(list, false)) -groupBy(list, first(array)) -groupBy(list, float(-1)) -groupBy(list, float(0.5)) -groupBy(list, floor(i)) -groupBy(list, floor(i64)) -groupBy(list, foo != #) +groupBy(list, false)?.str +groupBy(list, foo != nil) +groupBy(list, foo == #) groupBy(list, foo) groupBy(list, foo).Bar -groupBy(list, foo).Qux groupBy(list, foo).String groupBy(list, foo).add groupBy(list, foo).array -groupBy(list, foo).div -groupBy(list, foo).f32 groupBy(list, foo).f64 groupBy(list, foo).foo groupBy(list, foo).greet -groupBy(list, foo).half groupBy(list, foo).i -groupBy(list, foo).i32 -groupBy(list, foo).i64 groupBy(list, foo).list groupBy(list, foo).ok -groupBy(list, foo).score +groupBy(list, foo).str groupBy(list, foo)?.Bar -groupBy(list, foo)?.Qux groupBy(list, foo)?.String +groupBy(list, foo)?.[f64] +groupBy(list, foo)?.[foo] +groupBy(list, foo)?.[ok] +groupBy(list, foo)?.[str] groupBy(list, foo)?.add groupBy(list, foo)?.array -groupBy(list, foo)?.div -groupBy(list, foo)?.f32 groupBy(list, foo)?.f64 groupBy(list, foo)?.foo -groupBy(list, foo)?.half +groupBy(list, foo)?.greet groupBy(list, foo)?.i -groupBy(list, foo)?.i32 -groupBy(list, foo)?.i64 groupBy(list, foo)?.list groupBy(list, foo)?.ok -groupBy(list, foo)?.score -groupBy(list, foo)[i32] +groupBy(list, foo)?.str groupBy(list, foo.Bar) -groupBy(list, foo.String()) -groupBy(list, foo?.String()) -groupBy(list, greet != greet) -groupBy(list, greet("bar")) -groupBy(list, i * i) -groupBy(list, i / f64) -groupBy(list, i <= i) -groupBy(list, i ^ i) +groupBy(list, foo?.Bar) +groupBy(list, greet(.Bar)) +groupBy(list, i + i) groupBy(list, i) -groupBy(list, i).Bar -groupBy(list, i).Qux -groupBy(list, i).String groupBy(list, i).add groupBy(list, i).array -groupBy(list, i).div -groupBy(list, i).f32 groupBy(list, i).f64 groupBy(list, i).foo -groupBy(list, i).half groupBy(list, i).i -groupBy(list, i).i32 -groupBy(list, i).i64 groupBy(list, i).list groupBy(list, i).ok -groupBy(list, i).score -groupBy(list, i)?.Bar -groupBy(list, i)?.Qux -groupBy(list, i)?.String +groupBy(list, i).str +groupBy(list, i)?.[ok] groupBy(list, i)?.add groupBy(list, i)?.array -groupBy(list, i)?.div -groupBy(list, i)?.f32 groupBy(list, i)?.f64 groupBy(list, i)?.foo groupBy(list, i)?.greet -groupBy(list, i)?.half -groupBy(list, i)?.i -groupBy(list, i)?.i32 -groupBy(list, i)?.i64 -groupBy(list, i)?.list groupBy(list, i)?.ok -groupBy(list, i)?.score -groupBy(list, i32 != f32)?.foo -groupBy(list, i32 * 0.5) -groupBy(list, i32 ** 0.5) -groupBy(list, i32 ** f32) -groupBy(list, i32 > i) -groupBy(list, i32 ^ i) -groupBy(list, i32) -groupBy(list, i32).Bar -groupBy(list, i32).Qux -groupBy(list, i32).add -groupBy(list, i32).array -groupBy(list, i32).div -groupBy(list, i32).f32 -groupBy(list, i32).f64 -groupBy(list, i32).foo -groupBy(list, i32).greet -groupBy(list, i32).half -groupBy(list, i32).i -groupBy(list, i32).i32 -groupBy(list, i32).i64 -groupBy(list, i32).list -groupBy(list, i32).ok -groupBy(list, i32).score -groupBy(list, i32)?.Bar -groupBy(list, i32)?.Qux -groupBy(list, i32)?.String -groupBy(list, i32)?.add -groupBy(list, i32)?.array -groupBy(list, i32)?.div -groupBy(list, i32)?.f32 -groupBy(list, i32)?.f64 -groupBy(list, i32)?.foo -groupBy(list, i32)?.greet -groupBy(list, i32)?.half -groupBy(list, i32)?.i -groupBy(list, i32)?.i32 -groupBy(list, i32)?.i64 -groupBy(list, i32)?.list -groupBy(list, i32)?.ok -groupBy(list, i32)?.score -groupBy(list, i64 != i32) -groupBy(list, i64 != nil) -groupBy(list, i64 - 0.5) -groupBy(list, i64 < 1) -groupBy(list, i64 <= 1) -groupBy(list, i64 == 1) -groupBy(list, i64 == nil) -groupBy(list, i64) -groupBy(list, i64).Bar -groupBy(list, i64).Qux -groupBy(list, i64).String -groupBy(list, i64).add -groupBy(list, i64).array -groupBy(list, i64).div -groupBy(list, i64).f32 -groupBy(list, i64).f64 -groupBy(list, i64).foo -groupBy(list, i64).greet -groupBy(list, i64).half -groupBy(list, i64).i -groupBy(list, i64).i32 -groupBy(list, i64).list -groupBy(list, i64).ok -groupBy(list, i64).score -groupBy(list, i64)?.Bar -groupBy(list, i64)?.Qux -groupBy(list, i64)?.String -groupBy(list, i64)?.add -groupBy(list, i64)?.array -groupBy(list, i64)?.div -groupBy(list, i64)?.f32 -groupBy(list, i64)?.f64 -groupBy(list, i64)?.foo -groupBy(list, i64)?.greet -groupBy(list, i64)?.half -groupBy(list, i64)?.i -groupBy(list, i64)?.i32 -groupBy(list, i64)?.i64 -groupBy(list, i64)?.list -groupBy(list, i64)?.ok -groupBy(list, i64)?.score -groupBy(list, i64)[max(i)] -groupBy(list, i64)[ok] -groupBy(list, int(1)) -groupBy(list, list == array) -groupBy(list, lower("foo")) -groupBy(list, max(f64)) -groupBy(list, max(i)) -groupBy(list, nil != #) -groupBy(list, nil != div) -groupBy(list, nil != true) -groupBy(list, nil == #) -groupBy(list, nil == #).i -groupBy(list, nil in list) -groupBy(list, not false) -groupBy(list, not ok) -groupBy(list, ok != false) -groupBy(list, ok ? # : true) +groupBy(list, i)?.str +groupBy(list, if true { # } else { false }) +groupBy(list, nil != 0) +groupBy(list, nil == 1.0) +groupBy(list, none($env, true)) +groupBy(list, ok and ok) groupBy(list, ok) -groupBy(list, ok).Bar -groupBy(list, ok).Qux groupBy(list, ok).String groupBy(list, ok).add -groupBy(list, ok).array -groupBy(list, ok).div -groupBy(list, ok).f32 groupBy(list, ok).f64 groupBy(list, ok).foo -groupBy(list, ok).greet -groupBy(list, ok).half groupBy(list, ok).i -groupBy(list, ok).i32 -groupBy(list, ok).i64 groupBy(list, ok).list groupBy(list, ok).ok -groupBy(list, ok).score groupBy(list, ok)?.Bar -groupBy(list, ok)?.Qux -groupBy(list, ok)?.String +groupBy(list, ok)?.[f64] +groupBy(list, ok)?.[foo] +groupBy(list, ok)?.[i] +groupBy(list, ok)?.[ok] groupBy(list, ok)?.add -groupBy(list, ok)?.array -groupBy(list, ok)?.div -groupBy(list, ok)?.f32 -groupBy(list, ok)?.f64 groupBy(list, ok)?.foo -groupBy(list, ok)?.greet -groupBy(list, ok)?.half -groupBy(list, ok)?.i -groupBy(list, ok)?.i32 -groupBy(list, ok)?.i64 groupBy(list, ok)?.list -groupBy(list, ok)?.ok -groupBy(list, ok)?.score -groupBy(list, reduce(array, #)) -groupBy(list, reduce(list, #)).i32 -groupBy(list, reduce(list, f64)) -groupBy(list, reduce(list, i32)) -groupBy(list, reduce(map(list, i64), #)) -groupBy(list, round(0.5)) -groupBy(list, round(1)) -groupBy(list, round(f64)) -groupBy(list, score(1)) -groupBy(list, score(i)) +groupBy(list, ok)?.str +groupBy(list, str == nil) +groupBy(list, str) +groupBy(list, str).add +groupBy(list, str).array +groupBy(list, str).foo +groupBy(list, str).greet +groupBy(list, str).list +groupBy(list, str).ok +groupBy(list, str).str +groupBy(list, str)?.[f64] +groupBy(list, str)?.[foo] +groupBy(list, str)?.[i] +groupBy(list, str)?.[ok] +groupBy(list, str)?.add +groupBy(list, str)?.f64 +groupBy(list, str)?.foo +groupBy(list, str)?.foobar +groupBy(list, str)?.greet +groupBy(list, str)?.i +groupBy(list, str)?.list +groupBy(list, str)?.ok groupBy(list, string(#)) -groupBy(list, string(add)) -groupBy(list, string(half)) -groupBy(list, string(i32)) -groupBy(list, string(true)) -groupBy(list, toBase64("foo")) -groupBy(list, toJSON(#)) -groupBy(list, toJSON(1)) -groupBy(list, toJSON(array)) -groupBy(list, toJSON(foo)) -groupBy(list, true && false) -groupBy(list, true ? # : 1) -groupBy(list, true ? 1 : #) -groupBy(list, true).Qux -groupBy(list, true).String +groupBy(list, string(add)).str +groupBy(list, string(false)) +groupBy(list, true).Bar groupBy(list, true).add groupBy(list, true).array -groupBy(list, true).div -groupBy(list, true).f32 groupBy(list, true).f64 groupBy(list, true).foo groupBy(list, true).greet -groupBy(list, true).half groupBy(list, true).i -groupBy(list, true).i32 -groupBy(list, true).i64 groupBy(list, true).list groupBy(list, true).ok -groupBy(list, true).score groupBy(list, true)?.Bar -groupBy(list, true)?.Qux groupBy(list, true)?.String +groupBy(list, true)?.[f64] +groupBy(list, true)?.[i] +groupBy(list, true)?.[ok] +groupBy(list, true)?.[str] groupBy(list, true)?.add -groupBy(list, true)?.array -groupBy(list, true)?.div -groupBy(list, true)?.f32 groupBy(list, true)?.f64 -groupBy(list, true)?.foo groupBy(list, true)?.greet -groupBy(list, true)?.half -groupBy(list, true)?.i -groupBy(list, true)?.i32 -groupBy(list, true)?.i64 groupBy(list, true)?.list -groupBy(list, true)?.ok -groupBy(list, true)?.score -groupBy(list, type("foo")) -groupBy(list, type(#)) -groupBy(list, type(false)) -groupBy(list[i32:1], i64) -groupBy(list[i32:i32], foo) -groupBy(list[i64:1], i32) -groupBy(list[i:1], f64) -groupBy(map(array, #), # <= #) -groupBy(map(array, #), # == #) -groupBy(map(array, #), # >= #) -groupBy(map(array, #), #) -groupBy(map(array, #), 0.5 < 0.5) -groupBy(map(array, #), foo) -groupBy(map(array, #), i) -groupBy(map(array, #), i64) -groupBy(map(array, #), min(1)) -groupBy(map(array, #), ok) -groupBy(map(array, 0.5), # != 0.5) -groupBy(map(array, 0.5), # / #) -groupBy(map(array, 0.5), #) -groupBy(map(array, 0.5), f64) -groupBy(map(array, 1), 0.5 / #) -groupBy(map(array, 1), f64) -groupBy(map(array, 1), max(#)) -groupBy(map(array, 1), ok) -groupBy(map(array, div), div != #) -groupBy(map(array, f32), # - 0.5) -groupBy(map(array, f32), min(#)) -groupBy(map(array, f64), #) -groupBy(map(array, false), f64) -groupBy(map(array, false), i) -groupBy(map(array, foo), #).add -groupBy(map(array, foo), i) -groupBy(map(array, foo), ok) -groupBy(map(array, i), #) -groupBy(map(array, i32), # % i) -groupBy(map(array, i32), #) -groupBy(map(array, ok), i64) -groupBy(map(list, "bar"), #) -groupBy(map(list, "foo"), #) -groupBy(map(list, #), "bar" == "bar") -groupBy(map(list, #), #) -groupBy(map(list, #), #)?.array -groupBy(map(list, #), f32) -groupBy(map(list, #), f64) -groupBy(map(list, #), i32) -groupBy(map(list, #), i64) -groupBy(map(list, #), ok) -groupBy(map(list, 0.5), # * i64) -groupBy(map(list, 0.5), # ** #) -groupBy(map(list, 0.5), #) -groupBy(map(list, 0.5), i32) -groupBy(map(list, 1), #) -groupBy(map(list, 1), get(list, #)).i64 -groupBy(map(list, 1), i64) -groupBy(map(list, f32), # ** #).array -groupBy(map(list, f64), #) -groupBy(map(list, f64), #).half -groupBy(map(list, f64), f32) -groupBy(map(list, f64), i) -groupBy(map(list, i), #) -groupBy(map(list, i32), # == #) -groupBy(map(list, i64), #)?.i32 -groupBy(map(list, i64), i) -groupBy(map(list, list), foo) -groupBy(map(list, ok), #) -groupBy(ok ? "foo" : greet, # <= #) -groupBy(reduce(array, # .. i64), add) -groupBy(reduce(array, array), foo) -groupBy(reduce(array, array), i) -groupBy(reduce(list, array), # / #) -groupBy(reduce(list, array), true ? true : nil) -groupBy(sort(array), #) -groupBy(sort(array), foo) -groupBy(true ? "foo" : 1, # > 0.5) -groupBy(true ? "foo" : 1, foo) -groupBy(true ? "foo" : false, # / #) -groupBy(true ? "foo" : score, #) -half -half != half -half != half != nil -half != half and "bar" in foo -half != nil == false -half != nil ? "bar" : div -half != nil ? "bar" : false -half != nil ? true : div -half != reduce(list, half) -half == half -half == nil && ok -half == nil ? array : 0.5 -half == nil ? foo : false -half(-(0.5 + 1)) -half(-(f64 + 1)) -half(-(i64 - 0.5)) -half(-0.5) -half(-1) -half(-f64) -half(0.5 * 0.5) -half(0.5 * 1) -half(0.5 * f64) -half(0.5 * i) -half(0.5 * i32) -half(0.5 * i64) -half(0.5 ** 0.5) -half(0.5 ** 1) -half(0.5 ** f32) -half(0.5 ** f64) -half(0.5 ** i) -half(0.5 ** i32) -half(0.5 ** i64) -half(0.5 + 0.5) -half(0.5 + 1 + i64) -half(0.5 + 1) -half(0.5 + f32) -half(0.5 + f64) -half(0.5 + i) -half(0.5 + i32) -half(0.5 + i64) -half(0.5 - 0.5) -half(0.5 - 1) -half(0.5 - f32) -half(0.5 - f64) -half(0.5 - i) -half(0.5 - i32) -half(0.5 - i64) -half(0.5 / 0.5) -half(0.5 / 1) -half(0.5 / f32) -half(0.5 / f64) -half(0.5 / i) -half(0.5 / i64) -half(0.5 ^ 0.5) -half(0.5 ^ 1) -half(0.5 ^ f32) -half(0.5 ^ f64) -half(0.5 ^ i) -half(0.5 ^ i32) -half(0.5 ^ i64) -half(0.5) != -i64 -half(0.5) != 0.5 ^ i -half(0.5) != i32 -half(0.5) != i64 -half(0.5) * f32 -half(0.5) * i -half(0.5) * i32 -half(0.5) * i64 -half(0.5) ** f32 -half(0.5) ** i -half(0.5) ** i32 -half(0.5) ** i64 -half(0.5) ** max(1) -half(0.5) + 1 / 1 -half(0.5) + f32 -half(0.5) + f64 -half(0.5) + i32 -half(0.5) + i64 -half(0.5) - i64 -half(0.5) / -0.5 -half(0.5) / f64 -half(0.5) / i -half(0.5) / i64 -half(0.5) < f64 -half(0.5) <= f32 ? f64 : 1 -half(0.5) <= f64 -half(0.5) <= i32 -half(0.5) <= i64 + i32 -half(0.5) <= int(0.5) -half(0.5) == f32 -half(0.5) == i32 / i -half(0.5) == i64 -half(0.5) > f32 -half(0.5) > f64 -half(0.5) > i -half(0.5) > i64 -half(0.5) >= i32 -half(0.5) ^ (1 * i32) -half(0.5) ^ f32 -half(0.5) ^ f64 -half(0.5) ^ i -half(0.5) ^ i32 -half(0.5) ^ i64 -half(1 * 0.5) -half(1 * 1) -half(1 * f32) -half(1 * f64) -half(1 * i) -half(1 * i32) -half(1 * i64) -half(1 ** 0.5) -half(1 ** 1) -half(1 ** f32) -half(1 ** f64) -half(1 ** i) -half(1 ** i32) -half(1 ** i64) -half(1 + 0.5) -half(1 + 1) -half(1 + f32) -half(1 + f64) -half(1 + i) -half(1 + i32) -half(1 + i64) -half(1 - 0.5) -half(1 - 1) -half(1 - f32) -half(1 - f64) -half(1 - i) -half(1 - i32) -half(1 - i64) -half(1 / 0.5) -half(1 / 1) -half(1 / f32) -half(1 / f64) -half(1 / i) -half(1 / i32) -half(1 / i64) -half(1 ^ 0.5) -half(1 ^ 1) -half(1 ^ f32) -half(1 ^ f64) -half(1 ^ i) -half(1 ^ i32) -half(1 ^ i64) -half(1) != f32 -half(1) != f64 -half(1) != f64 ** f32 -half(1) != f64 ^ 0.5 -half(1) != i32 -half(1) != i64 -half(1) * i32 * i64 -half(1) ** (i64 * f32) -half(1) ** f32 -half(1) ** i -half(1) ** i32 -half(1) ** i64 -half(1) + f32 -half(1) + f32 / 0.5 -half(1) + i -half(1) + i32 -half(1) + i64 + i32 -half(1) - f32 -half(1) - i < i64 -half(1) - i32 -half(1) - i64 -half(1) / -1 -half(1) / 0.5 / i -half(1) / i -half(1) / i32 -half(1) < f64 -half(1) < i -half(1) < i64 -half(1) <= f32 -half(1) <= i32 -half(1) <= i64 -half(1) == -1 -half(1) == 1 ^ i64 -half(1) == f32 -half(1) == i32 -half(1) > i -half(1) > i32 -half(1) > i64 -half(1) >= f32 -half(1) >= i -half(1) >= i32 -half(1) >= i64 -half(1) >= max(1) -half(1) >= mean(array) -half(1) ^ f32 -half(1) ^ findIndex(list, true) -half(1) ^ i64 -half(1) in array -half(1) not in array -half(abs(0.5)) -half(abs(f64)) -half(ceil(0.5)) -half(ceil(1)) -half(ceil(f32)) -half(ceil(f64)) -half(ceil(i)) -half(ceil(i32)) -half(ceil(i64)) -half(f32 * 0.5) -half(f32 * 1) -half(f32 * f64) -half(f32 * i) -half(f32 * i32) -half(f32 ** 0.5) -half(f32 ** f32) -half(f32 ** f64) -half(f32 ** i64) -half(f32 + 0.5) -half(f32 + 1) -half(f32 + f64) -half(f32 + i32) -half(f32 + i64) -half(f32 - 0.5) -half(f32 - 1) -half(f32 - f64) -half(f32 - i) -half(f32 - i32) -half(f32 - i64) -half(f32 / 0.5) -half(f32 / 1) -half(f32 / f32) -half(f32 / f64) -half(f32 / i) -half(f32 / i32) -half(f32 / i64) -half(f32 ^ 0.5) -half(f32 ^ 1) -half(f32 ^ f32) -half(f32 ^ f64) -half(f32 ^ i) -half(f32 ^ i32) -half(f32 ^ i64) -half(f64 * 0.5) -half(f64 * f32) -half(f64 * f64) -half(f64 * i) -half(f64 * i32) -half(f64 * i64) -half(f64 ** 0.5) -half(f64 ** 1) -half(f64 ** f32) -half(f64 ** i) -half(f64 ** i32) -half(f64 + 0.5) -half(f64 + 1) -half(f64 + f64) -half(f64 + i) -half(f64 + i64) -half(f64 - 0.5) -half(f64 - 1) -half(f64 - f32) -half(f64 - f64) -half(f64 - i) -half(f64 - i64) -half(f64 / 0.5) -half(f64 / 1) -half(f64 / f32) -half(f64 / f64) -half(f64 / i) -half(f64 / i32) -half(f64 ^ 0.5) -half(f64 ^ 1) -half(f64 ^ f32) -half(f64 ^ f64) -half(f64 ^ i32) -half(f64) -half(f64) != f64 != false -half(f64) != i32 -half(f64) != i64 -half(f64) ** f64 -half(f64) ** i -half(f64) ** i32 -half(f64) + i32 -half(f64) + i64 -half(f64) - f64 -half(f64) - i32 -half(f64) / f64 -half(f64) / i32 -half(f64) < i -half(f64) < i32 -half(f64) <= f32 -half(f64) <= i32 -half(f64) == f32 -half(f64) == f64 -half(f64) == i -half(f64) == i32 -half(f64) == i64 -half(f64) > f32 -half(f64) > f64 -half(f64) > i -half(f64) > i32 -half(f64) > i64 -half(f64) >= i -half(f64) >= i64 -half(f64) ^ i -half(f64) not in array -half(false ? f64 : 0.5) -half(false ? i32 : 0.5) -half(false ? ok : 0.5) -half(false ? score : 0.5) -half(false ? true : f64) -half(float(0.5)) -half(float(1)) -half(float(f32)) -half(float(f64)) -half(float(i)) -half(float(i32)) -half(float(i64)) -half(floor(0.5)) -half(floor(1)) -half(floor(f32)) -half(floor(f64)) -half(floor(i)) -half(floor(i32)) -half(floor(i64)) -half(half(0.5)) -half(half(1)) -half(half(ceil(i))) -half(half(f64 - 0.5)) -half(half(f64)) -half(i * 0.5) -half(i * 1) -half(i * f64) -half(i ** 0.5) -half(i ** 1) -half(i ** f32) -half(i ** f64) -half(i ** i) -half(i ** i32) -half(i ** i64) -half(i + 0.5) -half(i + 1) -half(i + f32) -half(i + f64) -half(i - 1) -half(i - f32) -half(i - f64) -half(i / 0.5) -half(i / 1) -half(i / f64) -half(i / i) -half(i / i32) -half(i ^ 0.5) -half(i ^ 1) -half(i ^ i) -half(i ^ i32) -half(i ^ i64) -half(i32 * 0.5) -half(i32 * 1) -half(i32 * f32) -half(i32 * f64) -half(i32 ** 0.5) -half(i32 ** 1) -half(i32 ** f64) -half(i32 ** i) -half(i32 ** i32) -half(i32 ** i64) -half(i32 + 0.5) -half(i32 + 1) -half(i32 + f32) -half(i32 + f64) -half(i32 - 0.5) -half(i32 - 1) -half(i32 - f32) -half(i32 / 0.5) -half(i32 / 1) -half(i32 / f32) -half(i32 / f64) -half(i32 / i) -half(i32 / i32 / f32 / f64) -half(i32 / i32) -half(i32 / i64) -half(i32 ^ 0.5) -half(i32 ^ 1) -half(i32 ^ f32) -half(i32 ^ f64) -half(i32 ^ i) -half(i32 ^ i32) -half(i32 ^ i64 ^ i) -half(i32 ^ i64) -half(i64 != i ? true : 0.5) -half(i64 * 0.5) -half(i64 * 1) -half(i64 * f64) -half(i64 ** 0.5) -half(i64 ** 1) -half(i64 ** f64) -half(i64 ** i) -half(i64 ** i32) -half(i64 ** i64) -half(i64 + 0.5) -half(i64 + f32) -half(i64 + f64) -half(i64 - 0.5) -half(i64 - 1) -half(i64 - f32) -half(i64 - f64) -half(i64 / 0.5) -half(i64 / 1) -half(i64 / f32) -half(i64 / f64) -half(i64 / i) -half(i64 / i32) -half(i64 ^ 0.5) -half(i64 ^ 1) -half(i64 ^ f32) -half(i64 ^ f64) -half(i64 ^ i) -half(i64 ^ i32) -half(max(0.5)) -half(max(0.5)) ** i -half(max(f64)) -half(mean(array)) -half(median(array)) -half(min(0.5)) -half(min(0.5, f32)) -half(min(0.5, i32)) -half(min(f64)) -half(min(i, 0.5)) -half(reduce(array, 0.5)) -half(reduce(array, f64)) -half(reduce(list, 0.5)) -half(reduce(list, f64)) -half(round(0.5)) -half(round(1)) -half(round(f32)) -half(round(f64)) -half(round(i)) -half(round(i32)) -half(round(i64)) -half(score(1) ^ i64) -half(true ? 0.5 : i64) -half(true ? f64 : nil) +groupBy(list, true)?.str +groupBy(list, type(foo)) +groupBy(map($env, 1.0), sum(array)) +groupBy(map(array, list), $env?.[str]) +groupBy(map(list, #index), #) +groupBy(reverse(array), foo) +groupBy(reverse(array), i + f64) +groupBy(reverse(array), ok) +groupBy(sort($env), # != .array) +groupBy(sort($env), #.add not contains str) +groupBy(sort($env), i) +groupBy(sort($env), max(#)) +groupBy(toPairs($env), 1 <= 1.0) +groupBy(values($env), foo) +groupBy(values($env), i) +hasPrefix(str, str) +hasSuffix(foo.String(), str) +hasSuffix(str, greet(str)) +hasSuffix(str, str) i -i != -0.5 -i != -1 -i != -f32 -i != -f64 -i != -i -i != -i32 -i != 0.5 + 0.5 -i != 0.5 - 1 -i != 0.5 / 1 -i != 0.5 ? 1 : div -i != 0.5 ? false : i32 -i != 0.5 ^ 0.5 -i != 0.5 ^ 1 -i != 0.5 ^ f32 -i != 1 != nil +i != $env != $env +i != $env != true +i != $env || $env +i != $env.f64 +i != $env.i +i != $env?.$env?.list(add, nil) +i != $env?.Bar +i != $env?.Bar?.[f64] +i != $env?.String +i != $env?.[Bar] +i != $env?.[Bar]?.[i] +i != $env?.[String] +i != $env?.[String]?.[array] +i != $env?.[str] +i != $env?.f64 +i != $env?.i +i != $env?.true +i != 0 != $env +i != 0 ^ 0 +i != 0 or true i != 1 / 1 -i != 1 ? f64 : score -i != ceil(1) -i != ceil(f32) -i != ceil(i64) -i != f32 -i != f32 ** i64 -i != f32 + i64 -i != f32 == ok +i != 1 or ok +i != 1.0 * 1.0 +i != 1.0 * array?.[i] +i != 1.0 ** 0 +i != 1.0 + 1.0 +i != 1.0 + i +i != 1.0 - 1.0 +i != 1.0 == ok +i != 1.0 || $env +i != abs(i) +i != array?.[i] i != f64 -i != f64 + i32 -i != f64 == true -i != f64 ^ f32 -i != f64 ^ i64 -i != float(0.5) -i != float(i) -i != half(0.5) -i != half(f64) +i != f64 && false +i != f64 + 1.0 +i != float(1.0) +i != floor(0) +i != floor(1) i != i -i != i * 1 -i != i * i32 -i != i - i32 -i != i ? i : false -i != i32 -i != i32 != nil ? greet : score -i != i32 * 0.5 -i != i32 * f32 -i != i32 and ok -i != i64 -i != i64 ** i -i != i64 ? add : i64 -i != i64 ? f32 : nil -i != i64 ^ 1 -i != int(1) -i != min(i64) +i != i != $env.ok +i != i * f64 +i != last($env) +i != max(1.0) +i != mean(f64) +i != median(1.0) +i != min($env) +i != min(i) +i != nil != $env i != nil != ok -i != nil ? ok : f64 -i != reduce(array, #) -i != reduce(array, 0.5) -i != reduce(list, 1) -i != round(f64) -i != score(1) -i != score(i) -i != {"foo": score}?.f32 -i % (1 + i32) -i % (i32 + i32) -i % (i64 + 1) -i % -1 -i % -i -i % -i32 -i % 1 % i32 -i % 1 % i64 -i % 1 * i32 -i % 1 + i64 -i % 1 .. i -i % 1 / 0.5 -i % 1 / f32 -i % 1 <= i64 -i % 1 >= i -i % abs(1) -i % abs(i) -i % array[1] -i % array[i64] +i != sum(array) +i % $env.i +i % $env?.i +i % 1 != 1.0 +i % 1 == i +i % array?.[i] i % i -i % i / i -i % i32 -i % i32 != i32 -i % i32 * 1 -i % i32 * f64 -i % i32 / i32 -i % i32 <= f64 -i % i64 -i % i64 != i ? f64 : list -i % i64 <= i -i % min(1) -i % min(i64) -i % reduce(array, #) -i % score(i) -i * (1 + 1) -i * (f32 + 0.5) -i * (f32 + 1) -i * (f64 + i) -i * (f64 - i32) -i * -i32 -i * -i64 -i * 0.5 * f64 -i * 0.5 + i -i * 0.5 / i -i * 0.5 < i32 -i * 0.5 > i32 * f32 -i * 0.5 ^ 1 -i * 1 % i64 -i * 1 ** 1 -i * 1 < f64 -i * 1 < i32 -i * 1 == i32 -i * bitnand(i64, i64) -i * bitnot(i64) -i * ceil(1) -i * f32 -i * f32 <= f64 -i * f32 ^ 0.5 -i * f32 ^ 1 -i * f32 ^ f32 +i % i < i +i % i <= 1 +i % i <= 1.0 +i % i == i ^ i +i % len(str) +i * $env.f64 +i * $env.i +i * $env?.f64 +i * $env?.i +i * - - f64 +i * 0 != f64 +i * 0 != nil +i * 1 != 0 +i * 1 | bitshl(i) +i * 1.0 + 1.0 +i * 1.0 + f64 +i * 1.0 - i +i * 1.0 <= 0 +i * 1.0 == 0 +i * array?.[i] i * f64 -i * f64 != i -i * f64 * f32 > i -i * f64 * i -i * f64 ** i32 -i * float(f32) -i * floor(f32) -i * floor(i) -i * floor(i32) -i * floor(i64) -i * half(0.5) -i * half(1) -i * half(f64) +i * f64 ^ i +i * floor(0) i * i +i * i != i i * i % i -i * i * 0.5 -i * i * f32 -i * i ** 0.5 -i * i - f32 -i * i .. i -i * i == f32 -i * i32 -i * i32 * i -i * i32 .. i32 -i * i32 / min(1) -i * i32 == f32 -i * i32 in array -i * i64 -i * i64 < f64 -i * int(1) -i * max(1) -i * max(f64, f32) -i * max(i) -i * min(f64, i) -i * reduce(array, #) -i * score(1) -i * score(i) +i * i ** 1.0 +i * i / 1.0 +i * i <= i +i * i == 0 +i * int(0) +i * int(1.0) +i * mean(array) +i * mean(i) +i * median(f64) +i * median(i) +i * min(i) +i * sum($env, 0) i * sum(array) -i ** (0.5 * f64) -i ** (0.5 + 0.5) -i ** (0.5 - 1) -i ** (0.5 - f64) -i ** (0.5 / i32) -i ** (f32 + 0.5) -i ** (f32 + f32) -i ** (i * 0.5) -i ** (i * 1) -i ** (i + f64) -i ** (i - i32 + i32) -i ** (i32 - i64) -i ** (i32 / 1) -i ** (i64 - 0.5) -i ** -0.5 -i ** -1 -i ** -f32 -i ** -i32 -i ** -i64 -i ** 0.5 ** f32 -i ** 0.5 ** reduce(array, #) -i ** 0.5 < bitnot(i64) -i ** 0.5 < f32 -i ** 0.5 < f64 -i ** 0.5 <= i64 -i ** 0.5 ^ i -i ** 0.5 ^ i64 -i ** 1 ** 1 -i ** 1 / i -i ** 1 < -f32 -i ** 1 >= f64 -i ** 1 ^ i -i ** 1 ^ i32 -i ** abs(0.5) -i ** array[i64] -i ** bitnand(i32, 1) -i ** bitshl(i64, i32) -i ** ceil(1) -i ** f32 -i ** f32 * i32 -i ** f32 ** 1 -i ** f32 ^ f64 -i ** f32 ^ i64 +i ** $env.f64 +i ** $env.i +i ** $env?.f64 +i ** $env?.i +i ** 0 - abs(i) +i ** 1 ^ 1.0 +i ** 1.0 + 1.0 +i ** 1.0 - i +i ** 1.0 / i +i ** 1.0 == $env +i ** 1.0 >= f64 <= f64 +i ** 1.0 ^ 1 +i ** 1.0 ^ i +i ** 1.0 | max(1) +i ** abs(1.0) +i ** array?.[i] i ** f64 -i ** f64 != i32 -i ** f64 ** f64 -i ** f64 > i64 ? 1 : ok -i ** f64 >= i -i ** first(array) -i ** floor(f64) -i ** half(1) -i ** half(f64) -i ** half(i + f32) +i ** f64 * 1.0 +i ** f64 == nil i ** i -i ** i != i == ok -i ** i ^ 0.5 -i ** i32 -i ** i32 == f32 -i ** i32 > i64 -i ** i64 -i ** i64 ** i -i ** i64 < i -i ** i64 == i32 -i ** i64 >= i -i ** i64 ^ i64 -i ** i64 not in array -i ** len("foo") -i ** len(array) +i ** i ** 1.0 +i ** i + f64 +i ** i / 1.0 +i ** i < 1 +i ** i > 0 +i ** i >= i +i ** int(i) +i ** len($env) +i ** max(1) +i ** mean(1, array) i ** min(1) -i ** min(i32) -i ** reduce(array, #) -i ** score(1) -i ** score(i) -i + -0.5 -i + -1 -i + -f32 -i + -f64 -i + 0.5 ** 0.5 -i + 0.5 + i -i + 0.5 / 1 -i + 1 + f32 -i + 1 / f32 -i + 1 > f64 -i + 1 ^ 1 -i + 1 ^ f32 -i + abs(0.5) -i + array[i64] -i + array[i] -i + count(list, true) -i + f32 -i + f32 ** i -i + f32 / f64 -i + f32 / i32 -i + f32 < i64 +i ** min(1.0) +i ** min(1.0, array) +i ** min(array) +i ** sum($env, 1.0) +i + $env != str || true +i + $env.f64 +i + $env.i +i + $env?.f64 +i + $env?.i +i + 0 ** f64 +i + 1 != 1.0 +i + 1 .. i +i + 1 < 0 +i + 1 in array +i + 1.0 != nil +i + 1.0 ** f64 +i + 1.0 <= 1.0 +i + 1.0 == f64 +i + abs(1) +i + array?.[i] +i + bitnot(0) +i + ceil($env.i) i + f64 -i + f64 - i32 -i + f64 < i64 -i + f64 == i32 -i + f64 > f64 -i + float(0.5) -i + float(i32) -i + get(array, i) -i + half(1) -i + half(f64) +i + f64 ** i +i + f64 <= i +i + float(1.0) i + i -i + i * i64 -i + i ^ 1 -i + i32 -i + i32 .. -i64 -i + i32 .. i -i + i32 <= f32 -i + i32 == i64 -i + i32 > min(i) -i + i32 >= i32 == nil -i + i32 in array -i + i64 -i + i64 - f64 -i + i64 / 0.5 -i + i64 / f64 -i + i64 > f32 -i + int(f32) -i + len("bar") -i + reduce(array, #) -i + reduce(array, f32) -i + reduce(list, i32) -i + score(i) -i - -0.5 -i - -1 -i - -f32 -i - -f64 -i - -i64 -i - 0.5 + i64 -i - 0.5 - 1 -i - 0.5 < f64 -i - 0.5 > i -i - 0.5 not in array -i - 1 + i -i - 1 - i64 -i - 1 .. i64 -i - 1 < i32 -i - 1 <= f64 -i - 1 <= i -i - 1 > 0.5 - 0.5 -i - 1 ^ 0.5 -i - bitxor(i, i) -i - ceil(f64) -i - f32 -i - f32 * f32 -i - f32 - i32 -i - f32 / i -i - f32 ^ 0.5 +i + i / 0 +i + i > i <= 0 +i + i | add(1) +i + len($env) +i + max(array, array) +i + mean(0) +i + mean(1.0) +i + mean(i) +i + reduce(list, 1.0) +i - $env and false and ok +i - $env.f64 +i - $env.i +i - $env?.f64 +i - $env?.i +i - 0 ** f64 +i - 0 ** i +i - 0 | mean(1.0) +i - 1 ** 1.0 ^ 1 +i - 1 / f64 +i - 1 ^ f64 +i - 1.0 != $env?.String +i - 1.0 != 1.0 +i - 1.0 ** i +i - 1.0 + 1 +i - 1.0 - 1.0 +i - 1.0 < f64 +i - 1.0 == $env +i - 1.0 ^ i +i - 1.0 not in array +i - array?.[i] +i - ceil(1) +i - ceil(1.0) i - f64 -i - f64 + i32 -i - f64 + i32 - f64 -i - f64 / i32 -i - f64 ^ i64 -i - find(array, true) -i - float(0.5) -i - floor(1) -i - half(f64) +i - f64 != 1 +i - f64 != 1.0 +i - f64 >= f64 +i - f64 >= i +i - f64 ^ 1.0 == 0 +i - float(f64) +i - floor(1.0) +i - floor(f64) i - i -i - i + f32 -i - i32 -i - i32 + 0.5 -i - i32 - f32 -i - i32 - i32 -i - i64 -i - i64 .. i32 -i - i64 / i -i - i64 <= i32 -i - i64 ^ f32 -i - i64 ^ f64 -i - int(i32) -i - max(i64) -i - median(array) -i - round(i32) -i - score(1) -i .. -i -i .. -i32 -i .. -i64 -i .. abs(1) +i - i != i +i - i ** i +i - i == 1.0 +i - i >= i +i - i not in $env?.String +i - int(0) +i - len(array) +i - max(1.0) +i - max(array) +i - mean(1.0) +i - reduce($env, #acc, i) +i - reduce(array, #index) +i .. $env.i +i .. $env?.i +i .. 0 * i +i .. 0 == list +i .. 0 | all($env[.Bar:]) +i .. 0 | count($env) +i .. 0 | groupBy(greet) +i .. 0 | map(#) +i .. 0 | median(f64) +i .. 0 | sum(1) +i .. 0 | sum(foo) +i .. 0 | sum(str) +i .. 1 | groupBy(#) +i .. 1 | map(#) +i .. 1 | sortBy(1) +i .. 1 | sortBy(foo.Bar) +i .. abs(i) +i .. array?.[i] i .. i -i .. i32 -i .. i64 -i .. i64 * 1 -i .. i64 + 1 -i .. int(0.5) -i .. max(1) -i .. max(i) -i .. min(i) -i .. reduce(list, i64) -i .. score(1) -i .. score(i) -i / (0.5 + 1) -i / (0.5 + f64) -i / (0.5 + i) -i / (0.5 - f32) -i / (i + f32) -i / -1 -i / -f32 -i / -f64 -i / -i32 -i / 0.5 * 1 -i / 0.5 * f64 -i / 0.5 / f64 -i / 0.5 == nil != false -i / 0.5 >= f32 -i / 0.5 ^ i32 -i / 1 ** i32 -i / 1 <= i64 -i / 1 > i -i / abs(i) -i / bitnot(i64) +i .. i % 1 +i .. i | groupBy(#) +i .. i | reduce(#) +i .. i | reduce(false) +i .. int(0) +i .. len(array) +i .. max(0) +i .. median(i) +i .. min(1) +i / $env.f64 +i / $env.i +i / $env?.f64 +i / $env?.i +i / 0 + f64 == i +i / 0 - f64 +i / 0 < 1 +i / 0 == 1.0 +i / 1 * i +i / 1 ** f64 +i / 1.0 != 1 +i / 1.0 != 1.0 +i / 1.0 * ceil(1.0) +i / 1.0 + f64 +i / 1.0 - 0 +i / 1.0 - f64 +i / 1.0 < 0 +i / 1.0 < i +i / 1.0 > 1.0 +i / 1.0 in array +i / array?.[i] +i / bitnot(0) i / count(array, false) -i / f32 -i / f32 != i64 ? 1 : list -i / f32 >= len(array) i / f64 -i / f64 * f64 -i / f64 ^ i32 -i / float(0.5) -i / float(1) -i / float(f64) -i / floor(1) -i / floor(i32) +i / f64 < 1.0 +i / floor(1.0) i / i -i / i ** 1 -i / i / i -i / i < i32 -i / i ^ 1 -i / i32 -i / i32 / 1 -i / i64 -i / i64 * f32 -i / i64 / f64 -i / max(0.5) -i / mean(array) -i / min(f32) -i / min(i64) -i / score(1) -i < -(f32 * 1) -i < --f64 -i < -i32 -i < -i64 -i < 0.5 != nil -i < 0.5 + f64 -i < 0.5 == ok -i < 1 / 0.5 -i < 1 == nil -i < 1 ? array : score -i < 1 ^ i64 -i < abs(i32) -i < f32 -i < f32 && ok -i < f32 * 0.5 -i < f32 * i64 -i < f32 ** i -i < f32 ** i32 -i < f32 + 1 -i < f32 + array[i64] -i < f32 / 0.5 -i < f32 ? "bar" : div -i < f32 || ok +i / i + 1.0 +i / i < 0 +i / i <= 0 +i / i == 1.0 +i / i == i +i / i in array +i / len($env) +i / mean(1.0, 1.0) +i / sum(array) +i / sum(list, f64) +i < $env && false +i < $env || true +i < $env.f64 +i < $env.i +i < $env?.f64 +i < $env?.i +i < 0 && false +i < 0 / i +i < 0 < i +i < 0 <= f64 +i < 0 > 0 +i < 0 || $env +i < 1 ** i +i < 1 + 1.0 +i < 1 / 1.0 +i < 1 < f64 +i < 1 <= $env?.[foo] +i < 1 <= 1 +i < 1 <= sum($env, #) +i < 1 ? array : add +i < 1 || $env +i < 1.0 != ok +i < 1.0 ** 0 +i < 1.0 < $env?.f64 +i < 1.0 < 1.0 +i < 1.0 <= 1 +i < 1.0 <= 1.0 +i < 1.0 <= f64 +i < 1.0 == true +i < 1.0 || ok +i < abs(1.0) +i < array?.[i] +i < bitnot(i) +i < ceil(f64) i < f64 -i < f64 - 1 -i < float(f64) -i < floor(f32) -i < half(0.5) -i < half(1) -i < half(f64) +i < f64 != ok +i < f64 ** ceil(1.0) +i < f64 < 0 +i < f64 < f64 < i +i < f64 >= $env +i < f64 ? 1 : foo +i < findIndex($env, ok) +i < first(array) +i < float(i) +i < floor(0) i < i -i < i != true -i < i ** 1 -i < i / i64 -i < i ? score : list -i < i32 -i < i32 * f32 -i < i32 + 1 -i < i64 -i < i64 ^ f32 -i < max(0.5) -i < reduce(array, #) -i <= -0.5 -i <= -1 -i <= -f64 -i <= -i -i <= -i32 -i <= -i64 -i <= 0.5 * f32 -i <= 0.5 + 0.5 -i <= 0.5 / 1 -i <= 0.5 / f64 -i <= 0.5 == ok -i <= 0.5 ? i : ok -i <= 0.5 ? nil : i32 -i <= 0.5 ^ f32 -i <= 1 != nil -i <= 1 && ok -i <= 1 * 0.5 -i <= 1 ** i -i <= 1 + f64 -i <= 1 - f32 -i <= 1 ? 0.5 : f32 -i <= 1 ? 0.5 : list -i <= 1 ? list : div -i <= 1 ^ f32 -i <= abs(0.5) -i <= ceil(1) -i <= f32 -i <= f32 - 0.5 -i <= f32 ? array : nil +i < i + i +i < i ^ 0 +i < int(0) +i < max(f64) +i < min(1.0) +i < round(1.0) +i < sum(array) +i <= $env.f64 +i <= $env.i +i <= $env?.f64 +i <= $env?.i +i <= 0 && $env +i <= 0 * i +i <= 0 < $env +i <= 0 and $env +i <= 0 or false +i <= 1 / 1 +i <= 1 >= 1 +i <= 1 || ok +i <= 1.0 && ok +i <= 1.0 * i +i <= 1.0 < 0 +i <= 1.0 <= 1 +i <= 1.0 or ok +i <= 1.0 || $env.ok +i <= bitnot(1) +i <= ceil(1.0) i <= f64 -i <= float(0.5) -i <= float(f32) -i <= half(1) -i <= half(f64) +i <= f64 < 1.0 +i <= f64 > $env +i <= f64 in $env?.String +i <= floor(1) i <= i -i <= i != nil -i <= i * f32 -i <= i ** f64 -i <= i - 0.5 -i <= i - 1 -i <= i / i -i <= i ^ 1 -i <= i32 -i <= i32 - f64 -i <= i32 - i -i <= i32 == ok -i <= i32 ? array : false -i <= i32 ? greet : foo -i <= i32 || false ? f32 : i32 -i <= i64 -i <= i64 * i -i <= i64 + f64 -i <= len(list) -i <= max(0.5) -i <= max(f32, i32) -i <= round(f32) -i <= round(i32) -i <= score(1) -i == -f32 -i == -f64 -i == -i -i == -i32 -i == -i64 -i == 0.5 ** f64 -i == 0.5 == ok -i == 0.5 ? "foo" : f64 -i == 1 * 0.5 -i == 1 ** i64 -i == 1 / 0.5 -i == 1 / f32 -i == 1 ? f32 : 1 -i == 1 ? f64 : f64 -i == 1 ? greet : score -i == abs(i64) -i == bitnot(1) -i == f32 -i == f32 + i -i == f32 == nil -i == f32 ? foo : foo -i == f32 ^ i32 +i <= i + i +i <= i / 1 +i <= i <= 1 +i <= i == nil +i <= i >= i +i <= i ?: add +i <= i ^ i +i <= mean(1.0) +i <= median(1.0) +i == $env != $env +i == $env != ok +i == $env ?: 1.0 +i == $env || false +i == $env.f64 +i == $env.i +i == $env?.Bar +i == $env?.String +i == $env?.String?.[f64]?.foo +i == $env?.[Bar] +i == $env?.[String] +i == $env?.[foobar] +i == $env?.[str] +i == $env?.f64 +i == $env?.foobar +i == $env?.i +i == 0 != ok +i == 0 ** i +i == 0 - 1.0 +i == 0 - f64 && false +i == 0 ?: $env +i == 0 or $env +i == 0 or ok +i == 0 || $env +i == 1 != false +i == 1 ** 1.0 +i == 1 - 1.0 +i == 1 / f64 +i == 1 == false +i == 1 and true +i == 1.0 != ok ?: foo +i == 1.0 ** 1.0 +i == 1.0 + 1.0 +i == 1.0 - 1 +i == 1.0 == true +i == 1.0 ^ 1.0 +i == 1.0 || max($env) +i == abs(i) +i == array?.[i] +i == ceil(1.0) i == f64 -i == f64 + i32 -i == f64 - i -i == f64 ? i64 : div -i == f64 ? score : foo -i == f64 and ok -i == findIndex(list, true) -i == float(0.5) -i == floor(f32) -i == floor(i32) -i == half(0.5) -i == half(f64) +i == f64 != $env +i == f64 && $env +i == f64 * 0 +i == f64 * f64 +i == f64 / f64 +i == f64 ? f64 : foo +i == f64 ?: array +i == float(1.0) i == i -i == i + 0.5 -i == i - i32 -i == i == true -i == i ? add : i32 -i == i ? i32 : add -i == i and ok -i == i32 -i == i32 * 0.5 -i == i32 ** 0.5 -i == i32 + 0.5 -i == i32 + i64 -i == i32 ^ f32 -i == i64 -i == i64 * 0.5 -i == i64 * f32 -i == i64 ** 0.5 -i == i64 == nil -i == i64 == ok -i == i64 ? list : div -i == len("bar") -i == nil ? 0.5 : div -i == nil ? div : i32 -i == nil and add != nil -i == reduce(array, #) -i == reduce(array, 0.5) -i == score(1) -i == score(i) -i > -f32 -i > -f64 -i > -i -i > -i32 -i > 0.5 - 0.5 -i > 0.5 ^ i64 -i > 0.5 or ok -i > 0.5 || ok -i > 1 != ok -i > 1 % i64 -i > 1 ** i32 -i > 1 == ok -i > 1 ? greet : nil -i > 1 ? score : 0.5 -i > 1 ? true : greet -i > bitnot(1) -i > bitor(1, i32) -i > count(array, true) -i > f32 -i > f32 ** i32 -i > f32 - f64 -i > f32 ^ 1 +i == i == $env +i == i ^ 0 +i == int(i) +i == max(array) +i == max(i) +i == median(f64) +i == min($env) +i == min(f64) +i == nil == $env +i == nil ? $env?.[i] : list +i == nil ?: foo +i == sum(array) +i > $env.f64 +i > $env.i +i > $env?.f64 +i > $env?.i +i > 0 + 1 +i > 0 + i +i > 0 / f64 +i > 0 <= 1.0 +i > 0 == nil +i > 0 ?: ok +i > 0.0 +i > 1 && ok +i > 1 - 0 +i > 1 - 1.0 +i > 1 < 1.0 +i > 1 or ok +i > 1.0 ** f64 +i > 1.0 / 1 +i > 1.0 == $env +i > 1.0 > $env +i > 1.0 > 1.0 +i > 1.0 >= 1.0 +i > 1.0 or $env +i > array?.[i] +i > ceil(1.0) i > f64 +i > f64 != nil i > f64 != ok -i > f64 * 1 -i > f64 * f32 -i > f64 ** i32 -i > f64 ? foo : array -i > f64 ? greet : "bar" -i > first(array) -i > floor(f64) +i > f64 && $env +i > f64 ** i +i > f64 + 1 +i > f64 >= 1 +i > f64 >= 1.0 +i > find(array, ok) +i > floor(1.0) i > i -i > i % i32 -i > i ** i -i > i + i -i > i ? f32 : i32 -i > i32 -i > i32 * 1 -i > i32 * i32 -i > i32 + 1 -i > i32 == ok -i > i64 -i > i64 && f32 < 0.5 -i > i64 + 0.5 -i > i64 - 0.5 -i > i64 - i -i > int(f32) -i > len("bar") -i > reduce(list, i32) -i >= -0.5 -i >= -1 -i >= -f32 -i >= -i -i >= -i32 -i >= -i64 -i >= 0.5 / 1 -i >= 0.5 ? i64 : array -i >= 0.5 ? nil : ok -i >= 0.5 ^ i -i >= 1 * i64 -i >= 1 + f32 -i >= 1 == nil -i >= 1 ? f32 : nil -i >= 1 ? ok : false -i >= 1 ^ f64 -i >= bitnot(i) -i >= f32 -i >= f32 ? f32 : i -i >= f32 ? true : list +i > i ** f64 +i > i + 0 +i > i and $env +i > last(array) +i > len($env) +i > max(1.0) +i > mean(1.0) +i > median(f64) +i > sum(array) +i >= $env or true +i >= $env.f64 +i >= $env.i +i >= $env?.f64 +i >= $env?.i +i >= 0 / max(1.0) +i >= 0 <= i +i >= 0 >= 1 +i >= 0 ^ 1 +i >= 0 or $env +i >= 0 || $env +i >= 0.0 +i >= 1 && ok +i >= 1 ** f64 +i >= 1 - 1.0 +i >= 1 < f64 +i >= 1 > 1.0 +i >= 1 and $env +i >= 1 and $env?.[str] +i >= 1.0 && true +i >= 1.0 * 0 +i >= 1.0 ** i +i >= 1.0 + 1.0 +i >= 1.0 ^ i +i >= 1.0 and $env +i >= 1.0 or $env +i >= array?.[i] +i >= ceil(0) i >= f64 -i >= f64 * 0.5 -i >= f64 - 1 -i >= first(array) -i >= float(0.5) +i >= f64 * 0 +i >= f64 ** f64 +i >= f64 ** i +i >= f64 + 1 +i >= f64 < i +i >= f64 > 1.0 +i >= f64 || $env i >= float(1) -i >= get(array, i64) -i >= half(f64) +i >= floor(i) i >= i -i >= i * 1 -i >= i ** f32 -i >= i ? foo : div -i >= i32 -i >= i32 ** i64 -i >= i32 ? f32 : div -i >= i32 ^ 1 -i >= i64 -i >= int(0.5) -i >= min(0.5) -i >= reduce(array, f64) -i >= reduce(array, i) -i >= reduce(list, 1) -i >= round(1) -i >= score(1) -i >= score(i) -i ^ (1 % i) -i ^ (1 * f64) -i ^ (1 - 0.5) -i ^ (f32 - f64) -i ^ (f64 - 1) -i ^ (i + 0.5) -i ^ (i + i64) -i ^ (i - f32) -i ^ (i32 * i32) -i ^ (i32 + 1) -i ^ (i32 / f32) -i ^ (i32 / i) -i ^ (i64 * 1) -i ^ -1 -i ^ -f32 -i ^ -f64 -i ^ -i -i ^ 0.5 ** 0.5 -i ^ 0.5 + i32 -i ^ 0.5 < f64 -i ^ 0.5 < i -i ^ 0.5 <= i64 -i ^ 0.5 > f64 -i ^ 0.5 >= f32 -i ^ 0.5 >= reduce(array, #) -i ^ 0.5 ^ f32 -i ^ 0.5 ^ i64 -i ^ 1 * f64 -i ^ 1 / i -i ^ 1 >= f32 -i ^ 1 ^ i -i ^ 1 not in array -i ^ bitnot(i64 + 1) -i ^ bitnot(min(i)) -i ^ ceil(0.5) -i ^ f32 -i ^ f32 ** 1 -i ^ f32 < i -i ^ f32 <= -f32 +i >= i ** 0 +i >= i - i +i >= i / 1.0 +i >= int(1.0) +i >= min(1.0) +i >= reduce($env, 0, 0) +i >= round(i) +i ^ $env.f64 +i ^ $env.i +i ^ $env?.f64 +i ^ $env?.i +i ^ 0 != 1.0 +i ^ 0 < i +i ^ 0 not in array +i ^ 1 == 0 +i ^ 1.0 != i +i ^ 1.0 != nil +i ^ 1.0 - 0 +i ^ 1.0 < 1 +i ^ 1.0 <= 0 +i ^ 1.0 == 0 +i ^ 1.0 > 1.0 +i ^ 1.0 > f64 +i ^ 1.0 > i +i ^ 1.0 > max(0) +i ^ 1.0 | max(0) +i ^ abs(0) +i ^ array?.[i] +i ^ ceil(1) +i ^ count($env, false) i ^ f64 -i ^ f64 ** 0.5 -i ^ f64 - f64 -i ^ f64 / i32 -i ^ f64 <= f32 -i ^ f64 == i -i ^ f64 > f32 -i ^ find(array, ok) -i ^ floor(i32) -i ^ half(0.5) -i ^ half(1) -i ^ half(f64) +i ^ f64 * 0 +i ^ f64 ** f64 +i ^ f64 >= 1 +i ^ f64 ^ 1.0 +i ^ first(array) +i ^ float(1.0) +i ^ floor(1.0) i ^ i i ^ i * i -i ^ i * i64 -i ^ i ** i -i ^ i / i -i ^ i32 -i ^ i32 / f64 -i ^ i32 in array -i ^ i64 -i ^ i64 != f32 + 1 -i ^ i64 ** f32 -i ^ last(array) -i ^ median(array) -i ^ min(i32, 1) -i ^ reduce(array, #) -i ^ round(i32) -i ^ score(1) -i in 1 .. i +i ^ i / f64 +i ^ i == nil +i ^ i >= i +i ^ i not in array +i ^ int(1) +i ^ int(1.0) +i ^ len($env) +i ^ max(array) +i ^ mean(1.0) +i ^ mean(array) +i ^ mean(f64) +i ^ min(1.0) +i ^ min(i) +i ^ sum(array) +i in $env and false +i in $env.array +i in $env?.Bar +i in $env?.String +i in $env?.[Bar] +i in $env?.[String] +i in $env?.array i in array -i in array != nil -i in array ? nil : 1 -i in groupBy(list, #) -i in groupBy(list, foo) -i in map(array, #) -i in map(array, i64) -i not in 1 .. 1 +i in array and $env +i in array or ok +i in concat(array) +i in concat(list, list) +i in flatten(list) +i in groupBy(list, #)?.i +i in last($env) +i in {foo: 1.0}.greet +i not in $env.array +i not in $env?.Bar +i not in $env?.String +i not in $env?.[Bar] +i not in $env?.[Bar]?.array +i not in $env?.[String] +i not in $env?.[String]?.[list] +i not in $env?.array +i not in 1 .. i +i not in [1.0] +i not in [1] +i not in [true, nil] i not in array -i not in groupBy(array, #) -i not in groupBy(list, #) -i not in i64 .. 1 -i not in i64 .. i64 -i not in map(array, #) -i not in map(list, i32) -i32 -i32 != -0.5 -i32 != -1 -i32 != -f32 -i32 != -i -i32 != -i32 -i32 != -i64 -i32 != 0.5 - 0.5 -i32 != 0.5 - i32 -i32 != 0.5 / f32 -i32 != 0.5 ^ 0.5 -i32 != 0.5 ^ i64 -i32 != 0.5 || ok -i32 != 1 % i64 -i32 != 1 && ok -i32 != 1 * f32 -i32 != 1 ? "foo" : array -i32 != 1 ? greet : "foo" -i32 != array[i64] -i32 != bitnot(i) -i32 != bitnot(i64) -i32 != ceil(1) -i32 != ceil(f64) -i32 != count(array, false) -i32 != f32 -i32 != f32 == true -i32 != f32 ? false : 0.5 -i32 != f32 ? i : 0.5 -i32 != f64 -i32 != f64 ** i -i32 != f64 - 1 -i32 != f64 ? 1 : add -i32 != findLastIndex(array, false) -i32 != get(array, 1) -i32 != half(1) -i32 != i -i32 != i + 1 -i32 != i32 -i32 != i32 ** 0.5 -i32 != i32 + 0.5 -i32 != i32 ^ i64 -i32 != i64 -i32 != i64 * i64 -i32 != i64 / 0.5 -i32 != i64 / f32 -i32 != len(list) -i32 != max(f64) -i32 != min(1) -i32 != min(i32) -i32 != nil != false -i32 != nil ? f64 : "foo" -i32 != reduce(array, #) -i32 != reduce(array, i) -i32 != reduce(list, f32) -i32 != round(1) -i32 % -1 -i32 % -i32 -i32 % 1 % i32 -i32 % 1 * f32 -i32 % 1 * i -i32 % 1 * i32 -i32 % 1 .. i -i32 % 1 / 0.5 -i32 % 1 / i32 -i32 % 1 > i -i32 % array[i64] -i32 % get(array, 1) -i32 % i -i32 % i != i -i32 % i < i -i32 % i32 -i32 % i32 != f64 -i32 % i32 * i64 -i32 % i32 == i32 -i32 % i32 >= i64 -i32 % i64 -i32 % i64 % i -i32 % i64 * i64 -i32 % i64 + i -i32 % i64 .. i -i32 % i64 / i -i32 % i64 == f64 -i32 % max(i32) -i32 % reduce(array, #) -i32 % score(1) -i32 * (1 + f32) -i32 * (1 + f64) -i32 * (f32 + 1) -i32 * (f32 - i) -i32 * (f64 + 0.5) -i32 * (f64 + i) -i32 * (i - f32) -i32 * (i32 + i64) -i32 * (i32 - 1) -i32 * (i32 - f64) -i32 * -0.5 -i32 * -1 -i32 * -f32 -i32 * -i32 -i32 * -i64 -i32 * 0.5 * 0.5 -i32 * 0.5 / 0.5 -i32 * 0.5 / 1 -i32 * 0.5 / i32 -i32 * 0.5 == f64 -i32 * 0.5 == i64 -i32 * 0.5 ^ f64 -i32 * 0.5 ^ i32 -i32 * 1 * i -i32 * 1 ** i64 -i32 * 1 + f64 -i32 * 1 - i64 -i32 * 1 > half(0.5) -i32 * 1 ^ 1 -i32 * abs(i32) -i32 * bitnot(i32) -i32 * ceil(1) -i32 * f32 -i32 * f32 + f32 -i32 * f32 / i -i32 * f32 <= f64 -i32 * f32 <= i32 -i32 * f32 ^ f32 -i32 * f64 -i32 * f64 * 1 -i32 * f64 >= f32 -i32 * first(array) -i32 * float(f32) -i32 * float(f64) -i32 * floor(f64) -i32 * half(0.5) -i32 * half(1) -i32 * i -i32 * i / -i -i32 * i / f32 -i32 * i / i64 -i32 * i < f32 -i32 * i32 -i32 * i32 != f64 -i32 * i32 % i64 / i -i32 * i32 / i64 -i32 * i32 < i64 -i32 * i32 >= f32 -i32 * i64 -i32 * i64 % 1 -i32 * i64 % 1 % 1 -i32 * i64 ** i64 -i32 * i64 / f32 -i32 * i64 < i -i32 * len("foo") -i32 * max(i32) -i32 * max(i64) -i32 * median(array) -i32 * min(0.5) -i32 * min(i) -i32 * reduce(array, #) -i32 * round(i) -i32 * score(1) -i32 * score(i) -i32 ** (0.5 - i32) -i32 ** (1 * i64) -i32 ** (1 / 0.5) -i32 ** (f32 * i64) -i32 ** (i % i32) -i32 ** (i - i) -i32 ** (i - i32) -i32 ** (i / 0.5) -i32 ** (i32 / i64) -i32 ** (i64 + 0.5) -i32 ** (i64 - 1) -i32 ** -1 -i32 ** -f64 -i32 ** -i -i32 ** -i64 -i32 ** 0.5 * i64 -i32 ** 0.5 - f64 -i32 ** 0.5 / reduce(array, #) -i32 ** 0.5 ^ i -i32 ** 1 ** i64 -i32 ** 1 + f32 -i32 ** 1 / i64 -i32 ** 1 <= i -i32 ** 1 ^ i64 -i32 ** 1 in array -i32 ** array[1] -i32 ** array[i64] -i32 ** bitnot(i64) -i32 ** ceil(1) -i32 ** ceil(f64) -i32 ** f32 -i32 ** f32 / score(1) -i32 ** f32 < f32 -i32 ** f32 <= i -i32 ** f32 == f32 -i32 ** f64 -i32 ** f64 == f32 -i32 ** f64 > i -i32 ** find(array, ok) -i32 ** float(i32) -i32 ** half(0.5) -i32 ** half(1) -i32 ** half(f64) -i32 ** i -i32 ** i * f64 -i32 ** i ** i -i32 ** i ^ i -i32 ** i32 -i32 ** i32 ^ i64 -i32 ** i64 -i32 ** int(1) -i32 ** int(i32) -i32 ** len("foo") -i32 ** len(list) -i32 ** max(f32, i32) -i32 ** min(0.5) -i32 ** min(i64) -i32 ** reduce(array, 1) -i32 ** reduce(array, i64) -i32 ** reduce(list, i64) -i32 ** round(i64) -i32 ** sum(array) -i32 + -0.5 -i32 + -1 -i32 + -i -i32 + -i32 -i32 + -i64 -i32 + 0.5 != f32 -i32 + 0.5 != i32 -i32 + 0.5 * i -i32 + 0.5 + 0.5 -i32 + 0.5 + 1 -i32 + 0.5 + f32 -i32 + 0.5 + f64 -i32 + 0.5 + i -i32 + 0.5 + i64 -i32 + 0.5 / i64 -i32 + 0.5 <= -f32 -i32 + 1 % 1 -i32 + 1 + i64 -i32 + 1 - f32 -i32 + 1 - i -i32 + 1 - i64 -i32 + 1 / i -i32 + 1 ^ f32 -i32 + abs(f32) -i32 + array[i64] -i32 + bitnot(i32) -i32 + ceil(i) -i32 + f32 -i32 + f32 / i -i32 + f32 < i32 -i32 + f32 <= i64 -i32 + f64 -i32 + f64 * 1 -i32 + f64 * i32 -i32 + f64 > i32 -i32 + f64 ^ 0.5 -i32 + f64 ^ i32 -i32 + findIndex(list, true) -i32 + floor(0.5) -i32 + floor(f64) -i32 + i -i32 + i + f64 -i32 + i + i64 -i32 + i - 0.5 -i32 + i - i64 -i32 + i <= i32 -i32 + i > i64 -i32 + i32 -i32 + i32 + f64 -i32 + i32 <= i + i64 -i32 + i32 > i -i32 + i32 > i32 -i32 + i64 -i32 + i64 % i32 -i32 + i64 ** 1 -i32 + i64 - 0.5 -i32 + i64 - f32 -i32 + i64 / 0.5 -i32 + i64 ^ 1 -i32 + int(i64) -i32 + len("bar") -i32 + min(i32) -i32 + reduce(array, #) -i32 + round(f32) -i32 + round(i32) -i32 + score(i) -i32 - -0.5 -i32 - -1 -i32 - -f32 -i32 - -i -i32 - 0.5 * f32 -i32 - 0.5 + half(0.5) -i32 - 0.5 - i32 -i32 - 0.5 <= f32 -i32 - 0.5 ^ 0.5 -i32 - 1 ** i -i32 - 1 + 0.5 -i32 - 1 > -i64 -i32 - abs(i32) -i32 - abs(i64) -i32 - array[i] -i32 - bitushr(i32, i64) -i32 - div(1, i) -i32 - div(i, i) -i32 - f32 -i32 - f32 * 0.5 -i32 - f32 + i32 -i32 - f32 - int(f64) -i32 - f32 / i32 -i32 - f32 < i64 -i32 - f32 <= f32 -i32 - f32 <= i32 -i32 - f32 > i -i32 - f32 >= f32 -i32 - f64 -i32 - f64 + f32 -i32 - float(0.5) -i32 - float(1) -i32 - float(f64) -i32 - floor(1) -i32 - floor(f64) -i32 - get(array, i) -i32 - half(0.5) -i32 - half(f64) -i32 - i -i32 - i ** i64 -i32 - i + i32 -i32 - i / 0.5 -i32 - i == f32 -i32 - i > f64 -i32 - i > i -i32 - i >= i64 -i32 - i32 -i32 - i32 != i64 -i32 - i32 * 1 -i32 - i32 * i32 -i32 - i32 + 1 -i32 - i32 < i32 -i32 - i32 > i64 -i32 - i32 > i64 / i -i32 - i64 -i32 - i64 != -f32 -i32 - i64 / 1 -i32 - i64 == f64 -i32 - len(array) -i32 - len(list) -i32 - max(f32) -i32 - score(1) -i32 .. -i64 -i32 .. abs(i64) -i32 .. bitnot(i64) -i32 .. bitushr(i, 1) -i32 .. count(array, true) -i32 .. div(i, 1) -i32 .. i -i32 .. i32 -i32 .. i64 -i32 .. int(f32) -i32 .. len("foo") -i32 .. max(1) -i32 .. max(i32) -i32 .. max(i32, 0.5) -i32 .. score(i) -i32 / (1 + 1) -i32 / (1 + i64) -i32 / (f64 - i64) -i32 / (i32 + i64) -i32 / (i64 + 0.5) -i32 / -0.5 -i32 / -f32 -i32 / -i -i32 / -i32 -i32 / -i64 -i32 / 0.5 * i -i32 / 0.5 * i / 1 -i32 / 0.5 + i64 -i32 / 0.5 - i32 -i32 / 0.5 / i32 -i32 / 0.5 / i64 -i32 / 0.5 >= i64 -i32 / 0.5 ^ 1 -i32 / 0.5 ^ f64 -i32 / 1 != i -i32 / 1 * i64 -i32 / 1 ** 1 -i32 / 1 ^ 0.5 -i32 / abs(0.5) -i32 / abs(1) -i32 / abs(f64) -i32 / abs(i32) -i32 / array[1] -i32 / ceil(i32) -i32 / f32 -i32 / f32 ** 1 -i32 / f32 / i64 -i32 / f32 <= i32 -i32 / f32 <= i64 -i32 / f32 >= i32 == false -i32 / f64 -i32 / f64 != f64 -i32 / f64 != i64 -i32 / f64 * 1 -i32 / f64 - i32 -i32 / f64 == i64 -i32 / f64 >= f32 -i32 / find(array, ok) -i32 / float(f32) -i32 / floor(1) -i32 / floor(f64) -i32 / half(0.5) -i32 / i -i32 / i * i32 -i32 / i ^ i32 -i32 / i32 -i32 / i32 * f64 -i32 / i32 / i64 -i32 / i32 <= i64 -i32 / i64 -i32 / i64 ** f32 -i32 / i64 ^ 0.5 -i32 / int(1) -i32 / len("foo") -i32 / max(1) -i32 / max(i) -i32 / min(f32) -i32 / reduce(array, #) -i32 / score(i) -i32 < -f32 -i32 < -f64 -i32 < -i32 -i32 < 0.5 ** i32 -i32 < 0.5 - 1 -i32 < 0.5 - f32 -i32 < 0.5 / 1 -i32 < 0.5 == nil -i32 < 0.5 ? "foo" : half -i32 < 0.5 ? foo : 1 -i32 < 0.5 or ok -i32 < 0.5 || ok -i32 < 1 * f32 -i32 < 1 + i64 -i32 < 1 / f32 -i32 < 1 ^ i -i32 < abs(f64) -i32 < f32 -i32 < f32 * i -i32 < f32 - 0.5 -i32 < f32 - 1 -i32 < f64 -i32 < f64 * i64 -i32 < float(reduce(array, f32)) -i32 < get(array, i32) -i32 < get(array, i64) -i32 < half(1) -i32 < half(f64) -i32 < i -i32 < i ** i64 -i32 < i + 0.5 -i32 < i / i32 -i32 < i ? score : score -i32 < i32 -i32 < i32 % i -i32 < i32 ** 1 -i32 < i32 - f32 -i32 < i32 ^ i64 -i32 < i64 -i32 < i64 ** 0.5 -i32 < i64 + f32 -i32 < i64 / f64 -i32 < int(0.5) -i32 < last(array) -i32 < min(1) -i32 < min(f64) -i32 < min(i32) -i32 < score(1) -i32 < score(i) -i32 <= -0.5 -i32 <= -f32 -i32 <= -i -i32 <= -i32 -i32 <= -i64 -i32 <= 0.5 - f64 -i32 <= 0.5 == nil -i32 <= 0.5 ? i32 : greet -i32 <= 0.5 ? i32 : half -i32 <= 0.5 ^ i64 -i32 <= 0.5 and ok -i32 <= 1 + i32 -i32 <= 1 + i64 -i32 <= 1 ^ 0.5 -i32 <= 1 and ok -i32 <= 1 || i32 >= i32 -i32 <= abs(1) -i32 <= f32 -i32 <= f32 != ok -i32 <= f64 -i32 <= f64 != ok -i32 <= f64 * i -i32 <= f64 == ok -i32 <= f64 ^ f64 -i32 <= findIndex(array, true) -i32 <= float(i32) -i32 <= floor(0.5) -i32 <= half(0.5) -i32 <= half(1) -i32 <= half(f64) -i32 <= i -i32 <= i * 1 -i32 <= i * i64 -i32 <= i - 0.5 -i32 <= i32 -i32 <= i32 != true -i32 <= i64 -i32 <= i64 / 1 -i32 <= len("foo") -i32 <= max(i64) -i32 <= mean(array) -i32 <= round(0.5) -i32 <= score(1) -i32 <= score(i) -i32 == -0.5 -i32 == -1 -i32 == -f32 -i32 == -f64 -i32 == -i -i32 == 0.5 != false -i32 == 0.5 * f32 -i32 == 0.5 / 0.5 -i32 == 1 % 1 -i32 == 1 + f32 -i32 == 1 - i -i32 == 1 ? div : div -i32 == 1 ^ 0.5 -i32 == 1 ^ f64 -i32 == abs(f64) -i32 == abs(i) -i32 == bitnot(1) -i32 == bitnot(i) -i32 == ceil(1) -i32 == count(list, ok) -i32 == f32 -i32 == f32 * i32 -i32 == f32 ** 1 -i32 == f32 - f32 -i32 == f32 ? f64 : list -i32 == f32 ? i64 : true -i32 == f32 ? score : "bar" -i32 == f64 -i32 == f64 ** 0.5 -i32 == find(array, 0.5 == i64) -i32 == first(array) -i32 == floor(f64) -i32 == half(f64) -i32 == i -i32 == i ** f64 -i32 == i ? half : 1 -i32 == i ? i : "bar" -i32 == i32 -i32 == i32 && i == i -i32 == i32 - 1 -i32 == i32 - i64 -i32 == i64 -i32 == i64 * f32 -i32 == i64 ? "foo" : 1 -i32 == i64 or ok -i32 == int(f64) -i32 == int(i) -i32 == nil ? f32 : 0.5 -i32 == reduce(array, #) -i32 == round(i32) -i32 == round(i64) -i32 == score(1) -i32 > -0.5 -i32 > -f64 -i32 > -i32 -i32 > 0.5 != true -i32 > 0.5 * f64 -i32 > 0.5 ** 0.5 -i32 > 0.5 ** 1 -i32 > 0.5 ** i -i32 > 0.5 - i -i32 > 0.5 / 1 -i32 > 0.5 == ok -i32 > 0.5 ^ 1 -i32 > 0.5 || ok -i32 > 1 * f64 -i32 > 1 * i32 -i32 > 1 + i64 -i32 > 1 ? f32 : f64 -i32 > 1 ? i : "bar" -i32 > 1 ? i64 : div -i32 > ceil(0.5) -i32 > ceil(1) -i32 > count(array, ok) -i32 > f32 -i32 > f32 * i64 -i32 > f32 + 0.5 -i32 > f32 + 1 -i32 > f32 - f32 -i32 > f32 - i32 -i32 > f32 ^ 0.5 -i32 > f64 -i32 > f64 ** i32 -i32 > f64 + f64 -i32 > get(array, i32) -i32 > half(1) -i32 > half(half(1)) -i32 > i -i32 > i != ok -i32 > i + f32 -i32 > i ? i : i -i32 > i ^ i32 -i32 > i32 -i32 > i32 - i -i32 > i32 == nil ? score : i -i32 > i32 ? score : 1 -i32 > i32 ^ 1 -i32 > i32 ^ i32 -i32 > i64 -i32 > i64 != false -i32 > i64 ** f32 -i32 > i64 / 1 -i32 > i64 == ok -i32 > i64 || ok -i32 > int(1) -i32 > int(i64) -i32 > min(i32) -i32 > reduce(array, #) -i32 > round(i64) -i32 > score(i) -i32 >= -1 -i32 >= -f32 -i32 >= -f64 -i32 >= -i -i32 >= -i64 -i32 >= 0.5 != not true -i32 >= 0.5 == true -i32 >= 0.5 ? 0.5 : half -i32 >= 0.5 ^ 0.5 -i32 >= 0.5 ^ i32 -i32 >= 1 % i -i32 >= 1 * 0.5 -i32 >= 1 * i32 -i32 >= 1 + i64 -i32 >= 1 - 1 -i32 >= 1 == ok -i32 >= 1 ? 1 : false -i32 >= 1 ? add : 1 -i32 >= abs(0.5) -i32 >= abs(f32) -i32 >= bitnot(1 + i) -i32 >= bitnot(i64) -i32 >= ceil(1) -i32 >= ceil(f32) -i32 >= count(list, true) -i32 >= f32 -i32 >= f32 ** f32 -i32 >= f32 ^ 1 -i32 >= f64 -i32 >= f64 != false -i32 >= f64 ** f64 -i32 >= f64 / i64 -i32 >= f64 ? half : f64 -i32 >= f64 ^ f64 -i32 >= float(0.5) -i32 >= floor(1) -i32 >= floor(f32) -i32 >= half(0.5) -i32 >= i -i32 >= i % 1 -i32 >= i % i64 -i32 >= i / i32 -i32 >= i / i64 -i32 >= i == ok -i32 >= i32 -i32 >= i32 ** i32 -i32 >= i64 -i32 >= i64 != false -i32 >= i64 - i64 -i32 >= i64 / i32 -i32 >= i64 ? 0.5 : 0.5 -i32 >= i64 ? div : half -i32 >= i64 ? half : i64 -i32 >= i64 and ok -i32 >= int(i64) -i32 >= last(array) -i32 >= min(i32) -i32 >= reduce(array, #) -i32 >= reduce(array, i64) -i32 >= reduce(list, i32) -i32 >= round(f32) -i32 >= score(1) -i32 ^ (0.5 + 1) -i32 ^ (1 - i) -i32 ^ (i + 1) -i32 ^ (i / f64) -i32 ^ (i32 + 0.5) -i32 ^ (i32 - f32) -i32 ^ (i64 + i) -i32 ^ -0.5 -i32 ^ -1 -i32 ^ -f64 -i32 ^ -i -i32 ^ -i32 -i32 ^ -i64 -i32 ^ 0.5 != f32 -i32 ^ 0.5 != f64 -i32 ^ 0.5 * i -i32 ^ 0.5 ** i64 -i32 ^ 0.5 - f32 -i32 ^ 0.5 / i32 -i32 ^ 0.5 == i64 -i32 ^ 0.5 >= f64 -i32 ^ 1 ** i32 -i32 ^ 1 + i32 -i32 ^ 1 - f64 -i32 ^ 1 < f64 -i32 ^ 1 ^ (1 + i64) -i32 ^ 1 ^ f32 -i32 ^ array[i64] -i32 ^ f32 -i32 ^ f32 / bitnot(1) -i32 ^ f32 >= max(f64) -i32 ^ f64 -i32 ^ f64 + i -i32 ^ find(array, true) -i32 ^ first(array) -i32 ^ float(i64) -i32 ^ i -i32 ^ i * f64 -i32 ^ i + i64 -i32 ^ i <= f32 -i32 ^ i32 -i32 ^ i32 * f64 -i32 ^ i32 ** i -i32 ^ i64 -i32 ^ i64 == f64 -i32 ^ i64 > -f64 -i32 ^ len(list) -i32 ^ mean(array) -i32 ^ min(i) -i32 ^ reduce(array, #) -i32 ^ reduce(list, 1) -i32 in [0.5] -i32 in array -i32 in array || ok -i32 in groupBy(array, #) -i32 in groupBy(array, f32) -i32 in groupBy(list, #) -i32 in groupBy(list, #?.Bar) -i32 in groupBy(list, foo).i -i32 in i32 .. 1 -i32 in i32 .. i64 -i32 in map(array, #) -i32 in map(list, 0.5) -i32 in map(list, i32) -i32 not in 1 .. i -i32 not in array -i32 not in array ? array : array -i32 not in filter(array, ok) -i32 not in groupBy(list, #) -i64 -i64 != -1 -i64 != -i -i64 != -i64 -i64 != 0.5 && ok -i64 != 0.5 * 0.5 -i64 != 0.5 * i -i64 != 0.5 + 0.5 -i64 != 0.5 + i -i64 != 0.5 - 0.5 -i64 != 0.5 / i64 -i64 != 0.5 ? i : 1 -i64 != 0.5 ^ i32 -i64 != 1 * f64 -i64 != 1 - 1 -i64 != abs(f64) -i64 != array[i64] -i64 != bitnot(i32) -i64 != f32 -i64 != f32 + i64 -i64 != f64 -i64 != f64 * 1 -i64 != f64 == true -i64 != f64 or i64 <= f32 -i64 != findIndex(array, ok) -i64 != float(1) -i64 != floor(i) -i64 != get(array, i) -i64 != half(0.5) -i64 != half(1) -i64 != i -i64 != i % 1 -i64 != i + 1 -i64 != i / 0.5 -i64 != i ? f32 : true -i64 != i32 -i64 != i32 ? 0.5 : nil -i64 != i32 ? f64 : greet -i64 != i32 ^ i -i64 != i32 || ok -i64 != i64 -i64 != i64 - 0.5 -i64 != len("bar") -i64 != len(list) -i64 != max(0.5) -i64 != min(1) -i64 != min(1, f32) -i64 != min(f32) -i64 != min(i) -i64 != nil != ok -i64 != nil ? div : 1 -i64 != nil ? greet : i -i64 != nil ? i : i -i64 != nil ? i64 : false -i64 != score(1) -i64 != score(i) -i64 % -i -i64 % 1 % 1 -i64 % 1 * i -i64 % 1 < i32 -i64 % 1 >= f64 -i64 % 1 >= i32 -i64 % abs(i32) -i64 % array[i32] -i64 % i -i64 % i * i -i64 % i >= i -i64 % i32 -i64 % i32 / f64 -i64 % i32 <= f64 -i64 % i64 -i64 % i64 % 1 -i64 % i64 .. i64 -i64 % i64 == i64 -i64 % int(i32) -i64 % len("bar") -i64 % max(i) -i64 % min(1) -i64 % score(1) -i64 * (0.5 + f64) -i64 * (1 - i64) -i64 * (f32 - f32) -i64 * (f64 + f32) -i64 * (i + 0.5) -i64 * (i + f64) -i64 * (i32 + f64) -i64 * -0.5 -i64 * -1 -i64 * -f32 -i64 * -i32 -i64 * 0.5 * i32 -i64 * 0.5 ** 0.5 -i64 * 0.5 - f32 -i64 * 0.5 / 1 -i64 * 0.5 >= f32 -i64 * 1 % 1 -i64 * 1 * 0.5 -i64 * 1 * f64 -i64 * 1 ** 1 -i64 * 1 - i64 -i64 * 1 .. i32 -i64 * 1 / i64 -i64 * 1 <= f64 -i64 * 1 == 0.5 != true -i64 * 1 == f32 -i64 * 1 > 1 - i64 -i64 * 1 > f64 -i64 * 1 ^ i32 -i64 * add(1, 1) -i64 * ceil(1) -i64 * ceil(i) -i64 * ceil(i64) -i64 * count(array, false) -i64 * f32 -i64 * f32 * f32 -i64 * f32 ** 1 -i64 * f32 / f32 -i64 * f32 / i -i64 * f32 / i32 -i64 * f32 not in array -i64 * f64 -i64 * f64 + i32 -i64 * f64 - f64 -i64 * f64 / f64 -i64 * f64 < f64 -i64 * f64 > f64 -i64 * f64 ^ i32 -i64 * findIndex(array, ok) -i64 * float(i) -i64 * float(i64) -i64 * half(0.5) -i64 * i -i64 * i - -f64 -i64 * i <= f64 -i64 * i32 -i64 * i32 != i32 -i64 * i32 * 1 -i64 * i32 * i -i64 * i32 / 0.5 -i64 * i32 ^ i -i64 * i64 -i64 * i64 % i64 -i64 * i64 * i64 -i64 * i64 ** i -i64 * i64 / f32 -i64 * i64 > i32 -i64 * int(1) -i64 * int(i) -i64 * max(1) -i64 * max(i64) -i64 * min(1) -i64 * min(i32) -i64 * reduce(array, #) -i64 * reduce(list, 0.5) -i64 * reduce(list, 1) -i64 * round(i) -i64 * score(1) -i64 ** (0.5 + 0.5) -i64 ** (0.5 / 1) -i64 ** (1 % 1) -i64 ** (1 * 1) -i64 ** (1 - f32) -i64 ** (f32 + 1) -i64 ** (f32 / 0.5) -i64 ** (f64 - 0.5) -i64 ** (i * i64) -i64 ** (i / 1) -i64 ** (i64 % i) -i64 ** (i64 / i) -i64 ** -0.5 -i64 ** -1 -i64 ** -f32 -i64 ** 0.5 != i32 -i64 ** 0.5 <= f32 -i64 ** 0.5 <= i -i64 ** 1 + i32 -i64 ** 1 - f32 -i64 ** 1 / i64 -i64 ** 1 >= f32 -i64 ** bitnot(i32) -i64 ** ceil(i32) -i64 ** count(array, false) -i64 ** f32 -i64 ** f32 * min(0.5) -i64 ** f64 -i64 ** f64 ** f64 -i64 ** f64 not in array -i64 ** f64 not in array ? f32 : greet -i64 ** floor(f32) -i64 ** half(1) -i64 ** i -i64 ** i != f32 -i64 ** i * f32 -i64 ** i <= -i -i64 ** i == f64 -i64 ** i ^ f32 -i64 ** i32 -i64 ** i32 != i64 -i64 ** i32 * i ^ i -i64 ** i32 not in array -i64 ** i64 -i64 ** i64 - i64 -i64 ** i64 in array -i64 ** max(1) -i64 ** min(0.5) -i64 ** min(1) -i64 ** min(i32, 1) -i64 ** reduce(array, #) -i64 + -1 -i64 + -i -i64 + -i64 -i64 + 0.5 ** f32 -i64 + 0.5 + i32 -i64 + 0.5 + i64 -i64 + 0.5 - f64 -i64 + 0.5 <= bitnand(1, 1) -i64 + 0.5 <= f64 -i64 + 0.5 == f32 -i64 + 1 != f64 -i64 + 1 % i64 -i64 + 1 + f64 -i64 + 1 <= f32 -i64 + array[i64] -i64 + array[i] -i64 + f32 -i64 + f32 * f64 -i64 + f32 / i64 -i64 + f64 -i64 + f64 * 0.5 -i64 + f64 ** 0.5 -i64 + f64 > f32 -i64 + float(f32) -i64 + float(i32) -i64 + half(0.5) -i64 + i -i64 + i % 1 -i64 + i * 0.5 -i64 + i + f32 -i64 + i - i32 -i64 + i / i32 -i64 + i == 0.5 - i32 -i64 + i ^ f32 -i64 + i ^ f64 -i64 + i32 -i64 + i32 % i64 -i64 + i32 - 0.5 -i64 + i32 == f64 -i64 + i64 -i64 + i64 - 0.5 -i64 + reduce(array, #) -i64 + score(i) -i64 - -1 -i64 - -f32 -i64 - -i32 -i64 - -i64 -i64 - 0.5 + f32 -i64 - 0.5 / i64 -i64 - 0.5 <= i -i64 - 0.5 ^ f32 -i64 - 1 ** 1 -i64 - 1 < i -i64 - 1 == i32 -i64 - 1 > f32 -i64 - 1 >= i -i64 - 1 not in array -i64 - ceil(1) -i64 - f32 -i64 - f32 != f32 -i64 - f32 - 1 -i64 - f32 - i -i64 - f32 / 1 -i64 - f32 < i64 -i64 - f32 >= f64 -i64 - f64 -i64 - f64 != i -i64 - f64 ** f32 -i64 - f64 ** i32 -i64 - f64 + f32 -i64 - f64 + i32 -i64 - f64 >= f64 -i64 - float(0.5) -i64 - half(1) -i64 - half(f64) -i64 - i -i64 - i * 1 -i64 - i + i64 -i64 - i - 1 -i64 - i .. i64 -i64 - i < i32 -i64 - i > 1 - 0.5 -i64 - i >= f64 -i64 - i ^ i64 -i64 - i not in array -i64 - i32 -i64 - i32 - i64 -i64 - i32 .. i64 -i64 - i32 > i -i64 - i32 >= i -i64 - i64 -i64 - i64 > f32 -i64 - int(i) -i64 - len("foo") -i64 - max(0.5) -i64 - min(f32) -i64 - min(f64) -i64 - min(i) -i64 - reduce(array, #) -i64 - reduce(array, i64) -i64 - round(1) -i64 - score(1) -i64 - score(i) -i64 .. -1 -i64 .. -i -i64 .. -i32 -i64 .. -i64 -i64 .. 1 * i64 -i64 .. 1 - 1 -i64 .. 1 - i -i64 .. 1 - i64 -i64 .. abs(i) -i64 .. bitnot(i32) -i64 .. count(array, false) -i64 .. get(array, 1) -i64 .. i -i64 .. i * i -i64 .. i + 1 -i64 .. i == list -i64 .. i32 -i64 .. i32 * 1 -i64 .. i64 -i64 .. i64 * i32 -i64 .. i64 + i -i64 .. i64 - i -i64 .. int(0.5) -i64 .. int(f32) -i64 .. int(i64) -i64 .. min(i32) -i64 .. min(i64, 0.5) -i64 .. reduce(array, #) -i64 .. score(1) -i64 / (f32 + i64) -i64 / (f32 - i) -i64 / (i + 1) -i64 / (i32 + 0.5) -i64 / (i64 - i) -i64 / -0.5 -i64 / -1 -i64 / -f32 -i64 / -f64 -i64 / -i -i64 / 0.5 * f64 -i64 / 0.5 - i64 -i64 / 0.5 / i -i64 / 0.5 == i -i64 / 1 ** i64 -i64 / 1 / i32 -i64 / 1 / i64 -i64 / 1 < i -i64 / 1 == f32 -i64 / ceil(i) -i64 / f32 -i64 / f32 - i -i64 / f32 / i64 -i64 / f32 > i -i64 / f32 ^ 1 -i64 / f32 ^ i -i64 / f64 -i64 / f64 * i64 -i64 / f64 - min(i64) -i64 / f64 / f32 -i64 / f64 / i * 0.5 -i64 / f64 / i32 -i64 / f64 in array -i64 / float(1) -i64 / get(array, i32) -i64 / half(1) -i64 / i -i64 / i * i64 -i64 / i - f64 -i64 / i32 -i64 / i32 != f32 -i64 / i32 * f64 -i64 / i32 == f64 -i64 / i32 > 1 + 1 -i64 / i32 >= f32 -i64 / i32 >= f64 -i64 / i32 ^ f32 -i64 / i64 -i64 / i64 + f64 -i64 / i64 < i32 -i64 / i64 <= f32 -i64 / i64 == i32 -i64 / int(1) -i64 / len(list) -i64 / max(1) -i64 / reduce(array, #) -i64 / reduce(array, 1) -i64 / round(0.5) -i64 / round(i) -i64 / score(1) -i64 / score(i) -i64 < -0.5 -i64 < -1 -i64 < -f32 -i64 < -f64 -i64 < -i -i64 < -i32 -i64 < -i64 -i64 < 0.5 * 0.5 -i64 < 0.5 + i -i64 < 0.5 - 1 -i64 < 0.5 / 0.5 -i64 < 0.5 / 1 -i64 < 0.5 == ok -i64 < 0.5 || false ? 1 : nil -i64 < 1 * i32 -i64 < 1 ** 0.5 -i64 < 1 + 0.5 -i64 < 1 + i64 -i64 < 1 / f32 -i64 < ceil(i64) -i64 < f32 -i64 < f32 * 0.5 -i64 < f32 - i64 -i64 < f32 ^ f32 -i64 < f64 -i64 < f64 && ok -i64 < f64 - f64 -i64 < f64 ? score : add -i64 < float(0.5) -i64 < float(i32) -i64 < floor(0.5) -i64 < floor(i32) -i64 < half(1) -i64 < i -i64 < i % i64 -i64 < i ^ 0.5 -i64 < i || ok -i64 < i32 -i64 < i32 + 1 -i64 < i32 + i32 -i64 < i32 / f32 -i64 < i32 ? foo : i -i64 < i64 -i64 < i64 != nil -i64 < i64 * 1 -i64 < i64 * i64 -i64 < i64 / f32 -i64 < i64 / i -i64 < i64 ^ 1 -i64 < i64 ^ i -i64 < int(f64) -i64 < len("bar") -i64 < len("foo") -i64 <= -0.5 -i64 <= -1 -i64 <= -f32 -i64 <= -f64 -i64 <= -i64 -i64 <= 0.5 && ok -i64 <= 0.5 * 0.5 -i64 <= 0.5 + 1 -i64 <= 0.5 ? i : i32 -i64 <= 1 ** i32 -i64 <= 1 + 1 -i64 <= 1 - 0.5 -i64 <= 1 - 1 -i64 <= 1 / 1 -i64 <= 1 == ok -i64 <= 1 ? add : div -i64 <= 1 ? f32 : greet -i64 <= 1 ? i64 : true -i64 <= 1 ^ 1 -i64 <= array[i64] -i64 <= array[i] -i64 <= bitnot(1) -i64 <= f32 -i64 <= f32 ** i -i64 <= f32 ** i64 -i64 <= f32 == ok -i64 <= f64 -i64 <= f64 + 1 -i64 <= f64 + f32 -i64 <= f64 / 1 -i64 <= f64 ? nil : i32 -i64 <= float(1) -i64 <= floor(i) -i64 <= floor(i32) -i64 <= half(min(0.5, 1, i64)) -i64 <= i -i64 <= i * 1 -i64 <= i * f32 -i64 <= i ** i32 -i64 <= i ? greet : add -i64 <= i32 -i64 <= i32 ** i32 -i64 <= i32 ? list : half -i64 <= i32 ^ -1 -i64 <= i64 -i64 <= i64 * i -i64 <= len(list) -i64 <= max(f32) -i64 <= min(0.5) -i64 <= min(i32) -i64 <= reduce(array, i32) -i64 <= reduce(list, i64) -i64 <= round(0.5) -i64 == -1 -i64 == -f32 -i64 == -f64 -i64 == -i -i64 == -i32 -i64 == 0.5 * 1 -i64 == 0.5 - f64 -i64 == 0.5 == ok -i64 == 0.5 ? 0.5 : f64 -i64 == 1 ** f64 -i64 == 1 + 0.5 -i64 == 1 / i -i64 == 1 == ok -i64 == 1 ? "foo" : i -i64 == array[1] -i64 == bitnot(i64) -i64 == ceil(i64) -i64 == f32 -i64 == f32 != true -i64 == f32 + i -i64 == f32 - f32 -i64 == f32 == ok -i64 == f64 -i64 == f64 * f64 -i64 == f64 ? 1 : nil -i64 == f64 ^ 0.5 -i64 == f64 ^ f32 -i64 == f64 and not true -i64 == findIndex(list, f64 <= f64) -i64 == floor(0.5) -i64 == get(array, 1) -i64 == half(1) -i64 == i -i64 == i != nil -i64 == i + i32 -i64 == i ? i64 : foo -i64 == i32 -i64 == i64 -i64 == i64 * f32 -i64 == i64 / i64 -i64 == i64 ? add : 0.5 -i64 == i64 ? add : greet -i64 == int(0.5) -i64 == int(1) -i64 == int(i) -i64 == len("foo") -i64 == nil != nil -i64 == reduce(array, #) -i64 == score(1) -i64 > -0.5 -i64 > -f32 -i64 > -f64 -i64 > 0.5 + f32 -i64 > 0.5 - f64 -i64 > 0.5 - i32 -i64 > 0.5 ? array : 1 -i64 > 0.5 ? f32 : nil -i64 > 0.5 ? ok : nil -i64 > 0.5 ? score : foo -i64 > 0.5 or ok -i64 > 1 != true -i64 > 1 ** 1 -i64 > 1 == false -i64 > 1 ? nil : 1 -i64 > 1 ^ f32 -i64 > 1 ^ i32 -i64 > f32 -i64 > f32 * 0.5 -i64 > f32 + f64 -i64 > f32 / f32 -i64 > f32 ? "foo" : greet -i64 > f32 ? 1 : i32 -i64 > f64 -i64 > f64 * i -i64 > f64 - 0.5 -i64 > f64 - f32 -i64 > first(array) -i64 > half(0.5) -i64 > i -i64 > i != nil -i64 > i == true -i64 > i32 -i64 > i32 ? div : f32 -i64 > i32 ^ f32 -i64 > i64 -i64 > i64 - i -i64 > i64 - i32 -i64 > i64 / f64 -i64 > i64 == false -i64 > len(list) -i64 > max(0.5) -i64 > min(1) -i64 > min(i32) -i64 > reduce(array, #) -i64 > reduce(array, 1) -i64 > round(0.5) -i64 > round(i32) -i64 > score(i) -i64 >= -0.5 -i64 >= -1 -i64 >= -i -i64 >= -i64 -i64 >= 0.5 / i -i64 >= 0.5 == nil -i64 >= 0.5 ? 0.5 : f64 -i64 >= 0.5 ^ i -i64 >= 1 % i64 -i64 >= 1 * f64 -i64 >= 1 * i64 -i64 >= abs(i64) -i64 >= array[i32] -i64 >= bitnot(1) -i64 >= f32 -i64 >= f32 + f32 -i64 >= f32 - f32 -i64 >= f32 ? array : i -i64 >= f32 ? f32 : i32 -i64 >= f32 ? list : f32 -i64 >= f64 -i64 >= f64 + 0.5 -i64 >= first(array) -i64 >= float(0.5) -i64 >= float(f32) -i64 >= floor(1) -i64 >= floor(i64) -i64 >= half(0.5) -i64 >= half(half(f64)) -i64 >= i -i64 >= i / 0.5 -i64 >= i ? true : i32 -i64 >= i32 -i64 >= i32 * i -i64 >= i32 / f32 -i64 >= i32 == false -i64 >= i32 || f64 == 1 -i64 >= i64 -i64 >= i64 + 1 -i64 >= i64 ? foo : foo -i64 >= i64 or ok -i64 >= int(f64) -i64 >= last(array) -i64 >= max(i64) -i64 >= min(1) -i64 >= min(f64) -i64 >= round(1) -i64 >= round(i) -i64 >= score(1) -i64 ^ (0.5 * i32) -i64 ^ (0.5 / i64) -i64 ^ (1 * f64) -i64 ^ (1 - i) -i64 ^ (f32 / 1) -i64 ^ (i % i) -i64 ^ (i32 * f64) -i64 ^ (i32 - f64) -i64 ^ (i64 + 0.5) -i64 ^ (i64 + 1) -i64 ^ (i64 - f32) -i64 ^ -0.5 -i64 ^ -1 -i64 ^ -f32 -i64 ^ -i64 -i64 ^ 0.5 != i64 -i64 ^ 0.5 ** 0.5 -i64 ^ 0.5 / f32 -i64 ^ 0.5 <= i64 -i64 ^ 0.5 == i -i64 ^ 0.5 ^ f32 -i64 ^ 0.5 ^ i64 -i64 ^ 1 * i64 -i64 ^ 1 * round(0.5) -i64 ^ 1 ** f64 -i64 ^ 1 ** i32 -i64 ^ 1 - f32 -i64 ^ 1 < f64 -i64 ^ 1 >= f32 -i64 ^ 1 >= half(1) -i64 ^ 1 ^ f32 -i64 ^ 1 ^ i32 -i64 ^ abs(1) -i64 ^ array[i] -i64 ^ f32 -i64 ^ f32 * i32 -i64 ^ f32 ** f64 -i64 ^ f32 - f64 -i64 ^ f32 / i - i32 -i64 ^ f32 < f32 -i64 ^ f32 <= i64 -i64 ^ f32 ^ 1 -i64 ^ f64 -i64 ^ f64 * i -i64 ^ f64 ** 1 -i64 ^ f64 > i64 -i64 ^ f64 ^ f32 -i64 ^ float(i32) -i64 ^ floor(i32) -i64 ^ floor(i64) -i64 ^ half(0.5) -i64 ^ half(1) -i64 ^ i -i64 ^ i * i -i64 ^ i ** i32 -i64 ^ i + i % 1 -i64 ^ i + i64 -i64 ^ i - f32 ^ 1 -i64 ^ i - f64 -i64 ^ i / i -i64 ^ i < f32 -i64 ^ i ^ i32 -i64 ^ i32 -i64 ^ i32 * i -i64 ^ i32 + i32 -i64 ^ i32 + i64 -i64 ^ i64 -i64 ^ i64 * i64 -i64 ^ i64 + i -i64 ^ i64 == i64 -i64 ^ i64 ^ 1 -i64 ^ i64 in array -i64 ^ int(1) -i64 ^ max(0.5) -i64 ^ reduce(array, #) -i64 ^ round(i64) -i64 ^ score(1) -i64 in array -i64 in array == ok -i64 in groupBy(array, 0.5) -i64 in groupBy(array, foo) -i64 in groupBy(list, "bar") -i64 in groupBy(list, i) -i64 in i64 .. i32 -i64 in map(array, #) -i64 in map(list, 1) -i64 in map(list, i) -i64 not in 1 .. i -i64 not in array -i64 not in array ? f32 : i32 -i64 not in array ? ok : f32 -i64 not in map(array, #) -i64 not in map(list, 0.5) -int(-0.5) -int(-1) -int(-f32) -int(-f64) -int(-i) -int(-i32) -int(-i64) -int(0.5 * 0.5) -int(0.5 * f32) -int(0.5 * f64) -int(0.5 * i32) -int(0.5 ** 0.5) -int(0.5 ** 1) -int(0.5 ** f32) -int(0.5 ** f64) -int(0.5 ** i32) -int(0.5 + 0.5) -int(0.5 + 1) -int(0.5 + f64) -int(0.5 + i32) -int(0.5 + i64) -int(0.5 - f32) -int(0.5 - i) -int(0.5 - i32) -int(0.5 - i64) -int(0.5 / i) -int(0.5 / i64) -int(0.5 ^ i) -int(0.5 ^ i64) -int(0.5) * -i -int(0.5) ** f64 -int(0.5) ** i32 -int(0.5) + i -int(0.5) / i32 -int(0.5) < 0.5 * f64 -int(0.5) <= i -int(0.5) <= i32 -int(0.5) == f32 -int(0.5) > -i64 -int(0.5) > i -int(0.5) >= f32 -int(0.5) >= i32 -int(0.5) >= max(0.5) -int(0.5) ^ i32 -int(1 % i) -int(1 * f32) -int(1 * i) -int(1 * i32) +i not in array == true +i not in flatten(array) +i not in flatten(list) +i not in map(list, 1) +i | add(0) +i | add(1) +i | add(i) +i | bitand(0) +i | bitand(1) +i | bitand(1) + i +i | bitand(i) +i | bitnand(0) +i | bitnand(1) +i | bitnand(i) +i | bitor(0) +i | bitor(1 % 1) +i | bitor(1) +i | bitor(i) +i | bitshl($env.i) +i | bitshl(0) +i | bitshl(1) +i | bitshl(i) +i | bitshr(0) +i | bitshr(0) != 1.0 || false +i | bitshr(1) +i | bitshr(i) +i | bitushr(0) +i | bitushr(1) +i | bitushr(i) +i | bitxor(0) +i | bitxor(1) +i | bitxor(i) +i | max($env.i) +i | max(0) +i | max(0, 1.0) +i | max(1) +i | max(1.0) +i | max(1.0, array) +i | max(1.0, f64) +i | max(array) +i | max(f64) +i | max(f64, 0) +i | max(f64, f64) +i | max(i) +i | max(i, array) +i | mean(0) +i | mean(1) +i | mean(1, array) +i | mean(1.0) +i | mean(array) +i | mean(f64) +i | mean(f64, 1) +i | mean(i) +i | mean(i, f64) +i | median(0) +i | median(0, 0) +i | median(1) +i | median(1, 1) +i | median(1.0) +i | median(1.0, i) +i | median(array) +i | median(f64) +i | median(i) +i | median(i) != f64 +i | median(i, 1.0) +i | min(0) +i | min(0) | median(1.0) +i | min(0, f64) +i | min(1) +i | min(1.0) +i | min(array) +i | min(f64) +i | min(f64, array) +i | min(i) +i | min(i, 1) +i..array?.[i] +i..i +i..i - 0 +i..i == $env +i..i == nil +i..i | map(#) +i..i | reduce(foo) +i; 1.0; $env.foo +i; ceil(1.0) +i; f64 +i; greet +i; i; greet(str) +i; list +i; str +i; {foo: false} +if $env != f64 { add } else { foo } +if $env != foo { greet } else { str } +if $env == 1.0 { list } else { add } +if $env?.ok { foo?.String } else { greet } +if 0 > 1 { list } else { false ? ok : ok } +if 1.0 >= 0 { foo } else { ok } +if f64 not in array { map(list, list) } else { add } +if i > $env?.i { greet } else { list } +if nil != str { greet } else { array } +if ok or false { str } else { greet } +if ok { $env.foo } else { foo.Bar } +if ok { 0 != i } else { ok } +if ok { 1 > 1.0 } else { f64 } +if ok { add } else { add } +if ok { add } else { f64 } +if ok { add } else { foo } +if ok { add } else { greet } +if ok { add } else { i } +if ok { add } else { ok } +if ok { array } else { foo } +if ok { array } else { foo?.Bar } +if ok { f64 } else { f64 } +if ok { f64 } else { findLastIndex($env, $env) } +if ok { f64 } else { foo } +if ok { f64 } else { ok } +if ok { false && true } else { false == nil } +if ok { foo } else { $env ?: f64 } +if ok { foo } else { $env?.str } +if ok { foo } else { f64 } +if ok { foo } else { foo } +if ok { foo } else { greet } +if ok { foo } else { ok } +if ok { foo.Bar } else { 1 == 1.0 } +if ok { greet } else { array } +if ok { greet } else { f64 } +if ok { greet } else { i } +if ok { greet } else { str } +if ok { i } else { date($env) } +if ok { i } else { type(nil) } +if ok { list } else { i } +if ok { list } else { nil == true } +if ok { list } else { ok } +if ok { list } else { str } +if ok { nil == false } else { greet } +if ok { ok } else { $env.add } +if ok { ok } else { array } +if ok { ok } else { foo } +if ok { ok } else { greet } +if ok { str } else { array } +if ok { str } else { i } +if ok { str } else { ok } +if ok { type(f64) } else { foo } +if str == $env { foo?.String() } else { $env.foo } +if str > str { str } else { find(array, ok) } +if true && ok { array } else { greet } +indexOf($env?.[str], str) +indexOf(str, str) +indexOf(toJSON(1.0), toJSON(true)) +int($env | count(ok)) +int($env | findIndex(ok)) +int($env | findIndex(true)) +int($env | sum(i)) +int($env.f64) +int($env.i) +int($env?.f64) +int($env?.i) +int(0 % 1) +int(0 % i) +int(0 * 1) +int(0 * 1.0) +int(0 ** 1.0) +int(0 + 1) +int(0 + 1.0) +int(0 - 1.0) +int(0 / 0) +int(0 / 1) +int(0 / i) +int(0 ^ 0) +int(0 ^ 1.0) +int(0 ^ i) +int(0 | bitshl(0)) +int(0 | bitshr(i)) +int(0 | bitxor(i)) +int(0 | min(1.0, 1)) +int(0) % count(array, true) +int(0) * i +int(0) + i +int(0) - i +int(0) .. i +int(0) == i +int(0) > 1.0 > 1 +int(0) ^ i +int(0) | mean(i) +int(0) | median(array) +int(0)..i +int(1 % 1) +int(1 * 0) +int(1 * 1.0) +int(1 ** 1.0) int(1 ** i) -int(1 + 1) -int(1 + f32) int(1 + f64) -int(1 + i32) -int(1 - 0.5) -int(1 - f32) +int(1 - 1.0) int(1 - f64) -int(1 - i32) -int(1 - i64) -int(1 / 0.5) -int(1 / 1) -int(1 ^ 0.5) -int(1 ^ i64) -int(1) != i64 -int(1) ** f32 -int(1) ** i32 -int(1) + f32 -int(1) + i64 -int(1) + reduce(array, #) -int(1) - i -int(1) < f64 -int(1) < i64 * 0.5 -int(1) == i32 +int(1 - i) +int(1 / 1.0) +int(1 / f64) +int(1 ^ 0) +int(1 ^ 1.0) +int(1 | max(i)) +int(1) != i +int(1) <= f64 +int(1) == f64 +int(1) == i int(1) ^ f64 -int(abs(0.5)) +int(1) not in array +int(1.0 * 1) +int(1.0 * 1.0) +int(1.0 * f64) +int(1.0 ** 0) +int(1.0 ** 1.0) +int(1.0 ** f64) +int(1.0 + 0) +int(1.0 + 1) +int(1.0 - 1) +int(1.0 / 0) +int(1.0 / 1) +int(1.0 / 1.0) +int(1.0 ^ 1) +int(1.0 ^ 1.0) +int(1.0 ^ f64) +int(1.0 ^ i) +int(1.0 | min(f64)) +int(1.0) +int(1.0) != 1.0 ^ i +int(1.0) != f64 +int(1.0) != i +int(1.0) * i +int(1.0) ** f64 +int(1.0) / i +int(1.0) == f64 +int(1.0) == i +int(1.0) >= f64 +int(1.0) in array +int(1.0) | median(array) +int(1.0)..i +int(abs(0)) int(abs(1)) int(abs(f64)) int(abs(i)) -int(abs(i32)) -int(abs(i64)) -int(add(1, 1)) -int(array[i64]) +int(array | min(1.0)) +int(array | reduce(#)) +int(array | reduce(#index)) +int(array | sum(#)) +int(array?.[1]) +int(array?.[i]) +int(bitnot(0)) int(bitnot(1)) -int(bitnot(i32)) -int(bitnot(i64)) -int(bitshl(1, i)) -int(bitxor(1, i32) + i) -int(bitxor(i32, i)) -int(ceil(0.5)) +int(bitnot(i)) +int(bitshr(0, i)) +int(ceil($env?.i)) +int(ceil(0)) int(ceil(1)) -int(ceil(f32)) -int(ceil(half(1))) +int(ceil(f64)) int(ceil(i)) -int(ceil(i32)) -int(count(array, ok)) +int(count($env, true)) int(count(list, false)) -int(f32 * 1) -int(f32 * i) -int(f32 ** 0.5) -int(f32 ** i64) -int(f32 + f32) -int(f32 - 0.5) -int(f32 - i64) -int(f32 / 0.5) -int(f32 / 1) -int(f32 / f64) -int(f32 / i32) -int(f32 / i64) -int(f32 ^ f32) -int(f32 ^ i32) -int(f32) -int(f32) != i -int(f32) != i64 -int(f32) ** f64 -int(f32) + i32 -int(f32) - f32 -int(f32) < i -int(f32) <= i32 -int(f32) == i ? list : add -int(f64 * 0.5) +int(count(list, ok)) +int(f64 * 0) +int(f64 * 1) +int(f64 * 1.0) +int(f64 * f64) int(f64 ** 1) int(f64 ** i) -int(f64 ** i32) -int(f64 + 0.5) -int(f64 + 1) int(f64 + i) -int(f64 - 0.5) -int(f64 - f32) -int(f64 / 0.5) -int(f64 / i64) -int(f64 ^ 0.5) -int(f64 ^ 1) -int(f64 ^ f64) -int(f64 ^ i64) +int(f64 - 0) +int(f64 - 1) +int(f64 - 1.0) +int(f64 - i) +int(f64 / 0) +int(f64 ^ 0) +int(f64 ^ i) +int(f64 | mean(i)) +int(f64 | min(1.0)) int(f64) -int(f64) % i64 -int(f64) * f64 -int(f64) + f64 -int(f64) < i32 -int(f64) == f32 -int(f64) == f64 -int(f64) > i -int(f64) > i64 -int(false ? 0.5 : 0.5) -int(false ? i : 0.5) -int(findIndex(list, ok)) -int(findLastIndex(list, ok)) -int(first(array)) -int(float(0.5)) +int(f64) <= ceil(1.0) +int(f64) <= f64 +int(f64) == i +int(f64) in array +int(findLast(array, true)) +int(findLastIndex($env, ok)) +int(float(0)) int(float(1)) -int(float(f32)) +int(float(1.0)) int(float(f64)) -int(float(i32 ** i)) -int(float(i32)) +int(float(i)) +int(floor(1.0)) int(floor(f64)) int(floor(i)) -int(floor(i32)) -int(get(array, i64)) -int(half(0.5)) -int(half(1)) -int(half(f64)) -int(i % 1) -int(i % i32) -int(i % i64) -int(i * 0.5) -int(i * 1) -int(i * f64) -int(i ** f32) -int(i ** f64) -int(i ** i64) -int(i + f32) -int(i + f64) -int(i + i) -int(i - 0.5) -int(i - f32) -int(i - i32) -int(i - i64) -int(i / 0.5) -int(i / 1) -int(i / i) -int(i / i32) -int(i ^ 0.5) -int(i ^ 1) -int(i ^ i32) +int(i % i) +int(i ** 1) +int(i ** 1.0) +int(i ** i) +int(i + 0) +int(i + 1) +int(i + 1.0) +int(i - 1) +int(i - 1.0) +int(i - i) +int(i / 1.0) +int(i | bitxor(1)) int(i) -int(i) != i32 -int(i) * f64 -int(i) * i64 -int(i) - i -int(i) .. i64 -int(i32 * 0.5) -int(i32 * 1) -int(i32 * i64) -int(i32 ** 0.5) -int(i32 ** 1) -int(i32 + 0.5) -int(i32 + 1) -int(i32 + f64) -int(i32 + i64) -int(i32 - 1) -int(i32 - i) -int(i32 / 0.5) -int(i32 / 1) -int(i32 / f64) -int(i32 ^ 0.5) -int(i32 ^ f64) -int(i32 ^ i32) -int(i32) -int(i32) != f32 -int(i32) - i -int(i32) / f32 -int(i32) / i -int(i32) / i64 -int(i32) < i64 -int(i32) > half(0.5) -int(i64 * 1) -int(i64 ** 0.5) -int(i64 ** f64) -int(i64 ** i64) -int(i64 + i) -int(i64 + i32) -int(i64 - 0.5) -int(i64 - f32) -int(i64 - i) -int(i64 - i64) -int(i64 / 1) -int(i64 ^ f64) -int(i64 ^ i32) -int(i64 ^ i64) -int(i64) -int(i64) != i64 -int(i64) - i64 -int(i64) .. i32 -int(i64) / i -int(i64) <= i -int(i64) == f32 -int(i64) > i64 -int(i64) ^ i -int(int(0.5)) +int(i) != f64 +int(i) * i +int(i) .. i +int(i) < i +int(i) == sum(array) +int(i) | min(array) +int(if true { 1.0 } else { $env }) +int(int(0)) int(int(1)) -int(int(f64)) -int(len("bar")) +int(int(1.0)) +int(int(i)) +int(last(array)) +int(len($env)) +int(len(0 .. i)) int(len(array)) -int(max(0.5)) -int(max(0.5, i64)) -int(max(1)) -int(max(f32)) +int(len(list)) +int(let foobar = 1.0; foobar) +int(list | findLastIndex(ok)) +int(list | reduce(#index)) +int(list | reduce(0)) +int(list | reduce(1.0)) +int(list | sum(f64)) +int(max(0)) +int(max(1.0)) +int(max(array)) int(max(f64)) int(max(i)) -int(max(i64)) +int(mean(0)) +int(mean(1)) +int(mean(1.0)) +int(mean(1.0, f64)) int(mean(array)) -int(min(0.5)) +int(median(0)) +int(median(1)) +int(median(1.0)) +int(median(array)) +int(median(f64)) +int(median(i)) +int(min(0)) int(min(1)) -int(min(1, i64)) -int(min(f32)) +int(min(1.0)) +int(min(array)) int(min(i)) -int(min(i32)) -int(min(i64)) -int(ok ? i : div) -int(ok ? i : i64) -int(ok ? i64 : list) -int(reduce(array, #)) -int(reduce(array, f32)) -int(reduce(array, i32)) -int(reduce(list, 0.5)) -int(reduce(list, 1)) -int(reduce(list, i64)) -int(round(0.5)) +int(ok ? 1.0 : greet) +int(ok ? f64 : list) +int(reduce(list, 1.0)) int(round(1)) -int(round(f32)) +int(round(1.0)) int(round(f64)) int(round(i)) -int(score(1)) -int(score(1, i)) -int(score(i)) -int(string(1)) -int(string(i)) -int(string(i32)) -int(string(i64)) +int(string(0)) +int(string(1.0)) +int(sum($env, i)) int(sum(array)) -int(toJSON(i)) -int(toJSON(i32)) -int(toJSON(i64)) -int(true ? 1 : foo) -int(true ? f64 : greet) -join(map(array, "foo")) -join(map(list, "foo")) -keys(groupBy(array, "foo")) -keys(groupBy(array, # ** 0.5)) -keys(groupBy(array, #)) -keys(groupBy(array, f32 != f64)) -keys(groupBy(array, foo)) -keys(groupBy(array, i32)) -keys(groupBy(array, ok)) -keys(groupBy(list, "bar")) +int(sum(array, #)) +int(sum(array, f64)) +int(toJSON(0)) +int(toJSON(1)) +int(toJSON(1.0)) +int(toPairs($env) | reduce(i)) +int(true ? 1.0 : $env) +int(true ? f64 : foo) +join([str]) +join(array | map(str)) +join(keys($env)) +join(map(list, #.Bar)) +join(sort($env)) +keys($env) != array +keys($env) == nil && true +keys($env) | count(true) +keys($env) | find(false) +keys($env) | groupBy(#) +keys($env) | groupBy($env?.i) +keys($env) | map(#) +keys($env) | map(1) +keys($env) | map(1.0) +keys($env) | map(add) +keys($env) | map(f64) +keys($env) | map(str) +keys($env) | reduce(#) +keys($env) | reduce(1.0) +keys($env) | reduce(ok) +keys($env) | sortBy(str) +keys($env)?.[i] +keys(array | reduce($env)) keys(groupBy(list, #)) -keys(groupBy(list, false)) -keys(groupBy(list, i32)) -keys({"bar": 1}) -keys({"bar": array, "foo": "bar"}) -keys({"bar": f32}) -keys({"foo": array, "bar": f64}) -keys({"foo": array}) +keys(groupBy(list, foo)) +keys(max($env)) +keys(min($env)) +keys(reduce(list, $env)) +keys({foo: $env}) +keys({foo: 0}) +keys({foo: 1, foo: 0}) +keys({foo: 1, foo: false}) +keys({foo: 1.0}) +keys({foo: 1}) +keys({foo: add}) +keys({foo: array}) +keys({foo: f64}) +keys({foo: false}) +keys({foo: foo, foo: 0}) +keys({foo: foo, foo: 1.0}) +keys({foo: foo}) +keys({foo: greet}) +keys({foo: i, foo: true}) +keys({foo: i}) +keys({foo: nil}) +keys({foo: ok}) +keys({foo: str}) +keys({foo: true, foo: list}) +keys({foo: true}) +last($env | map(#index)) +last($env | map(1)) +last($env | map(add)) +last($env | map(foo)) +last($env | map(greet)) +last($env) == i +last($env) == ok +last($env) contains foo.Bar +last($env) in array +last($env) not contains foo.Bar +last($env) not in array +last($env) startsWith str +last($env)?.Bar +last($env)?.Bar() +last($env)?.Bar()?.foo +last($env)?.Bar(foobar) +last($env)?.Bar?.[i] +last($env)?.Bar?.greet +last($env)?.String +last($env)?.String() +last($env)?.String().add +last($env)?.[add] +last($env)?.[array] +last($env)?.[array].i +last($env)?.[f64] +last($env)?.[f64]?.f64(foobar, greet) +last($env)?.[f64]?.foo() +last($env)?.[foo] +last($env)?.[foo].Bar +last($env)?.[foo]?.foo +last($env)?.[greet] +last($env)?.[greet]?.[i] +last($env)?.[greet]?.[ok] +last($env)?.[i] +last($env)?.[list] +last($env)?.[list].greet +last($env)?.[ok] +last($env)?.[ok] != i +last($env)?.[ok].ok() +last($env)?.[str] +last($env)?.[str]?.[foo] +last($env)?.[str]?.i +last($env)?.add +last($env)?.add() +last($env)?.add(f64) +last($env)?.add.add() +last($env)?.add.i +last($env)?.add?.[ok] +last($env)?.array +last($env)?.array() +last($env)?.array.list() +last($env)?.f64 +last($env)?.f64() +last($env)?.f64(greet(foobar)) +last($env)?.f64(list) +last($env)?.f64?.[list] +last($env)?.findLast(foo, foobar) +last($env)?.foo +last($env)?.foo() +last($env)?.foo(String, foobar?.greet) +last($env)?.foo?.[foo] +last($env)?.foo?.[greet] +last($env)?.greet +last($env)?.greet() +last($env)?.greet?.i +last($env)?.i +last($env)?.i() +last($env)?.i.foo +last($env)?.i?.greet +last($env)?.i?.i +last($env)?.list +last($env)?.list() +last($env)?.list.array +last($env)?.none(foobar)?.String() +last($env)?.ok +last($env)?.ok() +last($env)?.str +last($env)?.str() +last($env)?.str(foobar) +last($env)?.str?.[list] +last($env)?.toJSON(str) +last($env.array) +last($env.list) +last($env?.$env) +last($env?.Bar) +last($env?.Bar)?.[add] +last($env?.Bar)?.[f64] +last($env?.Bar)?.[ok] +last($env?.Bar)?.add() +last($env?.Bar?.String) +last($env?.Bar?.[list]) +last($env?.Bar?.[ok]) +last($env?.String) +last($env?.String?.[add]) +last($env?.[Bar]) +last($env?.[Bar]?.[str]) +last($env?.[Bar]?.array) +last($env?.[String]) +last($env?.[String])?.Bar +last($env?.[String])?.[add] +last($env?.[String])?.[foo] +last($env?.[String]?.[foo]) +last($env?.[foobar]) +last($env?.[foobar])?.[f64] +last($env?.[foobar])?.f64() +last($env?.[foobar]?.str) +last($env?.[nil]) +last($env?.[str]) +last($env?.array) +last($env?.false) +last($env?.foobar) +last($env?.foobar)?.ok +last($env?.foobar?.[greet]) +last($env?.list) +last($env?.nil) +last($env?.true) +last(0 .. 0) +last(0 .. 1) +last(1 .. 0) last(1 .. 1) last(1 .. i) -last([0.5]) -last([f32, list]) -last([list, list]) +last([$env, true]) +last([$env]) +last([$env]).i +last([0]) +last([1, 0]) +last([1, nil]) +last([1.0]) +last([1]) +last([add]) +last([array, 0]) +last([array]) +last([f64]) +last([false, 0]) +last([false]) +last([foo, str]) +last([foo]) +last([greet]) +last([i]) +last([list]) +last([nil]) +last([ok]) +last([str]) +last(array | map(f64)) +last(array | map(false)) +last(array | reduce(#acc)) last(array) -last(array) != int(i64) -last(array) + f64 -last(array) - f32 -last(array) - i64 -last(array) .. i32 -last(array) / f32 -last(array) <= i32 -last(array) == f32 -last(array) > f32 * i64 -last(array) >= f64 -last(false ? "foo" : true) -last(false ? 0.5 : "bar") -last(false ? 1 : foo)?.div -last(false ? div : score) -last(false ? f64 : false) -last(filter(array, false)) -last(filter(array, ok)) +last(array) != i +last(array) % i +last(array) >= i +last(false ? $env : $env) +last(false ? $env : greet) +last(false ? add : greet) +last(false ? false : 1) +last(false ? foo : greet) +last(false ?: $env) +last(false ?: add) +last(filter($env, false)) +last(filter(array, true)) last(filter(list, true)) -last(groupBy(array, foo).Qux) -last(groupBy(array, i32).Qux) -last(groupBy(list, #).list) -last(groupBy(list, #)?.Qux) -last(groupBy(list, #)?.ok) -last(i32 .. 1) -last(i32 .. i64) -last(i64 .. 1) +last(first($env)) +last(flatten(array)) +last(flatten(list)) +last(groupBy(list, f64)?.[ok]) +last(if ok { false } else { $env }) +last(if ok { foo } else { true }) +last(if ok { list } else { $env }) +last(if true { $env } else { 1.0 }) +last(if true { 1.0 } else { 1 }) +last(if true { add } else { ok }) +last(if true { list } else { array }) +last(keys($env)) +last(last($env)) +last(last($env)?.[list]) +last(list | map(foo)) +last(list | map(greet)) +last(list | map(ok)) +last(list | map(str)) +last(list | reduce(array)) +last(list | sortBy(0)) last(list) +last(list) == foo last(list).Bar -last(list).Qux last(list).String last(list).String() last(list)?.Bar -last(list)?.Qux last(list)?.String last(list)?.String() -last(list[1:i64]) +last(list[1:]) +last(map($env, $env)) +last(map($env, f64)) +last(map($env, foo)) last(map(array, #)) -last(map(array, 1)) -last(map(array, array)) -last(map(array, foo)) -last(map(array, i)) -last(map(list, "foo")) +last(map(array, false)) last(map(list, #)) -last(map(list, 1)) -last(map(list, false)) -last(map(list, half)) -last(map(list, i32)) -last(map(list, i64)) -last(map(list, ok)) -last(ok ? "bar" : true) -last(ok ? "foo" : f64) -last(ok ? 0.5 : "foo") -last(ok ? 0.5 : list) -last(ok ? 1 : add) -last(ok ? 1 : half) -last(ok ? array : array) -last(ok ? array : ok) -last(ok ? f32 : 0.5) -last(ok ? greet : 1) -last(ok ? i32 : array) -last(ok ? i64 : add) -last(ok ? ok : 0.5) -last(reduce(array, list)) -last(reduce(list, array)) +last(map(list, 1.0)) +last(map(list, i)) +last(max($env)) +last(max($env?.Bar)) +last(max(0, array)) +last(max(array)) +last(mean(array)) +last(median(array)) +last(median(i, array)) +last(min($env)) +last(min(array)) +last(min(array, 1.0)) +last(min(if true { $env } else { f64 })) +last(reduce(list, #acc)) +last(reduce(list, list, foo)) +last(reverse(array)) +last(reverse(list)) +last(sort($env)) last(sort(array)) -last(true ? "bar" : half) -last(true ? add : list) -last(true ? foo : 1) -last(true ? greet : true) -last(true ? ok : 1) -len("bar") ** i64 -len("bar") + i64 - i64 -len("bar") / i64 -len("bar") >= i -len("bar") in array -len("foo") ** i32 -len("foo") ** i64 -len("foo") - i -len("foo") - i32 -len("foo") >= i -len(1 .. 1) -len([f32]) +last(sortBy(array, 0)) +last(toPairs($env)) +last(true ? 1.0 : greet) +last(true ? array : 0) +last(true ? foo : array) +last(true ? list : 1) +last(true ? str : 1.0) +last(uniq(array)) +last(uniq(list)) +last(values($env)) +last({foo: $env}?.foobar?.add) +last({foo: f64, foo: str}.foo) +last({foo: foo, foo: 1}?.[str]) +last({foo: foo}.greet) +lastIndexOf(str, str) +len($env | filter(ok)) +len($env | map(1.0)) +len($env | map(foo)) +len($env | map(i)) +len($env | map(true)) +len($env) != f64 +len($env) ** int(f64) +len($env) + i +len($env) ^ 1.0 < f64 +len($env) ^ max(f64) +len($env) ^ min(f64) +len($env.array) +len($env.list) +len($env.str) +len($env?.[str]) +len($env?.array) +len($env?.list) +len($env?.str) +len(0 .. 0) +len(0 .. i) +len(1 .. 0) +len([$env, 1.0]) +len([$env]) +len([0, str]) +len([1.0]) +len([1]) +len([add, i]) +len([add]) +len([f64, 0]) +len([f64]) +len([false]) +len([foo, 1]) +len([foo, foo]) +len([foo, i]) len([foo]) -len([half]) +len([greet]) +len([list, f64]) +len([list]) +len([nil, foo, add]) +len([nil, nil]) +len([nil]) +len([ok]) +len([str]) +len([true]) +len(array | filter(false)) +len(array | groupBy(1)) +len(array | groupBy(true)) +len(array | map(#)) +len(array | sortBy(#)) len(array) -len(array) != f32 -len(array) + i64 -len(array) < f64 -len(array) <= i32 -len(array) == f32 -len(array) >= f64 -len(array) ^ i32 -len(array) not in array -len(filter(list, false)) -len(filter(list, ok)) +len(array) * i +len(array) - i +len(array) == nil && false +len(array) > findIndex(list, true) +len(array[1:]) +len(array[:0]) +len(array[:1]) +len(array[:i]) +len(concat(array)) +len(concat(list)) +len(filter($env, ok)) +len(flatten(array)) +len(flatten(list)) +len(flatten(map($env, $env))) len(foo.Bar) len(foo.String()) len(foo?.Bar) -len(foo?.Qux("bar")) len(foo?.String()) -len(greet("bar")) -len(greet("foo")) -len(groupBy(array, #)) -len(groupBy(array, 0.5)) -len(groupBy(array, f32)) -len(groupBy(array, false)) -len(groupBy(array, i64)) -len(groupBy(array, true)) +len(greet(greet(str))) +len(greet(str)) +len(groupBy(array, 1.0)) +len(groupBy(array, f64)) +len(groupBy(array, foo)) +len(groupBy(array, i)) len(groupBy(list, #)) -len(groupBy(list, #).ok) -len(groupBy(list, 0.5)) -len(groupBy(list, false)) -len(groupBy(list, foo).list) -len(groupBy(list, i32)) -len(groupBy(list, i64)) -len(i64 .. 1) -len(i64 .. i) +len(groupBy(list, foo)) +len(if true { str } else { nil }) +len(keys($env)) +len(list | filter(false)) +len(list | filter(true)) +len(list | groupBy(#)) +len(list | groupBy(str)) +len(list | map(#.String)) +len(list | map($env)) +len(list | map(1)) +len(list | map(1.0)) +len(list | map(str)) +len(list | reduce(#.Bar)) len(list) -len(list) % i32 -len(list) % i64 -len(list) .. i64 -len(list) / i32 -len(list) <= i +len(list) % i +len(list) ** i +len(list) == f64 len(list) > i len(list) ^ f64 -len(list[1:i]) -len(lower("bar")) -len(lower("foo")) -len(map(array, "bar")) +len(list)..i +len(list[:]) +len(lower(str)) +len(map($env, 1)) +len(map($env, 1.0)) +len(map($env, array)) +len(map($env, f64)) +len(map($env, foo)) +len(map($env, str)) len(map(array, #)) -len(map(array, add)) -len(map(array, f32)) -len(map(array, greet)) -len(map(array, i)) -len(map(array, list)[i64]) -len(map(array, score)) +len(map(array, $env)) +len(map(array, 1)) +len(map(array, foo)) len(map(list, #)) -len(map(list, 1)) -len(map(list, f32)) len(map(list, f64)) -len(map(list, foo)) -len(map(list, i64)) -len(map(list, ok)) -len(map(list, true)) -len(ok ? list : score) -len(sort(array)) -len(string("bar")) -len(string("foo")) -len(string(0.5)) +len(max($env)) +len(min($env)) +len(reduce(array, $env)) +len(reduce(array, array)) +len(reduce(list, $env, foo)) +len(reverse(array)) +len(sort($env)) +len(sortBy(list, #.Bar)) +len(sortBy(list, .Bar)) +len(sortBy(list, 1)) +len(str) +len(str) + 1.0 - i +len(str) .. 0 | find($env) +len(str) .. i +len(str) == i +len(str) >= f64 +len(str) | bitnand(1) +len(str) | bitor(1) +len(str) | mean(i) +len(str) | median(1.0) +len(str) | min(1.0) +len(str[0:]) +len(str[1:]) +len(str[:1]) +len(string($env)) len(string(1)) -len(string(add)) -len(string(f64)) +len(string(1.0)) +len(string(array)) +len(string(false)) len(string(foo)) -len(string(half)) +len(string(greet)) len(string(i)) -len(string(i32)) -len(string(i64)) len(string(list)) len(string(nil)) -len(string(score)) -len(string(string(list))) -len(toJSON("bar")) -len(toJSON("foo")) -len(toJSON(0.5)) +len(string(ok)) +len(toBase64(str)) +len(toJSON(0)) len(toJSON(1)) -len(toJSON(array)) -len(toJSON(f32)) len(toJSON(false)) -len(toJSON(i)) -len(toJSON(i32)) +len(toJSON(foo)) len(toJSON(list)) len(toJSON(nil)) len(toJSON(ok)) +len(toJSON(str)) len(toJSON(true)) -len(trim("foo")) -len(trimPrefix("foo")) -len(trimSuffix("bar")) -len(type("foo")) -len(type(0.5)) +len(toPairs($env)) +len(trim(str)) +len(trimPrefix(str)) +len(trimSuffix(str)) +len(type($env)) +len(type(0)) len(type(1)) +len(type(1.0)) len(type(add)) len(type(array)) -len(type(div)) -len(type(half)) +len(type(foo)) +len(type(greet)) len(type(i)) -len(type(i32)) -len(type(i64)) len(type(list)) len(type(nil)) -len(type(ok)) -len(type(score)) -len(upper("bar")) -len(upper("foo")) -len({"bar": array}) -len({"bar": f64}) -len({"bar": score}) -len({"foo": 1}) -len({"foo": add, "foo": "foo"}) -len({"foo": i64}) +len(type(str)) +len(type(true)) +len(uniq(array)) +len(uniq(list)) +len(upper(str)) +len(values($env)) +len({foo: $env, foo: $env}) +len({foo: $env}) +len({foo: 0}) +len({foo: 1, foo: false}) +len({foo: 1.0, foo: f64}) +len({foo: 1.0}) +len({foo: 1}) +len({foo: add}) +len({foo: array, foo: 1.0}) +len({foo: array, foo: str}) +len({foo: array}) +len({foo: f64}) +len({foo: false}) +len({foo: foo, foo: 1.0}) +len({foo: foo, foo: foo}) +len({foo: foo, foo: nil}) +len({foo: foo}) +len({foo: greet, foo: str}) +len({foo: i, foo: $env}) +len({foo: i}) +len({foo: list}) +len({foo: nil}) +len({foo: ok, foo: $env}) +len({foo: ok}) +len({foo: str, foo: str}) +len({foo: str}) +len({foo: true}) +let foobar = $env not in array; foobar +let foobar = $env.f64; i < foobar +let foobar = $env.list; foobar +let foobar = $env.str; foobar +let foobar = $env; foobar == foobar +let foobar = $env; foobar.Bar +let foobar = $env; foobar.String +let foobar = $env; foobar.add +let foobar = $env; foobar.greet +let foobar = $env; foobar.ok +let foobar = $env; foobar.str +let foobar = $env; foobar?.[str] +let foobar = $env; foobar?.add +let foobar = $env; foobar?.foobar +let foobar = $env; foobar?.greet +let foobar = $env; foobar?.i +let foobar = $env; foobar?.list +let foobar = $env; foobar?.str +let foobar = $env?.[Bar]; foobar?.list +let foobar = $env?.[String]; foobar +let foobar = $env?.[String]; foobar?.[str] +let foobar = $env?.f64; foobar > foobar +let foobar = 0 + f64; foobar +let foobar = 0; foobar <= foobar +let foobar = 1 * 1.0; foobar +let foobar = 1.0 != 1.0; foobar +let foobar = 1.0; foobar * foobar +let foobar = 1; foobar % foobar +let foobar = 1; foobar < float(foobar) +let foobar = add; $env != foobar +let foobar = add; foobar +let foobar = array | sortBy(1.0); foobar +let foobar = array; foobar +let foobar = array; foobar?.[0] +let foobar = array; foobar?.[i] +let foobar = array?.[i]; f64 + foobar +let foobar = f64; foobar +let foobar = f64; foobar ** f64 +let foobar = f64; foobar + foobar +let foobar = f64; foobar == foobar +let foobar = false; foobar != foobar +let foobar = foo != nil; foobar || false +let foobar = foo; foobar +let foobar = foo; foobar.Bar +let foobar = foo; foobar?.Bar +let foobar = foo; foobar?.String +let foobar = foo?.Bar; foobar +let foobar = foo?.String; foobar +let foobar = greet; foobar +let foobar = greet; {foo: foobar} +let foobar = i <= i; foobar +let foobar = i; 1.0 == foobar +let foobar = i; foobar +let foobar = i; foobar != 0 +let foobar = i; foobar ** foobar / foobar +let foobar = i; foobar == f64 +let foobar = i; foobar ^ foobar +let foobar = i; {foo: foobar, foo: nil} +let foobar = last(array); foobar +let foobar = list; foobar +let foobar = list; foobar != list +let foobar = list; foobar?.[i] +let foobar = list; reduce(foobar, foobar, $env) +let foobar = map($env, 1); foobar +let foobar = ok ? nil : $env; foobar?.Bar +let foobar = ok; foobar +let foobar = ok; foobar == foobar +let foobar = str != $env; foobar +let foobar = str != nil; foobar +let foobar = str; foobar +let foobar = str; {foo: foobar} +let foobar = sum(array); foobar +let foobar = toPairs($env); foobar +let foobar = trimSuffix(str); foobar +let foobar = {foo: 0}; foobar.ok list -list != 1 .. 1 -list != ["foo"] -list != [i, 0.5] -list != [i] +list != $env != false +list != $env ? list : i +list != $env or 1.0 > f64 +list != $env or false +list != $env or ok +list != $env.array +list != $env.list +list != $env?.Bar +list != $env?.String +list != $env?.[Bar] +list != $env?.[String] +list != $env?.[str] +list != $env?.array +list != $env?.foobar +list != $env?.list +list != $env?.nil +list != [0] list != array -list != filter(array, ok) -list != filter(array, true) +list != array and ok +list != array or false +list != array || $env +list != flatten(list) +list != i .. i +list != keys($env) list != list -list != list ? 0.5 : div -list != list ? half : div -list != map(array, #) -list != map(list, 1) -list != map(list, i64) -list != nil && i32 <= 1 -list != nil ? false : 1 -list != nil ? i : 1 -list != sort(array) -list == [div, nil] -list == [i] +list != list != ok +list != list && true +list != list and false +list != map(list, str) +list != min(array) +list != nil ? ok : 1.0 +list != nil ?: list +list != nil || false +list != reverse($env.list) +list != reverse(array) +list == $env == nil +list == $env == ok +list == $env and false +list == $env || $env +list == $env.array +list == $env.list +list == $env?.$env +list == $env?.Bar +list == $env?.String +list == $env?.[Bar] +list == $env?.[String] +list == $env?.[foobar?.list] +list == $env?.[foobar?.str()] +list == $env?.[foobar] +list == $env?.[nil] +list == $env?.[str] +list == $env?.array +list == $env?.foobar +list == $env?.list +list == 0 .. 1 +list == [0] +list == [false] +list == [foo] +list == [greet, 0] +list == [list] +list == [nil] +list == [str] list == array -list == array == nil +list == array ? nil : foo +list == array ?: list +list == array or ok +list == array[:i] +list == flatten(array) +list == keys($env) list == list -list == list != false -list == list ? i32 : i -list == map(list, #) -list == nil && ok -list == nil ? nil : "foo" -list == nil or f64 == f64 -list not in groupBy(list, #).i -list[-1] -list[-i32] -list[-i64] -list[-i] -list[1 - 1] -list[1] not in list -list[1].Bar -list[1].Qux -list[1].String -list[1].String() -list[1]?.Bar -list[1]?.Qux -list[1]?.String -list[1]?.String() -list[bitnot(i)] -list[bitshr(i32, i32)] -list[findIndex(array, true)] -list[first(array)] -list[i * i64] -list[i32:i32] -list[i32:i] -list[i32] -list[i32] in list -list[i32].Bar -list[i32].Qux -list[i32].String -list[i32]?.Bar -list[i32]?.Qux -list[i32]?.String -list[i32]?.String() -list[i64:i32 - i] -list[i64:i64] -list[i64] -list[i64] in list -list[i64].Bar -list[i64].Qux -list[i64].String -list[i64]?.Bar -list[i64]?.Qux -list[i64]?.String -list[i:i32] -list[i:i64] -list[i:i64] == nil != nil +list == list and true +list == map($env, str) +list == nil && false +list == nil == nil +list == nil ? add : $env +list == nil or $env +list == reverse(array) +list == toPairs($env) +list == values($env) +list in $env?.Bar +list in $env?.String +list in $env?.String?.f64 +list in $env?.[Bar] +list in $env?.[Bar]?.[array] +list in $env?.[String] +list in $env?.[foobar] +list in $env?.foobar +list in [$env, 1.0] +list in [$env, nil] +list in [nil, $env] +list in concat(list) +list in last($env) +list not in $env?.Bar +list not in $env?.String +list not in $env?.String?.[add] +list not in $env?.String?.add +list not in $env?.[Bar] +list not in $env?.[String] +list not in $env?.foobar +list not in [array, true] +list not in toPairs($env) +list | all(# == nil) +list | all($env | any(true)) +list | all(.Bar not in #) +list | all(0 == nil) +list | all(1.0 != f64) +list | all(false && $env) +list | all(false) +list | all(false) ?: f64 +list | all(list != array) +list | all(ok) +list | all(true) +list | any($env != #) +list | any($env != 1.0) +list | any($env == $env) +list | any(.Bar in foo) +list | any(false) +list | any(nil == i) +list | any(ok != nil) +list | any(ok) +list | any(true ?: nil) +list | any(true) +list | concat(array) +list | concat(list) +list | count(# != nil) +list | count($env == #) +list | count(1.0 != $env) +list | count(1.0 != nil) +list | count(false) +list | count(false) | bitxor(i) +list | count(ok) +list | count(true != true) +list | count(true and false) +list | count(true) +list | filter(# == #) +list | filter(false) +list | filter(i <= 1) +list | filter(list == $env) +list | filter(nil != #.String) +list | filter(ok == nil) +list | filter(ok) +list | filter(ok) | sum(1.0) +list | filter(str not startsWith .Bar) +list | filter(true) +list | filter(true) | groupBy(ok) +list | filter(true) | sum(1.0) +list | find(# != $env) +list | find(# == #) +list | find(# == $env) +list | find(0 < 0) +list | find(1.0 > 0) +list | find(array | one(true)) +list | find(f64 > 1.0) +list | find(false) +list | find(foo == #) +list | find(foo == foo) +list | find(nil != $env?.f64) +list | find(nil != foo) +list | find(nil == foo) +list | find(ok) +list | find(true) +list | findIndex(# != #) +list | findIndex(# != foo) +list | findIndex(false && $env) +list | findIndex(false) +list | findIndex(nil == .Bar) +list | findIndex(ok == true) +list | findIndex(ok) +list | findIndex(true == ok) +list | findIndex(true) +list | findLast($env == $env) +list | findLast($env == 0) +list | findLast($env.ok) +list | findLast(.Bar in foo) +list | findLast(1.0 <= 1) +list | findLast(f64 < 0) +list | findLast(false) +list | findLast(nil != str) +list | findLast(ok) +list | findLast(true) +list | findLastIndex(# == #) +list | findLastIndex(# == $env) +list | findLastIndex($env != nil) +list | findLastIndex(array == $env) +list | findLastIndex(false or true) +list | findLastIndex(false) +list | findLastIndex(foo == #) +list | findLastIndex(greet != $env) +list | findLastIndex(nil not in list) +list | findLastIndex(ok) +list | findLastIndex(true) +list | get(0) +list | get(1) +list | get(i) +list | groupBy(# != nil) +list | groupBy(#) +list | groupBy(#.Bar) +list | groupBy($env?.f64) +list | groupBy(.Bar) +list | groupBy(0 > i) +list | groupBy(0) +list | groupBy(1 / 1.0) +list | groupBy(1) +list | groupBy(1.0 >= 1.0) +list | groupBy(1.0 in array) +list | groupBy(1.0) +list | groupBy(f64 + 1) +list | groupBy(f64) +list | groupBy(false && $env) +list | groupBy(false) +list | groupBy(foo) +list | groupBy(i) +list | groupBy(i) | get(true) +list | groupBy(list?.[i]) +list | groupBy(ok) +list | groupBy(ok) | get(str) +list | groupBy(str) +list | groupBy(string(#)) +list | groupBy(string(str)) +list | groupBy(toJSON(array)) +list | groupBy(true && ok) +list | groupBy(true && true) +list | groupBy(true) +list | map(# != foo) +list | map(#) +list | map(#) == array +list | map(#) | all(true) +list | map(#) | findIndex(false) +list | map(#) | get(0) +list | map(#) | map(#) +list | map(#) | one(false) +list | map(#) | reduce(#) +list | map(#.Bar) +list | map(#.Bar) | reduce(#, nil) +list | map(#.String()) +list | map(#.String) +list | map(#index) +list | map($env) +list | map($env) == list +list | map($env) | all(#.ok) +list | map($env) | all(.ok) +list | map($env) | any(true) +list | map($env) | findLastIndex(#.ok) +list | map($env) | groupBy(0) +list | map($env) | map(#.i) +list | map($env) | map(.ok) +list | map($env) | reduce(str) +list | map($env?.Bar) +list | map($env?.String) +list | map($env?.[Bar]) +list | map($env?.[String]) +list | map($env?.f64) +list | map($env?.list) +list | map($env?.str) +list | map(.Bar) +list | map(.String) +list | map(.String) == array +list | map(0) +list | map(0) | map(array) +list | map(1 > 1) +list | map(1) +list | map(1.0 * f64) +list | map(1.0) +list | map(1.0) | any(true) +list | map(1.0) | map(str) +list | map(1.0) | reduce(1.0) +list | map([.Bar, str]) +list | map(add) +list | map(array == nil) +list | map(array) +list | map(array) == array +list | map(bitnot(i)) +list | map(f64) +list | map(f64) | sum(#) +list | map(false) +list | map(false) | map(#) +list | map(false) | sum(f64) +list | map(foo == #) +list | map(foo == $env) +list | map(foo) +list | map(foo) | groupBy(#) +list | map(foo) | groupBy(true) +list | map(foo) | reduce(#acc) +list | map(foo.Bar) +list | map(foo?.String) +list | map(get($env, str)) +list | map(greet) +list | map(greet) != array +list | map(greet) | sortBy(i) +list | map(i != 1.0) +list | map(i / f64) +list | map(i) +list | map(if true { 1.0 } else { # }) +list | map(let foobar = str; foobar) +list | map(list) +list | map(list) | none(ok) +list | map(nil != 1) +list | map(ok) +list | map(ok) | reduce(1.0, 0) +list | map(sortBy(array, #)) +list | map(str) +list | map(str) | groupBy(foo) +list | map(str) | sortBy(f64) +list | map(true || ok) +list | map(true) +list | map(true) | find(true) +list | map(type(#)) +list | none(# != #) +list | none(# == $env) +list | none(#.Bar in foo) +list | none($env != $env) +list | none($env == #) +list | none($env?.ok) +list | none(1.0 <= 1) +list | none(f64 <= f64) +list | none(false) +list | none(false) || ok +list | none(foo != #) +list | none(foo == #) +list | none(i == 0) +list | none(list | any(ok)) +list | none(nil == add) +list | none(ok) +list | none(true) +list | one(# != foo) +list | one(# != nil) +list | one($env == $env) +list | one($env == false) +list | one(.Bar not endsWith str) +list | one(0 != 1.0) +list | one(add == nil) +list | one(false) +list | one(i == i) +list | one(ok ?: 0) +list | one(ok) +list | one(str == str) +list | one(true) +list | reduce(#) +list | reduce(#, $env) +list | reduce(#, 0) +list | reduce(#, 1) +list | reduce(#, 1.0) +list | reduce(#, add) +list | reduce(#, array) +list | reduce(#, f64) +list | reduce(#, false) +list | reduce(#, foo) +list | reduce(#, greet) +list | reduce(#, i) +list | reduce(#, list) +list | reduce(#, nil) +list | reduce(#, ok) +list | reduce(#, str) +list | reduce(#, true) +list | reduce(#.Bar) +list | reduce(#.Bar, $env) +list | reduce(#.Bar, 0) +list | reduce(#.Bar, 1) +list | reduce(#.Bar, array) +list | reduce(#.Bar, f64) +list | reduce(#.Bar, foo) +list | reduce(#.Bar, greet) +list | reduce(#.Bar, i) +list | reduce(#.Bar, list) +list | reduce(#.Bar, nil) +list | reduce(#.Bar, ok) +list | reduce(#.String == nil) +list | reduce(#.String) +list | reduce(#.String, $env) +list | reduce(#.String, 1) +list | reduce(#.String, f64) +list | reduce(#.String, i) +list | reduce(#.String, nil) +list | reduce(#.String, true) +list | reduce(#?.Bar) +list | reduce(#?.String) +list | reduce(#acc) +list | reduce(#acc, $env) +list | reduce(#acc, 1) +list | reduce(#acc, 1.0) +list | reduce(#acc, add) +list | reduce(#acc, f64) +list | reduce(#acc, foo) +list | reduce(#acc, nil) +list | reduce(#acc, str) +list | reduce(#acc, true) +list | reduce(#index - 0) +list | reduce(#index <= 1) +list | reduce(#index) +list | reduce(#index, $env) +list | reduce(#index, 1.0) +list | reduce(#index, false) +list | reduce(#index, foo) +list | reduce(#index, list) +list | reduce(#index, nil) +list | reduce($env != #) +list | reduce($env not in array) +list | reduce($env) +list | reduce($env, $env) +list | reduce($env, 1) +list | reduce($env, 1.0) +list | reduce($env, add) +list | reduce($env, f64) +list | reduce($env, foo) +list | reduce($env, greet) +list | reduce($env, i) +list | reduce($env, list) +list | reduce($env, nil) +list | reduce($env, ok) +list | reduce($env, str) +list | reduce($env, true) +list | reduce($env.i) +list | reduce($env?.String) +list | reduce($env?.[String]) +list | reduce($env?.[foobar]) +list | reduce($env?.[str]) +list | reduce($env?.add) +list | reduce($env?.greet, max(1)) +list | reduce(.Bar not in $env) +list | reduce(.Bar) +list | reduce(.Bar, 0) +list | reduce(.Bar, 1.0) +list | reduce(.Bar, i) +list | reduce(.Bar, nil) +list | reduce(.Bar, ok) +list | reduce(.Bar, true) +list | reduce(.String) +list | reduce(.String, $env) +list | reduce(.String, 0) +list | reduce(.String, 1.0) +list | reduce(.String, array) +list | reduce(.String, foo) +list | reduce(.String, greet) +list | reduce(.String, i) +list | reduce(.String, list) +list | reduce(.String, nil) +list | reduce(.String, ok) +list | reduce(0 == f64) +list | reduce(0) +list | reduce(0) ^ f64 +list | reduce(0) | median(1.0) +list | reduce(0, $env) +list | reduce(0, 1.0) +list | reduce(0, array) +list | reduce(0, false) +list | reduce(0, foo) +list | reduce(0, i) +list | reduce(0, list) +list | reduce(0, nil) +list | reduce(0, ok) +list | reduce(0, true) +list | reduce(1 ** #index) <= i +list | reduce(1) +list | reduce(1, $env) +list | reduce(1, 1) +list | reduce(1, 1.0) +list | reduce(1, add) +list | reduce(1, array) +list | reduce(1, false) +list | reduce(1, foo) +list | reduce(1, greet) +list | reduce(1, i) +list | reduce(1, list) +list | reduce(1, nil) +list | reduce(1, ok) +list | reduce(1, str) +list | reduce(1, true) +list | reduce(1.0 <= i) +list | reduce(1.0 == 0) +list | reduce(1.0) +list | reduce(1.0, $env) +list | reduce(1.0, 0) +list | reduce(1.0, 1) +list | reduce(1.0, array) +list | reduce(1.0, f64) +list | reduce(1.0, false) +list | reduce(1.0, foo) +list | reduce(1.0, greet) +list | reduce(1.0, i) +list | reduce(1.0, list) +list | reduce(1.0, nil) +list | reduce(1.0, str) +list | reduce(1.0, true) +list | reduce([ok, foo]) +list | reduce([true, #]) +list | reduce(add) +list | reduce(add, $env) +list | reduce(add, 1) +list | reduce(add, 1.0) +list | reduce(add, array) +list | reduce(add, f64) +list | reduce(add, false) +list | reduce(add, foo) +list | reduce(add, nil) +list | reduce(array) +list | reduce(array) | none(ok) +list | reduce(array) | reduce(array) +list | reduce(array, $env) +list | reduce(array, 0) +list | reduce(array, 1) +list | reduce(array, 1.0) +list | reduce(array, add) +list | reduce(array, array) +list | reduce(array, f64) +list | reduce(array, false) +list | reduce(array, foo) +list | reduce(array, greet) +list | reduce(array, i) +list | reduce(array, nil) +list | reduce(array, ok) +list | reduce(array, str) +list | reduce(f64 != nil) +list | reduce(f64 <= 1.0) +list | reduce(f64) +list | reduce(f64, $env) +list | reduce(f64, 0) +list | reduce(f64, 1.0) +list | reduce(f64, array) +list | reduce(f64, f64) +list | reduce(f64, false) +list | reduce(f64, foo) +list | reduce(f64, greet) +list | reduce(f64, list) +list | reduce(f64, nil) +list | reduce(f64, str) +list | reduce(false || $env) +list | reduce(false) +list | reduce(false, $env) +list | reduce(false, 1) +list | reduce(false, 1.0) +list | reduce(false, array) +list | reduce(false, f64) +list | reduce(false, false) +list | reduce(false, foo) +list | reduce(false, greet) +list | reduce(false, i) +list | reduce(false, ok) +list | reduce(false, true) +list | reduce(first($env)) +list | reduce(float(1.0)) +list | reduce(foo == foo) +list | reduce(foo) +list | reduce(foo, $env) +list | reduce(foo, $env.array) +list | reduce(foo, 0) +list | reduce(foo, 1) +list | reduce(foo, 1.0) +list | reduce(foo, add) +list | reduce(foo, array) +list | reduce(foo, f64) +list | reduce(foo, foo) +list | reduce(foo, greet) +list | reduce(foo, i) +list | reduce(foo, list) +list | reduce(foo, nil) +list | reduce(foo, ok) +list | reduce(foo, str) +list | reduce(foo, true) +list | reduce(foo.Bar) +list | reduce(greet) +list | reduce(greet, $env) +list | reduce(greet, 1.0) +list | reduce(greet, add) +list | reduce(greet, array) +list | reduce(greet, false) +list | reduce(greet, foo) +list | reduce(greet, greet) +list | reduce(greet, list) +list | reduce(greet, nil) +list | reduce(greet, str) +list | reduce(greet, true) +list | reduce(i ^ i) +list | reduce(i) +list | reduce(i, 0) +list | reduce(i, 1.0) +list | reduce(i, add) +list | reduce(i, false) +list | reduce(i, foo) +list | reduce(i, greet) +list | reduce(i, i) +list | reduce(i, list) != $env?.String +list | reduce(i, nil) +list | reduce(i, str) +list | reduce(list) +list | reduce(list) | groupBy(0) +list | reduce(list, $env) +list | reduce(list, 1.0) +list | reduce(list, add) +list | reduce(list, array) +list | reduce(list, foo) +list | reduce(list, greet) +list | reduce(list, i) +list | reduce(list, nil) +list | reduce(list, ok) +list | reduce(list, str) +list | reduce(ok and #acc) +list | reduce(ok) +list | reduce(ok, $env) +list | reduce(ok, add) +list | reduce(ok, false) +list | reduce(ok, foo) +list | reduce(ok, i) +list | reduce(ok, list) +list | reduce(ok, nil) +list | reduce(ok, ok) +list | reduce(reduce(list, .Bar), ok) +list | reduce(str) +list | reduce(str) >= foo.Bar +list | reduce(str) contains str +list | reduce(str, $env) +list | reduce(str, 0) +list | reduce(str, 1.0) +list | reduce(str, add) +list | reduce(str, array) +list | reduce(str, f64) +list | reduce(str, foo) +list | reduce(str, i) +list | reduce(str, list) +list | reduce(str, ok) +list | reduce(str, str) +list | reduce(trim(str)) +list | reduce(true and ok) +list | reduce(true) +list | reduce(true, 0) +list | reduce(true, array) +list | reduce(true, f64) +list | reduce(true, false) +list | reduce(true, foo) +list | reduce(true, i) +list | reduce(true, ok) +list | reduce(type(#)) +list | reduce(values($env)) +list | sortBy(#.Bar) +list | sortBy(#.String()) +list | sortBy(#?.Bar) +list | sortBy($env?.i) +list | sortBy(.Bar) +list | sortBy(0) +list | sortBy(1) +list | sortBy(1) | map(str) +list | sortBy(1.0 ** 0) +list | sortBy(1.0) +list | sortBy(1.0) | filter(false) +list | sortBy(1.0) | groupBy(true) +list | sortBy(1.0) | map(.String) +list | sortBy(1.0) | reduce($env) +list | sortBy(f64 ** 0) +list | sortBy(f64) +list | sortBy(f64) == array +list | sortBy(float(1)) +list | sortBy(greet(.Bar)) +list | sortBy(i) +list | sortBy(i) | groupBy(0) +list | sortBy(last(array)) +list | sortBy(str) +list | sortBy(str) | count(ok) +list | sum($env.i) +list | sum(0 - 1.0) +list | sum(0) +list | sum(0) != i +list | sum(0) >= 1.0 == false +list | sum(1) +list | sum(1) / 0 ** 1 +list | sum(1) | median(array) +list | sum(1.0) +list | sum(array | findLastIndex(true)) +list | sum(f64 * 1.0) +list | sum(f64) +list | sum(f64) in array +list | sum(i) +list | sum(int(i)) +list | take(0) +list | take(1) +list | take(1) | sum(0) +list | take(i) +list; $env.i +list; add +list; foo; $env.array +list; foo?.Bar +list; greet +list; list +list; nil == nil +list; nil; foo?.String +list; ok +list; str +list?.[$env.i] +list?.[0 % 1] +list?.[0] +list?.[0].Bar +list?.[0].String +list?.[0]?.Bar +list?.[0]?.String +list?.[1 + 0] +list?.[1] +list?.[1].Bar +list?.[1].String +list?.[1].String() +list?.[1]?.Bar +list?.[array?.[0]] +list?.[i] +list?.[i] != foo && $env +list?.[i] == foo +list?.[i] == nil && $env +list?.[i] not in list +list?.[i].Bar +list?.[i].String +list?.[i].String() +list?.[i]?.Bar +list?.[i]?.String +list?.[i]?.String() +list?.[max(i)] +list[$env.i:] +list[$env?.i:] +list[0:] | reduce(1.0) +list[0:] | reduce(str) +list[0:]?.[i] +list[1 + 0:] +list[1:] | findLast(true) +list[1:] | map(0) +list[1:] | map(ok) +list[1:] | reduce(foo) +list[:$env?.i] +list[:0 * 0] +list[:0] | findIndex(nil != foo) +list[:1] | groupBy(ok) +list[:] +list[:] | map(#index) +list[:]?.[i] +list[:bitnot(1)] +list[:i] +list[:i] | filter(true) +list[:i] | sum(f64) +list[:mean(i)] +list[:median(array)] +list[:min(i)] +list[:sum(array)] +list[add(1, 0):] +list[array?.[i]:] +list[i:] +list[i:] | groupBy(true) +list[i:] | sortBy(0) list[i:i] -list[i] -list[i].Bar -list[i].Qux -list[i].String -list[i].String() -list[i]?.Bar -list[i]?.Qux -list[i]?.String -list[i]?.String() -list[int(f32)] -list[int(f64)] -list[int(i)] -list[int(i64)] -list[max(i64, 1)] -list[min(i)] -list[min(i32)] -list[ok ? 1 : half] -list[score(1)] -list[score(i)] -lower("bar" + "bar") -lower("bar") == trimSuffix("bar") -lower("foo" + "bar") -lower(false ? foo : "bar") +list[int(1.0):] +list[min(array):] +lower($env | reduce(str, 1.0)) +lower($env.str) +lower($env?.[str]) +lower($env?.str) +lower(false ? array : str) lower(foo.Bar) lower(foo.String()) lower(foo?.Bar) lower(foo?.String()) -lower(greet("bar")) -lower(greet("foo")) -lower(lower("bar")) -lower(lower("foo")) -lower(reduce(array, "bar")) -lower(reduce(list, "bar")) -lower(string("foo")) -lower(string(0.5)) +lower(greet(str)) +lower(greet(string(nil))) +lower(greet(toJSON(array))) +lower(list?.[i]?.Bar) +lower(lower(str)) +lower(reduce(array, str)) +lower(str + str) +lower(str | greet()) +lower(str) +lower(str) == str +lower(str) | greet() +lower(str[1:]) +lower(string($env)) +lower(string(1)) +lower(string(1.0)) lower(string(add)) -lower(string(f32)) +lower(string(array)) lower(string(f64)) +lower(string(false)) lower(string(foo)) -lower(string(greet)) -lower(string(i)) -lower(string(i32)) -lower(string(i64)) lower(string(list)) lower(string(nil)) -lower(string(score)) -lower(toBase64("foo")) -lower(toBase64(string(i))) -lower(toJSON("bar")) -lower(toJSON("foo")) -lower(toJSON(0.5)) -lower(toJSON(1)) +lower(string(ok)) +lower(string(str)) +lower(string(true)) +lower(toBase64(str)) +lower(toJSON(0)) +lower(toJSON(1.0)) +lower(toJSON(array)) lower(toJSON(f64)) +lower(toJSON(false)) lower(toJSON(foo)) +lower(toJSON(i)) lower(toJSON(list)) lower(toJSON(nil)) lower(toJSON(ok)) +lower(toJSON(str)) lower(toJSON(true)) -lower(trim("bar")) -lower(trim("foo")) -lower(trimPrefix("bar")) -lower(trimPrefix("foo")) -lower(trimSuffix("bar")) -lower(type("bar")) -lower(type("foo")) -lower(type(0.5)) +lower(trimPrefix(str)) +lower(trimSuffix(str)) +lower(type($env)) lower(type(1)) +lower(type(1.0)) lower(type(add)) -lower(type(div)) -lower(type(f32)) -lower(type(half)) +lower(type(false)) +lower(type(foo)) lower(type(i)) -lower(type(i32)) -lower(type(i64)) lower(type(list)) +lower(type(nil)) lower(type(ok)) +lower(type(str)) lower(type(true)) -lower(upper("bar")) -lower(upper("foo")) -map(1 .. 1, f32) -map(1 .. 1, foo) -map(1 .. 1, score) -map(1 .. i, foo) -map(1 .. i32, #) -map(1 .. i32, 0.5 / f64) -map(1 .. i32, div) -map(1 .. i32, reduce(array, #)) -map(1 .. i64, # ^ #) -map(1 .. i64, #) -map(1 .. i64, half) -map(1 .. i64, i32) -map([f64], half) -map([false], ok) -map([half], #) -map([i * i32], score) -map([i32, foo, score], #) -map([i32], foo) -map([i32], greet) -map([i32], half) -map([list, 1, foo], i32) -map([nil], foo) -map([score, "bar"], f32) -map([true, i32, 1], #) -map(array, !(# == #)) -map(array, !(nil in list)) -map(array, !ok) -map(array, "bar" in foo) -map(array, "foo" not endsWith "bar") -map(array, "foo") == array -map(array, # != #) -map(array, # != 0.5) -map(array, # != 1) -map(array, # != f64) -map(array, # != i32) -map(array, # != nil) -map(array, # % #) -map(array, # % 1) -map(array, # % i) -map(array, # % i64) -map(array, # * #) -map(array, # * 0.5) -map(array, # * 1) -map(array, # * f32) -map(array, # * f64) -map(array, # * i) -map(array, # ** #) -map(array, # ** 1) -map(array, # ** f32) -map(array, # ** i) -map(array, # ** i64) -map(array, # + #) -map(array, # + 0.5) +map($env | map(foo), #.String) +map($env, #index) | filter(false) +map($env, #index) | map(greet) +map($env, #index) | reduce(0, $env) +map($env, $env) | count(ok) +map($env, $env) | findLast(ok) +map($env, $env) | map(array) +map($env, $env) | map(foo) +map($env, $env) | reduce($env) +map($env, $env) | reduce(0) +map($env, $env)?.[i] +map($env, 0) != i .. 0 +map($env, 0) | map(str) +map($env, 0) | reduce(ok, i) +map($env, 0) | sortBy(1.0) +map($env, 1) | count(ok) +map($env, 1) | reduce(foo) +map($env, 1) | sum(#) +map($env, 1)?.[i] +map($env, 1.0) | all(true) +map($env, 1.0) | map(str) +map($env, 1.0)?.[i] +map($env, add) | map(false) +map($env, add) | reduce(add, false) +map($env, add) | sum(f64) +map($env, add)?.[i] +map($env, array) | findIndex(ok) +map($env, array) | reduce(f64) +map($env, f64) | count(ok) +map($env, f64) | reduce(#) +map($env, f64) | reduce(foo) +map($env, f64) | sortBy(#) +map($env, f64) | sum(#) +map($env, f64)?.[i] +map($env, false) | filter(false) +map($env, false) | map(#) +map($env, false) | map(greet) +map($env, false) | reduce(str, nil) +map($env, false)?.[i] +map($env, foo) not in [add, f64] +map($env, foo) | get(1) +map($env, foo) | map(f64) +map($env, foo) | map(greet) +map($env, foo) | map(list) +map($env, foo) | none(true) +map($env, foo) | sortBy(str) +map($env, foo)?.[i] +map($env, greet) | map(greet) +map($env, greet) | reduce(list) +map($env, greet) | sortBy(i) +map($env, greet)?.[i] +map($env, i) | any(true) +map($env, i)?.[i] +map($env, list) | filter(false) +map($env, list) | reduce(1.0) +map($env, list) | reduce(list) +map($env, list)?.[i] +map($env, ok)?.[i] +map($env, str) | find(ok) +map($env, str) | find(true) +map($env, str) | findIndex(false) +map($env, str) | groupBy(#) +map($env, str)?.[i] +map($env, true) | any(#) +map($env, true) | find(#) +map($env, true) | map(#) +map($env, true)?.[i] +map($env.array, #) +map($env.array, #index - 1.0) +map($env.array, #index) +map($env.array, add) +map($env.array, foo) +map($env.array, list) +map($env.array, mean(0)) +map($env.list, #) +map($env.list, #index) +map($env.list, .String) +map($env.list, array) +map($env.list, f64 ^ f64) +map($env.list, greet) +map($env.list, list) +map($env.list, ok) +map($env.list, str) +map($env?.[str], # ** #) +map($env?.[str], #) +map($env?.[str], array) +map($env?.[str], greet) +map($env?.[str], i != f64) +map($env?.[str], list) +map($env?.[str], median(0)) +map($env?.[str], nil != false) +map($env?.[str], ok) +map($env?.[str], str) +map($env?.array, #) +map($env?.array, $env?.i) +map($env?.array, add) +map($env?.array, all(list, true)) +map($env?.array, array) +map($env?.array, f64) +map($env?.array, list) +map($env?.array, str) +map($env?.list, # != $env) +map($env?.list, #) +map($env?.list, $env?.[String]) +map($env?.list, foo) +map($env?.list, greet) +map(1 .. 1, list) +map([$env], #) +map([$env], #.Bar not in #.array) +map([$env], #?.f64) +map([$env], 1 ^ 1.0) +map([$env], add) +map([$env], false != #) +map([$env], greet) +map([0], #) +map([1.0], #) +map([1.0], greet) +map([1.0], ok) +map([1], greet) +map([false], list) +map([foo], #) +map([foo], #?.Bar) +map([foo], add) +map([foo], f64) +map([foo], foo) +map([foo], str) +map([i, 1.0], #) +map([i], str) +map([list], f64 + 1.0) +map([list], f64) +map([nil], 1.0 <= 1) +map([nil], list) +map([nil], ok) +map([ok], #) +map([str], greet) +map([true], foo) +map(array | reduce($env), list) +map(array, # ** 1.0) map(array, # + 1) -map(array, # + f32) -map(array, # + i) -map(array, # + i32) -map(array, # - #) -map(array, # - 0.5) -map(array, # - 1) -map(array, # - f32) -map(array, # - f64) -map(array, # - i) -map(array, # - i32) map(array, # .. #) -map(array, # .. 1) -map(array, # / #) -map(array, # / 0.5) -map(array, # / 1) -map(array, # / f32) -map(array, # / f64) -map(array, # / i) -map(array, # / i64) -map(array, # < #) -map(array, # < 1) -map(array, # < f32) -map(array, # < i32) -map(array, # < i64) map(array, # <= #) -map(array, # <= f32) -map(array, # <= i) -map(array, # <= i32) +map(array, # <= 1.0) map(array, # == #) -map(array, # == f32) -map(array, # == f64) -map(array, # == nil) -map(array, # > #) -map(array, # > 0.5) -map(array, # > 1) -map(array, # > f32) -map(array, # > f64) +map(array, # > 0) map(array, # >= #) -map(array, # >= 1) -map(array, # >= f32) -map(array, # >= i32) -map(array, # >= i64) map(array, # ^ #) -map(array, # ^ 0.5) -map(array, # ^ 1) -map(array, # ^ i) -map(array, # ^ i32) -map(array, # not in array) +map(array, # ^ 1.0) map(array, #) -map(array, #) != array -map(array, #) != list -map(array, #) == array -map(array, #) == list -map(array, #)[i64] -map(array, #)[i] -map(array, -#) -map(array, --#) -map(array, -0.5) -map(array, -1) -map(array, -f64) -map(array, -i) -map(array, -i32) -map(array, -i64) -map(array, 0.5 != #) -map(array, 0.5 != 0.5) -map(array, 0.5 * #) -map(array, 0.5 * f64) -map(array, 0.5 ** f32) -map(array, 0.5 ** i64) -map(array, 0.5 + #) -map(array, 0.5 + 1) -map(array, 0.5 - #) -map(array, 0.5 - 0.5) -map(array, 0.5 / i) -map(array, 0.5 < #) -map(array, 0.5 < i32) -map(array, 0.5 > #) -map(array, 0.5 > i64) -map(array, 0.5 >= #) -map(array, 0.5 ^ #) -map(array, 0.5)[i] +map(array, #) | findLastIndex(true) +map(array, #) | groupBy(#) +map(array, #) | map($env) +map(array, #) | map(bitnot(1)) +map(array, #) | map(foo) +map(array, #) | sortBy(#) +map(array, #)?.[i] +map(array, #index) +map(array, #index) | groupBy(ok) +map(array, #index)?.[i] +map(array, $env && true) +map(array, $env == #) +map(array, $env == true) +map(array, $env)?.[i] +map(array, $env.f64) +map(array, $env.foo) +map(array, $env.greet) +map(array, $env.list) +map(array, $env.str) +map(array, $env?.String) +map(array, $env?.[foobar]) +map(array, $env?.[str]) +map(array, $env?.add) +map(array, $env?.greet) +map(array, $env?.list) +map(array, 0 != #) +map(array, 0 - #) +map(array, 0 | bitxor(#)) +map(array, 0) | find(false) +map(array, 0) | map(array) +map(array, 0) | sortBy(f64) map(array, 1 != #) -map(array, 1 != f32) -map(array, 1 % #) -map(array, 1 ** #) -map(array, 1 ** i) -map(array, 1 ** i64) -map(array, 1 + #) -map(array, 1 + f64) -map(array, 1 - #) -map(array, 1 .. #) -map(array, 1 / #) -map(array, 1 / i32) -map(array, 1 < #) -map(array, 1 <= #) -map(array, 1 <= 1) -map(array, 1 <= f32) -map(array, 1 == #) -map(array, 1 ^ #) -map(array, abs(#)) -map(array, abs(i64)) -map(array, add == nil) -map(array, add(#, #)) -map(array, add(#, i)) +map(array, 1) | map(1) +map(array, 1)?.[i] +map(array, 1.0 != 1.0) +map(array, 1.0 + #) +map(array, 1.0 + 1.0) +map(array, 1.0 == #) +map(array, 1.0) | reduce(1.0) +map(array, 1.0) | take(1) +map(array, 1.0)?.[i] +map(array, [#]) +map(array, [0, $env]) map(array, add) +map(array, add) | groupBy(foo) map(array, array) -map(array, array)[bitnot(i32)] -map(array, array)[i64] -map(array, array[#:#]) -map(array, bitand(#, 1)) -map(array, bitnand(#, 1)) +map(array, array)?.[i] map(array, bitnot(#)) -map(array, bitnot(1)) -map(array, bitshl(#, #)) -map(array, bitshr(#, #)) -map(array, bitshr(#, i64)) -map(array, bitushr(1, #)) -map(array, ceil(#)) -map(array, ceil(0.5)) -map(array, ceil(f32)) -map(array, div(#, #)) -map(array, div) -map(array, f32 * #) -map(array, f32 * f64) -map(array, f32 ** #) -map(array, f32 + #) -map(array, f32 / #) -map(array, f32 < #) -map(array, f32 == #) -map(array, f32 > #) -map(array, f32 >= #) -map(array, f32 >= i) -map(array, f32 ^ #) -map(array, f32) -map(array, f32)[min(i32)] -map(array, f64 != #) -map(array, f64 != 0.5) -map(array, f64 * #) -map(array, f64 ** #) -map(array, f64 ** 0.5) -map(array, f64 / #) -map(array, f64 < #) -map(array, f64 < f64) -map(array, f64 <= #) -map(array, f64 == #) -map(array, f64 >= #) -map(array, f64 >= i32) -map(array, f64 ^ #) +map(array, f64 - 1.0) map(array, f64) -map(array, false && false) -map(array, false ? # : f64) -map(array, false ? greet : i) -map(array, false)[i32] -map(array, find(array, true)) -map(array, findIndex(list, ok)) -map(array, float(# + #)) +map(array, f64) != list +map(array, f64)?.[i] +map(array, false) | count(false) +map(array, false) | reduce(greet) +map(array, false) | sortBy(str) +map(array, false)?.[i] +map(array, flatten(array)) +map(array, flatten(list)) map(array, float(#)) -map(array, floor(#)) +map(array, foo != $env) map(array, foo == foo) map(array, foo) -map(array, foo.Bar) -map(array, foo.Qux) -map(array, foo.String()) +map(array, foo) != array +map(array, foo) | count(true) +map(array, foo) | findLastIndex(false) +map(array, foo) | map(#.Bar) +map(array, foo) | map(ok) +map(array, foo) | reduce(list) +map(array, foo) | reduce(str, f64) +map(array, foo)?.[i] +map(array, foo)[:] map(array, foo.String) -map(array, foo?.Bar) map(array, foo?.String) -map(array, get(array, #)) -map(array, greet("bar")) -map(array, greet("foo")) map(array, greet) -map(array, groupBy(array, #)) -map(array, groupBy(array, f32)) -map(array, groupBy(list, #)) -map(array, groupBy(list, f64)) -map(array, groupBy(list, i)) -map(array, half != half) -map(array, half != nil) -map(array, half(0.5)) -map(array, half(1)) -map(array, half(f64)) -map(array, half(i - 0.5)) -map(array, half) -map(array, i % #) -map(array, i + #) -map(array, i - i32) -map(array, i / 0.5) -map(array, i <= #) -map(array, i <= f32) -map(array, i <= f64) -map(array, i == #) -map(array, i == f64) -map(array, i > i32) -map(array, i >= #) +map(array, greet)?.[i] +map(array, i < 0) +map(array, i == #index) map(array, i) -map(array, i)[i] -map(array, i32 * #) -map(array, i32 ** #) -map(array, i32 ** f64) -map(array, i32 / f32) -map(array, i32 < #) -map(array, i32 < f64) -map(array, i32 == #) -map(array, i32 == 1) -map(array, i32 > #) -map(array, i32 ^ #) -map(array, i32 not in array) -map(array, i32) -map(array, i32) == array -map(array, i32) == list -map(array, i64 != #) -map(array, i64 % #) -map(array, i64 * #) -map(array, i64 * 0.5) -map(array, i64 + 0.5) -map(array, i64 - #) -map(array, i64 .. #) -map(array, i64 < #) -map(array, i64 <= #) -map(array, i64 <= f64) -map(array, i64 <= i64) -map(array, i64 > #) -map(array, i64) -map(array, int(#)) -map(array, int(0.5)) -map(array, len("foo")) -map(array, list != array) +map(array, i) | find(ok) +map(array, i)?.[i] +map(array, int(#index)) +map(array, len($env)) +map(array, list == $env) +map(array, list == list) map(array, list) -map(array, map(array, f64)) -map(array, map(list, greet)) -map(array, max(#)) -map(array, max(f32, 1)) -map(array, max(f64)) -map(array, mean(array)) -map(array, min(#, #)) -map(array, nil == #) -map(array, nil == ok) -map(array, nil not in list) -map(array, not ok) -map(array, not true) -map(array, ok || ok) +map(array, list)?.[i] +map(array, median(#)) +map(array, median(1.0)) +map(array, min(0)) +map(array, ok != true) +map(array, ok || false) map(array, ok) -map(array, ok)[i64] -map(array, reduce(array, "bar")) -map(array, reduce(array, #)) -map(array, reduce(list, add)) -map(array, reduce(list, half)) -map(array, round(#)) -map(array, score(#)) -map(array, score(#, #)) -map(array, score(1)) -map(array, score) -map(array, string(add)) -map(array, string(foo)) -map(array, string(i64)) -map(array, take(array, #)) -map(array, toBase64("foo")) -map(array, toJSON(#)) -map(array, toJSON(foo)) -map(array, toJSON(list)) -map(array, true != nil) -map(array, true ? 0.5 : #) -map(array, true ? 0.5 : 1) -map(array, true ? f32 : div) -map(array, true ? i : true) -map(array, type(#)) -map(array, type(f32)) -map(array[1:i32], list) -map(false ? i32 : list, ok) -map(filter(array, false), foo) -map(filter(array, ok), 1 * #) -map(filter(list, # != #), #) -map(filter(list, false), #) -map(filter(list, ok), #) -map(filter(list, ok), i) -map(filter(list, true), i64) -map(groupBy(array, #).String, i32) -map(groupBy(array, #).greet, foo.Qux(.f32)) -map(groupBy(array, #).greet, score) -map(groupBy(array, #).score, #?.list()) -map(groupBy(list, i32).i, #) -map(i .. 1, -#) -map(i .. 1, 0.5 ^ #) -map(i .. 1, f32) -map(i .. 1, i) -map(i .. i, add(#, #)) -map(i .. i, div) -map(i .. i, i32) -map(i .. i32, half) -map(i .. i64, min(#, #, #)) -map(i32 .. 1, half) -map(i32 .. i, f32) -map(i32 .. i32, array) -map(i32 .. i64, div) -map(i32 .. i64, list) -map(i64 .. 1, #) -map(i64 .. 1, 1 ^ #) -map(i64 .. 1, array) -map(i64 .. 1, f32) -map(i64 .. 1, f64) -map(i64 .. i32, #) -map(i64 .. i64, # - #) -map(i64 .. i64, #) -map(list, !false) -map(list, !ok) -map(list, "bar" not matches "foo") -map(list, "bar") != list -map(list, "bar")[i64] -map(list, "foo" not in foo) -map(list, "foo" not matches #.Bar) +map(array, ok) | count(1 >= 1.0) +map(array, ok) | map(1) +map(array, ok) | one(true) +map(array, ok) | sum(1.0) +map(array, reduce(array, foo, #index)) +map(array, sort(array)) +map(array, str == nil) +map(array, str) +map(array, str) == list +map(array, str) | groupBy(#) +map(array, str) | map(list) +map(array, str) | reduce(#) +map(array, str)?.[i] +map(array, true) != array +map(array, true)?.[i] +map(array, type(1.0)) +map(concat(array), # == f64) +map(concat(array), greet) +map(false ? foo : list, $env.ok) +map(filter(array, true), greet) +map(flatten(array), #) +map(flatten(array), i) +map(list | map($env), #) +map(list | map(.Bar), #) +map(list | sortBy(1.0), .String) +map(list | sortBy(1.0), string(#)) map(list, # != #) -map(list, # != nil) map(list, # == #) -map(list, # in list) +map(list, # == foo) map(list, #) -map(list, #) != array -map(list, #) == list -map(list, #)[i64] -map(list, #)[i] -map(list, #?.Bar) -map(list, #?.Qux) -map(list, #?.String()) +map(list, #) | any(false) +map(list, #) | any(ok) +map(list, #) | findIndex(ok) +map(list, #) | findLastIndex(ok) +map(list, #) | groupBy(#) +map(list, #) | groupBy(1.0) +map(list, #) | groupBy(foo) +map(list, #) | map(#) +map(list, #) | map(1.0) +map(list, #) | map(true) +map(list, #) | one(true) +map(list, #) | reduce(#.String, foo) +map(list, #) | reduce(#acc, 1) +map(list, #) | sortBy(1.0) +map(list, #)?.[i] +map(list, #.Bar <= #.Bar) +map(list, #.Bar) +map(list, #.String) +map(list, #.String)?.[i] map(list, #?.String) -map(list, -0.5) -map(list, -f32) -map(list, -i) -map(list, -i32) +map(list, #index + i) +map(list, #index - 1) +map(list, #index | add(i)) +map(list, #index) +map(list, #index)?.[i] +map(list, $env != nil) +map(list, $env) | findIndex(.ok) +map(list, $env) | findLastIndex(#.foo != #) +map(list, $env) | map(1.0) +map(list, $env)?.[i] +map(list, $env.add) +map(list, $env.f64) +map(list, $env.foo) +map(list, $env.greet) +map(list, $env?.[.Bar]) +map(list, $env?.[Bar]) +map(list, $env?.add) +map(list, $env?.array) +map(list, $env?.greet) +map(list, $env?.i) +map(list, $env?.ok) map(list, .Bar) -map(list, .Qux) -map(list, .String()) map(list, .String) -map(list, 0.5 != 0.5) -map(list, 0.5 != i64) -map(list, 0.5 + i64) -map(list, 0.5 - 0.5) -map(list, 0.5 <= 0.5) -map(list, 0.5 == i32) -map(list, 0.5 in array) -map(list, 0.5) != array -map(list, 0.5) == array -map(list, 1 % i) -map(list, 1 ** 0.5) -map(list, 1 ** f32) -map(list, 1 + 1) -map(list, 1 / f64) -map(list, 1 / i64) -map(list, 1 < 0.5) -map(list, 1 <= i32) -map(list, 1 ^ i32) -map(list, [#]) -map(list, [foo, 0.5, #]) -map(list, [score]) -map(list, abs(f32)) +map(list, .String) | map(#) +map(list, .String)?.[i] +map(list, 0 <= 1.0) +map(list, 0 > 1) +map(list, 0) | groupBy(foo) +map(list, 0) | sum(#) +map(list, 1 == 1.0) +map(list, 1) | groupBy(#) +map(list, 1)?.[i] +map(list, 1.0 / i) +map(list, 1.0) | findLast(true) +map(list, 1.0) | groupBy(#) +map(list, 1.0) | reduce(foo) +map(list, 1.0) | sortBy(#) +map(list, 1.0)?.[i] +map(list, [$env, nil, add]) +map(list, abs(1.0)) map(list, add) +map(list, add)?.[i] map(list, array) -map(list, ceil(0.5)) -map(list, count(array, true)) -map(list, div) -map(list, f32 != i32) -map(list, f32 ** 1) -map(list, f32 + i64) -map(list, f32 < f32) -map(list, f32 == 0.5) -map(list, f32 > i64) -map(list, f32 >= i) -map(list, f32 >= i32) -map(list, f32 ^ i) -map(list, f32) -map(list, f64 < 0.5) -map(list, f64 < f32) -map(list, f64 <= 1) -map(list, f64 > 1) -map(list, f64 >= 0.5) -map(list, f64 >= f32) +map(list, array) | one(ok) +map(list, array) | one(true) +map(list, bitnot(0)) +map(list, bitnot(i)) +map(list, ceil(1.0)) +map(list, f64 / 1.0) map(list, f64) -map(list, f64)[i] -map(list, false ? # : list) -map(list, false) != array -map(list, float(f64)) -map(list, float(i)) -map(list, float(i32)) -map(list, foo == #) +map(list, f64) | groupBy(#) +map(list, f64) | map($env) +map(list, f64) | reduce(1) +map(list, false) | map(#) +map(list, floor(1.0)) map(list, foo) -map(list, foo.Qux) -map(list, foo.String()) -map(list, foo?.String) +map(list, foo) | reduce(#.String) +map(list, foo) | reduce(1) +map(list, foo) | sum(0) +map(list, foo)?.[i] +map(list, foo.Bar) +map(list, foo.String) +map(list, foo?.Bar) +map(list, foo?.String()) +map(list, greet(#.Bar)) +map(list, greet(str)) map(list, greet) -map(list, groupBy(array, #)) -map(list, groupBy(array, i)) -map(list, groupBy(list, #)) -map(list, half(0.5)) -map(list, half(f64)) -map(list, half) -map(list, i ** 1) -map(list, i + i64) -map(list, i .. i) -map(list, i < 0.5) -map(list, i == 1) +map(list, greet) | findIndex(true) +map(list, i >= 0) map(list, i) -map(list, i)[i64] -map(list, i32 % i64) -map(list, i32 ** 0.5) -map(list, i32 + f32) -map(list, i32 - i32) -map(list, i32 / f64) -map(list, i32 < 1) -map(list, i32 < i32) -map(list, i32 <= 1) -map(list, i32 >= 1) -map(list, i32) -map(list, i64 * i) -map(list, i64 + i64) -map(list, i64 <= i64) -map(list, i64 == nil) -map(list, i64) -map(list, i64)[i64] -map(list, i64)[i] -map(list, last(array)) +map(list, i) | groupBy(# < #) +map(list, i) | sortBy(#) +map(list, i)?.[i] map(list, list) -map(list, list)[i] -map(list, map(array, #)) -map(list, map(array, 1)) -map(list, map(array, div)) -map(list, map(array, i64)) -map(list, map(list, "foo")) -map(list, max(f32)) -map(list, min(0.5)) -map(list, min(f64)) -map(list, nil != #) -map(list, nil != i64) -map(list, nil == #) -map(list, nil == ok) -map(list, nil not in list) -map(list, none(array, true)) -map(list, not ok) -map(list, ok ? # : #) -map(list, ok || ok) +map(list, list) | sum(f64) +map(list, list)?.[i] +map(list, max(f64)) +map(list, nil != add) +map(list, none($env, true)) +map(list, ok or ok) map(list, ok) -map(list, reduce(array, half)) -map(list, reduce(list, foo)) -map(list, reduce(list, half)) -map(list, score(1)) -map(list, score) -map(list, score)[i64] +map(list, round(f64)) +map(list, str not in #) +map(list, str) +map(list, str) | findLast(false) +map(list, str) | map(#) +map(list, str) | reduce(#) map(list, string(#)) -map(list, string(1)) -map(list, string(add)) -map(list, string(i32)) -map(list, toJSON(#)) -map(list, toJSON([#])) -map(list, toJSON(false)) -map(list, toJSON(ok)) -map(list, true ? i : f32) -map(list, true ? i32 : #) -map(list, true ? list : div) -map(list, true)[i32] -map(list, type("bar")) +map(list, sum(array)) +map(list, trim(str)) +map(list, true ? array : f64) +map(list, true)?.[i] map(list, type(#)) -map(list, type(i32)) -map(list, type(true)) -map(list[i64:i32], greet) -map(map(array, #), # - i32) -map(map(array, #), # == #) -map(map(array, #), # >= #) +map(list, type($env)) +map(list, upper(#.Bar)) map(map(array, #), #) -map(map(array, #), add) -map(map(array, #), bitand(#, #)) -map(map(array, #), foo) -map(map(array, #), greet) -map(map(array, #), half) -map(map(array, #), i % i64) -map(map(array, #), i) -map(map(array, #), i32) -map(map(array, #), i64) -map(map(array, #), list) -map(map(array, 0.5), #) -map(map(array, 0.5), ok) -map(map(array, 1), greet) -map(map(array, array), i32 ^ i32) -map(map(array, array), i64) -map(map(array, array), reduce(#, array)) -map(map(array, div), i) -map(map(array, div), list) -map(map(array, f32), #) -map(map(array, f32), array) -map(map(array, f32), f64) -map(map(array, f64), # > #) -map(map(array, f64), f64) -map(map(array, f64), greet) -map(map(array, foo), div) -map(map(array, greet), foo) -map(map(array, greet), list) -map(map(array, half), array) -map(map(array, i), #) -map(map(array, i32), #) -map(map(array, i64), array) -map(map(array, i64), f64) -map(map(array, list), foo) -map(map(array, ok), !#) -map(map(array, ok), -f32) -map(map(array, true), # != nil) -map(map(array, true), i64) -map(map(list, #), # != #) -map(map(list, #), #) -map(map(list, #), #?.Qux) -map(map(list, #), .Bar) -map(map(list, #), div) -map(map(list, #), f32) -map(map(list, #), f64) -map(map(list, #), greet) -map(map(list, #), half) -map(map(list, #), list) -map(map(list, #), ok) -map(map(list, #), score) -map(map(list, 0.5), #) -map(map(list, 0.5), div) -map(map(list, 1), # * #) -map(map(list, 1), f32) -map(map(list, add), #) -map(map(list, add), i) -map(map(list, array), f64) -map(map(list, array), findIndex(#, ok)) -map(map(list, f64), f32) -map(map(list, f64), i32) -map(map(list, false), 0.5 / f64) -map(map(list, foo), #) -map(map(list, foo), list) -map(map(list, greet), "bar" <= "foo") -map(map(list, i64), # >= f64) -map(map(list, i64), #) -map(map(list, i64), i64) -map(map(list, list), #) -map(map(list, ok), f64 > i64) -map(map(list, ok), foo) -map(map(list, true), f64) -map(map(list, true), list) -map(ok ? "bar" : i64, ok) -map(ok ? "bar" : ok, i64) -map(ok ? "bar" : score, 1 .. #) -map(ok ? array : foo, foo) -map(ok ? array : i64, list) -map(ok ? list : i64, #) -map(ok ? list : list, add) -map(reduce(array, array), # <= #) -map(reduce(array, array), #) -map(reduce(list, array), -i32) -map(reduce(list, array), foo) -map(reduce(list, array), half) -map(reduce(list, list), #) -map(sort(array), # / 0.5) -map(sort(array), #) -map(sort(array), greet) -map(split("foo", "bar"), #) -map(true ? "foo" : 0.5, # * #) -map(true ? array : "foo", f32 + #) -map(true ? list : greet, greet) -map(true ? list : list, #) -max(-0.5) -max(-1) -max(-f32) -max(-f64) -max(-findIndex(array, ok)) -max(-i) -max(-i, f32) -max(-i32) -max(-i64) -max(-reduce(array, #)) -max(0.5 * f32) -max(0.5 * i) -max(0.5 * i64) -max(0.5 ** 0.5) -max(0.5 ** 1) -max(0.5 ** f32) -max(0.5 ** f64 ^ reduce(array, f64)) -max(0.5 ** i) -max(0.5 ** i32) -max(0.5 + 1) -max(0.5 - 0.5) -max(0.5 - f32) -max(0.5 - f64) -max(0.5 / 0.5) -max(0.5 / 1) -max(0.5 / f64) -max(0.5 / i32) -max(0.5 / i64) -max(0.5 ^ 0.5) -max(0.5 ^ 1) -max(0.5 ^ i) -max(0.5 ^ i32) -max(0.5 ^ i64) -max(0.5) != f32 -max(0.5) != i -max(0.5) + f64 -max(0.5) + i -max(0.5) - i32 -max(0.5) / i64 -max(0.5) <= i -max(0.5) > f64 -max(0.5) > i -max(0.5) > i64 -max(0.5) >= i64 -max(0.5, 0.5) != i -max(0.5, i) ** i32 -max(1 % 1) -max(1 % i64) -max(1 * 0.5) -max(1 * 1) -max(1 * f64) -max(1 * i32) -max(1 ** 0.5) -max(1 ** 1) -max(1 ** f32) -max(1 ** i64) -max(1 + f32) -max(1 + i64) -max(1 - f32) -max(1 - f64) -max(1 / 1) -max(1 / f32) -max(1 / f32, i64) -max(1 / f64) -max(1 / i) -max(1 / i32) -max(1 / i64) -max(1 ^ 0.5) -max(1 ^ 1) -max(1 ^ f32) -max(1 ^ f64) -max(1 ^ i32) -max(1 ^ i64) -max(1) != 1 ? foo : "bar" -max(1) + f32 -max(1) - f64 +map(map(array, list), str) +map(map(list, f64), ok) +map(min($env), f64) +map(reduce(array, $env), foo.String()) +map(reverse(array), str) +map(sort($env), #.greet?.Bar(Bar)) +map(sort($env), lower(#)) +map(sort(array), ok) +map(sortBy(array, str), # >= #index) +map(uniq(list), reduce(list, foo)) +map(values($env), #) +max($env | find(false)) +max($env | findIndex(ok)) +max($env | findLastIndex(ok)) +max($env | map(#index)) +max($env | map(0)) +max($env | sum(i)) +max($env) != $env?.array +max($env) != greet +max($env) == $env?.foo +max($env) == list +max($env) == ok +max($env) | count($env.ok) +max($env) | count(false) +max($env) | count(true) +max($env) | find(false) +max($env) | map(1.0) +max($env) | map(add) +max($env) | map(f64) +max($env) | map(greet) +max($env) | map(i) +max($env) | map(str) +max($env) | sum(1.0) +max($env).Bar +max($env).Bar?.i().str +max($env).String +max($env).add +max($env).array +max($env).f64 +max($env).foo +max($env).foobar?.[greet] +max($env).foobar?.str +max($env).greet +max($env).greet(foobar) +max($env).i +max($env).list +max($env).not +max($env).ok +max($env).str +max($env)?.Bar +max($env)?.String +max($env)?.[str] +max($env)?.[str]?.[i] +max($env)?.add +max($env)?.array +max($env)?.array not in list +max($env)?.f64 +max($env)?.foo +max($env)?.foobar?.[greet] +max($env)?.greet +max($env)?.greet(foobar) +max($env)?.i +max($env)?.list +max($env)?.list?.[f64] +max($env)?.not +max($env)?.ok +max($env)?.str +max($env.array) +max($env.array, array) +max($env.f64) +max($env.i) +max($env?.$env) +max($env?.Bar) +max($env?.Bar)?.[foo] +max($env?.Bar)?.foo +max($env?.Bar)?.list +max($env?.String) +max($env?.String)?.[i] +max($env?.[Bar]) +max($env?.[String]) +max($env?.[String])?.[i] +max($env?.[String]?.[f64]) +max($env?.[String]?.ok) +max($env?.[foobar]) +max($env?.[nil]) +max($env?.[str]) +max($env?.[str]) | reduce(ceil(#)) +max($env?.array) +max($env?.f64 ^ i) +max($env?.f64) +max($env?.f64, i) +max($env?.false) +max($env?.foobar) +max($env?.i) +max($env?.nil) +max($env?.true) +max(0 % 1) +max(0 % i) +max(0 * 0) +max(0 * 1) +max(0 * 1.0) +max(0 ** f64) +max(0 + 1) +max(0 - 0) +max(0 - 1.0) +max(0 - f64) +max(0 - i) +max(0 .. 1, i) +max(0 .. i) +max(0 / 0) +max(0 / 1) +max(0 ^ 1) +max(0 ^ 1.0) +max(0 ^ f64) +max(0 | min(1.0, 1.0)) +max(0) != 0 || ok +max(0) - i +max(0..i) +max(0.1) +max(1 ** 1.0) +max(1 + 0) +max(1 - 1.0) +max(1 .. 1) +max(1 / 1.0) +max(1 ^ 0) +max(1 ^ 1.0) +max(1 | max(1.0)) +max(1) ** f64 max(1) .. i max(1) / i -max(1) == i64 -max(1) > f64 -max(1) > i32 -max(1, i) not in array -max(abs(0.5)) +max(1, 1.0) in array +max(1.0 * 0) +max(1.0 * 1) +max(1.0 * 1.0) +max(1.0 * f64) +max(1.0 * i) +max(1.0 ** 0) +max(1.0 ** 1.0) +max(1.0 + 0) +max(1.0 + 1) +max(1.0 + 1.0) +max(1.0 - 0) +max(1.0 - 1.0) +max(1.0 - f64) +max(1.0 - i) +max(1.0 / 0) +max(1.0 / 1.0) +max(1.0 ^ 0) +max(1.0 ^ f64) +max(1.0 ^ i) +max(1.0) +max(1.0) ** i +max(1.0) < i +max(1.0) <= $env.f64 +max(1.0) <= i +max(1.0) > f64 +max(1.0) >= i +max(1.0) ^ f64 +max(1.0) | min(array) +max([1.0]) +max([1]) +max([array]) +max([i]) +max(abs(0)) max(abs(1)) -max(abs(f32)) +max(abs(1.0)) max(abs(f64)) max(abs(i)) -max(abs(i32)) -max(add(1, i)) -max(array[1]) -max(array[i64]) -max(bitnand(i32, 1)) +max(array | get(i)) +max(array | map(1.0)) +max(array | map(i)) +max(array | reduce(#index)) +max(array | reduce($env, 0)) +max(array | reduce(1.0, foo)) +max(array | sortBy(#)) +max(array | sortBy(0)) +max(array | sortBy(f64)) +max(array | sum(0)) +max(array) +max(array) != array +max(array) - f64 +max(array) / median(1) +max(array) == i +max(array) == str +max(array) > f64 +max(array, abs(i)) +max(array, array) +max(array, f64) +max(array, i) +max(array?.[1]) +max(array?.[i]) +max(array[:]) +max(bitnot(0)) max(bitnot(1)) max(bitnot(i)) -max(bitnot(i64)) -max(bitshr(1, i32)) -max(bitxor(1, 1)) -max(ceil(0.5), f64 / i64) -max(ceil(f32)) -max(ceil(i32)) -max(f32 * 1) -max(f32 * f64) -max(f32 * i64) -max(f32 ** 1) -max(f32 ** f64) -max(f32 + 1) -max(f32 + f64) -max(f32 + i) -max(f32 + i64) -max(f32 - 1) -max(f32 - i64) -max(f32 / 0.5) -max(f32 / f32) -max(f32 ^ 1) -max(f32 ^ f32) -max(f32 ^ f64) -max(f32 ^ i64) -max(f32) -max(f32) * i64 -max(f32) ** i -max(f32) + f32 -max(f32) + f64 -max(f32) - f64 -max(f32) / i32 -max(f32) < i -max(f32) == i -max(f32) ^ f32 -max(f32, f32) -max(f32, f64) -max(f32, f64) in array -max(f32, i) -max(f32, i32) -max(f32, i32) ** i64 -max(f32, i64) -max(f64 * 1) +max(ceil(0)) +max(ceil(1)) +max(ceil(1.0)) +max(concat(array)) +max(count(list, false)) +max(count(list, ok)) max(f64 * f64) -max(f64 ** 0.5) -max(f64 ** f64) -max(f64 ** i) +max(f64 * i) +max(f64 ** 1) +max(f64 + 0) max(f64 + 1) -max(f64 + f32) -max(f64 + f64) -max(f64 - 0.5) -max(f64 - i) -max(f64 ^ 0.5) -max(f64 ^ 1) -max(f64 ^ f32) -max(f64 ^ f64) +max(f64 ^ 1.0) max(f64) max(f64) != f64 -max(f64) < i32 -max(f64) <= f32 -max(f64) == f32 -max(f64) == i -max(f64) == round(i) -max(f64) ^ f32 -max(f64) ^ i64 -max(f64, f32) -max(f64, f32) <= int(f64) +max(f64) < i +max(f64) <= 0 * f64 +max(f64) <= f64 +max(f64) >= f64 +max(f64) not in array +max(f64, array) +max(f64, array, array) max(f64, f64) max(f64, i) -max(f64, i) - 1 ^ i -max(f64, i) < i -max(f64, i) > f64 -max(f64, i32) -max(f64, i64) -max(f64, i64) ^ f32 -max(false ? 0.5 : array) -max(false ? add : f64) -max(false ? div : half) -max(false ? div : i64) -max(false ? ok : 0.5) -max(find(array, false)) -max(findIndex(list, false)) -max(findIndex(list, ok)) -max(findLast(array, false)) -max(float(0.5)) +max(false ? foo : 0) +max(false ? nil : $env) +max(false ?: foo) +max(findLastIndex(array, false)) +max(findLastIndex(array, ok)) +max(findLastIndex(array, true)) +max(first($env)) +max(flatten(array)) +max(float(0)) max(float(1)) -max(float(1), i) -max(float(i32)) -max(float(i64)) -max(float(score(i))) -max(floor(0.5)) +max(float(1.0)) +max(float(f64)) +max(float(i)) max(floor(1)) -max(floor(f32)) max(floor(i)) -max(floor(i32)) -max(floor(len(array))) -max(get(array, 1)) -max(get(array, i)) -max(get(array, i32)) -max(get(array, i64)) -max(half(0.5)) -max(half(1)) -max(half(1), i64) -max(half(f64)) max(i % 1) -max(i * 0.5) -max(i * f32) -max(i * i) -max(i * i64) +max(i % i) +max(i * 1.0) +max(i * i, i) +max(i ** 1.0) max(i ** f64) -max(i ** score(1)) -max(i + 1) +max(i + 0) +max(i + f64) max(i - 1) -max(i - i) -max(i - i64) -max(i ^ f64) +max(i - 1.0) +max(i .. 0) +max(i / 1) +max(i / 1.0) +max(i / i) +max(i ^ 0) +max(i ^ i) +max(i | bitor(i)) +max(i | min(f64)) max(i) -max(i) != i32 -max(i) != i64 -max(i) % (i64 + i) -max(i) % array[i32] -max(i) ** (1 / i32) -max(i) + f64 -max(i) - i -max(i) / f32 -max(i) / i -max(i) < 0.5 - f64 -max(i) < f32 -max(i) < i32 +max(i) < f64 max(i) <= f64 -max(i) == f64 -max(i) >= i -max(i, f32) +max(i) not in array +max(i) | bitxor(0) +max(i, array) max(i, f64) max(i, i) -max(i, i32) -max(i, i64) -max(i, i64, i32) -max(i32 % 1) -max(i32 * 0.5) -max(i32 * 1) -max(i32 * f32) -max(i32 * i) -max(i32 * i64) -max(i32 ** f32) -max(i32 ** i) -max(i32 ** i32) -max(i32 + 0.5) -max(i32 + i64) -max(i32 - 0.5) -max(i32 - 1) -max(i32 - f64) -max(i32 - i) -max(i32 / 1) -max(i32 ^ i) -max(i32 ^ i, f32) -max(i32) -max(i32) * i32 -max(i32) / f32 -max(i32) / i -max(i32) <= f32 -max(i32) ^ f32 -max(i32) in array -max(i32, f32) -max(i32, f64) -max(i32, i) -max(i32, i32) -max(i32, i64) -max(i64 % i) -max(i64 * 0.5) -max(i64 * i64) -max(i64 ** 0.5) -max(i64 ** f32) -max(i64 ** i64) -max(i64 + i) -max(i64 + i64) -max(i64 - 0.5) -max(i64 - 1) -max(i64 - f64) -max(i64 / f64) -max(i64 / i32) -max(i64 / i64) -max(i64 ^ 0.5) -max(i64 ^ 1) -max(i64 ^ i) -max(i64) -max(i64) ** (1 + 1) -max(i64) ** f32 -max(i64) + i32 -max(i64) - i32 -max(i64) - i64 -max(i64) .. i32 -max(i64) < f32 -max(i64) >= f32 -max(i64) ^ i -max(i64, 0.5 + 1) -max(i64, 0.5, i64) ** i32 -max(i64, f32) -max(i64, f64) -max(i64, half(1)) -max(i64, i) -max(i64, i) + i32 -max(i64, i32) -max(i64, i32) == f64 -max(i64, i64) -max(int(0.5)) -max(int(f32)) -max(int(i32)) -max(int(i64)) -max(len("foo")) -max(len(array)) +max(if false { ok } else { 1.0 }) +max(if ok { foo } else { 1.0 }) +max(if ok { ok } else { 0 }) +max(if true { $env } else { f64 }) +max(int(0)) +max(int(1)) +max(int(1.0)) +max(int(f64)) +max(int(i)) +max(last($env)) +max(last($env)?.ok) +max(last(array)) +max(len($env)) max(len(list)) -max(max(0.5)) -max(max(0.5, f64)) +max(len(str)) +max(let foobar = f64; foobar) +max(list | count(ok)) +max(list | map(f64)) +max(list | reduce($env)) +max(list) startsWith str and false +max(map($env, #index)) +max(map(array, 1)) +max(map(array, array)) +max(map(array, f64)) +max(map(list, 1)) +max(map(list, i)) +max(max($env)) +max(max(0)) max(max(1)) +max(max(1.0)) +max(max(array)) +max(max(array?.[i])) +max(max(f64)) max(max(i)) -max(max(i32)) -max(max(i64)) +max(mean(0)) +max(mean(1)) +max(mean(1.0)) +max(mean(1.0, 1.0)) max(mean(array)) +max(mean(f64)) +max(mean(i)) +max(mean(i), array) +max(median(0)) +max(median(1.0)) max(median(array)) -max(min(0.5, 0.5)) +max(median(array, 1)) +max(median(f64)) +max(median(i)) +max(min(0)) max(min(1)) -max(min(1, f64)) -max(min(f32, i64, i32)) +max(min(1.0)) +max(min(array)) +max(min(f64)) max(min(i)) -max(min(i32)) -max(ok ? "foo" : f64) -max(ok ? 0.5 : i64) -max(ok ? 1 : i) -max(ok ? array : true) -max(ok ? foo : greet) -max(ok ? half : f32) -max(ok ? half : list) -max(ok ? i : 1) -max(ok ? i : nil) -max(reduce(array, # % #)) +max(ok ? 1.0 : nil) +max(ok ? f64 : $env) +max(reduce($env, i, foo)) max(reduce(array, #)) -max(reduce(array, 1)) -max(reduce(array, f32)) -max(reduce(array, f64)) -max(reduce(list, 0.5)) -max(reduce(list, f32), i64) -max(reduce(list, i64)) -max(round(1)) -max(round(f32)) -max(round(f64)) +max(reduce(array, #acc)) +max(reduce(array, $env)) +max(reduce(array, 1.0)) +max(reduce(list, 0)) +max(reduce(list, 1.0)) +max(reverse(array)) +max(round(1.0)) max(round(i)) -max(round(i32)) -max(score(1)) -max(score(i), i) -max(true ? f32 : f32) -max(true ? foo : array) -max(true ? greet : 1) -max({"bar": list}.String) -max({"foo": array}?.f32) -max({"foo": half}?.f32) -mean(1 .. 1) -mean(1 .. i) -mean([f64, 0.5]) +max(sort($env)) +max(sort(array)) +max(sortBy(array, #)) +max(sortBy(array, 1)) +max(sum($env, f64)) +max(sum(array)) +max(sum(array, #)) +max(sum(array, 1.0)) +max(sum(list, f64)) +max(true ? array : false) +max(true ?: list) +max(uniq(array)) +max({foo: $env}?.add) +max({foo: true, foo: str}?.list) +mean($env | map(0)) +mean($env | reduce(1.0, greet)) +mean($env | reduce(i, nil)) +mean($env.array) +mean($env.array, median(0)) +mean($env.f64) +mean($env.i) +mean($env.i, i) +mean($env.i, sort(array)) +mean($env?.array) +mean($env?.f64) +mean($env?.f64, array) +mean($env?.f64, f64) +mean($env?.i) +mean($env?.i, mean(f64)) +mean(0 % 1) +mean(0 * 1) +mean(0 * 1.0) +mean(0 ** 0) +mean(0 ** 1) +mean(0 ** f64) +mean(0 ** f64, i) +mean(0 + f64) +mean(0 + i) +mean(0 - 0) +mean(0 - 1.0) +mean(0 / 1) +mean(0 / i) +mean(0 ^ f64) +mean(0) <= i +mean(0) == f64 +mean(0) | max(f64) +mean(0, 1.0) >= 1 == nil +mean(1 % 1) +mean(1 % i) +mean(1 ** 0) +mean(1 + 1) +mean(1 + 1.0) +mean(1 + f64) +mean(1 .. 0) +mean(1 / 0) +mean(1 / 1.0) +mean(1 ^ 1.0) +mean(1 ^ f64) +mean(1) * i +mean(1) ** i +mean(1) ^ bitnot(1) +mean(1) not in array +mean(1, 1) * f64 +mean(1, 1.0) < i +mean(1, f64) / f64 +mean(1..i) +mean(1.0 * 0) +mean(1.0 * 1) +mean(1.0 * i) +mean(1.0 ** 0) +mean(1.0 ** 1) +mean(1.0 ** i) +mean(1.0 + 1.0) +mean(1.0 + i) +mean(1.0 - 0) +mean(1.0 - 1) +mean(1.0 - 1.0) +mean(1.0 - i) +mean(1.0 / 1) +mean(1.0 / 1.0) +mean(1.0 / f64) +mean(1.0 ^ 0) +mean(1.0 ^ 1.0) +mean(1.0 ^ f64) +mean(1.0 ^ i) +mean(1.0 | max(1.0)) +mean(1.0) * i +mean(1.0) + i +mean(1.0) / f64 +mean(1.0) >= i || true +mean(1.0) ^ i +mean(1.0) | max(array) +mean([0, array]) +mean([0]) +mean([1.0]) +mean([1]) +mean([array]) +mean([f64, i]) +mean([i, 1.0]) mean([i]) +mean(abs(0)) +mean(abs(1)) +mean(abs(1.0)) +mean(abs(f64)) +mean(abs(i), f64) +mean(array | count(true)) +mean(array | findLastIndex(ok)) +mean(array | map(#index)) +mean(array | max(0)) +mean(array | max(1.0)) +mean(array | mean(array)) +mean(array | sortBy(#)) +mean(array | sortBy(1)) mean(array) -mean(array) * i -mean(array) + i -mean(array) - min(i) -mean(array) / i -mean(array) / i64 -mean(array) < f32 -mean(array) < f64 -mean(array) <= i64 -mean(array) > f32 -mean(array) >= f32 -mean(array) >= i64 -mean(array) ^ i -mean(array) ^ i32 -mean(filter(array, true)) -mean(groupBy(array, i64).score) +mean(array) != add +mean(array) not in array +mean(array) | median(array) +mean(array, array) +mean(array, f64) +mean(array, f64, i) +mean(array, i) +mean(array?.[i]) +mean(array[:0]) +mean(bitnot(1)) +mean(bitnot(1)) ** f64 +mean(bitnot(i)) +mean(bitor(0, 0)) +mean(bitushr(1, 1)) +mean(ceil(0)) +mean(ceil(1)) +mean(ceil(1.0)) +mean(ceil(f64)) +mean(ceil(i)) +mean(concat(array)) +mean(f64 * 0) +mean(f64 * 1.0) +mean(f64 ** 1.0) +mean(f64 ** i) +mean(f64 + 1.0) +mean(f64 - 1.0) +mean(f64 - i) +mean(f64 / 1.0) +mean(f64 ^ 0) +mean(f64 | min(1.0)) +mean(f64) +mean(f64) * i +mean(f64) - f64 +mean(f64) > i +mean(f64) in $env?.array +mean(f64, 0) | median(1) +mean(f64, array) +mean(f64, f64) +mean(f64, i) +mean(f64, sum(array)) +mean(false ? add : 1.0) +mean(false ?: 1) +mean(find(array, ok)) +mean(findIndex($env, true)) +mean(findLastIndex($env, true)) +mean(findLastIndex(array, true)) +mean(first(array), i * i) +mean(flatten(array)) +mean(float(0)) +mean(float(1.0)) +mean(float(f64)) +mean(float(float(f64))) +mean(float(i)) +mean(floor(0)) +mean(floor(1)) +mean(floor(1.0)) +mean(floor(f64)) +mean(floor(i)) +mean(floor(len(str))) +mean(i * 1) +mean(i * 1.0) +mean(i ** 0) +mean(i ** 1.0) +mean(i ** i) +mean(i + 1) +mean(i + 1.0) +mean(i - 1.0) mean(i .. 1) mean(i .. i) +mean(i / 1) +mean(i / i) +mean(i ^ 1.0) +mean(i | max(1, 1.0)) +mean(i | mean(1.0)) +mean(i) +mean(i) ^ f64 +mean(i) in array +mean(i, array) +mean(i, f64) +mean(i, float(f64)) +mean(i, i) +mean(i, int(0)) +mean(if ok { 0 } else { foo }) +mean(int(0)) +mean(int(1)) +mean(int(1.0)) +mean(int(i)) +mean(last(array)) +mean(len(array)) +mean(list | filter(false)) +mean(list | reduce(1)) +mean(list | reduce(array)) +mean(list | reduce(f64)) +mean(map($env, 1)) +mean(map($env, array)) +mean(map($env, f64)) mean(map(array, #)) -mean(map(array, -#)) -mean(map(array, f32)) -mean(map(array, i)) -mean(map(array, i32)) -mean(map(list, 1)) -mean(map(list, f32)) -mean(map(list, i)) -mean(map(list, i32)) -mean(sort(array)) -median(1 .. i) +mean(map(array, 0)) +mean(map(array, f64)) +mean(map(list, 0)) +mean(map(list, array)) +mean(map(list, f64)) +mean(max(0)) +mean(max(1.0)) +mean(max(array)) +mean(max(f64)) +mean(max(i)) +mean(max(i), i) +mean(mean(0)) +mean(mean(1)) +mean(mean(1.0)) +mean(mean(1.0, 0)) +mean(mean(array)) +mean(mean(f64)) +mean(mean(f64, f64)) +mean(mean(i)) +mean(median(0)) +mean(median(0, f64)) +mean(median(1)) +mean(median(1, 0)) +mean(median(1.0)) +mean(median(1.0, f64)) +mean(median(f64)) +mean(median(i)) +mean(min(1)) +mean(min(1, 1.0)) +mean(min(1.0)) +mean(min(1.0, array)) +mean(min(array)) +mean(min(i)) +mean(reduce($env, i, greet)) +mean(reduce(array, #)) +mean(reduce(array, 1.0)) +mean(reduce(list, 1)) +mean(reduce(list, array)) +mean(round(1)) +mean(round(1.0)) +mean(sort($env)) +mean(sortBy(array, #)) +mean(sortBy(array, 1.0)) +mean(sum($env, 1)) +mean(sum($env, 1.0)) +mean(sum($env, f64)) +mean(sum(array)) +mean(sum(array, #)) +mean(sum(array, 1.0)) +mean(true ? 0 : str) +mean(uniq(array)) +median($env | findIndex(true)) +median($env | findLastIndex(ok)) +median($env | sum(0)) +median($env | sum(1.0)) +median($env.array) +median($env.array, f64) +median($env.f64) +median($env.i) +median($env.i, i) +median($env?.array) +median($env?.f64) +median($env?.i) +median($env?.i, $env.i) +median(0 % 1) +median(0 * 1) +median(0 * 1.0) +median(0 * f64) +median(0 * i) +median(0 ** 0) +median(0 ** i) +median(0 + 1) +median(0 + 1.0) +median(0 + i) +median(0 - 0) +median(0 - 1) +median(0 - 1.0) +median(0 .. 0) +median(0 / 1.0) +median(0 / i) +median(0 ^ 1) +median(0 | max(1)) +median(0) * i +median(0) / f64 +median(0) >= i +median(0) not in [nil] +median(1 * 1) +median(1 * 1.0) +median(1 * i) +median(1 ** i) +median(1 + 0) +median(1 + 1) +median(1 + f64) +median(1 + i) +median(1 - 0) +median(1 - 1) +median(1 - 1.0) +median(1 - f64) +median(1 .. 0) +median(1 / 1.0) +median(1 ^ 0) +median(1 ^ 0, f64) +median(1 ^ i) +median(1 | max(array), i) +median(1) != 1.0 && ok +median(1) ^ $env?.f64 +median(1.0 * f64) +median(1.0 * i) +median(1.0 ** 1.0) +median(1.0 ** f64) +median(1.0 ** i) +median(1.0 + 0) +median(1.0 + 1.0) +median(1.0 + f64) +median(1.0 + i) +median(1.0 - 1) +median(1.0 - 1.0) +median(1.0 - i) +median(1.0 / 1) +median(1.0 / 1.0) +median(1.0 / f64) +median(1.0 / i) +median(1.0 ^ 1) +median(1.0 ^ f64) +median(1.0 ^ i) +median(1.0 | mean(i)) +median(1.0) + 1.0 != f64 +median(1.0) + i +median(1.0) - f64 +median(1.0) / f64 +median(1.0) <= f64 +median(1.0) <= i / 0 +median(1.0) > 1.0 ? greet : list +median(1.0) >= f64 +median(1.0) in array +median(1.0) not in array +median(1.0) | max(i) +median(1.0, 0) ** f64 +median(1.1) +median([0]) +median([1 % i]) +median([1, 1.0]) +median([1.0]) +median([1]) +median([1], $env.f64) +median([array]) +median([i]) +median(abs(0)) +median(abs(1)) +median(abs(1.0)) +median(abs(f64)) +median(abs(i)) +median(add(1, 0)) +median(array | find(ok)) +median(array | map(#)) +median(array | reduce(1.0)) +median(array | reduce(i, foo)) +median(array | sortBy(#)) +median(array | sortBy(i)) +median(array | sum(#)) median(array) -median(array) != f32 -median(array) * 1 * f32 -median(array) * i32 -median(array) ** i64 -median(array) + f32 -median(array) >= i32 -median(array) ^ i32 -median(array) ^ i64 -median(array) not in array -median(array[1:1]) -median(filter(array, ok)) -median(groupBy(list, #).i32) +median(array) != ok +median(array) / f64 +median(array) < i +median(array) >= i +median(array) ^ f64 +median(array, $env?.i) +median(array, array) +median(array, f64) +median(array, i .. 0) +median(array, i) +median(array?.[i]) +median(array[0:]) +median(array[1:]) +median(bitand(1, 1)) +median(bitnot(0)) +median(bitnot(1)) +median(bitnot(i)) +median(ceil($env.i)) +median(ceil(0)) +median(ceil(1.0)) +median(ceil(f64)) +median(ceil(i)) +median(concat(array)) +median(count(array[0:0])) +median(f64 * $env?.f64) +median(f64 * f64) +median(f64 ** $env?.i) +median(f64 ** 1.0) +median(f64 + 1.0) +median(f64 + f64) +median(f64 - 1.0) +median(f64 - i) +median(f64 / 1.0) +median(f64 / f64) +median(f64 ^ 1) +median(f64 ^ f64) +median(f64 | min(1.0)) +median(f64) +median(f64) + i +median(f64) < f64 +median(f64, array) +median(f64, array) / 0 == 0 +median(f64, f64) +median(f64, i) +median(f64, i) + i +median(f64, i, 1 - 0) +median(f64, list | sum(i)) +median(filter(list, false)) +median(findIndex($env, true)) +median(first(array)) +median(flatten(array)) +median(float(0)) +median(float(1)) +median(float(1.0)) +median(float(f64)) +median(float(i)) +median(floor(0)) +median(floor(1)) +median(floor(1.0)) +median(floor(f64)) +median(floor(i)) +median(i % i) +median(i * 0) +median(i * 1) +median(i * 1.0) +median(i ** 0) +median(i + 1) +median(i - 1.0) +median(i - i) median(i .. i) -median(i .. i64) -median(i64 .. i64) -median(map(array, #)) -median(map(array, 1)) -median(map(list, 0.5)) -median(map(list, f32)) -median(map(list, i32)) -median(reduce(array, array)) -median(reduce(list, array)) +median(i / 0) +median(i / 1.0) +median(i ^ 1.0) +median(i ^ f64) +median(i ^ i) +median(i | bitnand(i)) +median(i) +median(i) | median(array) +median(i) | min(f64) +median(i, array) +median(i, f64) +median(i, floor(1)) +median(i, i) +median(i..i) +median(if false { $env } else { 1 }) +median(if false { 1.0 } else { i }) +median(int(1)) +median(int(1.0)) +median(int(1.0), array) +median(int(f64)) +median(int(i)) +median(last(array)) +median(len($env)) +median(list | map(array)) +median(list | reduce(i)) +median(map($env, 1)) +median(map($env, f64)) +median(map(list, 1.0)) +median(max(0)) +median(max(1)) +median(max(1.0)) +median(max(1.0, i)) +median(max(i)) +median(mean(0)) +median(mean(1)) +median(mean(1.0)) +median(mean(1.0, i)) +median(mean(array)) +median(mean(f64)) +median(mean(i)) +median(median(0)) +median(median(1, 1.0)) +median(median(1.0)) +median(median(array)) +median(median(f64, i)) +median(median(i)) +median(min(0 * 1)) +median(min(0)) +median(min(1)) +median(min(array)) +median(min(f64)) +median(min(i)) +median(reduce(array, #)) +median(reduce(array, i)) +median(reduce(list, #index)) +median(reduce(list, 1.0)) +median(reverse(array)) +median(round(0)) +median(round(1)) +median(round(1.0)) +median(round(f64)) +median(round(i)) +median(sort($env)) median(sort(array)) -min(-0.5) -min(-0.5, i) -min(-1) -min(-f32) -min(-f64) -min(-half(0.5)) -min(-i) -min(-i32) -min(-i64) -min(0.5 * 0.5) -min(0.5 * 1) -min(0.5 * f32, i32 ** i32) -min(0.5 * f64) -min(0.5 * i32) -min(0.5 * i64) -min(0.5 ** i) -min(0.5 ** i64) -min(0.5 + f64) -min(0.5 + i) -min(0.5 + i32) -min(0.5 - 0.5) -min(0.5 - 1) -min(0.5 - f32) -min(0.5 - f64) -min(0.5 - i) -min(0.5 / 0.5) -min(0.5 / i64) -min(0.5 / i64, i64) -min(0.5 ^ 0.5) -min(0.5 ^ f32) -min(0.5 ^ i) -min(0.5 ^ i32) -min(0.5) != i64 -min(0.5) * i32 -min(0.5) ** f64 -min(0.5) ** i -min(0.5) + f64 ^ i64 -min(0.5) - f32 -min(0.5) - f64 -min(0.5) / i32 -min(0.5) < i32 -min(0.5) == f32 / f32 -min(0.5) == i -min(0.5) >= i64 -min(0.5) ^ (f32 - i64) -min(0.5, 0.5) < f32 + f64 -min(1 % 1) -min(1 % i) -min(1 % i32) -min(1 % i64) -min(1 * 0.5) +median(sum($env, 1.0)) +median(sum(array)) +median(sum(array), f64) +median(sum(array, #)) +median(sum(list, i)) +median(true ? 0 : 1.0, f64) +median(uniq(array)) +min($env | findIndex(false)) +min($env | map(1)) +min($env | map(1.0)) +min($env | reduce(array, 1)) +min($env | sum(1.0)) +min($env | sum(f64)) +min($env) != array +min($env) == greet +min($env) == i +min($env) | all(false) +min($env) | any(false) +min($env) | count(ok) +min($env) | map(f64) +min($env) | reduce(0, 1) +min($env) | sum(0) +min($env).Bar +min($env).String +min($env).add +min($env).array +min($env).f64 +min($env).false?.f64 +min($env).foo +min($env).foobar +min($env).foobar?.ok +min($env).greet +min($env).i +min($env).list +min($env).nil?.foobar +min($env).ok +min($env).str +min($env)?.Bar +min($env)?.Bar?.foobar.foo().list +min($env)?.String +min($env)?.[str] +min($env)?.add +min($env)?.array +min($env)?.f64 +min($env)?.foo +min($env)?.foobar +min($env)?.foobar?.foo.i +min($env)?.greet +min($env)?.i +min($env)?.list +min($env)?.not +min($env)?.ok +min($env)?.str +min($env.array) +min($env.array, sum(array)) +min($env.f64) +min($env.i) +min($env?.$env) +min($env?.Bar) +min($env?.String) +min($env?.[Bar]) +min($env?.[Bar])?.add() +min($env?.[Bar]?.Bar) +min($env?.[Bar]?.[greet]) +min($env?.[String]) +min($env?.[String])?.f64 +min($env?.[foobar]) +min($env?.[str]) +min($env?.array) +min($env?.f64) +min($env?.f64, i) +min($env?.false) +min($env?.foobar) +min($env?.i) +min($env?.nil) +min($env?.true) +min(0 * 1) +min(0 * 1.0) +min(0 * f64) +min(0 ** 0) +min(0 ** 1.0) +min(0 ** i) +min(0 + f64) +min(0 - 1.0) +min(0 - f64) +min(0 - i) +min(0 .. i) +min(0 / 0) +min(0 ^ 1) +min(0 | bitshl(1)) +min(0) * 0 < f64 +min(0) * f64 +min(0) ** f64 +min(0) + i +min(0) - ceil(i) +min(0) ^ f64 +min(0) in array +min(0) | max(0) +min(0.0) min(1 * 1) -min(1 * f32) -min(1 * i) -min(1 * i32) +min(1 ** 0) +min(1 ** 1.0) min(1 ** i) -min(1 + 0.5) -min(1 + 1) -min(1 + f32) -min(1 + i64) -min(1 - 1) +min(1 + 1.0) min(1 - f64) -min(1 - i) -min(1 - i32) -min(1 - i64) -min(1 / 0.5) -min(1 / f32) +min(1 / 0) +min(1 / 1) +min(1 / 1.0) min(1 / i) -min(1 / i32) -min(1 / i64) -min(1 ^ 0.5) -min(1 ^ 1) -min(1 ^ f32) -min(1 ^ i) -min(1 ^ i32) -min(1 ^ i64) -min(1) != i -min(1) - i -min(1) .. i32 -min(1) <= f32 -min(1) <= f64 -min(1) > i64 -min(1) >= i -min(1) >= i64 -min(1) ^ f64 -min(abs(0.5)) +min(1 ^ 0) +min(1 | min(1.0)) +min(1) % i +min(1) < f64 +min(1) < i +min(1) <= i +min(1, 1.0) in array +min(1..i) +min(1.0 * 1.0) +min(1.0 * f64) +min(1.0 ** 0) +min(1.0 ** 1) +min(1.0 ** i) +min(1.0 + 0) +min(1.0 + 1) +min(1.0 + 1.0) +min(1.0 + i) +min(1.0 - 0) +min(1.0 - 1) +min(1.0 - f64) +min(1.0 - i) +min(1.0 / 1) +min(1.0 / 1.0) +min(1.0 / f64) +min(1.0 ^ 1) +min(1.0 ^ 1.0) +min(1.0 ^ f64) +min(1.0 | max(array)) +min(1.0 | min(1.0)) +min(1.0) ** i +min(1.0) - f64 +min(1.0) <= 1.0 + 0 +min(1.0) > i +min(1.0) >= i +min(1.0) not in array +min(1.0, 0) + i +min(1.1) +min([0]) +min([1.0]) +min([1]) +min([array]) +min([f64, 0]) +min([f64]) +min([i]) +min(abs(0)) min(abs(1)) -min(abs(f32)) +min(abs(1.0)) min(abs(f64)) -min(abs(i)) -min(abs(i32)) -min(array[1]) -min(array[i32]) -min(array[i]) -min(bitnand(1, i32)) +min(add(0, 0)) +min(array | find(ok)) +min(array | findIndex(false)) +min(array | findIndex(ok)) +min(array | map(#)) +min(array | reduce(#)) +min(array | reduce(0)) +min(array | reduce(1.0)) +min(array | sortBy(0)) +min(array | sortBy(1.0)) +min(array | sum(#)) +min(array | sum(1.0)) +min(array) +min(array) .. i +min(array) / i +min(array) < 1.0 - i +min(array) | bitushr(0) +min(array) | get(str) +min(array) | median(0) +min(array, 1 - 0) +min(array, array) +min(array, ceil(0)) +min(array, f64) +min(array, float(1.0)) +min(array, i) +min(array, int(0)) +min(array, sortBy(array, #)) +min(array?.[i]) +min(array[:0])?.[greet] +min(array[min(1):]) min(bitnot(1)) min(bitnot(i)) -min(bitnot(i32)) -min(bitnot(i32), i64) -min(bitnot(i64)) -min(ceil(0.5)) min(ceil(1)) -min(ceil(f32)) +min(ceil(1.0)) min(ceil(f64)) min(ceil(i)) -min(count(array, false)) -min(count(list, ok)) -min(f32 * 1) -min(f32 * i64) -min(f32 ** 0.5) -min(f32 - 0.5) -min(f32 - 1) -min(f32 - f64) -min(f32 - i) -min(f32 - i64) -min(f32 / 1) -min(f32 / i64) -min(f32 ^ i32) -min(f32) -min(f32) * i64 -min(f32) / f64 -min(f32) / i32 -min(f32) == i -min(f32) >= f64 -min(f32, -0.5) -min(f32, ceil(1)) -min(f32, f32) -min(f32, f64) -min(f32, i) -min(f32, i32) -min(f32, i64) -min(f64 * 1) +min(count($env, false)) +min(count($env, ok)) min(f64 * f64) -min(f64 ** f32) +min(f64 ** 1) +min(f64 ** 1.0) min(f64 ** f64) -min(f64 + 0.5) -min(f64 + f32) -min(f64 + i64) -min(f64 - 1) +min(f64 + 0) +min(f64 + 1.0) +min(f64 + f64) +min(f64 - 0) +min(f64 - 1.0) min(f64 - i) -min(f64 - i32) -min(f64 / 0.5) -min(f64 / f32) -min(f64 / i) -min(f64 / i64) +min(f64 / 1) +min(f64 / 1.0) +min(f64 ^ 0) min(f64 ^ 1) +min(f64 ^ 1.0) +min(f64 ^ f64) +min(f64 ^ i) min(f64) -min(f64) * f64 -min(f64) * i32 -min(f64) / i -min(f64) >= f64 -min(f64, 0.5 ** i64) -min(f64, 0.5) == f64 -min(f64, f32) +min(f64) <= $env.i +min(f64) not in array +min(f64, 1.0 / 1.0) +min(f64, abs(f64)) +min(f64, array) min(f64, f64) min(f64, i) -min(f64, i32) -min(f64, i64) -min(false ? foo : i32) -min(false ? greet : f32) -min(find(array, false)) -min(find(array, ok)) -min(findIndex(array, false)) -min(findLastIndex(array, i32 > #)) -min(findLastIndex(array, ok)) -min(findLastIndex(array, true)) -min(findLastIndex(list, ok)) +min(f64, min(1.0)) +min(false ? 0 : greet) +min(false ? 0 : nil) +min(false ? array : nil) +min(false ? greet : foo) +min(findLast(array, false)) +min(findLastIndex($env, true)) +min(first($env)) min(first(array)) -min(float(0.5)) +min(flatten(array)) min(float(1)) -min(float(f32)) +min(float(1.0)) min(float(f64)) min(float(i)) -min(float(i64), i) -min(floor(0.5)) -min(floor(1)) -min(floor(f32)) +min(floor(1.0 + i)) +min(floor(1.0)) +min(floor(f64)) min(floor(i)) -min(floor(i32)) -min(floor(i64)) -min(half(0.5)) -min(half(1)) -min(half(1), -1) -min(half(f64 - 0.5)) -min(half(f64)) -min(i % 1) -min(i % i64) +min(groupBy(array, #)?.array) +min(i % i) +min(i * f64) min(i * i) -min(i ** 0.5) -min(i ** i) -min(i + 1) -min(i - 0.5) +min(i + 1.0) +min(i + i) +min(i - 0) min(i - f64) -min(i - i32) -min(i / 1) + f64 -min(i / f64) -min(i ^ f32) -min(i ^ f64) -min(i ^ i) +min(i - i) +min(i .. 0) +min(i / 1.0) +min(i ^ 1.0) +min(i | bitor(0)) +min(i | bitshr(1)) +min(i | min(0)) min(i) -min(i) * f32 -min(i) ** i64 -min(i) / f64 -min(i) / i -min(i) < f64 -min(i) < i32 -min(i) >= i32 -min(i) ^ f32 -min(i, f32) -min(i, f32, i) + i32 +min(i) != $env?.i +min(i) % i +min(i) < i +min(i) <= f64 +min(i, array) +min(i, array) .. i min(i, f64) min(i, i) -min(i, i32) -min(i, i64) -min(i, last(array)) -min(i32 % 1) -min(i32 * f32) -min(i32 * i) -min(i32 ** 0.5) -min(i32 ** i32) -min(i32 + i32) -min(i32 + i64) -min(i32 - 0.5) -min(i32 - i64) -min(i32 / 0.5) -min(i32 / f64) -min(i32 ^ 0.5) -min(i32 ^ f32) -min(i32 ^ f64) -min(i32 ^ i64) -min(i32) -min(i32) - i -min(i32) .. i32 -min(i32) / i -min(i32) < i -min(i32) <= f32 -min(i32) <= i -min(i32) > f32 -min(i32) > i64 + f64 -min(i32) >= i -min(i32) ^ f32 -min(i32) ^ i64 -min(i32, f32) -min(i32, f64 * 0.5) -min(i32, f64) -min(i32, i) -min(i32, i32) -min(i32, i64) -min(i64 % 1) -min(i64 * 0.5) -min(i64 * 1) -min(i64 * bitnot(i64)) -min(i64 * i) -min(i64 * i32) -min(i64 * i64) -min(i64 ** 0.5) -min(i64 ** f64) -min(i64 ** i) -min(i64 ** i32) -min(i64 + f32) -min(i64 - f64) -min(i64 - i32) -min(i64 / 1) -min(i64 / f32) -min(i64 / i) -min(i64 / i32) -min(i64 / i64) -min(i64 ^ 0.5) -min(i64 ^ 1) -min(i64 ^ f64) -min(i64 ^ i32) -min(i64) -min(i64) / f32 -min(i64) < i32 -min(i64) >= f64 -min(i64) not in array -min(i64, f32) -min(i64, f64) -min(i64, i) -min(i64, i32) -min(i64, i64) -min(i64, i64) < i64 -min(int(0.5)) +min(i, max(sum(array))) +min(if false { nil } else { 0 }) +min(if false { ok } else { array }) +min(if true { 1 } else { $env }) +min(if true { 1.0 } else { true }) +min(if true { false } else { foo }) +min(if true { greet } else { 1.0 }) +min(int(0)) min(int(1)) -min(int(f32)) -min(int(f64)) +min(int(1.0)) min(int(i)) -min(int(i32)) -min(int(i64)) -min(last(1 .. 1)) +min(last($env)) min(last(array)) +min(len($env)) min(len(array)) min(len(list)) -min(max(0.5)) -min(max(1, 0.5)) -min(max(f32)) +min(len(str)) +min(list | count(false)) +min(list | count(true)) +min(list | findIndex(false)) +min(list | reduce(1)) +min(list | reduce(1.0)) +min(list | reduce(array)) +min(list | sum(1)) +min(list[1:1]) +min(map($env, 0)) +min(map($env, array)) +min(map(array, #)) +min(map(array, #index)) +min(map(array, 1.0)) +min(map(list, f64)) +min(max($env)) +min(max(0)) +min(max(0, 1)) +min(max(0, 1.0, 0)) +min(max(1)) +min(max(1.0)) +min(max(1.0, 1.0)) +min(max(array)) min(max(f64)) min(max(i)) -min(max(i64, 1)) +min(mean(0)) +min(mean(1)) +min(mean(1.0)) min(mean(array)) -min(min(1)) -min(min(1, 1, 1)) -min(min(1, i, f32)) +min(mean(f64)) +min(mean(i)) +min(median(0)) +min(median(1)) +min(median(1.0)) +min(median(array)) +min(median(f64)) +min(min($env)) +min(min(0)) +min(min(1.0)) +min(min(1.0, 1)) +min(min(f64)) +min(min(f64, 1.0)) min(min(i)) -min(min(i32)) -min(min(reduce(list, f32))) -min(ok ? array : false) -min(ok ? f64 : i) -min(ok ? half : ok) -min(ok ? i : f32) -min(ok ? array : score) -min(ok ? true : div) -min(reduce(array, #)) -min(reduce(array, 0.5)) -min(reduce(array, 1)) -min(reduce(list, 1)) -min(round(0.5)) +min(ok ?: 1.0) +min(reduce(array, i)) +min(reduce(list, f64)) +min(reduce(list, f64), $env?.array) +min(reverse(array)) +min(round(0)) +min(round(0), array) min(round(1)) -min(round(f32)) -min(round(i32)) -min(round(i64)) -min(score(1)) -min(score(i)) +min(round(1.0)) +min(round(f64)) +min(sort(array)) +min(sortBy(array, f64)) +min(sum($env, 1)) +min(sum($env, 1.0)) min(sum(array)) -min(true ? i : "foo") -min(true ? i : i32) -min(true ? i64 : "foo") -nil != array != nil ? add : half -nil != array && ok -nil != div == reduce(array, ok) -nil != f64 || ok || false -nil != false && ok -nil != false or i == nil -nil != foo and ok +min(sum(array), array) +min(sum(array, #)) +min(sum(array, 1.0)) +min(sum(list, 1)) +min(sum(list, f64)) +min(true ? 1.0 : str) +min(true ? nil : i) +min(true ?: add) +min(uniq(array)) +min({foo: 0}.foo) +min({foo: add}.i) +min({foo: i}?.i) +min({foo: nil}?.i) +min({foo: sum(array)}.array) +nil != $env.add +nil != $env.array +nil != $env.f64 +nil != $env.foo +nil != $env.greet +nil != $env.i +nil != $env.list +nil != $env.ok +nil != $env.str +nil != $env?.Bar +nil != $env?.String +nil != $env?.[1.0 | first(nil)] +nil != $env?.[Bar] +nil != $env?.[String] +nil != $env?.[foobar] +nil != $env?.[greet(foobar)] +nil != $env?.[str] +nil != $env?.add +nil != $env?.array +nil != $env?.f64 +nil != $env?.foo +nil != $env?.greet +nil != $env?.i +nil != $env?.list +nil != $env?.ok +nil != $env?.str +nil != 0 - i +nil != 0 / f64 +nil != 0 ?: array +nil != 0 ^ $env?.i +nil != 1 % i +nil != 1.0 ?: reduce($env, #.String, true) +nil != 1.0 ^ f64 +nil != 1.0 or 1.0 == 1 +nil != add and ok +nil != array?.[i] +nil != f64 / f64 && ok +nil != f64 or i == i +nil != false || $env > $env +nil != foo ?: greet +nil != foo ?: list nil != foo.Bar -nil != foo.Qux nil != foo.String nil != foo.String() nil != foo?.Bar -nil != foo?.Qux nil != foo?.String nil != foo?.String() -nil != nil ? score : div -nil != true || i < 1 -nil == "foo" != ok -nil == "foo" && 0.5 < f64 -nil == 0.5 and reduce(list, true) -nil == add && 0.5 >= 0.5 -nil == add || f32 >= i64 -nil == array and ok -nil == array or ok -nil == array[i64] -nil == div ? f64 : ok -nil == false && nil != true -nil == false ? i64 : toBase64("bar") +nil != greet ?: i +nil != list?.[i] +nil != list?.[i]?.Bar +nil != list?.[i]?.String +nil != list[:] +nil != nil && $env?.[array] +nil != ok || abs($env) +nil != str && get($env, nil) +nil != true || $env == 1.0 +nil == $env or f64 < 1.0 +nil == $env.add +nil == $env.array +nil == $env.f64 +nil == $env.foo +nil == $env.greet +nil == $env.i +nil == $env.list +nil == $env.ok +nil == $env.str +nil == $env?.Bar +nil == $env?.String +nil == $env?.String?.[list] +nil == $env?.[Bar] +nil == $env?.[String] +nil == $env?.[foo.Bar] +nil == $env?.[foobar?.[i]] +nil == $env?.[foobar] +nil == $env?.[str] +nil == $env?.add +nil == $env?.array +nil == $env?.f64 +nil == $env?.foo +nil == $env?.foobar +nil == $env?.foobar?.add(foobar, foobar) +nil == $env?.greet +nil == $env?.i +nil == $env?.list +nil == $env?.ok +nil == $env?.str +nil == 0 ** 1.0 ? nil : nil +nil == 0 || ok +nil == 1 * i +nil == 1 and find($env, #.add)?.[i] +nil == 1.0 ?: i +nil == 1.0 ^ f64 +nil == array?.[i] +nil == f64 * f64 +nil == foo != ok +nil == foo and ok nil == foo.Bar -nil == foo.Qux nil == foo.String nil == foo.String() nil == foo?.Bar -nil == foo?.Qux nil == foo?.String -nil == greet ? i : greet("bar") -nil == list || f32 == i -nil == list[i32] +nil == foo?.String() +nil == greet != $env?.Bar +nil == greet and $env?.[list] +nil == greet or ok +nil == i + i +nil == i and ok +nil == i in $env?.[String] +nil == list?.[i] +nil == nil != $env?.[String] +nil == nil != nil || false nil == nil and ok -nil in array || score == nil -nil in list != not false -none(1 .. i, # < #) -none(1 .. i32, # <= #) -none([foo, list, 1 >= i], ok) -none([greet], ok) -none([true], #) -none(array, !(i32 != i32)) -none(array, !false) -none(array, !true) -none(array, "bar" endsWith "foo") +nil == ok != ok +nil == str != false || true +nil in $env.array +nil in $env.list +nil in $env?.Bar +nil in $env?.String +nil in $env?.[Bar] +nil in $env?.[String] +nil in $env?.array +nil in $env?.foobar?.i(false) +nil in $env?.list +nil in list && ok +nil in list and $env == foo +nil in list or ok +nil not in $env or ok +nil not in $env || 0 <= $env +nil not in $env.array +nil not in $env.list +nil not in $env?.$env?.ok +nil not in $env?.Bar +nil not in $env?.Bar?.str +nil not in $env?.String +nil not in $env?.String?.greet +nil not in $env?.[Bar] +nil not in $env?.[String] +nil not in $env?.[foobar] +nil not in $env?.array +nil not in $env?.foobar?.[list] +nil not in $env?.foobar?.add(nil, f64) +nil not in $env?.list +nil not in array ?: i +nil not in list[i:] +nil; $env.greet +nil; $env.ok +none($env | map($env), .f64 != foo) +none($env, false) && ok == true +none($env.array, str not in $env) +none($env?.[str], 1 > f64) +none($env?.[str], ok) +none(1 .. 0, $env < $env) +none(1 .. 0, $env | all(ok)) +none([$env, foo], false != #) +none([$env], .f64 in #.String) +none([1.0], ok) +none([greet, 1.0], ok) +none([nil, foo], ok) none(array, # != #) -none(array, # != 0.5) -none(array, # != 1) -none(array, # != f32) -none(array, # != f64) -none(array, # != i) -none(array, # < #) -none(array, # < 0.5) -none(array, # < f32) -none(array, # < i32) -none(array, # < i64) +none(array, # != 0) +none(array, # != nil) +none(array, # < 1) none(array, # <= #) -none(array, # <= 0.5) -none(array, # <= 1) -none(array, # <= f32) -none(array, # <= i) -none(array, # <= i32) -none(array, # <= i64) -none(array, # == #) -none(array, # == 0.5) -none(array, # == f32) -none(array, # == i32) -none(array, # == i64) -none(array, # == nil) -none(array, # > #) -none(array, # > 0.5) -none(array, # > i) +none(array, # == 0) none(array, # >= #) -none(array, # >= 0.5) -none(array, # >= 1) -none(array, # >= f32) -none(array, # >= f64) -none(array, # >= i32) -none(array, # >= i64) -none(array, # in array) -none(array, 0.5 != #) -none(array, 0.5 != 1) -none(array, 0.5 < #) -none(array, 0.5 < i64) -none(array, 0.5 <= #) -none(array, 0.5 <= 1) -none(array, 0.5 <= f64) -none(array, 0.5 == #) -none(array, 0.5 > 0.5) -none(array, 0.5 > 1) -none(array, 0.5 > f32) -none(array, 0.5 >= #) -none(array, 0.5 >= 1) -none(array, 1 < #) -none(array, 1 <= #) -none(array, 1 == 1) -none(array, 1 > #) -none(array, any(array, true)) -none(array, f32 != #) -none(array, f32 < 0.5) -none(array, f32 < 1) -none(array, f32 == 1) -none(array, f32 > #) -none(array, f32 >= #) -none(array, f32 >= 1) -none(array, f32 >= f32) -none(array, f64 != 1) +none(array, $env == foo) +none(array, $env.ok) +none(array, 0 <= 0) +none(array, 1 == #) +none(array, add == add) none(array, f64 == #) -none(array, f64 > #) -none(array, f64 >= #) none(array, i != #) none(array, i < #) -none(array, i < f64) -none(array, i <= #) -none(array, i > #) -none(array, i >= #) -none(array, i >= 0.5) -none(array, i >= i32) -none(array, i32 != #) -none(array, i32 != i) -none(array, i32 != nil) -none(array, i32 < #) -none(array, i32 > #) -none(array, i64 != #) -none(array, i64 != 0.5) -none(array, i64 > i64) -none(array, i64 >= #) -none(array, nil != "bar") -none(array, nil != #) -none(array, nil != false) -none(array, nil != greet) -none(array, nil == #) -none(array, nil == 1) -none(array, nil == f32) -none(array, nil == greet) -none(array, nil == half) -none(array, not (# == #)) -none(array, not (# >= 1)) -none(array, not false) +none(array, nil == i) +none(array, ok && false) none(array, ok) -none(array, reduce(array, true)) -none(filter(array, # >= f64), ok) -none(groupBy(array, #).f64, # or #.Bar) -none(groupBy(list, #).div, ok) -none(groupBy(list, #).greet, #) -none(groupBy(list, 0.5).i, ok) -none(i .. i, ok) -none(i .. i32, # <= #) -none(list, !false) -none(list, !ok) -none(list, "bar" contains "bar") -none(list, # != #) +none(concat(array), f64 >= #) +none(flatten(array), ok) +none(list | map($env), #.ok) +none(list | map(str), ok) none(list, # != foo) -none(list, # != nil) none(list, # == #) -none(list, # == foo) -none(list, # in list) -none(list, # not in list) -none(list, (0.5 not in array) || ok) -none(list, 0.5 != i32) -none(list, 0.5 > f64) -none(list, 0.5 > i) -none(list, 1 != i64) -none(list, 1 != nil) -none(list, 1 == f32) -none(list, 1 > 0.5) -none(list, all(array, ok)) -none(list, f32 != 1 ** f64) -none(list, f32 >= 0.5) -none(list, f32 in array) -none(list, f32 not in array) -none(list, f64 <= i32) -none(list, f64 >= 1) -none(list, false) ? ok : half -none(list, false) || ok -none(list, foo != #) +none(list, $env != $env) +none(list, $env != i) +none(list, $env != nil) +none(list, $env.ok) +none(list, 1 == f64) +none(list, 1.0 > 1.0) +none(list, array == $env) +none(list, f64 != $env) +none(list, false != true) +none(list, foo != foo) +none(list, foo == #) none(list, foo == foo) -none(list, i != i) -none(list, i != i64) -none(list, i >= f32) -none(list, i32 == f32) -none(list, i32 > 1) -none(list, i32 > i64) -none(list, i32 not in array) -none(list, i64 != 0.5) -none(list, i64 > i64) -none(list, nil != #) -none(list, nil != greet) -none(list, nil != i64) -none(list, nil == #) -none(list, nil == list) -none(list, not false) +none(list, ok == $env) none(list, ok) -none(list, one(array, true)) -none(list, true && ok) -none(list, true) and ok -none(map(array, #), ok) -none(map(array, div), # != #) -none(map(array, f64 == #), ok) -none(map(list, "bar"), # endsWith #) -none(map(list, #), nil == list) -none(map(list, #), ok) -none(map(list, 1), i > #) -none(map(list, ok), # ? true : #) -none(map(list, ok), #) -none(map(list, score), ok) -none(sort(filter(array, false)), #?.div > greet(#)) -not !(0.5 != i64) -not !(i < 1) -not !(i >= 0.5) -not !(i32 != i32) -not !(nil != false) -not !false -not !not false -not !ok -not !true -not ("bar" != "bar") -not ("bar" != "foo") -not ("bar" != nil) -not ("bar" < "bar") -not ("bar" < "foo") -not ("bar" <= "bar") -not ("bar" <= "foo") -not ("bar" == "bar") -not ("bar" == "foo") -not ("bar" == nil) -not ("bar" > "bar") -not ("bar" > "foo") -not ("bar" >= "bar") -not ("bar" >= "foo") -not ("bar" contains "bar") -not ("bar" contains "foo") -not ("bar" endsWith "bar") -not ("bar" endsWith "foo") -not ("bar" in foo) -not ("bar" matches "bar") -not ("bar" matches "foo") -not ("bar" not contains "bar") -not ("bar" not contains "foo") -not ("bar" not endsWith "bar") -not ("bar" not endsWith "foo") -not ("bar" not in foo) -not ("bar" not matches "bar") -not ("bar" not matches "foo") -not ("bar" not startsWith "bar") -not ("bar" not startsWith "foo") -not ("bar" startsWith "bar") -not ("bar" startsWith "foo") -not ("foo" != "bar") -not ("foo" != "foo") -not ("foo" != nil) -not ("foo" < "bar") -not ("foo" < "foo") -not ("foo" <= "bar") -not ("foo" <= "foo") -not ("foo" == "bar") -not ("foo" == "foo") -not ("foo" == nil) -not ("foo" > "bar") -not ("foo" > "foo") -not ("foo" >= "bar") -not ("foo" >= "foo") -not ("foo" contains "bar") -not ("foo" contains "foo") -not ("foo" endsWith "bar") -not ("foo" endsWith "foo") -not ("foo" in foo) -not ("foo" matches "bar") -not ("foo" matches "foo") -not ("foo" not contains "bar") -not ("foo" not contains "foo") -not ("foo" not endsWith "bar") -not ("foo" not endsWith "foo") -not ("foo" not in foo) -not ("foo" not matches "foo") -not ("foo" not startsWith "foo") -not ("foo" startsWith "bar") -not ("foo" startsWith "foo") -not (0.5 != 0.5) -not (0.5 != 1) -not (0.5 != f32) -not (0.5 != f64) -not (0.5 != i) -not (0.5 != i32) -not (0.5 != i64) -not (0.5 != nil) -not (0.5 < 0.5) -not (0.5 < 1) -not (0.5 < f32) -not (0.5 < f64) -not (0.5 < i) -not (0.5 < i32) -not (0.5 < i64) -not (0.5 <= 0.5) -not (0.5 <= 1) -not (0.5 <= f32) -not (0.5 <= f64) -not (0.5 <= i) -not (0.5 <= i32) -not (0.5 <= i64) -not (0.5 == 0.5) -not (0.5 == 1) -not (0.5 == f32) -not (0.5 == f64) -not (0.5 == i && i32 != i32) -not (0.5 == i) -not (0.5 == i32) -not (0.5 == i64) -not (0.5 == nil) -not (0.5 > 0.5) -not (0.5 > 1) -not (0.5 > f32) -not (0.5 > f64) -not (0.5 > i) -not (0.5 > i32) -not (0.5 > i64) -not (0.5 >= 0.5) -not (0.5 >= 1) -not (0.5 >= f32) -not (0.5 >= f64) -not (0.5 >= i) -not (0.5 >= i32) -not (0.5 >= i64) -not (0.5 in array) -not (0.5 not in array) -not (1 != 0.5) -not (1 != 1) -not (1 != f32) -not (1 != f64) -not (1 != i) -not (1 != i32) -not (1 != i64) -not (1 != nil) -not (1 < 0.5) -not (1 < 1) -not (1 < f32) -not (1 < f64) -not (1 < i) -not (1 < i32) -not (1 < i64) -not (1 <= 0.5) -not (1 <= 1) -not (1 <= f32) -not (1 <= f64) -not (1 <= i) -not (1 <= i32) -not (1 <= i64) -not (1 == 0.5) -not (1 == 1) -not (1 == f32) -not (1 == f64) -not (1 == i) -not (1 == i32) -not (1 == i64) -not (1 == nil) -not (1 > 0.5) -not (1 > 1) -not (1 > f32) -not (1 > f64) -not (1 > i) -not (1 > i32) -not (1 > i64) -not (1 >= 0.5) -not (1 >= 1) -not (1 >= f32) -not (1 >= f64) -not (1 >= i) -not (1 >= i32) -not (1 >= i64) -not (1 in array) -not (1 not in array) -not (add != add) -not (add != nil) -not (add == div) -not (add == nil) -not (array != array) -not (array != list) -not (array != nil) -not (array == array) -not (array == list) -not (array == nil) -not (array[i32] > i64) -not (div != add) -not (div != div) -not (div != nil) -not (div == add) -not (div == div) -not (div == nil) -not (f32 != 0.5) -not (f32 != 1) -not (f32 != f32) -not (f32 != f64) -not (f32 != i) -not (f32 != i32) -not (f32 != i64) -not (f32 != nil) -not (f32 < 0.5) -not (f32 < 1) -not (f32 < f32) -not (f32 < f64) -not (f32 < i) -not (f32 < i32) -not (f32 < i64) -not (f32 <= 0.5) -not (f32 <= 1) -not (f32 <= f64) -not (f32 <= i) -not (f32 <= i32) -not (f32 <= i64) -not (f32 == 0.5) -not (f32 == 1) -not (f32 == f32) -not (f32 == f64) -not (f32 == i) -not (f32 == i32) -not (f32 == i64) -not (f32 == nil) -not (f32 > 0.5) -not (f32 > 1) -not (f32 > f32) -not (f32 > f64) -not (f32 > i) -not (f32 > i32) -not (f32 > i64) -not (f32 >= 0.5) -not (f32 >= 1) -not (f32 >= f32) -not (f32 >= f64) -not (f32 >= i) -not (f32 >= i32) -not (f32 >= i64) -not (f32 in array) -not (f32 not in array) -not (f64 != 0.5) -not (f64 != 1) -not (f64 != f32) -not (f64 != f64) -not (f64 != i) -not (f64 != i32) -not (f64 != i64) -not (f64 != nil) -not (f64 < 0.5) -not (f64 < 1) -not (f64 < f32) -not (f64 < f64) -not (f64 < i32) -not (f64 < i64) -not (f64 <= -0.5) -not (f64 <= 0.5) -not (f64 <= 1) -not (f64 <= f32) -not (f64 <= f64) -not (f64 <= i) -not (f64 <= i32) -not (f64 <= i64) -not (f64 == 0.5) -not (f64 == 1) -not (f64 == f64) -not (f64 == i) -not (f64 == i32) -not (f64 == i64) -not (f64 == nil) -not (f64 > 0.5) -not (f64 > 1) -not (f64 > f32) -not (f64 > f64) -not (f64 > i) -not (f64 > i32) -not (f64 > i64) -not (f64 >= 0.5) -not (f64 >= 1) -not (f64 >= f32) -not (f64 >= f64) -not (f64 >= i) -not (f64 >= i32) -not (f64 >= i64) -not (f64 in array) -not (f64 not in array) -not (false != false) -not (false != nil) -not (false != ok) -not (false != true) -not (false && false) -not (false && ok) -not (false == nil) -not (false == ok) -not (false and false) -not (false and ok) -not (false and true) -not (false or false) -not (false or ok) -not (false or true) -not (false || false) -not (false || ok) -not (false || true) -not (findIndex(list, ok) != i ^ f64) -not (foo != foo) -not (foo != nil) -not (foo == foo) -not (foo == nil) -not (foo in list) -not (foo not in list) -not (greet != greet) -not (greet != nil) -not (greet == greet) -not (greet == nil) -not (half != half) -not (half != nil) -not (half == half) -not (half == nil) -not (i != 0.5) -not (i != 1) -not (i != f32) -not (i != f64) -not (i != i) -not (i != i32) -not (i != i64) -not (i != nil) -not (i < 0.5) -not (i < 1) -not (i < f32) -not (i < f64) -not (i < i) -not (i < i32) -not (i < i64) -not (i <= 0.5) -not (i <= 1) -not (i <= f32) -not (i <= f64) -not (i <= i) -not (i <= i32) -not (i <= i64) -not (i == 0.5) -not (i == 1) -not (i == ceil(f64)) -not (i == f32) -not (i == f64) -not (i == i) -not (i == i32) -not (i == i64) -not (i == nil) -not (i > 0.5) -not (i > 1) -not (i > f32) -not (i > f64) -not (i > i) -not (i > i32) -not (i > i64) -not (i >= 0.5) -not (i >= 1) -not (i >= f32) -not (i >= f64) -not (i >= i) -not (i >= i32) -not (i >= i64) -not (i in array) -not (i not in array) -not (i32 != 0.5) -not (i32 != 1) -not (i32 != f32) -not (i32 != f64) -not (i32 != i) -not (i32 != i32) -not (i32 != i64) -not (i32 != nil) -not (i32 < 0.5) -not (i32 < 1) -not (i32 < f32 ** 0.5) -not (i32 < f32) -not (i32 < f64) -not (i32 < i) -not (i32 < i32) -not (i32 < i64) -not (i32 <= 0.5) -not (i32 <= 1) -not (i32 <= f32) -not (i32 <= f64) -not (i32 <= i) -not (i32 <= i32) -not (i32 <= i64) -not (i32 == -i) -not (i32 == 0.5) -not (i32 == 1) -not (i32 == f32) -not (i32 == f64) -not (i32 == i) -not (i32 == i32) -not (i32 == i64) -not (i32 == nil) -not (i32 > 0.5) -not (i32 > 1) -not (i32 > f32) -not (i32 > f64) -not (i32 > i) -not (i32 > i32) -not (i32 > i64) -not (i32 >= 0.5) -not (i32 >= 1) -not (i32 >= f32) -not (i32 >= f64) -not (i32 >= i) -not (i32 >= i32) -not (i32 >= i64) -not (i32 in array) -not (i32 not in array) -not (i64 != 0.5) -not (i64 != 1) -not (i64 != f32) -not (i64 != f64) -not (i64 != i) -not (i64 != i32) -not (i64 != i64) -not (i64 != nil) -not (i64 < 0.5) -not (i64 < 1) -not (i64 < f32) -not (i64 < f64) -not (i64 < i) -not (i64 < i32) -not (i64 < i64) -not (i64 <= 0.5) -not (i64 <= 1) -not (i64 <= f32) -not (i64 <= f64) -not (i64 <= i) -not (i64 <= i32) -not (i64 <= i64) -not (i64 == 0.5) -not (i64 == 1) -not (i64 == f32) -not (i64 == f64) -not (i64 == i) -not (i64 == i32) -not (i64 == i64) -not (i64 == nil) -not (i64 > 0.5) -not (i64 > 1) -not (i64 > f32) -not (i64 > f64) -not (i64 > i) -not (i64 > i32) -not (i64 > i64) -not (i64 >= 0.5) -not (i64 >= 1) -not (i64 >= f32) -not (i64 >= f64) -not (i64 >= i) -not (i64 >= i32) -not (i64 >= i64) -not (i64 not in array) -not (list != array) -not (list != list) -not (list != nil) -not (list == array) -not (list == list) -not (list == nil) -not (nil != "bar") -not (nil != "foo") -not (nil != 0.5) -not (nil != 1) -not (nil != add) -not (nil != array) -not (nil != div) -not (nil != f32) -not (nil != f64) -not (nil != false) -not (nil != foo) -not (nil != half) -not (nil != i) -not (nil != i32) -not (nil != i64) -not (nil != list) -not (nil != nil) -not (nil != ok) -not (nil != score) -not (nil != true) -not (nil == "bar") -not (nil == "foo") -not (nil == 0.5) -not (nil == 1) -not (nil == add) -not (nil == array) -not (nil == div) -not (nil == f32) -not (nil == f64) -not (nil == false) -not (nil == foo) -not (nil == greet) -not (nil == half) -not (nil == i) -not (nil == i32) -not (nil == i64) -not (nil == list) -not (nil == nil) -not (nil == ok) -not (nil == score) -not (nil == true) -not (nil in array) -not (nil in list) -not (nil not in array) -not (nil not in list) -not (ok != nil) -not (ok != ok) -not (ok != true) -not (ok && false) -not (ok && ok) -not (ok && true) -not (ok == false) -not (ok == nil) -not (ok == ok) -not (ok == true) -not (ok and false) -not (ok and ok) -not (ok and true) -not (ok or false) -not (ok or ok) -not (ok or true) -not (ok || ok) -not (ok || true) -not (score != nil) -not (score != score) -not (score == nil) -not (score == score) -not (true != false) -not (true != nil) -not (true != ok) -not (true != true) -not (true && false) -not (true && true) -not (true == false) -not (true == nil) -not (true == ok) -not (true == true) -not (true and false) -not (true and ok) -not (true and true) -not (true or false) -not (true or ok) -not (true or true) -not (true || false) -not (true || ok) -not (true || true) -not all(array, false) -not all(array, ok) -not all(array, true) -not all(list, nil == #) -not all(list, ok) -not all(list, true) -not any(array, false) -not any(array, ok) -not any(array, true) -not any(list, false) -not any(list, ok) -not any(list, true) -not false && nil == f64 -not false && ok -not false == ok -not false ? "foo" : "foo" -not false ? 0.5 : "foo" -not false ? 0.5 : array -not false ? 0.5 : div -not false ? 0.5 : foo -not false ? 0.5 : i64 -not false ? 0.5 : nil -not false ? 1 : 0.5 -not false ? add : array -not false ? array : 0.5 -not false ? array : 1 -not false ? array : f64 -not false ? array : i -not false ? array : true -not false ? div : 0.5 -not false ? div : f64 -not false ? f32 : 0.5 -not false ? f32 : 1 -not false ? f32 : i -not false ? f32 : nil -not false ? f32 : score -not false ? f64 : "foo" -not false ? f64 : f64 -not false ? false : half -not false ? false : list -not false ? foo : f64 -not false ? greet : 1 -not false ? i : "bar" -not false ? i : 1 -not false ? i : array -not false ? i : i -not false ? i32 : greet -not false ? i64 : list -not false ? list : i -not false ? list : true -not false ? nil : f32 -not false ? nil : half -not false ? nil : ok -not false ? ok : 1 -not false ? score : ok -not false ? true : f64 -not false ? true : nil -not false or false == false -not false or ok -not false || ok -not none(array, # > f32) -not none(array, false) -not none(array, ok) -not none(array, true) -not none(list, false) -not none(list, ok) -not none(list, true) -not not (f64 <= 1) -not not (i32 < i64) -not not (i64 >= f64) -not not (nil != greet) -not not (ok or ok) -not not false -not not ok -not not true -not ok -not ok != ok -not ok && 1 > 0.5 -not ok && ok -not ok ? "bar" : list -not ok ? "foo" : 0.5 -not ok ? "foo" : 1 -not ok ? 0.5 : "bar" -not ok ? 0.5 : 0.5 -not ok ? 0.5 : i -not ok ? 1 : f64 -not ok ? 1 : nil -not ok ? add : array -not ok ? add : groupBy(array, #) -not ok ? array : 1 -not ok ? array : f32 -not ok ? div : f64 -not ok ? f32 : f32 -not ok ? f64 : f64 -not ok ? f64 : half -not ok ? foo : foo -not ok ? greet : 0.5 -not ok ? half : half -not ok ? i : 1 -not ok ? i : add -not ok ? i32 : 1 -not ok ? i32 : i -not ok ? i64 : f32 -not ok ? i64 : f64 -not ok ? nil : "bar" -not ok ? nil : 0.5 -not ok ? nil : foo -not ok ? nil : greet -not ok ? nil : i -not ok ? ok : false -not ok ? ok : list -not ok ? score : "foo" -not ok ? score : score -not ok ? true : 1 -not ok ? true : div -not ok ? true : half -not ok ? true : i64 -not ok ? true : nil -not ok and "foo" == "foo" -not ok and i32 > 0.5 -not ok and ok -not ok or 1 != i -not ok or ok -not ok || array == list -not ok || ok -not one(array, false) -not one(array, ok) -not one(array, true) -not one(list, false) -not one(list, ok) -not one(list, true) -not reduce(array, false) -not reduce(array, ok) -not reduce(array, true) -not reduce(list, false) -not reduce(list, ok) -not reduce(list, true) -not true != ok -not true && ok -not true == ok -not true ? "bar" : array -not true ? "bar" : i32 -not true ? "foo" : f32 -not true ? "foo" : f64 -not true ? 0.5 : foo -not true ? 0.5 : greet -not true ? 0.5 : i -not true ? 0.5 : i64 -not true ? 1 : f32 -not true ? add : i32 -not true ? add : ok -not true ? array : nil -not true ? f32 : 0.5 -not true ? f32 : div -not true ? f64 : 1 -not true ? f64 : array -not true ? foo : greet -not true ? foo : ok -not true ? greet : 1 -not true ? greet : i64 -not true ? greet : list -not true ? greet : true -not true ? half : half -not true ? i : f64 -not true ? i64 : "foo" -not true ? i64 : array -not true ? i64 : i64 -not true ? list : "bar" -not true ? list : f64 -not true ? list : foo -not true ? nil : div -not true ? ok : nil -not true ? score : f32 -not true ? score : score -not true ? true : 1 -not true and ok ? i : half -not true || ok +none(list, str < .Bar) +none(list, true == $env) +none(map($env, 1.0), ok) +none(map(list, $env), ok) +none(sort($env), #.add?.greet(foo)) ok -ok != !ok -ok != (0.5 not in array) -ok != false != ok -ok != false ? f32 : list -ok != nil == nil -ok != nil ? f32 : greet -ok != nil ? nil : array -ok != not ok +ok != $env and $env +ok != $env.ok +ok != $env?.Bar +ok != $env?.String +ok != $env?.[Bar] +ok != $env?.[String] +ok != $env?.[str] +ok != $env?.foobar +ok != $env?.foobar?.greet +ok != $env?.ok +ok != any($env, ok) +ok != any(array, false) +ok != false && $env +ok != false or false +ok != nil && ok +ok != nil == ok and ok +ok != nil ? f64 : 1 +ok != nil and $env ok != ok -ok != ok ? false : "bar" -ok && !false -ok && !ok -ok && "foo" matches "bar" -ok && ("bar" not endsWith "bar") -ok && (false || ok) -ok && (ok or false) -ok && (true || true) -ok && 0.5 < 1 -ok && 0.5 < f64 -ok && 0.5 <= 1 -ok && 0.5 == nil -ok && 0.5 > i64 -ok && 1 != 0.5 -ok && 1 != i32 -ok && 1 <= 1 -ok && 1 <= f64 -ok && 1 == 0.5 -ok && 1 == nil -ok && 1 >= f64 -ok && f32 != i -ok && f32 >= i64 -ok && f64 <= 0.5 -ok && false != ok -ok && false ? i : list -ok && false ? ok : ok -ok && i < 0.5 -ok && i < i64 -ok && i == 0.5 -ok && i > f64 -ok && i32 > 0.5 -ok && i32 >= i64 -ok && i64 != i -ok && i64 == 0.5 -ok && nil != 0.5 -ok && nil != 1 -ok && nil == ok -ok && not false -ok && not true +ok != sum($env?.[str]) +ok != true != nil +ok != true != true +ok != true && ok +ok && $env != array +ok && $env != str +ok && $env == foo +ok && $env == greet +ok && $env not in array +ok && $env.ok +ok && $env?.Bar +ok && $env?.String +ok && $env?.String?.String +ok && $env?.String?.list +ok && $env?.[Bar] +ok && $env?.[Bar]?.add +ok && $env?.[String] +ok && $env?.[foobar?.Bar] +ok && $env?.[foobar] +ok && $env?.[str] +ok && $env?.foobar +ok && $env?.ok +ok && 0 < 0 +ok && 1 != i +ok && 1 == 1 +ok && 1 == f64 +ok && 1.0 != $env +ok && 1.0 != 1.0 +ok && 1.0 != f64 +ok && 1.0 < f64 +ok && 1.0 > 1 +ok && add != $env +ok && add != $env?.String +ok && f64 > 1 or $env +ok && f64 > 1.0 +ok && foo != foo +ok && foo != nil +ok && i <= f64 +ok && i >= 1 +ok && i not in array +ok && max($env) +ok && median(array) +ok && nil != $env +ok && nil == i +ok && nil == true +ok && nil in array ok && ok -ok && ok ? nil : div -ok && ok and false -ok && true != false -ok && true && 1 >= i64 -ok == !false -ok == !true -ok == ("bar" not endsWith "foo") -ok == (0.5 not in array) -ok == (false and ok) -ok == (i32 not in array) -ok == (nil not in list) -ok == false ? f64 : 1 -ok == false ? score : 1 -ok == nil ? i64 : add -ok == nil ? nil : f64 -ok == none(array, true) -ok == not false +ok && ok && $env?.[str] +ok && ok == ok +ok && ok and $env +ok && ok or false +ok && ok || false +ok && one(list, false) +ok && str endsWith str +ok && true || $env?.String +ok == $env && ok +ok == $env || ok +ok == $env.ok +ok == $env?.Bar +ok == $env?.String +ok == $env?.String?.[greet] +ok == $env?.[Bar] +ok == $env?.[Bar]?.[array] +ok == $env?.[String] +ok == $env?.[str] +ok == $env?.foobar +ok == $env?.nil +ok == $env?.ok +ok == false != nil +ok == mean(array) +ok == min($env) +ok == nil != true +ok == nil ? 1.0 : $env ok == ok -ok == ok != false -ok == true && ok -ok ? "bar" : f64 <= f32 -ok ? "foo" : foo.Bar -ok ? -0.5 : add -ok ? -f64 : list -ok ? -i32 : i -ok ? 0.5 / 0.5 : f64 -ok ? 0.5 : i32 >= i64 -ok ? 0.5 > 1 : 0.5 * i64 -ok ? 1 + i : i32 -ok ? 1 / i64 : greet -ok ? 1 : foo.Bar -ok ? 1 : foo?.Qux -ok ? abs(i64) : i64 -ok ? add : abs(f32) +ok == ok ? nil : $env +ok == true && $env +ok ? $env : $env >= 1.0 | date(ok, true) +ok ? $env : $env | find(.f64) +ok ? $env : $env?.Bar +ok ? $env : $env?.String() +ok ? $env : $env?.[String] +ok ? $env : $env?.[str] +ok ? $env : $env?.array +ok ? $env : $env?.ok +ok ? $env : foo.Bar +ok ? $env : foo?.Bar +ok ? 0 : $env.list +ok ? 0 : foo?.Bar +ok ? 1 : $env.add +ok ? 1 : $env?.[f64] +ok ? 1 : $env[timezone(array):] +ok ? 1.0 : $env | groupBy(#.str) +ok ? 1.0 : $env.array +ok ? 1.0 : $env.list +ok ? 1.0 : $env?.Bar +ok ? 1.0 : $env?.[array] +ok ? 1.0 : $env?.greet +ok ? 1.0 : $env?.list +ok ? 1.0 : list | groupBy($env) +ok ? add : $env | groupBy(#.list) +ok ? add : $env | map(foo) +ok ? add : $env | none(#) +ok ? add : $env.array +ok ? add : $env.f64 +ok ? add : $env.greet +ok ? add : $env?.[greet] +ok ? add : $env?.ok ok ? add : add -ok ? add : array ok ? add : f64 -ok ? add : foo -ok ? add : foo?.String -ok ? add : greet -ok ? add : half -ok ? add : i -ok ? add : i64 -ok ? add : list -ok ? add : ok -ok ? array : array -ok ? array : f32 -ok ? array : f64 + f64 +ok ? add : list | reduce(#) +ok ? add : str +ok ? array : $env | sum(#) +ok ? array : add ok ? array : foo -ok ? array : foo.String -ok ? array : foo?.String -ok ? array : greet -ok ? array : i -ok ? array : i32 -ok ? array : list +ok ? array : list | min(i) ok ? array : ok -ok ? array : score -ok ? div : add -ok ? div : array -ok ? div : div -ok ? div : f64 -ok ? div : foo -ok ? div : foo.Bar -ok ? div : greet -ok ? div : half -ok ? div : i32 > reduce(array, #) -ok ? div : nil == true -ok ? div : ok -ok ? div : score -ok ? f32 != i32 : f32 -ok ? f32 ** i64 : score -ok ? f32 : -0.5 -ok ? f32 : add -ok ? f32 : array -ok ? f32 : div -ok ? f32 : f32 -ok ? f32 : f64 -ok ? f32 : foo -ok ? f32 : half -ok ? f32 : i32 -ok ? f32 : i64 -ok ? f32 : ok -ok ? f32 : score -ok ? f64 : add -ok ? f64 : array -ok ? f64 : div -ok ? f64 : f64 - f64 -ok ? f64 : false != true +ok ? array : sum(array) +ok ? f64 : $env.foo +ok ? f64 : $env.i +ok ? f64 : $env.ok +ok ? f64 : $env[bitxor(foobar):] +ok ? f64 : f64 ok ? f64 : foo -ok ? f64 : foo.String -ok ? f64 : greet -ok ? f64 : i32 -ok ? f64 : i32 % i32 -ok ? f64 : i32 >= -i64 -ok ? f64 : ok -ok ? f64 : score +ok ? f64 : foo?.String() +ok ? f64 : uniq($env) +ok ? false : $env.foo +ok ? false : $env?.[add] +ok ? false : $env?.list ok ? false : foo.Bar -ok ? foo : div -ok ? foo : f32 +ok ? false : list?.[i] +ok ? foo : $env not endsWith $env?.true +ok ? foo : $env | groupBy(.list) +ok ? foo : $env | groupBy(i) +ok ? foo : $env.add +ok ? foo : $env.greet +ok ? foo : $env?.[f64] +ok ? foo : $env?.[find(foobar, .f64)] +ok ? foo : $env?.add +ok ? foo : $env?.array +ok ? foo : $env?.foobar?.String() +ok ? foo : $env?.greet +ok ? foo : add +ok ? foo : array?.[i] ok ? foo : foo -ok ? foo : greet -ok ? foo : half -ok ? foo : i32 -ok ? foo : i32 > i32 -ok ? foo : i64 +ok ? foo : foo?.Bar +ok ? foo : foo?.String ok ? foo : list -ok ? foo : ok -ok ? foo : score -ok ? foo.Qux : ok -ok ? greet : 0.5 > i -ok ? greet : 1 <= 0.5 -ok ? greet : add -ok ? greet : div -ok ? greet : f32 +ok ? foo not in list : array +ok ? greet : array ok ? greet : f64 ok ? greet : foo -ok ? greet : half -ok ? greet : i64 -ok ? greet : list -ok ? greet : map(list, i) -ok ? greet : ok -ok ? greet : score -ok ? half : add -ok ? half : f32 -ok ? half : f64 -ok ? half : foo -ok ? half : foo?.Qux -ok ? half : greet -ok ? half : half -ok ? half : list -ok ? half : nil in list -ok ? half : ok -ok ? half : reduce(list, "bar") -ok ? half : string(array) -ok ? half(1) : add -ok ? i : 1 / i64 -ok ? i : add -ok ? i : array -ok ? i : f32 <= 0.5 +ok ? greet : groupBy($env, greet)?.[i] +ok ? greet : i +ok ? greet : list | mean(nil) +ok ? greet : sortBy($env, 1) +ok ? greet : str +ok ? greet : {foo: true} +ok ? i : $env?.[greet] ok ? i : foo -ok ? i : half -ok ? i : i -ok ? i : i32 -ok ? i : i64 ok ? i : list -ok ? i : ok -ok ? i : score -ok ? i32 : 1 - f64 -ok ? i32 : add -ok ? i32 : div -ok ? i32 : f32 -ok ? i32 : f32 + 0.5 -ok ? i32 : f64 -ok ? i32 : foo -ok ? i32 : foo.Qux -ok ? i32 : greet -ok ? i32 : i -ok ? i32 : i32 -ok ? i32 : i32 + i32 -ok ? i32 : list -ok ? i32 : ok -ok ? i32 : score -ok ? i64 : (ok ? list : half) -ok ? i64 : div -ok ? i64 : f32 -ok ? i64 : foo -ok ? i64 : foo.String -ok ? i64 : half -ok ? i64 : i -ok ? i64 : i32 -ok ? i64 : i64 -ok ? i64 : list -ok ? i64 : ok -ok ? i64 ^ f32 : foo -ok ? list : 0.5 * f64 -ok ? list : add -ok ? list : array -ok ? list : div -ok ? list : div(i64, 1) -ok ? list : f32 -ok ? list : foo.String -ok ? list : greet -ok ? list : half -ok ? list : i -ok ? list : i - f32 -ok ? list : i64 -ok ? list : list -ok ? list : list != array -ok ? list : not ok -ok ? list : score -ok ? map(list, #) : add -ok ? nil : 0.5 <= f64 -ok ? nil : foo.Qux -ok ? nil : foo?.Bar -ok ? not false : i32 -ok ? ok : 0.5 ** i32 -ok ? ok : add -ok ? ok : array -ok ? ok : div -ok ? ok : f32 -ok ? ok : f64 ** int(f64) +ok ? i : list?.[i] +ok ? list : $env.i +ok ? list : f64 +ok ? list : foo +ok ? list : str +ok ? nil : $env not matches $env?.[i] +ok ? nil : $env.foo +ok ? nil : $env?.String +ok ? nil : $env?.[String] +ok ? nil : $env?.[greet] +ok ? nil : $env?.[ok] +ok ? nil : $env?.i +ok ? nil : $env?.ok +ok ? nil : $env?.str +ok ? nil : foo.String +ok ? ok : $env | filter(one(array, ok)) +ok ? ok : $env.list +ok ? ok : $env?.[array] +ok ? ok : false and ok ok ? ok : foo -ok ? ok : foo.String -ok ? ok : greet -ok ? ok : half -ok ? ok : i32 -ok ? ok : i64 -ok ? ok : list -ok ? ok : ok -ok ? reduce(array, false) : score -ok ? reduce(list, #) : list -ok ? score : 1 == i32 -ok ? score : div -ok ? score : f32 -ok ? score : f64 -ok ? score : greet -ok ? score : half -ok ? score : i -ok ? score : i32 -ok ? score : min(i64) -ok ? score : score -ok ? score : true == nil -ok ? toJSON(i64) : div -ok and !ok -ok and "bar" < "foo" -ok and ("foo" not contains "bar") -ok and 1 < i64 -ok and 1 == 1 -ok and 1 == i64 -ok and add == nil -ok and f32 != 1 -ok and f32 >= 1 -ok and greet == greet -ok and i == 0.5 -ok and i32 < f32 -ok and i32 <= i64 -ok and i32 > i32 -ok and i64 < i32 -ok and i64 <= i64 -ok and i64 > 1 -ok and i64 >= i -ok and i64 in array -ok and list != nil -ok and nil == array -ok and nil == nil -ok and nil in array -ok and nil in list +ok ? ok : foo | date(list) +ok ? reduce($env, $env, true) : foo?.Bar +ok ? str : $env?.String(i)?.ok +ok ? str : $env?.foo +ok ? str : $env?.ok +ok ? str : f64 +ok ? str : foo +ok ? str : ok +ok ? true : foo?.String +ok ? true ?: 0 : str +ok ?: $env not endsWith str +ok ?: $env | any(.Bar) +ok ?: $env | filter(.Bar) +ok ?: $env | find(#.str) +ok ?: $env | one(#.Bar) +ok ?: $env | reduce(#) +ok ?: $env | sortBy(.i != #) +ok ?: $env | sortBy(foo) +ok ?: $env.add +ok ?: $env.array +ok ?: $env.f64 +ok ?: $env.foo +ok ?: $env.ok +ok ?: $env.str +ok ?: $env?.[Bar] +ok ?: $env?.[Bar]?.str +ok ?: $env?.[String] +ok ?: $env?.[add] +ok ?: $env?.[array] +ok ?: $env?.[greet] +ok ?: $env?.[i] +ok ?: $env?.[ok] +ok ?: $env?.[str] +ok ?: $env?.array +ok ?: $env?.f64 +ok ?: $env?.foo +ok ?: $env?.greet +ok ?: $env?.i +ok ?: $env?.list +ok ?: $env[foobar not in list:] +ok ?: $env[foobar:] +ok ?: 1 % 1 +ok ?: 1.0 | date($env) +ok ?: add +ok ?: array +ok ?: array | sum(greet) +ok ?: array?.[i] +ok ?: ceil(f64) +ok ?: count($env) +ok ?: count(array) +ok ?: count(list) +ok ?: date(false) +ok ?: f64 +ok ?: foo +ok ?: foo not in $env +ok ?: foo?.Bar +ok ?: foo?.String +ok ?: foo?.String() +ok ?: fromJSON(str) +ok ?: greet +ok ?: greet($env) +ok ?: i +ok ?: i == 1 +ok ?: i >= i +ok ?: int(1.0) +ok ?: list +ok ?: list | findIndex($env) +ok ?: max(list) +ok ?: nil in $env +ok ?: ok +ok ?: str +ok ?: str startsWith $env +ok ?: sum($env) +ok and $env != 0 +ok and $env != 1.0 +ok and $env != false +ok and $env != list +ok and $env == list +ok and $env in array +ok and $env.ok +ok and $env?.Bar +ok and $env?.Bar?.foobar +ok and $env?.String +ok and $env?.[Bar] +ok and $env?.[Bar]?.array +ok and $env?.[String] +ok and $env?.[String]?.[add] +ok and $env?.[foobar] +ok and $env?.[str] +ok and $env?.foobar +ok and $env?.nil?.f64 +ok and $env?.ok +ok and 0 != nil +ok and 0 < i +ok and 1.0 != i +ok and 1.0 <= i +ok and 1.0 not in array +ok and add == $env +ok and array != array +ok and f64 not in array +ok and false && $env +ok and false ? $env : $env +ok and foo != foo +ok and foo == nil +ok and i < i +ok and i == f64 +ok and last($env) +ok and nil != ok +ok and nil == $env ok and nil not in array -ok and not ok -ok and not true ok and ok -ok and ok && ok -ok and true ? f64 : add -ok and true ? greet : i -ok in groupBy(array, "bar") -ok in groupBy(list, #) -ok in groupBy(list, i32) -ok in {"bar": true}?.greet -ok not in groupBy(array, # != i32) -ok not in groupBy(array, 0.5) -ok not in groupBy(array, f64) -ok not in groupBy(list, #)?.f64 -ok not in groupBy(list, f64)?.Bar -ok or !ok -ok or !true -ok or "bar" endsWith "foo" -ok or 0.5 != f32 -ok or 0.5 != nil -ok or 0.5 == i -ok or 1 != f32 -ok or 1 <= 1 +ok and ok ? add : i +ok and str not startsWith str +ok and true != false +ok and true && $env +ok and true || $env.ok +ok and {foo: i}?.foo +ok in $env && false +ok in $env?.Bar +ok in $env?.String +ok in $env?.[Bar] +ok in $env?.[String] +ok in $env?.[foobar] +ok in $env?.foobar +ok in [false] +ok in [ok] +ok in concat(array) +ok in sort(array) +ok not in $env || true +ok not in $env?.Bar +ok not in $env?.Bar?.list +ok not in $env?.String +ok not in $env?.[Bar] +ok not in $env?.[Bar]?.[foo] +ok not in $env?.[Bar]?.ok() +ok not in $env?.[String] +ok not in $env?.[String]?.String +ok not in $env?.[foobar] +ok not in $env?.false?.[i] +ok not in [0, nil] +ok not in [false] +ok not in [true] +ok not in groupBy(list, i) +ok not in last($env) +ok not in map($env, false) +ok or $env != 1 +ok or $env * f64 +ok or $env == $env +ok or $env == $env?.foo +ok or $env == array +ok or $env == list +ok or $env == ok +ok or $env > str +ok or $env >= i +ok or $env ?: ok +ok or $env and $env?.String +ok or $env not startsWith str +ok or $env or $env +ok or $env || true +ok or $env.ok +ok or $env?.Bar +ok or $env?.Bar() +ok or $env?.Bar(list()) +ok or $env?.Bar(list) +ok or $env?.Bar(one(foobar, false)) +ok or $env?.String +ok or $env?.String(1.0, i)?.f64 +ok or $env?.[$env]?.ok(foobar?.str) +ok or $env?.[1.0 not matches f64] +ok or $env?.[Bar] +ok or $env?.[Bar]?.[list] +ok or $env?.[String] +ok or $env?.[String].list +ok or $env?.[add] +ok or $env?.[array] +ok or $env?.[array].ok +ok or $env?.[f64] +ok or $env?.[f64].i +ok or $env?.[foo not in foobar] +ok or $env?.[foo] +ok or $env?.[foobar] +ok or $env?.[greet()] +ok or $env?.[greet] +ok or $env?.[i] +ok or $env?.[list] +ok or $env?.[list]?.add() +ok or $env?.[ok | reduce(foo)] +ok or $env?.[ok()] +ok or $env?.[ok] +ok or $env?.[str] +ok or $env?.[str]?.[f64] +ok or $env?.ok +ok or $env?.upper(1.0, 0, foo) +ok or $env[$env:foobar]?.[foo]?.[foo] +ok or $env[:nil .. add] +ok or $env[add.Bar():] +ok or $env[foobar.foo(nil):f64?.[foo]] +ok or $env[foobar:] +ok or $env[nil matches i:foobar not startsWith foobar] +ok or $env[ok():] +ok or $env[ok:] +ok or 0 == nil +ok or 0 == nil ? 0 : array +ok or 1 <= 1.0 ok or 1 <= i -ok or div != nil -ok or f32 != f32 -ok or f32 == 0.5 -ok or f32 == f32 -ok or f64 <= 1 -ok or false ? ok : 1 -ok or false and false -ok or foo != foo -ok or i < 1 -ok or i == 0.5 -ok or i == f32 -ok or i32 < 1 -ok or i32 > f64 -ok or i64 != i32 -ok or i64 > i64 -ok or i64 >= 0.5 -ok or i64 not in array -ok or nil != "foo" -ok or nil != f64 +ok or 1 >= 1.0 +ok or 1.0 < 0 +ok or 1.0 < 1.0 +ok or 1.0 <= $env +ok or 1.0 <= f64 +ok or 1.0 <= f64 + 1 +ok or 1.0 == $env +ok or 1.0 >= $env +ok or 1.0 >= 1 +ok or 1.0 in $env +ok or abs($env) +ok or array != nil +ok or f64 <= i +ok or f64 == nil +ok or f64 > $env +ok or f64 > 1 +ok or f64 > f64 +ok or f64 >= 0 +ok or false ? foo : foo +ok or false or ok +ok or false || false +ok or find($env, .greet) +ok or find($env, .str) +ok or foo != $env.foo +ok or foo in $env +ok or foo in list +ok or foo in sum($env) +ok or foo not in groupBy($env, 1) +ok or fromJSON($env) +ok or greet != $env +ok or greet not in $env +ok or i == nil +ok or mean(array) +ok or nil != $env ok or nil != foo -ok or nil != greet -ok or nil != ok -ok or nil == div -ok or not false -ok or not ok +ok or nil != str +ok or nil == add +ok or nil == array +ok or none($env, #) ok or ok -ok or ok == true -ok or true || true -ok or {"foo": false}.String -ok || !ok -ok || (nil not in list) -ok || 0.5 < f32 -ok || 0.5 > 0.5 -ok || 0.5 > 1 -ok || 0.5 >= f64 -ok || 1 != nil -ok || 1 < i32 -ok || 1 == i -ok || f32 >= 1 -ok || f64 < 1 -ok || f64 == i -ok || f64 > f64 -ok || f64 >= i64 -ok || false ? half : i64 -ok || foo == foo -ok || i == i -ok || i32 < f32 -ok || i32 <= 0.5 -ok || i32 == i -ok || i32 > 0.5 -ok || i32 >= i32 -ok || i64 != i32 -ok || i64 == 0.5 -ok || list == list -ok || nil == 0.5 -ok || nil == array -ok || nil == nil +ok or ok == false +ok or ok or ok +ok or reduce($env, ok) +ok or sortBy($env, 1.0) +ok or sortBy($env, true)?.array?.[array] +ok or str + $env +ok or str == $env +ok or str not endsWith $env +ok or str not in foo +ok or sum($env) +ok or true == $env?.[String] +ok or true == nil +ok or true or $env?.String(i) +ok or true || ok +ok or {foo: nil}?.i +ok || $env != false +ok || $env + i +ok || $env < $env +ok || $env <= 0 +ok || $env == $env +ok || $env == list +ok || $env >= str +ok || $env matches $env +ok || $env not contains str +ok || $env not in str +ok || $env or false +ok || $env || $env +ok || $env.ok +ok || $env?.$env.str +ok || $env?.Bar +ok || $env?.Bar() +ok || $env?.String +ok || $env?.String() +ok || $env?.String?.ok()?.array +ok || $env?.[Bar] +ok || $env?.[String] +ok || $env?.[String]?.Bar +ok || $env?.[add] +ok || $env?.[all(foobar, foobar)] +ok || $env?.[array] +ok || $env?.[f64] +ok || $env?.[f64].str(list?.[ok]) +ok || $env?.[foo] +ok || $env?.[foobar startsWith foobar] +ok || $env?.[foobar?.i] +ok || $env?.[greet] +ok || $env?.[greet]?.String +ok || $env?.[greet]?.f64 +ok || $env?.[i] +ok || $env?.[i].str +ok || $env?.[i]?.[foo] +ok || $env?.[list] +ok || $env?.[nil endsWith list] +ok || $env?.[ok] +ok || $env?.[str()] +ok || $env?.[str] +ok || $env?.[str].list +ok || $env?.foobar +ok || $env?.ok +ok || $env?.sortBy(nil) +ok || $env?.toPairs(add, true) +ok || $env[1.0:] +ok || $env[:String()] +ok || $env[:add()] +ok || $env[:foo] +ok || $env[:foobar] +ok || $env[Bar(foo):add and foobar] +ok || $env[add():] +ok || $env[add:foobar] +ok || $env[f64.ok:array(foobar, foobar, String)] +ok || $env[f64:ok(true)] +ok || $env[foo:foobar] +ok || $env[foobar:] +ok || $env[str?.add:groupBy(i, foobar)] +ok || 0 == $env +ok || 0 == 1 +ok || 0 == 1.0 +ok || 1 > 1 +ok || 1.0 != f64 +ok || 1.0 * $env +ok || 1.0 - $env?.[ok] +ok || 1.0 <= 1 +ok || 1.0 <= i +ok || 1.0 == 1 +ok || 1.0 == 1.0 +ok || 1.0 in $env +ok || add not in $env +ok || any($env, #) +ok || any($env, .list) +ok || f64 != $env +ok || f64 != f64 +ok || f64 + $env +ok || f64 < $env +ok || f64 > $env +ok || f64 > 1 +ok || false ?: foo +ok || false not in sum(list, $env) +ok || foo == nil +ok || foo not in list +ok || fromJSON($env) +ok || greet != nil +ok || greet == $env +ok || i * $env +ok || i + $env +ok || i < f64 +ok || i > i +ok || list != list +ok || mean(list) +ok || median(array) +ok || median(array, 1) +ok || median(array, str) +ok || min($env) +ok || nil != add +ok || nil != i +ok || nil != true +ok || nil == false +ok || nil in $env?.String +ok || nil in array ok || nil not in array -ok || not false -ok || not ok ok || ok -ok || ok ? f64 : i64 -ok || ok ? ok : score -ok || ok or ok -ok || reduce(array, false) -ok || true ? add : ok -one(1 .. i64, ok) -one([div], nil == i32) -one([false], i64 != i32) -one(array, !(# <= 0.5)) -one(array, !false) -one(array, !ok) -one(array, !true) -one(array, "bar" matches "bar") +ok || ok == ok +ok || ok ?: foo +ok || ok || $env +ok || one($env, .add) +ok || sortBy($env, array).str +ok || sortBy($env, foo, 1) +ok || sortBy($env, i, str) +ok || str != $env +ok || str != nil +ok || str != str +ok || str <= str +ok || str contains $env +ok || str endsWith str +ok || sum($env) +ok || true && $env +ok || true and $env +ok || true and true +ok || {foo: nil}?.add +ok; add +ok; f64 +ok; foo?.String; groupBy(list, #) +ok; greet +ok; list +ok; ok +ok; str +one($env | map(true), ok) +one($env, true) ?: greet +one($env, true) || $env?.Bar +one($env.array, nil != true) +one($env?.[str], ok) +one($env?.array, ok) +one($env?.list, 0 <= 1.0) +one($env?.list, ok) +one([$env], #.ok) +one([$env], .array != add) +one([false], 0 <= f64) +one([foo], ok) +one([i], ok) +one([ok], #) +one([str], none($env, false)) one(array, # != #) -one(array, # != 0.5) -one(array, # != 1) -one(array, # != f32) -one(array, # != f64) -one(array, # != i) -one(array, # != i32) -one(array, # != nil) -one(array, # / i >= f64) -one(array, # < #) -one(array, # < 0.5) -one(array, # < 1) -one(array, # < f32) -one(array, # < i64) -one(array, # <= #) -one(array, # <= 0.5) +one(array, # <= 0) one(array, # <= 1) -one(array, # <= f32) -one(array, # <= f64) -one(array, # <= i32) -one(array, # == #) -one(array, # == 0.5) one(array, # == 1) -one(array, # == nil) -one(array, # > #) -one(array, # > f32) -one(array, # > f64) -one(array, # > i32) one(array, # >= #) -one(array, # >= 0.5) -one(array, # >= 1) -one(array, # >= f64) -one(array, 0.5 != #) -one(array, 0.5 != i64) -one(array, 0.5 < #) -one(array, 0.5 < 0.5) -one(array, 0.5 <= #) -one(array, 0.5 == #) -one(array, 0.5 == 0.5) -one(array, 0.5 > #) -one(array, 0.5 > 1) -one(array, 0.5 >= #) -one(array, 1 != #) -one(array, 1 != i64) -one(array, 1 != nil) -one(array, 1 < #) -one(array, 1 < f64) -one(array, 1 <= #) -one(array, 1 > 0.5) -one(array, 1 >= #) -one(array, add == div) -one(array, all(array, true)) -one(array, f32 <= #) -one(array, f32 <= 0.5) -one(array, f32 >= #) -one(array, f64 < #) -one(array, f64 == #) -one(array, f64 >= #) -one(array, f64 >= 1) -one(array, f64 >= i32) -one(array, f64 in array) -one(array, false || true) -one(array, i < #) -one(array, i > 0.5) -one(array, i > f64) -one(array, i32 != #) -one(array, i32 < #) -one(array, i32 <= #) -one(array, i32 > #) -one(array, i32 >= #) -one(array, i64 != #) -one(array, i64 < #) -one(array, i64 == #) -one(array, i64 == f32) -one(array, i64 >= #) -one(array, i64 >= f64) -one(array, list != array) -one(array, nil != #) -one(array, nil != i64) -one(array, not ok) +one(array, $env && false) +one(array, $env.ok) +one(array, 0 >= 0) +one(array, 1.0 < #) +one(array, 1.0 <= #) +one(array, f64 == i) +one(array, false and $env?.[ok]) +one(array, false) != $env?.ok +one(array, i != $env) +one(array, i <= f64) +one(array, list != $env) +one(array, nil != add) +one(array, nil in $env) one(array, ok) -one(array, one(list, false)) -one(array, true != false) -one(array, true == nil) -one(array, true) ? greet : add -one(array, true) or 1 != nil -one(false ? greet : "bar", f64 != #) -one(groupBy(array, f64).array, .i(nil).ok) -one(groupBy(list, ok).foo, .add?.array) -one(i32 .. 1, # == #) -one(i32 .. i32, not ok) -one(i64 .. 1, # >= 1) -one(i64 .. i32, # != #) -one(i64 .. i32, # >= #) -one(list, !(i64 != 1)) -one(list, !false) -one(list, !ok) -one(list, "foo" < "bar") -one(list, "foo" not endsWith "bar") -one(list, "foo" not in #) -one(list, "foo" startsWith "bar") -one(list, # != #) +one(array, str > str) +one(array, true) == ok +one(if ok { $env } else { add }, ok) one(list, # != foo) one(list, # == #) -one(list, # in list) -one(list, # not in list) -one(list, 0.5 < 1) -one(list, 0.5 <= 0.5) -one(list, 0.5 == f64) -one(list, 1 > i) -one(list, add != nil) -one(list, all(array, true)) -one(list, any(list, true)) -one(list, div != nil) -one(list, f32 == nil) -one(list, f32 > i) -one(list, f32 >= 1) -one(list, f64 >= 1) -one(list, false == nil) +one(list, $env != i) +one(list, $env == foo) +one(list, $env?.ok) +one(list, 1 <= f64) +one(list, 1.0 == $env) +one(list, any(list, ok)) +one(list, f64 == 1) one(list, foo != #) -one(list, foo != nil) -one(list, foo == #) one(list, greet == nil) -one(list, half == nil) -one(list, i <= i64) -one(list, i > f64) -one(list, i > i32) -one(list, i32 != f32) -one(list, i64 == 1) -one(list, nil != #) -one(list, nil != half) -one(list, nil == #) -one(list, nil == f64) -one(list, ok or true) +one(list, i == 0) +one(list, list != $env) +one(list, nil == list) +one(list, nil not in $env) one(list, ok) -one(list, ok) or 0.5 == nil -one(list, score != nil) -one(list, true == nil) -one(list[i64:i32], i != i) -one(map(array, "bar"), not false) -one(map(array, #), # != #) -one(map(array, #), # >= #) -one(map(array, #), i32 == #) -one(map(array, 1), ok) -one(map(array, div), # == #) -one(map(array, f64), # < 0.5) -one(map(array, false), #) -one(map(array, i), ok) -one(map(array, list), ok) -one(map(array, true), #) -one(map(list, ok), #) -one(map(list, score), # != #) -one(ok ? "foo" : false, # > #) -one(reduce(array, array), ok) -one(true ? array : 1, # <= #) -reduce(1 .. 1, #) -reduce(1 .. 1, f32 >= i) -reduce(1 .. i64, array) -reduce(1 .. i64, greet) -reduce(1 .. i64, half) -reduce(["foo"], f32) -reduce([0.5], f64) -reduce([div, "foo"], i32) -reduce([f32, f64], f32) +one(list, str < #.Bar) +one(list, str >= str) +one(list, true != $env) +one(sort($env), $env == nil) +one(sort($env), .greet[:.i]) +one(sort($env), ok) +reduce($env | map(1.0), str) +reduce($env, #.list) == 1 && false +reduce($env, $env, $env).greet +reduce($env, $env, $env)?.f64 +reduce($env, $env, $env)?.greet +reduce($env, $env, 1)?.f64 +reduce($env, $env, 1.0)?.add +reduce($env, $env, false).str +reduce($env, $env, foo)?.str +reduce($env, $env, greet).String +reduce($env, $env, greet)?.greet +reduce($env, $env, i)?.f64 +reduce($env, $env, list)?.add +reduce($env, $env, nil)?.str +reduce($env, array, 1.0) | all(false) +reduce($env, array, false)?.[i] +reduce($env, foo, 1).Bar +reduce($env, foo, false).Bar +reduce($env, foo, nil)?.Bar +reduce($env.array, #) +reduce($env.array, i) +reduce($env.array, last($env)) +reduce($env.array, mean(f64, #)) +reduce($env.array, str) +reduce($env.list, #) +reduce($env.list, #.Bar) +reduce($env.list, #?.Bar) +reduce($env.list, 1.0 + 1.0) +reduce($env.list, [nil]) +reduce($env.list, add) +reduce($env.list, array) +reduce($env.list, f64 ^ 1) +reduce($env.list, greet) +reduce($env.list, str) +reduce($env?.[str], #) +reduce($env?.[str], #index != #) +reduce($env?.[str], foo) +reduce($env?.[str], list) +reduce($env?.[str], nil != list) +reduce($env?.[str], ok) +reduce($env?.[str], str) +reduce($env?.array, # != f64) +reduce($env?.array, # < #) +reduce($env?.array, # >= 1.0) +reduce($env?.array, #) +reduce($env?.array, #acc ** #) +reduce($env?.array, #acc) +reduce($env?.array, add) +reduce($env?.array, foo) +reduce($env?.array, i != #) +reduce($env?.array, list | groupBy(foo)) +reduce($env?.array, list) +reduce($env?.list, #) +reduce($env?.list, #.String) +reduce($env?.list, #.String, array) +reduce($env?.list, .Bar) +reduce($env?.list, add) +reduce($env?.list, i ^ 0) +reduce($env?.list, i in array) +reduce($env?.list, i) +reduce($env?.list, ok) +reduce(1 .. 1, #acc?.[foo]) +reduce([$env], #.Bar) +reduce([$env], #.String != $env) +reduce([$env], #.foo?.[list]) +reduce([$env], .str) +reduce([$env], add) +reduce([$env], f64 <= #.f64) +reduce([$env], greet) +reduce([$env], i) +reduce([$env], round($env)) +reduce([0, $env], array) +reduce([0], array) +reduce([1.0, foo], #) +reduce([1.0], $env[:#]) +reduce([foo], #) +reduce([foo], #.Bar + #acc) +reduce([foo], #index) +reduce([foo], foo).String +reduce([foo], greet) reduce([foo], ok) -reduce([i32], list) -reduce([i64, half], "bar" not startsWith "foo") -reduce([i], # < #) -reduce([i], ok) -reduce([list], f64) -reduce([nil], # in array) -reduce(array, !false) -reduce(array, "foo" endsWith "foo") -reduce(array, "foo") not in foo +reduce([greet, greet], str) +reduce([i, 1.0], # != #) +reduce([i, i], foo) +reduce([list], #) +reduce([list], greet) +reduce([nil != true], list) +reduce([ok], #) +reduce([ok], add) +reduce([str], i) +reduce([true], foo.Bar) +reduce(array | map(#), f64) +reduce(array | map(#), foo) +reduce(array | map($env), #index) +reduce(array | map(foo), f64) +reduce(array | sortBy(#), ok) +reduce(array | sortBy(1), #acc) reduce(array, # != #) -reduce(array, # != 1) -reduce(array, # != i32) -reduce(array, # != nil) -reduce(array, # % #) -reduce(array, # % i64) +reduce(array, # % i) reduce(array, # * #) -reduce(array, # * 0.5) -reduce(array, # * 1) -reduce(array, # * f32) -reduce(array, # * i) -reduce(array, # * i32) -reduce(array, # * i64) -reduce(array, # ** #) -reduce(array, # ** f32) -reduce(array, # ** i32) -reduce(array, # + #) -reduce(array, # + 0.5) -reduce(array, # + 1) -reduce(array, # + i) -reduce(array, # + i64) -reduce(array, # - #) -reduce(array, # - 0.5) -reduce(array, # - 1) -reduce(array, # - i) -reduce(array, # - i32) -reduce(array, # - i64) -reduce(array, # .. #) -reduce(array, # .. i32) +reduce(array, # + 0) reduce(array, # / #) -reduce(array, # / 0.5) -reduce(array, # / 1) -reduce(array, # / f32) -reduce(array, # / i32) -reduce(array, # < #) -reduce(array, # < 0.5) -reduce(array, # < 1) -reduce(array, # < i32) reduce(array, # <= #) -reduce(array, # <= 0.5) -reduce(array, # <= f32) -reduce(array, # <= i32) reduce(array, # == #) -reduce(array, # == 0.5) -reduce(array, # == 1) -reduce(array, # == f32) -reduce(array, # == i32) -reduce(array, # == i64) -reduce(array, # == nil) -reduce(array, # > #) -reduce(array, # > 1) -reduce(array, # > f64) reduce(array, # > i) reduce(array, # >= #) -reduce(array, # >= f32) -reduce(array, # >= f64) -reduce(array, # >= i32) -reduce(array, # >= i64) reduce(array, # ^ #) -reduce(array, # ^ 0.5) -reduce(array, # ^ f32) -reduce(array, # ^ f64) -reduce(array, # ^ i64) reduce(array, # in array) -reduce(array, # not in array) reduce(array, #) -reduce(array, #) != 0.5 == true -reduce(array, #) != 0.5 ? ok : nil -reduce(array, #) != f32 -reduce(array, #) != i32 -reduce(array, #) != i64 -reduce(array, #) % i -reduce(array, #) % i32 -reduce(array, #) % i64 -reduce(array, #) * i -reduce(array, #) * i32 -reduce(array, #) * len("foo") -reduce(array, #) ** f64 -reduce(array, #) ** min(1, i32) -reduce(array, #) + i -reduce(array, #) + i64 -reduce(array, #) + reduce(array, #) -reduce(array, #) - f64 -reduce(array, #) - i -reduce(array, #) - max(f32) -reduce(array, #) .. i -reduce(array, #) .. i32 -reduce(array, #) .. i64 -reduce(array, #) / f32 -reduce(array, #) / f64 -reduce(array, #) / i32 -reduce(array, #) / i64 -reduce(array, #) < f32 -reduce(array, #) < f32 / 0.5 -reduce(array, #) < f64 -reduce(array, #) < i -reduce(array, #) <= -1 -reduce(array, #) <= f32 -reduce(array, #) <= f64 -reduce(array, #) <= f64 * 0.5 -reduce(array, #) <= i -reduce(array, #) == f64 -reduce(array, #) == i64 -reduce(array, #) > i32 -reduce(array, #) >= f32 -reduce(array, #) >= f64 -reduce(array, #) >= i32 -reduce(array, #) >= i64 -reduce(array, #) ^ f32 ** 0.5 -reduce(array, #) ^ i32 -reduce(array, #) not in array -reduce(array, #) not in map(array, #) -reduce(array, (0.5 + #) * f32) -reduce(array, -#) -reduce(array, -(# - #)) -reduce(array, -0.5) -reduce(array, -1) -reduce(array, -f32) -reduce(array, -f64) -reduce(array, -i) -reduce(array, -i32) -reduce(array, -i64) -reduce(array, 0.5 != #) -reduce(array, 0.5 != 0.5) -reduce(array, 0.5 * #) -reduce(array, 0.5 ** #) -reduce(array, 0.5 ** 1) -reduce(array, 0.5 + #) -reduce(array, 0.5 - #) -reduce(array, 0.5 - i64) -reduce(array, 0.5 / #) -reduce(array, 0.5 / f32) -reduce(array, 0.5 < #) -reduce(array, 0.5 < 1) -reduce(array, 0.5 <= #) -reduce(array, 0.5 <= 1) -reduce(array, 0.5 == #) -reduce(array, 0.5 == f64) -reduce(array, 0.5 == i64) -reduce(array, 0.5 > #) -reduce(array, 0.5 > 0.5) -reduce(array, 0.5 >= 0.5) -reduce(array, 0.5 >= 1) -reduce(array, 0.5 ^ #) -reduce(array, 0.5 ^ 0.5) -reduce(array, 0.5) * f32 -reduce(array, 0.5) - i -reduce(array, 0.5) > i64 ? 1 : 0.5 -reduce(array, 1 != #) -reduce(array, 1 * f64) -reduce(array, 1 ** #) -reduce(array, 1 + #) -reduce(array, 1 - #) -reduce(array, 1 - 1) -reduce(array, 1 / i32) -reduce(array, 1 < #) -reduce(array, 1 >= #) -reduce(array, 1 ^ #) -reduce(array, 1 ^ 0.5) -reduce(array, 1 ^ i32) -reduce(array, 1) % i32 -reduce(array, 1) ** f32 -reduce(array, 1) + f64 -reduce(array, 1) / f64 -reduce(array, 1) / i32 -reduce(array, 1) <= i32 -reduce(array, 1) ^ i -reduce(array, 1) not in array -reduce(array, [#]) -reduce(array, abs(#)) -reduce(array, abs(f64)) -reduce(array, abs(i64)) -reduce(array, add(#, #)) +reduce(array, #) * f64 +reduce(array, #, add) +reduce(array, #, array) +reduce(array, #, i) | mean(array) +reduce(array, #, ok) +reduce(array, #acc) +reduce(array, #acc, nil)?.list +reduce(array, #index != f64) +reduce(array, #index ** 1.0) +reduce(array, #index ** f64) +reduce(array, #index) +reduce(array, $env != foo) +reduce(array, $env == #) +reduce(array, $env) | count(false) +reduce(array, $env).Bar +reduce(array, $env).String +reduce(array, $env).add +reduce(array, $env).array +reduce(array, $env).f64 +reduce(array, $env).foobar +reduce(array, $env).greet +reduce(array, $env).i +reduce(array, $env).list +reduce(array, $env).str +reduce(array, $env)?.Bar +reduce(array, $env)?.String +reduce(array, $env)?.[str] +reduce(array, $env)?.add +reduce(array, $env)?.array +reduce(array, $env)?.f64 +reduce(array, $env)?.foo +reduce(array, $env)?.greet +reduce(array, $env)?.i +reduce(array, $env)?.list +reduce(array, $env)?.ok +reduce(array, $env)?.str +reduce(array, $env, $env)?.str +reduce(array, $env, 0)?.String +reduce(array, $env, f64)?.[str] +reduce(array, $env, foo)?.ok +reduce(array, $env, str)?.greet +reduce(array, $env, true).array +reduce(array, $env.array) +reduce(array, $env.greet) +reduce(array, $env.i) +reduce(array, $env.str) +reduce(array, $env?.add) +reduce(array, $env?.f64) +reduce(array, $env?.foo) +reduce(array, $env?.greet) +reduce(array, $env?.list, greet) +reduce(array, $env?.str) +reduce(array, 0) | min(1.0) +reduce(array, 1 != $env) +reduce(array, 1 != nil) +reduce(array, 1.0 != #) +reduce(array, 1.0 != 1) +reduce(array, 1.0 * #) +reduce(array, 1.0 ** #) +reduce(array, 1.0 ** #index) +reduce(array, 1.0 ** 1.0) +reduce(array, 1.0 - #acc) +reduce(array, 1.0 - i) +reduce(array, 1.0 / #) +reduce(array, 1.0 < #) +reduce(array, 1.0 == i) +reduce(array, 1.0 ^ #) +reduce(array, 1.0) / $env?.i +reduce(array, 1.0) == $env?.[str] +reduce(array, 1.0) ^ $env?.f64 +reduce(array, [1.0]) +reduce(array, [flatten(list)]) +reduce(array, [foo]) reduce(array, add) -reduce(array, all(list, ok)) +reduce(array, add, f64) reduce(array, array) -reduce(array, array)[i32] -reduce(array, array[#:#]) -reduce(array, array[i64:#]) -reduce(array, bitand(i32, i32)) +reduce(array, array) | mean(1, i) +reduce(array, array)?.[i] +reduce(array, array[1:]) +reduce(array, bitnand(1, #acc)) reduce(array, bitnot(#)) -reduce(array, bitor(#, #)) -reduce(array, bitshr(#, #)) -reduce(array, bitushr(#, #)) +reduce(array, bitnot(#)) % i +reduce(array, bitor(i, #)) reduce(array, ceil(#)) -reduce(array, div(#, #)) -reduce(array, div) -reduce(array, f32 ** #) -reduce(array, f32 + #) -reduce(array, f32 / #) -reduce(array, f32 <= #) -reduce(array, f32 == #) -reduce(array, f32 == i) -reduce(array, f32 >= #) -reduce(array, f32 >= 0.5) -reduce(array, f32 ^ #) -reduce(array, f32 ^ f32) -reduce(array, f32 ^ i32) -reduce(array, f32) -reduce(array, f32) ** (0.5 * f64) -reduce(array, f32) <= f32 -reduce(array, f32) not in array -reduce(array, f64 ** #) -reduce(array, f64 + #) -reduce(array, f64 + i32) -reduce(array, f64 - #) -reduce(array, f64 / 1) -reduce(array, f64 < #) -reduce(array, f64 == #) -reduce(array, f64 ^ 1) +reduce(array, concat(list)) reduce(array, f64) -reduce(array, f64) != i32 -reduce(array, f64) * i -reduce(array, f64) / f64 -reduce(array, f64) <= f32 -reduce(array, f64) <= first(array) -reduce(array, f64) == i -reduce(array, f64) >= i -reduce(array, f64) ^ f64 -reduce(array, false ? f64 : #) -reduce(array, false ? score : #) -reduce(array, false) ? i64 : f32 -reduce(array, false) || ok -reduce(array, findLastIndex(list, false)) -reduce(array, findLastIndex(list, reduce(array, true))) -reduce(array, float(#)) -reduce(array, floor(i64)) +reduce(array, false) == $env?.String +reduce(array, float(i)) +reduce(array, foo == $env) reduce(array, foo) reduce(array, foo).Bar -reduce(array, foo).Qux reduce(array, foo).String -reduce(array, foo).String() reduce(array, foo)?.Bar -reduce(array, foo)?.Qux reduce(array, foo)?.String reduce(array, foo)?.String() +reduce(array, foo, 1.0).Bar +reduce(array, foo, greet)?.String() +reduce(array, foo, i).Bar +reduce(array, foo, list).Bar reduce(array, foo.Bar) reduce(array, foo.String) -reduce(array, foo?.String()) +reduce(array, foo?.Bar) reduce(array, foo?.String) -reduce(array, get(array, 1)) -reduce(array, get(list, #)) -reduce(array, greet("bar")) +reduce(array, greet(str)) reduce(array, greet) -reduce(array, groupBy(array, #)) -reduce(array, groupBy(list, #)) -reduce(array, groupBy(list, #)?.f32) -reduce(array, half(1)) -reduce(array, half) -reduce(array, i != #) -reduce(array, i % #) -reduce(array, i * #) -reduce(array, i ** f64) -reduce(array, i + 0.5) -reduce(array, i - #) -reduce(array, i / #) +reduce(array, greet, foo) +reduce(array, i .. #, greet) reduce(array, i <= #) -reduce(array, i <= i64) -reduce(array, i > i32) -reduce(array, i ^ #) +reduce(array, i ^ #acc) reduce(array, i) -reduce(array, i) % i32 -reduce(array, i) + i32 -reduce(array, i) - f32 -reduce(array, i) == 0.5 ** 1 -reduce(array, i32 != #) -reduce(array, i32 != i32) -reduce(array, i32 + 0.5) -reduce(array, i32 - #) -reduce(array, i32 .. #) -reduce(array, i32 < #) -reduce(array, i32 < 1) -reduce(array, i32 > #) -reduce(array, i32 >= #) -reduce(array, i32) -reduce(array, i32) * 1 * 0.5 -reduce(array, i64 != #) -reduce(array, i64 % i) -reduce(array, i64 % i32) -reduce(array, i64 * #) -reduce(array, i64 + i32) -reduce(array, i64 - #) -reduce(array, i64 .. #) -reduce(array, i64 .. 1) -reduce(array, i64 / f64) -reduce(array, i64 <= #) -reduce(array, i64 == 1) -reduce(array, i64 == nil) -reduce(array, i64 ^ #) -reduce(array, i64 ^ f64) -reduce(array, i64) -reduce(array, i64) + i -reduce(array, i64) / f64 -reduce(array, i64) < i -reduce(array, i64) == f32 -reduce(array, int(f64)) -reduce(array, len(array)) +reduce(array, i, array) % i +reduce(array, i, f64) not in $env?.array +reduce(array, keys($env)) reduce(array, list) -reduce(array, list) != map(list, half) -reduce(array, map(array, div)) -reduce(array, map(array, score)) -reduce(array, map(list, 1)) -reduce(array, max(#, #, #)) -reduce(array, max(0.5)) -reduce(array, min(#)) -reduce(array, min(#, #, 0.5)) -reduce(array, min(0.5)) -reduce(array, min(1, 1)) -reduce(array, nil != "bar") -reduce(array, nil != #) -reduce(array, nil != 1) -reduce(array, not ok) -reduce(array, ok ? "foo" : "bar") -reduce(array, ok ? # : array) -reduce(array, ok ? # : i) -reduce(array, ok || true) +reduce(array, list[:#]) +reduce(array, mean(#)) +reduce(array, median(#)) +reduce(array, ok ? ok : #index) reduce(array, ok) -reduce(array, ok) and ok -reduce(array, reduce(array, 1)) -reduce(array, reduce(list, 0.5)) -reduce(array, round(0.5)) -reduce(array, score(#)) -reduce(array, score(1, #)) -reduce(array, score) -reduce(array, string(0.5)) -reduce(array, string(1)) -reduce(array, string(foo)) -reduce(array, string(i32)) -reduce(array, toJSON(i)) -reduce(array, trimPrefix("bar")) -reduce(array, true && true) -reduce(array, true ? add : #) -reduce(array, true) != ok -reduce(array, true) and ok +reduce(array, ok, $env.ok) +reduce(array, reduce(array, #)) +reduce(array, reduce(array, #, i)) +reduce(array, round(#)) +reduce(array, round(1)) +reduce(array, str not in foo) +reduce(array, str) +reduce(array, str) | greet() +reduce(array, string(#)) +reduce(array, sum(array, 1.0)) +reduce(array, toJSON(#)) +reduce(array, toJSON(1.0)) +reduce(array, true and ok) reduce(array, type(#)) -reduce(array, type(1)) -reduce(array, type(add)) -reduce(array, type(greet)) -reduce(array, type(score)) -reduce(array, upper("bar")) -reduce(false ? 0.5 : "bar", # and false) -reduce(false ? i32 : array, toJSON(#)) -reduce(false ? nil : list, #) -reduce(filter(array, ok), foo) -reduce(filter(list, ok), foo.Bar) -reduce(filter(list, true), i) -reduce(i .. 1, f64) -reduce(i .. 1, score) -reduce(i .. i, #) -reduce(i .. i, foo) -reduce(i .. i32, add) -reduce(i32 .. 1, #) -reduce(i32 .. 1, foo) -reduce(i32 .. i, 0.5 - #) -reduce(i32 .. i32, i64) -reduce(i32 .. i64, abs(f64)) -reduce(i64 .. 1, -#) -reduce(i64 .. i, #) -reduce(i64 .. i, -0.5) -reduce(i64 .. i, false ? "bar" : #) -reduce(i64 .. i, i) -reduce(i64 .. i, ok) -reduce(i64 .. i, round(i32)) -reduce(i64 .. i64, i64) -reduce(list, !true) -reduce(list, "bar" <= "bar") -reduce(list, "bar" in #) -reduce(list, "foo" not in #) -reduce(list, # != #) -reduce(list, # != foo) -reduce(list, # != nil) +reduce(array, uniq(list)) +reduce(array[0:], list) +reduce(flatten(array), array) +reduce(flatten(array), foo) +reduce(flatten(list), #) +reduce(keys($env), sum(#)) +reduce(let foobar = array; foobar, #) +reduce(list | map(1), $env?.f64) +reduce(list | sortBy(1.0), greet) reduce(list, # == #) -reduce(list, # == foo) -reduce(list, # == nil) -reduce(list, # in list) -reduce(list, # not in list) reduce(list, #) -reduce(list, #) != foo -reduce(list, #) not in groupBy(array, i) -reduce(list, #) not in list reduce(list, #).Bar -reduce(list, #).Qux reduce(list, #).String reduce(list, #).String() reduce(list, #)?.Bar -reduce(list, #)?.Qux reduce(list, #)?.String reduce(list, #)?.String() -reduce(list, #?.Bar not in # ? # : #) -reduce(list, #?.Bar) -reduce(list, #?.Qux("foo")) -reduce(list, #?.Qux) -reduce(list, #?.String()) +reduce(list, #, 1.0)?.Bar +reduce(list, #, array)?.String +reduce(list, #, f64).String +reduce(list, #, nil).String +reduce(list, #, ok)?.Bar +reduce(list, #.Bar != nil) +reduce(list, #.Bar) +reduce(list, #.String) reduce(list, #?.String) -reduce(list, -0.5) -reduce(list, -f64) -reduce(list, -i) -reduce(list, -i32) +reduce(list, #acc == 0) +reduce(list, #acc) +reduce(list, #acc)?.Bar +reduce(list, #acc, foo).String +reduce(list, #index) +reduce(list, $env && true) +reduce(list, $env).Bar +reduce(list, $env).String +reduce(list, $env).add +reduce(list, $env).array +reduce(list, $env).array?.[i] +reduce(list, $env).f64 +reduce(list, $env).foo +reduce(list, $env).greet +reduce(list, $env).i +reduce(list, $env).list +reduce(list, $env).ok +reduce(list, $env).str +reduce(list, $env)?.Bar +reduce(list, $env)?.String +reduce(list, $env)?.[str] +reduce(list, $env)?.add +reduce(list, $env)?.f64 +reduce(list, $env)?.foobar +reduce(list, $env)?.greet +reduce(list, $env)?.i +reduce(list, $env)?.list +reduce(list, $env)?.ok +reduce(list, $env)?.str +reduce(list, $env, $env)?.i +reduce(list, $env, add).array +reduce(list, $env, add).foo +reduce(list, $env, add)?.list +reduce(list, $env, foo).ok +reduce(list, $env, greet)?.Bar?.str +reduce(list, $env, nil)?.greet +reduce(list, $env.f64) +reduce(list, $env.list) +reduce(list, $env?.[#.Bar]) +reduce(list, $env?.[foobar]) +reduce(list, $env?.add) +reduce(list, $env?.f64) +reduce(list, $env?.foo) +reduce(list, $env?.list) +reduce(list, $env?.ok) +reduce(list, $env?.str) +reduce(list, .Bar not in foo, {foo: str}) reduce(list, .Bar) -reduce(list, .Qux) -reduce(list, .String()) reduce(list, .String) -reduce(list, 0.5 != f64) -reduce(list, 0.5 != nil) -reduce(list, 0.5 == i64) -reduce(list, 0.5 >= 0.5) -reduce(list, 0.5) != i -reduce(list, 0.5) / i64 -reduce(list, 0.5) < f32 -reduce(list, 0.5) < i -reduce(list, 0.5) < i32 -reduce(list, 0.5) < i64 -reduce(list, 0.5) <= f32 -reduce(list, 0.5) >= f64 -reduce(list, 0.5) >= i64 -reduce(list, 1 != nil) -reduce(list, 1 + f64) -reduce(list, 1 - 0.5) -reduce(list, 1 / 0.5) -reduce(list, 1 < f64) -reduce(list, 1 <= 1) -reduce(list, 1 == 0.5) -reduce(list, 1 == nil) -reduce(list, 1 ^ 1) -reduce(list, 1) * f64 -reduce(list, 1) + f32 -reduce(list, 1) - i +reduce(list, 0) != i +reduce(list, 1) * i +reduce(list, 1) / i +reduce(list, 1.0 * f64) +reduce(list, 1.0 + 1) +reduce(list, 1.0) * i +reduce(list, 1.0) == i +reduce(list, [$env, 0]) +reduce(list, [f64, false]) +reduce(list, add == $env) reduce(list, add) -reduce(list, add) != div -reduce(list, array != array) reduce(list, array) -reduce(list, div) -reduce(list, f32 / 0.5) -reduce(list, f32 < i32) -reduce(list, f32 <= f32) -reduce(list, f32) -reduce(list, f32) == f32 -reduce(list, f64 != nil) -reduce(list, f64 + 0.5) -reduce(list, f64 + 1) -reduce(list, f64 / i32) -reduce(list, f64 <= i32) -reduce(list, f64 == f32) -reduce(list, f64 > f32) -reduce(list, f64 >= 0.5) +reduce(list, array) | map(foo) +reduce(list, array) | sum(#) +reduce(list, array)?.[i] +reduce(list, array, add) +reduce(list, bitnot(1)) +reduce(list, f64 != $env) +reduce(list, f64 * f64) +reduce(list, f64 / f64) reduce(list, f64) -reduce(list, f64) * i64 -reduce(list, false == false) -reduce(list, false ? "foo" : list) -reduce(list, false ? # : #) -reduce(list, false || true) -reduce(list, filter(list, ok)) -reduce(list, findIndex(array, true)) -reduce(list, findLastIndex(list, false)) -reduce(list, float(i)) -reduce(list, floor(0.5)) -reduce(list, foo != #) +reduce(list, f64, f64) +reduce(list, false ?: foo) +reduce(list, false) ? f64 : [false] +reduce(list, first(#acc)) reduce(list, foo) -reduce(list, foo) == foo reduce(list, foo).Bar -reduce(list, foo).Qux reduce(list, foo).String -reduce(list, foo).String() reduce(list, foo)?.Bar -reduce(list, foo)?.Qux reduce(list, foo)?.String -reduce(list, foo)?.String() -reduce(list, foo.Bar) +reduce(list, foo, foo) +reduce(list, foo, i)?.String +reduce(list, foo, str) +reduce(list, foo.Bar, list) reduce(list, foo.String) -reduce(list, foo?.Bar) -reduce(list, foo?.Qux) +reduce(list, foo?.String()) reduce(list, foo?.String) -reduce(list, get(list, i)) -reduce(list, greet != nil) -reduce(list, greet("bar")) +reduce(list, greet(#.Bar)) reduce(list, greet) -reduce(list, groupBy(array, 1)) -reduce(list, groupBy(list, "bar")) -reduce(list, groupBy(list, #)) -reduce(list, half(1)) -reduce(list, half) -reduce(list, i * i64) -reduce(list, i + 1) -reduce(list, i - f64) -reduce(list, i .. 1) -reduce(list, i == 0.5) -reduce(list, i > i64) -reduce(list, i >= 0.5) +reduce(list, greet, greet) +reduce(list, i ^ 0) reduce(list, i) -reduce(list, i) * i64 -reduce(list, i) .. 1 % 1 -reduce(list, i) .. i -reduce(list, i) / f64 -reduce(list, i) / i32 -reduce(list, i) < f32 -reduce(list, i) == f32 -reduce(list, i) > f32 -reduce(list, i) ^ f32 -reduce(list, i32 != nil) -reduce(list, i32 - i32) -reduce(list, i32 .. 1) -reduce(list, i32 / 0.5) -reduce(list, i32 < i) -reduce(list, i32 <= i) -reduce(list, i32 == f64) -reduce(list, i32 >= f32) -reduce(list, i32) -reduce(list, i32) != f64 -reduce(list, i32) % i -reduce(list, i32) - f32 -reduce(list, i32) >= i -reduce(list, i64 .. 1) -reduce(list, i64 < i64) -reduce(list, i64 > i64) -reduce(list, i64 >= 0.5) -reduce(list, i64) -reduce(list, i64) * f64 -reduce(list, i64) ** i32 -reduce(list, i64) <= i64 -reduce(list, int(i64)) -reduce(list, len(array)) -reduce(list, list != nil) -reduce(list, list == nil) +reduce(list, i, $env?.list[:]) +reduce(list, i, 1.0) == i +reduce(list, i, list) +reduce(list, int(#index)) +reduce(list, int(0)) +reduce(list, list | any(ok)) +reduce(list, list | map($env)) reduce(list, list) -reduce(list, map(array, "bar")) -reduce(list, map(array, #)) -reduce(list, map(list, 1)) -reduce(list, max(0.5)) -reduce(list, max(f32)) -reduce(list, min(0.5)) -reduce(list, min(1)) -reduce(list, min(f32)) -reduce(list, nil != #) -reduce(list, nil != add) -reduce(list, nil != half) -reduce(list, nil == #) -reduce(list, not false) -reduce(list, not ok) -reduce(list, not true) -reduce(list, ok ? # : #) -reduce(list, ok ? # : score) -reduce(list, ok ? greet : add) -reduce(list, ok ? score : #) +reduce(list, list)?.[i] +reduce(list, list, i) +reduce(list, nil != $env) reduce(list, ok) -reduce(list, reduce(array, ok)) -reduce(list, reduce(array, score)) -reduce(list, reduce(list, #)) -reduce(list, reduce(list, 1)) -reduce(list, reduce(list, add)) -reduce(list, reduce(list, i32)) -reduce(list, score(i)) -reduce(list, score) -reduce(list, string(greet)) -reduce(list, toBase64("bar")) -reduce(list, toBase64("foo")) -reduce(list, toJSON(array)) -reduce(list, toJSON(list)) -reduce(list, toJSON(nil)) -reduce(list, true == nil) -reduce(list, true ? foo : f64) -reduce(list, type(#)) -reduce(map(array, "bar"), # not endsWith #) -reduce(map(array, "bar"), add) -reduce(map(array, "foo"), half(f64)) -reduce(map(array, #), # != i) -reduce(map(array, #), # .. #) -reduce(map(array, #), #) -reduce(map(array, #), abs(#)) -reduce(map(array, #), i) -reduce(map(array, #), i32 * #) -reduce(map(array, #), not ok) -reduce(map(array, 0.5), add) -reduce(map(array, 0.5), div) -reduce(map(array, 0.5), f32) -reduce(map(array, 1), # ^ 0.5) -reduce(map(array, 1), #) -reduce(map(array, 1), foo) -reduce(map(array, add), #) -reduce(map(array, add), f32) -reduce(map(array, add), list) -reduce(map(array, array), f64) -reduce(map(array, div), #) -reduce(map(array, div), div) -reduce(map(array, div), i32 * i) -reduce(map(array, f32), f32) -reduce(map(array, f32), i) -reduce(map(array, f32), i32) -reduce(map(array, f64), #) -reduce(map(array, f64), f32 < #) -reduce(map(array, false), # and true) -reduce(map(array, false), f32) -reduce(map(array, foo), # == nil) -reduce(map(array, i), # / 1) -reduce(map(array, i), #) -reduce(map(array, i), add) -reduce(map(array, i), f64 + 1) -reduce(map(array, i32), array) -reduce(map(array, i32), list) -reduce(map(array, i64), # <= #) -reduce(map(array, i64), #) -reduce(map(array, list), filter(#, false)) -reduce(map(array, ok), i) -reduce(map(array, score), i32) -reduce(map(list, "bar"), #) -reduce(map(list, "foo"), #) -reduce(map(list, #), #) -reduce(map(list, #), .Qux) -reduce(map(list, #), add) -reduce(map(list, #), array) -reduce(map(list, #), f32) -reduce(map(list, #), f64) -reduce(map(list, #), half) -reduce(map(list, #), i64) -reduce(map(list, #), ok) -reduce(map(list, 0.5), #) -reduce(map(list, 0.5), foo) -reduce(map(list, 1), # > #) -reduce(map(list, 1), #) -reduce(map(list, 1), list) -reduce(map(list, array), div) -reduce(map(list, div), add) -reduce(map(list, f64), #) -reduce(map(list, f64), ok) -reduce(map(list, false), div) -reduce(map(list, greet), #) +reduce(list, ok, f64) +reduce(list, reduce(array, greet, foo)) +reduce(list, str) +reduce(list, str) == str +reduce(list, string(ok)) +reduce(list, toBase64(#.Bar)) +reduce(list, true != $env) +reduce(list, true != ok) +reduce(list, true || false) +reduce(list, true || true) +reduce(list, type(i)) +reduce(list, type(list)) +reduce(list[:1], [$env]) +reduce(map($env, 1.0), #) +reduce(map($env, foo), str) +reduce(map(array, foo), foo?.Bar) +reduce(map(array, list), list) +reduce(map(list, #), $env?.add) reduce(map(list, i), #) -reduce(map(list, i), [i32]) -reduce(map(list, i), f32) -reduce(map(list, i), score(#)) -reduce(map(list, i32), #) -reduce(map(list, i32), foo) -reduce(map(list, i64), #) -reduce(map(list, i64), i32) -reduce(map(list, list), ok) -reduce(map(list, score), #) -reduce(map(list, score), f64) -reduce(map(list, true), #) -reduce(map(list, true), add) -reduce(map(list, true), half) -reduce(ok ? "bar" : i32, #) -reduce(ok ? "foo" : list, #) -reduce(ok ? array : half, f32) -reduce(ok ? list : i, #) -reduce(reduce(array, array), f64 != #) -reduce(reduce(array, list), get(array, i32)) -reduce(reduce(list, array), f64) -reduce(sort(array), #) -reduce(sort(array), foo) -reduce(sort(array), greet) -reduce(sort(array), ok) -reduce(true ? array : 1, array) -reduce(true ? array : array, #) -repeat(type(ok), i) -round(-0.5) -round(-1) -round(-f32) -round(-f64) -round(-i) -round(-i32) -round(-i64) -round(0.5 * 1) -round(0.5 * f64) -round(0.5 * i32) -round(0.5 ** 0.5) -round(0.5 ** 1) -round(0.5 ** i) -round(0.5 ** i32) -round(0.5 ** i64) -round(0.5 + 1) -round(0.5 + f64) -round(0.5 + i) -round(0.5 + i32) -round(0.5 - 0.5) -round(0.5 - 1) -round(0.5 - i32) -round(0.5 / 0.5) -round(0.5 / 1) -round(0.5 / f64) -round(0.5 / i32) -round(0.5 ^ f64) -round(0.5 ^ i) -round(0.5 ^ i64) -round(0.5) * f32 -round(0.5) ** i32 -round(0.5) + -f32 -round(0.5) - i64 ^ i -round(0.5) < f64 -round(0.5) <= i64 -round(0.5) == i32 -round(0.5) == i64 -round(0.5) == max(i, i64) -round(0.5) > -1 -round(0.5) > i -round(0.5) >= i -round(0.5) in array -round(1 % i) -round(1 % i64) -round(1 * 0.5) -round(1 * f32) -round(1 * i64) -round(1 ** 0.5) +reduce(reduce(array, list), #index) +reduce(reverse(array), $env.ok) +reduce(reverse(array), $env?.ok) +reduce(reverse(list), str) +reduce(sort(array), str) +reduce(values($env), #) +repeat(str, i) +repeat(str, i) not startsWith str +repeat(type(1), i) +reverse($env | filter(false)) +reverse($env | map($env)) +reverse($env | map(0)) +reverse($env | map(1.0)) +reverse($env | map(false)) +reverse($env | map(true)) +reverse($env.array) +reverse($env.list) +reverse($env?.array) +reverse($env?.list) +reverse(0 .. 1) +reverse(0 .. i) +reverse(1 .. 1) +reverse([$env, 0]) +reverse([$env, f64]) +reverse([$env]) +reverse([0, $env, foo]) +reverse([0]) +reverse([1 .. 1]) +reverse([1, true]) +reverse([1.0, list]) +reverse([1.0]) +reverse([1]) +reverse([add, list]) +reverse([array, array]) +reverse([array, greet]) +reverse([array]) +reverse([f64, nil]) +reverse([f64]) +reverse([false]) +reverse([foo, 1.0]) +reverse([foo, str]) +reverse([foo]) +reverse([greet]) +reverse([i, 1]) +reverse([i]) +reverse([list]) +reverse([nil, list]) +reverse([nil, nil]) +reverse([nil]) +reverse([ok]) +reverse([str, ok]) +reverse([str]) +reverse([true]) +reverse(array | map($env)) +reverse(array | map(ok)) +reverse(array | map(str)) +reverse(array | reduce(array, foo)) +reverse(array | sortBy(1)) +reverse(array) +reverse(array) | findIndex(ok) +reverse(array) | findLastIndex(false) +reverse(array) | map(#) +reverse(array) | one(ok) +reverse(array) | reduce(#) +reverse(array) | reduce(#, greet) +reverse(array) | reduce($env) +reverse(array) | reduce(foo) +reverse(array) | reduce(str) +reverse(array) | sortBy(1) +reverse(array) | sortBy(i) +reverse(array) | sum(#) +reverse(array)?.[i] +reverse(array[i:1]) +reverse(concat(array)) +reverse(concat(list)) +reverse(filter($env, false)) +reverse(flatten(list)) +reverse(if false { $env } else { array }) +reverse(keys($env)) +reverse(let foobar = array; foobar) +reverse(let foobar = list; foobar) +reverse(list | filter(true)) +reverse(list | map(#)) +reverse(list | map(i)) +reverse(list | map(str)) +reverse(list | map(true)) +reverse(list | sortBy(1.0)) +reverse(list) +reverse(list) != list +reverse(list) == array +reverse(list) | any(true) +reverse(list) | count(true) +reverse(list) | groupBy(#) +reverse(list) | groupBy(foo) +reverse(list) | reduce(0) +reverse(list) | reduce(f64) +reverse(list) | reduce(foo) +reverse(list) | reduce(greet) +reverse(list) | reduce(true) +reverse(list)?.[i] +reverse(map($env, 0)) +reverse(map($env, 1.0)) +reverse(map($env, array)) +reverse(map($env, f64)) +reverse(map($env, list)) +reverse(map($env, str)) +reverse(map(array, #)) +reverse(map(array, #index)) +reverse(map(array, foo)) +reverse(map(list, #)) +reverse(map(list, #.Bar)) +reverse(map(list, $env)) +reverse(reduce(array, list)) +reverse(reverse(list)) +reverse(sort($env)) +reverse(sort(array)) +reverse(sortBy(array, #)) +reverse(sortBy(array, 1.0)) +reverse(sortBy(array, str)) +reverse(sortBy(list, 1.0)) +reverse(toPairs($env)) +reverse(uniq(array)) +reverse(uniq(list)) +round($env | findIndex(true)) +round($env | reduce(0, foo)) +round($env | sum(1.0)) +round($env.f64) +round($env.f64) != i +round($env.i) +round($env?.f64) +round($env?.i) +round(0 * 1.0) +round(0 * f64) +round(0 ** 0) +round(0 ** f64) +round(0 ** i) +round(0 + 0) +round(0 + 1) +round(0 + 1.0) +round(0 + i) +round(0 - 1) +round(0 / 0) +round(0 / 1.0) +round(0 / f64) +round(0 ^ 1.0) +round(0 ^ f64) +round(0) / f64 +round(0) < i +round(0) ^ f64 +round(0) ^ i +round(0.1) +round(1 * 0) +round(1 ** 0) round(1 ** 1) -round(1 ** f32) -round(1 ** f64) round(1 ** i) -round(1 + 0.5) -round(1 + 1) -round(1 + i64) -round(1 - 0.5) -round(1 - 1) +round(1 + 0) +round(1 + 1.0) +round(1 + i) +round(1 - 0) +round(1 - 1.0) round(1 - i) -round(1 - i32) -round(1 - i64) -round(1 / 0.5) round(1 / 1) -round(1 / f32) round(1 / i) -round(1 / i64) -round(1 ^ 0.5) -round(1 ^ 1) -round(1 ^ f32) -round(1 ^ i) -round(1 ^ i64) -round(1) != ceil(i32) -round(1) * i32 -round(1) + i64 -round(1) - i64 -round(1) / i32 -round(1) / i64 -round(1) < i64 -round(1) <= i -round(1) == i -round(1) >= f64 -round(1) >= i32 -round(1) >= i64 -round(1) ^ f64 +round(1 ^ 0) +round(1 ^ 1.0) +round(1 ^ f64) +round(1 | bitnand(0)) +round(1) / f64 +round(1) ^ sum(array) round(1) not in array -round(abs(0.5)) -round(abs(1)) -round(abs(f64)) +round(1.0 * 0) +round(1.0 * 1) +round(1.0 * 1.0) +round(1.0 * f64) +round(1.0 * i) +round(1.0 ** 0) +round(1.0 ** 1.0) +round(1.0 ** i) +round(1.0 + 0) +round(1.0 - 1) +round(1.0 - 1.0) +round(1.0 - f64) +round(1.0 - i) +round(1.0 / 1) +round(1.0 / 1.0) +round(1.0 / i) +round(1.0 ^ $env.i) +round(1.0 ^ 0) +round(1.0 ^ 1.0) +round(1.0 ^ f64) +round(1.0 ^ i) +round(1.0 | max(i)) +round(1.0 | mean(0)) +round(1.0) +round(1.0) * $env and false +round(1.0) * f64 +round(1.0) ** 1.0 != 1 +round(1.0) ** f64 +round(1.0) + f64 +round(1.0) + mean(1.0, f64) +round(1.0) / i +round(1.0) <= i +round(1.0) > i +round(1.0) >= f64 +round(1.0) ^ f64 +round(1.0) ^ i +round(1.0) ^ sum($env, 1) +round(1.0) | median(array) +round(1.1) +round(abs(1.0)) round(abs(i)) -round(abs(i64)) -round(add(1, i)) -round(array[1]) -round(array[i32]) -round(array[i64]) +round(array | reduce(#)) +round(array | sum(#)) +round(array | sum(1)) +round(array?.[0]) +round(array?.[i]) round(bitnot(i)) -round(bitnot(i32)) -round(bitnot(i64)) -round(ceil(1)) +round(ceil(1.0)) round(ceil(f64)) -round(ceil(i32)) -round(ceil(i64)) -round(count(list, true)) -round(div(1, 1)) -round(f32 * 0.5) -round(f32 * 1) -round(f32 * f64) -round(f32 * i32 ^ f32) -round(f32 * i64) -round(f32 ** 0.5) -round(f32 ** 1) -round(f32 + f64) -round(f32 + i32) -round(f32 - 0.5) -round(f32 - i) -round(f32 / i32) -round(f32 ^ 0.5) -round(f32 ^ f32) -round(f32 ^ i) -round(f32 ^ i64) -round(f32) -round(f32) * i32 -round(f32) - i32 -round(f32) / f32 -round(f32) == i32 -round(f64 * 0.5) +round(f64 * 0) +round(f64 * 1) +round(f64 * 1.0) round(f64 * i) -round(f64 ** 0.5) -round(f64 ** 1) -round(f64 ** f32) -round(f64 ** i) -round(f64 + f64) -round(f64 + i) -round(f64 + i32) -round(f64 - 0.5) -round(f64 - 1) -round(f64 - i32) +round(f64 ** 0) +round(f64 + 1.0) +round(f64 - 0) +round(f64 - i) +round(f64 / 0) +round(f64 / 1.0) round(f64 / f64) -round(f64 / i) -round(f64 / i32) -round(f64 / i64) round(f64 ^ 1) +round(f64 ^ 1.0) round(f64 ^ f64) round(f64) -round(f64) * f32 -round(f64) ** i32 round(f64) + f64 -round(f64) <= f64 -round(f64) > i -round(f64) > i32 -round(f64) >= i64 -round(f64) not in array -round(false ? f32 : f64) -round(false ? f64 : 1) -round(false ? nil : 1) -round(findIndex(array, # <= #)) -round(findIndex(list, ok)) +round(f64) + f64 < 0 +round(f64) <= i +round(f64) >= i +round(false ? 0 : 1.0) +round(false ?: 1) round(findLast(array, ok)) -round(findLast(array, true)) -round(findLastIndex(array, ok)) -round(findLastIndex(list, ok)) -round(float(0.5)) +round(findLastIndex($env, true)) +round(first(array)) +round(float(0)) round(float(1)) -round(float(f32)) +round(float(1.0)) +round(float(f64)) round(float(i)) -round(floor(0.5)) +round(floor(0)) round(floor(1)) +round(floor(1.0)) round(floor(f64)) -round(floor(i32)) -round(floor(i64)) -round(get(array, i)) -round(get(array, i32)) -round(get(array, i64)) -round(half(-1)) -round(half(0.5)) -round(half(1)) -round(half(f64)) -round(i % i32) -round(i % i64) -round(i * 1) -round(i * f64) -round(i * i32) +round(floor(i)) +round(i % 1) +round(i * 1.0) +round(i * i) +round(i ** 0) round(i ** 1) -round(i ** i64) -round(i + 0.5) -round(i + 1) -round(i + f64) -round(i + i) -round(i + i32) -round(i + i64) -round(i - i) -round(i - i32) -round(i / 1) +round(i ** 1.0) +round(i - 1) +round(i - f64) +round(i / 1.0) +round(i / f64) round(i / i) -round(i / i64) -round(i ^ 0.5) > f32 -round(i ^ 1) -round(i ^ f32) +round(i ^ 0) +round(i ^ 1.0) round(i) -round(i) * f32 -round(i) * i -round(i) / f64 -round(i) < i -round(i) < i32 -round(i) > i -round(i) > i64 != ok -round(i) >= f32 -round(i) >= i64 -round(i) ^ i32 -round(i32 % 1) -round(i32 * 1) -round(i32 ** 1) -round(i32 ** f32) -round(i32 ** f64) -round(i32 + 0.5) -round(i32 + 1) -round(i32 + i32) -round(i32 - 1) -round(i32 - f32) -round(i32 - f64) -round(i32 / 0.5) -round(i32 / 1) -round(i32 ^ f64) -round(i32) -round(i32) != i -round(i32) * f32 -round(i32) ** f64 -round(i32) - i -round(i32) < i32 -round(i32) <= ceil(1) -round(i32) <= f64 -round(i32) <= i64 -round(i32) >= f64 -round(i32) >= i32 -round(i32) ^ f64 -round(i64 % i) -round(i64 % i32) -round(i64 * 0.5) -round(i64 * i) -round(i64 ** 1) -round(i64 ** f64) -round(i64 ** i64) -round(i64 + f32) -round(i64 - 0.5) -round(i64 - 1) -round(i64 - i) -round(i64 / 0.5) -round(i64 / 1) -round(i64 ^ 1) -round(i64 ^ i32) -round(i64 ^ i64) -round(i64) -round(i64) != f64 -round(i64) * i64 -round(i64) ** i32 -round(i64) - bitnot(1) -round(i64) - f32 -round(i64) < f64 -round(i64) ^ f64 -round(int(0.5)) +round(i) + i +round(i) / i +round(i) == i +round(i) > $env?.i +round(i) > f64 +round(if false { foo } else { 0 }) +round(if true { 0 } else { greet }) +round(int(0)) round(int(1)) -round(int(f32)) round(int(f64)) -round(int(i)) -round(int(i32)) -round(int(i64)) +round(int(string(1.0))) round(last(array)) -round(len("bar")) -round(len("foo")) -round(len(array)) round(len(list)) -round(max(0.5)) -round(max(1)) +round(len(str)) +round(list | count(ok)) +round(list | reduce(1.0, 1.0)) +round(list | reduce(f64)) +round(max(1.0 * 0)) +round(max(1.0)) +round(max(array)) +round(max(array, array)) +round(max(f64)) round(max(i)) -round(max(i32)) -round(max(i64)) -round(max(i64, f32)) +round(mean(0)) +round(mean(1)) +round(mean(1, 1.0)) +round(mean(1.0)) round(mean(array)) +round(mean(f64)) +round(mean(f64, f64)) +round(mean(i)) +round(median(0)) +round(median(1)) round(median(array)) -round(min(0.5)) +round(median(f64)) +round(median(f64, i)) +round(median(i)) round(min(1)) -round(min(f32)) +round(min(1.0)) +round(min(array)) round(min(f64)) -round(min(i32)) -round(min(i64)) +round(min(i)) +round(ok ? i : 0) round(reduce(array, #)) -round(reduce(array, 0.5)) -round(reduce(array, 1)) -round(reduce(array, i64)) -round(reduce(list, 0.5)) -round(reduce(list, f32)) -round(round(0.5)) +round(reduce(array, #, nil)) +round(reduce(list, #index, nil)) round(round(1)) -round(round(f32)) -round(round(f64)) -round(round(i)) -round(round(i32)) -round(round(i64)) -round(score(1)) -round(score(i)) +round(round(1.0)) +round(sum($env, 0)) +round(sum($env, 1)) +round(sum($env, f64)) round(sum(array)) -round(true ? i : ok) -score -score != nil != ok -score != nil ? half : f64 -score != nil or i32 > 0.5 -score != nil || ok -score != score -score != score != ok -score != score ? i32 : i32 -score == nil != nil -score == nil && ok -score == nil ? 0.5 : "bar" -score == score -score == score == true -score == score ? 0.5 : score -score in groupBy(list, #)?.array -score in sort(array) -score(-1) -score(-1, i) -score(-get(array, i)) -score(-i) -score(-i, i) -score(1 % 1) -score(1 % i) -score(1 % i32) -score(1 % i64) -score(1 * 1) -score(1 * i) -score(1 * i32) -score(1 * i64) -score(1 + 1) -score(1 + i) -score(1 + i32) -score(1 + i64) -score(1 - 1) -score(1 - i) -score(1 - i32) -score(1) != -f32 -score(1) != i -score(1) != i32 -score(1) % -1 -score(1) % i -score(1) % i64 -score(1) * f32 -score(1) * i -score(1) * i64 -score(1) ** i32 -score(1) + f64 -score(1) + i32 -score(1) - f32 -score(1) - i -score(1) - i32 -score(1) - int(0.5) -score(1) .. i -score(1) .. i32 -score(1) .. i64 -score(1) .. score(1) -score(1) / f32 -score(1) / i32 -score(1) < i -score(1) < i32 -score(1) < i64 -score(1) < i64 - 0.5 -score(1) <= 0.5 * 1 -score(1) <= i -score(1) <= i64 -score(1) == i32 -score(1) == i64 -score(1) > bitshr(i64, 1) -score(1) > f32 -score(1) > i64 -score(1) >= 0.5 + f64 -score(1) >= f32 -score(1) >= i -score(1) >= sum(array) -score(1) ^ f64 -score(1) ^ i -score(1) ^ i32 -score(1) in array -score(1) not in groupBy(list, false) -score(1, 1) < i -score(1, i) < f64 -score(1, i) ^ f32 -score(abs(1)) -score(abs(i)) -score(add(1, i)) -score(array[1]) -score(array[i64]) -score(array[i]) -score(bitnand(1, i64)) -score(bitnand(i64, i32)) -score(bitnot(1)) -score(bitnot(i)) -score(bitnot(i32)) -score(bitnot(i64)) -score(bitshl(i32, i)) -score(bitshr(1, i64)) -score(bitshr(i32, i64)) -score(bitushr(1, i)) -score(count(array, false)) -score(count(array, ok)) -score(count(array, true)) -score(count(list, ok)) -score(false ? f64 : 1) -score(false ? foo : 1) -score(find(array, i != #)) -score(find(array, ok)) -score(find(array, true)) -score(findIndex(array, ok)) -score(findIndex(array, true)) -score(findIndex(list, true)) -score(findLast(array, true)) -score(findLastIndex(array, true)) -score(findLastIndex(list, ok)) -score(findLastIndex(list, true)) -score(first(array)) -score(get(array, 1)) -score(get(array, i)) -score(get(array, i32)) -score(get(array, i64)) -score(i % 1) -score(i % i) -score(i % i64) -score(i * 1 * i) -score(i * 1) -score(i * i) -score(i * i32) -score(i * i64) -score(i + 1) -score(i + i) -score(i + i32) -score(i - 1) -score(i - i) -score(i - i32) -score(i) -score(i) != f32 -score(i) != f64 -score(i) % i -score(i) % i * f64 -score(i) * f32 -score(i) * i32 -score(i) ** (0.5 / 0.5) -score(i) ** -0.5 -score(i) ** i32 -score(i) ** i64 -score(i) + f64 -score(i) - f64 -score(i) - i32 -score(i) / i64 -score(i) < 1 != ok -score(i) < f32 -score(i) < f64 / 0.5 -score(i) < i32 -score(i) < i64 -score(i) <= 0.5 / f32 -score(i) <= f32 -score(i) <= f64 -score(i) <= i -score(i) <= i32 -score(i) == f32 -score(i) > f32 -score(i) > i -score(i) > i64 -score(i) >= f32 -score(i) >= f64 -score(i) >= i -score(i) >= i32 -score(i) >= i64 -score(i) ^ f32 -score(i) ^ i32 -score(i) ^ i64 -score(i) ^ score(1) -score(i, 1) + -1 -score(i, 1) .. i64 -score(i, 1) <= f32 -score(i, i) -score(i, i) ** f32 -score(i32 % 1) -score(i32 % i) -score(i32 % i32) -score(i32 * 1) -score(i32 * i) -score(i32 * i32) -score(i32 * i64) -score(i32 + 1) -score(i32 + i) -score(i32 + i32) -score(i32 + i64) -score(i32 - 1) -score(i32 - i) -score(i32 - i32) -score(i32 - i64) -score(i64 % 1) -score(i64 % i) -score(i64 % i32) -score(i64 % i64) -score(i64 * 1) -score(i64 * i32) -score(i64 * i64) -score(i64 + 1) -score(i64 + i) -score(i64 + i32) -score(i64 - 1) -score(i64 - i64) -score(int(0.5)) -score(int(1)) -score(int(f32)) -score(int(f64)) -score(int(float(0.5))) -score(int(i)) -score(int(i32)) -score(int(i64)) -score(last(array)) -score(len("bar")) -score(len("foo")) -score(len(array)) -score(len(list)) -score(max(1)) -score(max(1, i32, 0.5)) -score(max(i)) -score(max(i, i32)) -score(min(1)) -score(min(i)) -score(min(i, i32)) -score(ok ? 1 : "bar") -score(ok ? 1 : list) -score(reduce(array, #)) -score(reduce(array, i)) -score(reduce(list, 1)) -score(reduce(list, i)) -score(score(1)) -score(score(i)) -score(score(i32 + i)) -score(sum(array)) -sort(1 .. 1) -sort(1 .. i) +sort($env | map(#index)) +sort($env | map(0)) +sort($env) | all(#.Bar) +sort($env) | all(#.add) +sort($env) | all(#.ok) +sort($env) | all(.str) +sort($env) | all(true) +sort($env) | any(#) +sort($env) | any(#.f64) +sort($env) | any(.String) +sort($env) | any(.array) +sort($env) | concat(list) +sort($env) | count(#) +sort($env) | count(#.foo) +sort($env) | count(#.i == 0) +sort($env) | count($env) +sort($env) | filter(#) +sort($env) | filter(#.i) +sort($env) | find(#) +sort($env) | find(#.Bar) +sort($env) | find(#.list) +sort($env) | find(false) +sort($env) | findIndex(#) +sort($env) | findIndex(#.add) +sort($env) | findIndex(#.array) +sort($env) | findIndex(.String) +sort($env) | findIndex(.foo) +sort($env) | findIndex(.ok) +sort($env) | findIndex(ok) +sort($env) | findLast(#) +sort($env) | findLast(#.array) +sort($env) | findLast(#.list?.foo(#)) +sort($env) | findLastIndex(#) +sort($env) | findLastIndex(#.list) +sort($env) | findLastIndex(.Bar) +sort($env) | groupBy(#) +sort($env) | groupBy(#.add) +sort($env) | groupBy(#.greet) +sort($env) | groupBy(#?.foo(i)) +sort($env) | groupBy(.array) +sort($env) | groupBy(add) +sort($env) | groupBy(i) +sort($env) | map(#) +sort($env) | map(#.f64) +sort($env) | map(.foo) +sort($env) | map(.list) +sort($env) | map(1.0) +sort($env) | map(i) +sort($env) | map(true) +sort($env) | mean(1.0) +sort($env) | none(#) +sort($env) | none(#.ok) +sort($env) | none($env) +sort($env) | none(.String) +sort($env) | none(.array) +sort($env) | one(#.f64) +sort($env) | one(#.list) +sort($env) | one(#.ok) +sort($env) | one(#.ok.nil) +sort($env) | one($env) +sort($env) | one(.f64) +sort($env) | one(.f64?.[.greet]) +sort($env) | one(.list) +sort($env) | one(ok) +sort($env) | reduce(#.String, nil) +sort($env) | reduce(foo, foo) +sort($env) | sortBy(#) +sort($env) | sortBy(1.0) +sort($env) | sortBy(i) +sort($env) | sortBy(str) +sort($env) | sum(#.greet) +sort($env) | sum(#.str?.String) +sort($env) | sum(.array) +sort($env) | sum(false) +sort($env) | sum(foo) +sort($env)?.[i] +sort($env)?.[i].add() +sort($env)[:] +sort($env.array) +sort($env?.Bar) +sort($env?.Bar?.greet) +sort($env?.String) +sort($env?.[Bar]) +sort($env?.[Bar]?.[array]) +sort($env?.[String]) +sort($env?.[foobar]) +sort($env?.[nil]) +sort($env?.[str]) +sort($env?.array) +sort($env?.false) +sort($env?.foobar) +sort($env?.foobar?.greet) +sort($env?.list | reduce(#acc)) +sort($env?.nil) +sort(1..i) +sort([$env]) +sort([0 .. 0]) +sort([0]) +sort([1.0]) +sort([1]) sort([add]) -sort([greet]) -sort([half]) -sort([i64]) +sort([array]) +sort([false]) +sort([foo]) +sort([i]) sort([list]) +sort([nil]) +sort([ok]) +sort([str]) +sort([true]) +sort(array | map(#)) +sort(array | sortBy(#)) sort(array) -sort(array) == array -sort(false ? greet : array) -sort(groupBy(list, #)?.foo) -sort(groupBy(list, i32).half) -sort(i .. i32) -sort(i .. i64) -sort(i32 .. 1) -sort(i64 .. 1) -sort(map(array, "bar")) -sort(map(array, "foo")) +sort(array) == list +sort(array) | find(true) +sort(array) | findIndex($env?.ok) +sort(array) | findLastIndex(false) +sort(array) | get(i) +sort(array) | groupBy(#) +sort(array) | groupBy(str) +sort(array) | map(#) +sort(array) | map(0) +sort(array) | map(1.0) +sort(array) | map(list) +sort(array) | one(false) +sort(array) | reduce($env) +sort(array) | reduce(foo) +sort(array) | reduce(true, 1.0) +sort(array) | sortBy(1) +sort(array)?.[i] +sort(array[0:]) +sort(concat(array)) +sort(false ? true : 0) +sort(false ?: 1.0) +sort(false ?: i) +sort(filter($env, false)) +sort(first($env)) +sort(if false { 1 } else { 1.0 }) +sort(if false { 1.0 } else { 1 }) +sort(if ok { ok } else { 1.0 }) +sort(if true { add } else { str }) +sort(if true { f64 } else { $env }) +sort(if true { greet } else { 1 }) +sort(keys($env)) +sort(last($env)) +sort(list | map(#.Bar)) sort(map(array, #)) -sort(map(array, 1)) -sort(map(array, f64)) -sort(map(array, i)) -sort(map(array, i64)) +sort(map(array, 0)) +sort(map(array, 1.0)) +sort(map(list, str)) +sort(max($env)) +sort(max(array)) +sort(max(array, 1.0)) +sort(mean(array)) +sort(median(array)) +sort(min($env)) +sort(min(array)) +sort(min(array, 1.0)) +sort(ok ? 1.0 : $env) +sort(ok ? list : str) +sort(ok ?: 1.0) +sort(ok ?: list) sort(reduce(array, array)) -sortBy(array, string(true)) -string(!!false) -string(!false) -string(!ok) -string(!true) -string("bar" != nil) -string("bar" <= "bar") -string("bar" == "bar") -string("bar" > "foo") -string("bar" >= "bar") -string("bar" not endsWith "bar") -string("bar" not matches "bar") -string("bar" not startsWith "foo") -string("bar" startsWith "foo") -string("bar") > type(i64) -string("bar") >= toJSON("bar") -string("foo" != nil) -string("foo" == "foo") -string("foo" == nil) -string("foo" > "bar") -string("foo" in foo) -string("foo" matches "bar") -string("foo" not contains "bar") -string("foo" not contains "foo") -string("foo" not in foo) -string(--i) -string(-0.5) -string(-1) -string(-f32) -string(-f64) -string(-i) -string(-i32) -string(-i64) -string(0.5 != 0.5) -string(0.5 != f64) -string(0.5 != i) -string(0.5 != i32) -string(0.5 * 0.5) -string(0.5 * i) -string(0.5 * i32) -string(0.5 ** f32) -string(0.5 ** i32) -string(0.5 + f64) -string(0.5 + i) -string(0.5 + i64) -string(0.5 - f32) -string(0.5 - f64) -string(0.5 / 0.5) -string(0.5 / 1) -string(0.5 / f32) -string(0.5 / i) -string(0.5 < 0.5) -string(0.5 < 1) -string(0.5 < i64) -string(0.5 <= 0.5) -string(0.5 <= f64) -string(0.5 <= i) -string(0.5 <= i32) -string(0.5 == 0.5) -string(0.5 == 1) -string(0.5 == i64) -string(0.5 == nil) -string(0.5 > 0.5) -string(0.5 > 1) -string(0.5 > i) -string(0.5 > i64) -string(0.5 >= 0.5) -string(0.5 >= 1) -string(0.5 >= f32) -string(0.5 >= i32) -string(0.5 >= i64) -string(0.5 ^ f32) -string(0.5 ^ i) -string(0.5 ^ i32) -string(0.5 ^ i64) -string(0.5 in array) -string(0.5 not in array) -string(1 != 0.5) -string(1 != 1) -string(1 != i) -string(1 != i64) +sort(reverse(array)) +sort(sort($env)) +sort(sort(array)) +sort(sortBy(array, 1.0)) +sort(toPairs($env)) +sort(true ? i : 1.0) +sort({foo: 1.0}.add) +sort({foo: str}.greet) +sortBy($env.array, #) +sortBy($env.array, f64) +sortBy($env.list, #.Bar) +sortBy($env.list, f64) +sortBy($env?.[str], $env?.i) +sortBy($env?.[str], f64) +sortBy($env?.array, #) +sortBy($env?.list, f64) +sortBy(0 .. 0, #) +sortBy(0 .. 1, #) +sortBy(0 .. i, # ^ i) +sortBy([$env], #) +sortBy([$env], #?.add) +sortBy([$env], .list) +sortBy([0], $env.ok) +sortBy([0], $env?.Bar) +sortBy([0], add) +sortBy([0], greet) +sortBy([1.0], $env?.ok) +sortBy([1.0], f64) +sortBy([1], 0 >= #) +sortBy([array], f64) +sortBy([f64], add) +sortBy([false], list) +sortBy([foo], #) +sortBy([foo], add) +sortBy([foo], array) +sortBy([foo], foo) +sortBy([list], #) +sortBy([nil], array) +sortBy([true], f64) +sortBy([true], i) +sortBy(array, # * #) +sortBy(array, # ** #) +sortBy(array, # + #) +sortBy(array, # ^ #) +sortBy(array, #) +sortBy(array, #) | findIndex(false) +sortBy(array, #) | groupBy(true) +sortBy(array, #) | map(0) +sortBy(array, #) | reduce(#) +sortBy(array, #) | reduce($env) +sortBy(array, #)?.[i] +sortBy(array, $env.i) +sortBy(array, $env?.[str]) +sortBy(array, $env?.i) +sortBy(array, 0 * #) +sortBy(array, 0 - 1) +sortBy(array, 0) | map(#) +sortBy(array, 0)?.[i] +sortBy(array, 1 ** f64) +sortBy(array, 1 / #) +sortBy(array, 1 ^ #) +sortBy(array, 1) | groupBy(#) +sortBy(array, 1) | reduce($env) +sortBy(array, 1)?.[i] +sortBy(array, 1.0 ^ #) +sortBy(array, 1.0)?.[i] +sortBy(array, abs(#)) +sortBy(array, bitnot(#)) +sortBy(array, f64 ** #) +sortBy(array, f64) +sortBy(array, f64)?.[i] +sortBy(array, findLast(array, ok)) +sortBy(array, findLastIndex($env, ok)) +sortBy(array, float(1)) +sortBy(array, i ** #) +sortBy(array, i) +sortBy(array, i)?.[i] +sortBy(array, max(#)) +sortBy(array, mean(#)) +sortBy(array, round(#)) +sortBy(array, round(i)) +sortBy(array, str) +sortBy(array, str) | map(list) +sortBy(array, str) | none(ok) +sortBy(array, str)?.[i] +sortBy(array, toJSON(foo)) +sortBy(array, toJSON(nil)) +sortBy(array[:i], str) +sortBy(concat(array), #) +sortBy(concat(array), round(i)) +sortBy(filter($env, false), #.foo) +sortBy(flatten(list), f64) +sortBy(let foobar = array; foobar, # * 1.0) +sortBy(list | map(i), # ^ #) +sortBy(list, #.Bar) +sortBy(list, #.Bar)?.[i] +sortBy(list, #.String()) +sortBy(list, #?.Bar) +sortBy(list, $env.f64) +sortBy(list, $env.i) +sortBy(list, $env?.i) +sortBy(list, .Bar) +sortBy(list, .Bar) | sum(f64) +sortBy(list, 0)?.[i] +sortBy(list, 1)?.[i] +sortBy(list, 1.0 ** f64) +sortBy(list, 1.0)?.[$env?.i] +sortBy(list, abs(0)) +sortBy(list, bitnand(0, 1)) +sortBy(list, bitnot(1)) +sortBy(list, f64) +sortBy(list, f64) | filter(true) +sortBy(list, f64) | map($env) +sortBy(list, f64) | reduce(#) +sortBy(list, f64) | sum(0) +sortBy(list, f64)?.[i] +sortBy(list, greet(#.Bar)) +sortBy(list, greet(.Bar)) +sortBy(list, greet(str)) +sortBy(list, i) +sortBy(list, i) == list +sortBy(list, i) | reduce($env) +sortBy(list, len(#.Bar)) +sortBy(list, reduce(array, i)) +sortBy(list, str) +sortBy(list, str) | reduce(true) +sortBy(list, str)?.[i] +sortBy(list, string(1.0)) +sortBy(list, string(greet)) +sortBy(list, string(ok)) +sortBy(list, toBase64(str)) +sortBy(list, toJSON(#.Bar)) +sortBy(list, toJSON(i)) +sortBy(list, type(add)) +sortBy(list, type(false)) +sortBy(list, type(list)) +sortBy(map($env, greet), type(f64)) +sortBy(sort($env), #) +sortBy(sort($env), #.array .. .f64) +sortBy(sort($env), map(#.list, array)) +sortBy(sortBy(array, i), #) +sortBy(take(list, 1), #) +split(str, $env?.[str]) +split(str, str) +split(str, string($env)) +split(str, toBase64(str)) +splitAfter(foo?.Bar, str) +splitAfter(str, foo?.String()) +splitAfter(str, str) +splitAfter(str, toJSON(nil)) +str +str != $env == $env +str != $env ? 1.0 : $env +str != $env and ok +str != $env or $env +str != $env.str +str != $env?.Bar +str != $env?.String +str != $env?.[Bar] +str != $env?.[String] +str != $env?.[nil] +str != $env?.[str] +str != $env?.str +str != foo.Bar +str != foo.String() +str != foo?.Bar +str != foo?.String() +str != greet(str) +str != median(array) +str != min(array, array) +str != nil && $env +str != nil ? foo : f64 +str != nil or $env +str != nil or $env?.[Bar] +str != nil or ok +str != nil || $env +str != reduce(array, #acc, foo) +str != reduce(list, .Bar, false) +str != str +str != str && $env?.String.i() +str != str && true +str != str ? 0 : 1.0 +str != str ? foo : true +str != string(f64) +str != string(list) +str != toJSON(false) +str != toJSON(foo) +str != trim(str) +str != type(foo) +str != type(str) +str + $env not endsWith $env and false +str + $env.str +str + $env?.[str] +str + $env?.str +str + foo.Bar +str + foo.String() +str + foo?.Bar +str + foo?.String() +str + greet(str) +str + str +str + str != $env +str + string($env) +str + string(add) +str + string(f64) +str + string(str) +str + toBase64(str) +str + toJSON(i) +str + toJSON(list) +str + toJSON(nil) +str + toJSON(str) +str + type($env) +str < $env && false +str < $env.str +str < $env?.[str] +str < $env?.str +str < foo.Bar +str < foo.String() +str < foo?.Bar +str < foo?.String() +str < greet(str) +str < str +str < str && false +str < str || ok +str < string(add) +str < string(foo) +str < type(array) +str < type(nil) +str < type(true) +str <= $env.str +str <= $env?.[str] +str <= $env?.foobar and false +str <= $env?.str +str <= foo.Bar +str <= foo.String() +str <= foo?.Bar +str <= foo?.String() +str <= greet(str) +str <= str +str <= str ?: str +str <= str[:i] +str <= string($env) +str <= string(0) +str <= string(list) +str <= string(nil) +str <= toJSON(nil) +str <= type(1.0) +str <= type(true) +str == $env or $env +str == $env || $env?.[Bar] +str == $env.str +str == $env?.Bar +str == $env?.String +str == $env?.[Bar] +str == $env?.[Bar]?.[array] +str == $env?.[String] +str == $env?.[String]?.array +str == $env?.[foobar] +str == $env?.[str] +str == $env?.foo.Bar +str == $env?.foobar +str == $env?.not +str == $env?.str +str == $env?.true +str == first($env) +str == foo.Bar +str == foo.String() +str == foo?.Bar +str == foo?.String() +str == greet(str) +str == max($env) +str == nil or true || $env +str == reduce(array, str) +str == str +str == str || true +str == string(add) +str == string(foo) +str == toBase64(str | repeat(0)) +str == toJSON(0) +str == toJSON(1.0) +str == trim(str) +str == type(add) +str == type(foo) +str == type(greet) +str == {foo: 1}.array +str > $env or true +str > $env || true +str > $env.str +str > $env?.[str] +str > $env?.str +str > foo.Bar +str > foo.String() +str > foo?.Bar +str > foo?.String() +str > str +str > str + str +str > str ?: 1 +str > str and true +str > str[1:] +str > string($env) +str > toJSON(ok) +str > trimSuffix(str) +str > type(1) +str > type(1.0) +str > type(add) +str > type(nil) +str >= $env && false +str >= $env or true +str >= $env.str +str >= $env?.[str] +str >= $env?.str +str >= foo.Bar +str >= foo.String() +str >= foo?.Bar +str >= foo?.String() +str >= greet(str) +str >= str +str >= string(1) +str >= string(1.0) +str >= toJSON(false) +str >= type(list) +str contains $env.str +str contains $env?.Bar +str contains $env?.String +str contains $env?.String?.list +str contains $env?.[Bar] +str contains $env?.[Bar]?.foo +str contains $env?.[String] +str contains $env?.[String]?.[i] +str contains $env?.[foobar] +str contains $env?.[str] +str contains $env?.false +str contains $env?.foobar +str contains $env?.str +str contains foo.Bar +str contains foo.String() +str contains foo?.Bar +str contains foo?.String() +str contains greet(str) +str contains str +str contains string(ok) +str contains string(str) +str contains toJSON(f64) +str contains toJSON(ok) +str contains type(foo) +str contains type(nil) +str contains type(ok) +str endsWith $env.str +str endsWith $env?.Bar +str endsWith $env?.String +str endsWith $env?.[Bar] +str endsWith $env?.[String] +str endsWith $env?.[String]?.[add] +str endsWith $env?.[foobar] +str endsWith $env?.[str] +str endsWith $env?.str +str endsWith foo.Bar +str endsWith foo.String() +str endsWith foo?.Bar +str endsWith foo?.String() +str endsWith greet(str) +str endsWith str +str endsWith string(foo) +str endsWith string(nil) +str endsWith string(ok) +str endsWith toJSON(0) +str endsWith toJSON(foo) +str endsWith toJSON(i) +str endsWith toJSON(true) +str endsWith trimPrefix($env.str) +str endsWith type(list) +str endsWith {foo: f64}.f64 +str endsWith {foo: nil, foo: $env}?.f64 +str in $env && $env +str in $env == ok +str in $env || $env +str in $env.foo +str in $env?.Bar +str in $env?.String +str in $env?.[Bar] +str in $env?.[Bar]?.[str] +str in $env?.[String] +str in $env?.[String]?.str() +str in $env?.[foobar?.[str]] +str in $env?.foo +str in $env?.foobar +str in $env?.foobar?.greet +str in [$env, nil] +str in [nil] +str in concat(array) +str in find(list, true) +str in foo +str in foo and false +str in foo || $env +str in list?.[i] +str in {foo: 1} +str in {foo: f64} +str in {foo: foo} +str in {foo: i, foo: 1} +str in {foo: nil, foo: 1.0} +str in {foo: nil} +str matches $env and false +str matches $env.str +str matches $env?.Bar +str matches $env?.String +str matches $env?.String?.list +str matches $env?.[Bar] +str matches $env?.[Bar]?.f64 +str matches $env?.[String] +str matches $env?.[foobar] +str matches $env?.[foobar]?.str +str matches $env?.[str] +str matches $env?.foobar?.[ok] +str matches $env?.str +str matches foo.Bar +str matches foo.String() +str matches foo?.Bar +str matches foo?.String() +str matches str +str matches string($env?.[String]) +str matches string(1) +str matches string(1.0) +str matches string(add) +str matches toJSON(nil) +str matches type(0) +str matches type(foo) +str matches type(i) +str matches type(str) +str matches type(true) +str not contains $env.str +str not contains $env?.Bar +str not contains $env?.Bar?.[f64] +str not contains $env?.String +str not contains $env?.String?.String +str not contains $env?.[Bar] +str not contains $env?.[Bar]?.Bar() +str not contains $env?.[String] +str not contains $env?.[foobar] +str not contains $env?.[str] +str not contains $env?.foobar +str not contains $env?.nil +str not contains $env?.str +str not contains foo.Bar +str not contains foo.String() +str not contains foo?.Bar +str not contains foo?.String() +str not contains greet(str) +str not contains last($env)?.add +str not contains str +str not contains str + str +str not contains str[:1] +str not contains string(str) +str not contains toJSON(0) +str not contains type(0) +str not contains type(foo) +str not contains type(list) +str not contains type(str) +str not contains upper(str) +str not contains {foo: foo}.String +str not endsWith $env.str +str not endsWith $env?.Bar +str not endsWith $env?.String +str not endsWith $env?.[Bar] +str not endsWith $env?.[String] +str not endsWith $env?.[String]?.String +str not endsWith $env?.[foobar?.foo($env)] +str not endsWith $env?.[str] +str not endsWith $env?.false +str not endsWith $env?.not +str not endsWith $env?.str +str not endsWith first($env) +str not endsWith first($env)?.[greet] +str not endsWith foo.Bar +str not endsWith foo.String() +str not endsWith foo?.Bar +str not endsWith foo?.String() +str not endsWith greet(str) +str not endsWith str +str not endsWith str && $env?.String +str not endsWith str || true +str not endsWith string(1) +str not endsWith type(i) +str not endsWith type(list) +str not in $env.foo +str not in $env?.Bar +str not in $env?.String +str not in $env?.String?.[ok] +str not in $env?.[Bar] +str not in $env?.[Bar]?.list +str not in $env?.[String] +str not in $env?.[String]?.add() +str not in $env?.[foobar] +str not in $env?.[foobar]?.[ok] +str not in $env?.[nil] +str not in $env?.foo +str not in $env?.foobar +str not in [nil, greet] +str not in [nil] +str not in foo +str not in foo && $env +str not in foo and false +str not in foo and ok +str not in foo || $env +str not in foo || ok +str not in foo || true +str not in groupBy(list, #) +str not in list?.[i] +str not in reduce($env, $env, list) +str not in {foo: 0, foo: add} +str not in {foo: 1.0} +str not in {foo: add} +str not in {foo: foo, foo: list, foo: $env} +str not in {foo: foo} +str not in {foo: nil} +str not matches $env.str +str not matches $env?.Bar +str not matches $env?.String +str not matches $env?.[Bar] +str not matches $env?.[String] +str not matches $env?.[foobar] +str not matches $env?.[str] +str not matches $env?.foobar +str not matches $env?.str +str not matches foo.Bar +str not matches foo.String() +str not matches foo?.Bar +str not matches foo?.String() +str not matches str +str not matches str || ok +str not matches string(foo) +str not matches toJSON(1.0) +str not matches toJSON(f64) +str not matches toJSON(i) +str not matches toJSON(nil) +str not matches type(false) +str not matches type(true) +str not startsWith $env.str +str not startsWith $env?.$env?.[add] +str not startsWith $env?.Bar +str not startsWith $env?.String +str not startsWith $env?.[Bar] +str not startsWith $env?.[Bar]?.[i] +str not startsWith $env?.[String] +str not startsWith $env?.[nil] +str not startsWith $env?.[str] +str not startsWith $env?.nil +str not startsWith $env?.str +str not startsWith foo.Bar +str not startsWith foo.String() +str not startsWith foo?.Bar +str not startsWith foo?.String() +str not startsWith greet(str) +str not startsWith lower(str) +str not startsWith str +str not startsWith str ?: 1.0 +str not startsWith str ?: ok +str not startsWith string(nil) +str not startsWith toJSON(foo) +str not startsWith toJSON(true) +str not startsWith trimSuffix(string(foo)) +str not startsWith type(0) +str not startsWith type(add) +str not startsWith type(f64) +str not startsWith type(ok) +str startsWith $env.str +str startsWith $env?.Bar +str startsWith $env?.String +str startsWith $env?.String?.[greet] +str startsWith $env?.[Bar] +str startsWith $env?.[String] +str startsWith $env?.[foobar] +str startsWith $env?.[str] +str startsWith $env?.foobar +str startsWith $env?.str +str startsWith first($env) +str startsWith foo.Bar +str startsWith foo.String() +str startsWith foo?.Bar +str startsWith greet(str) +str startsWith str +str startsWith str && ok +str startsWith str[1:] +str startsWith toJSON(1.0) +str startsWith toJSON(list) +str startsWith toJSON(true) +str | date(str) +str | greet() +str | greet() != $env?.$env +str | greet() not in foo +str | hasPrefix($env?.[str]) +str | hasPrefix(str) +str | hasSuffix(str) +str | indexOf(str) +str | lastIndexOf(str) +str | repeat(0) +str | repeat(1) +str | repeat(i) +str | split(str) +str | splitAfter(str) +str | splitAfter(str, 1) +str | trim(str) +str | trimPrefix(str) +str | trimPrefix(toJSON(ok)) +str | trimPrefix(type(i)) +str | trimSuffix(str) +str; add +str; foo +str; greet +str; i +str; ok +str; str +str; uniq(array) +str[$env?.i:] +str[1:] endsWith str +str[1:] not contains str +str[1:] | greet() +str[:$env.i] +str[:$env?.i] +str[:] +str[:array | reduce(#)] +str[:array?.[i]] +str[:i] +str[:median(1, 1.0)] +str[:min(0)] +str[first(array):] +str[i:] +str[i:] not endsWith str +str[i:i] +string($env != 0) +string($env != 1) +string($env != 1.0) +string($env != add) +string($env != f64) +string($env != foo) +string($env != i) +string($env != nil) +string($env != ok) +string($env != str) +string($env != true) +string($env && false) +string($env && true) +string($env == $env) +string($env == array) +string($env == false) +string($env == foo) +string($env == greet) +string($env == nil) +string($env and true) +string($env in $env?.[Bar]) +string($env in array) +string($env not in array) +string($env | all(false)) +string($env | all(ok)) +string($env | count(false)) +string($env | findIndex(ok)) +string($env | findIndex(true)) +string($env | findLastIndex(true)) +string($env | map(#index)) +string($env | map($env)) +string($env | map(1)) +string($env | map(array)) +string($env | map(greet)) +string($env | none(ok)) +string($env | one(true)) +string($env | reduce(f64, 1.0)) +string($env | sum(0)) +string($env | sum(1)) +string($env | sum(1.0)) +string($env || false) +string($env) matches str +string($env) not startsWith str +string($env) | greet() +string($env)[i:] +string($env.add) +string($env.array) +string($env.f64) +string($env.foo) +string($env.greet) +string($env.i) +string($env.list) +string($env.ok) +string($env.str) +string($env?.$env) +string($env?.Bar) +string($env?.Bar?.[str]) +string($env?.String) +string($env?.String?.Bar) +string($env?.String?.String) +string($env?.[Bar]) +string($env?.[Bar]?.[i]) +string($env?.[String]) +string($env?.[foobar]) +string($env?.[str]) +string($env?.add) +string($env?.array) +string($env?.f64) +string($env?.false) +string($env?.foo) +string($env?.foobar) +string($env?.greet) +string($env?.i) +string($env?.list) +string($env?.ok) +string($env?.str) +string(0 != 0) +string(0 != 1.0) +string(0 != nil) +string(0 % 1) +string(0 * 0) +string(0 * 1) +string(0 * f64) +string(0 * i) +string(0 ** 0) +string(0 ** 1) +string(0 ** 1.0) +string(0 ** f64) +string(0 + 1.0) +string(0 - 1) +string(0 .. i) +string(0 < 0) +string(0 < 1) +string(0 < 1.0) +string(0 < f64) +string(0 <= 0) +string(0 <= f64) +string(0 <= i) +string(0 == $env) +string(0 == 1) +string(0 == i) +string(0 == nil) +string(0 > f64) +string(0 > i) +string(0 >= 1) +string(0 >= i) +string(0) >= str +string(1 != f64) string(1 != nil) string(1 % 1) -string(1 % i) -string(1 % i32) -string(1 * 0.5) -string(1 * f32) +string(1 * 0) +string(1 * 1.0) string(1 * f64) -string(1 ** 0.5) +string(1 * i) +string(1 ** 0) string(1 ** 1) -string(1 ** i) -string(1 ** i64) -string(1 + 0.5) -string(1 + 1) -string(1 + f64) -string(1 - 0.5) -string(1 - f32) -string(1 - i32) -string(1 - i64) +string(1 ** 1.0) +string(1 ** f64) +string(1 + i) +string(1 - 1) +string(1 - 1.0) +string(1 - f64) +string(1 .. 0) string(1 .. 1) -string(1 .. i32) -string(1 .. i64) -string(1 / 0.5) +string(1 / 0) +string(1 / 1.0) string(1 / f64) -string(1 / i) -string(1 / i32) -string(1 / i64) -string(1 < 0.5) -string(1 <= 1) -string(1 <= f32) +string(1 < 0) +string(1 < 1.0) +string(1 <= 1.0) +string(1 <= f64) string(1 <= i) -string(1 <= i32) -string(1 <= i64) -string(1 == 1) -string(1 == f32) -string(1 == i32) -string(1 > 0.5) -string(1 > 1) -string(1 > i64) -string(1 >= f32) +string(1 == $env) +string(1 == i) +string(1 == nil) +string(1 > $env?.i) +string(1 > 0) +string(1 >= 1) +string(1 >= 1.0) +string(1 >= f64) string(1 >= i) -string(1 ^ 0.5) string(1 ^ 1) -string(1 ^ f32) -string(1 ^ f64) -string(1 ^ i64) -string(1 not in array) -string([0.5]) -string([div]) +string(1 ^ 1.0) +string(1 ^ i) +string(1 | min(1.0)) +string(1) != str +string(1) < foo?.Bar +string(1) == $env?.[Bar] +string(1) not in foo +string(1) not startsWith toJSON(1) +string(1) | greet() +string(1..i) +string(1.0 != $env) +string(1.0 != 0) +string(1.0 != 1.0) +string(1.0 != nil) +string(1.0 * 0) +string(1.0 * 1) +string(1.0 * 1.0) +string(1.0 * f64) +string(1.0 * i) +string(1.0 ** 0) +string(1.0 ** 1) +string(1.0 ** 1.0) +string(1.0 ** f64) +string(1.0 ** i) +string(1.0 + 1.0) +string(1.0 + f64) +string(1.0 + i) +string(1.0 - 0) +string(1.0 - 1) +string(1.0 - 1.0) +string(1.0 - i) +string(1.0 / 0) +string(1.0 / 1) +string(1.0 / 1.0) +string(1.0 / f64) +string(1.0 < 1) +string(1.0 <= 1) +string(1.0 <= 1.0) +string(1.0 == 1) +string(1.0 == 1.0) +string(1.0 == f64) +string(1.0 == i) +string(1.0 == nil) +string(1.0 > 0) +string(1.0 > 1) +string(1.0 > 1.0) +string(1.0 > i) +string(1.0 >= 1) +string(1.0 >= 1.0) +string(1.0 ^ 0) +string(1.0 ^ 1) +string(1.0 ^ 1.0) +string(1.0 ^ f64) +string(1.0 ^ i) +string(1.0 in array) +string(1.0) +string(1.0) != str +string(1.0) not startsWith toJSON(false) +string(1.0) startsWith str +string(1.0) startsWith type(foo) +string(1.0) | greet() +string([$env, foo]) +string([$env, ok]) +string([$env]) +string([0, nil]) +string([1, true]) +string([1.0]) +string([1]) +string([add]) +string([array]) +string([f64, f64]) string([f64]) -string([list]) -string([score]) +string([false, 1]) +string([false]) +string([foo]) +string([greet, i]) +string([greet]) +string([nil]) +string([ok, 1]) +string([ok, list]) +string([ok, nil]) +string([ok]) +string([str]) +string([true, list]) string([true]) -string(abs(0.5)) +string(abs(0)) string(abs(1)) -string(abs(f32)) -string(abs(i)) -string(abs(i32)) -string(add != add) -string(add != div) -string(add == div) +string(abs(1.0)) +string(abs(f64)) string(add == nil) +string(add(1, 0)) +string(add(1, 1)) string(add) -string(add) in foo ? i64 : i32 -string(add) not endsWith foo.Bar -string(all(array, ok)) -string(all(array, true)) +string(add) in foo +string(add) matches str +string(add) | greet() string(any(array, ok)) -string(any(list, false)) -string(any(list, ok)) +string(array != $env) string(array != array) string(array != nil) +string(array == $env) +string(array == array) +string(array == list) +string(array == nil) +string(array | any(ok)) +string(array | map($env)) +string(array | map(f64)) +string(array | one(true)) +string(array | reduce(#acc)) +string(array | reduce(add)) +string(array | sortBy(#)) +string(array | sum(#)) +string(array | sum(f64)) string(array) -string(array[i32]) +string(array) > str +string(array) >= foo.Bar +string(array) not in foo +string(array) not startsWith str +string(array) | greet() +string(array)[:i] +string(array?.[i]) +string(array[i:]) +string(bitnot(0)) string(bitnot(1)) -string(bitnot(i32)) -string(bitnot(i64)) -string(ceil(0.5)) +string(bitnot(i)) +string(ceil(0)) string(ceil(1)) -string(ceil(f32)) +string(ceil(1.0)) string(ceil(f64)) -string(ceil(i)) -string(ceil(i64)) -string(div != div) -string(div != nil) -string(div == add) -string(div == div) -string(div) -string(f32 != 0.5) -string(f32 != f64) -string(f32 != i) -string(f32 != nil) -string(f32 * 0.5) -string(f32 * 1) -string(f32 * f64) -string(f32 * i) -string(f32 * i32) -string(f32 ** 1) -string(f32 ** f64) -string(f32 + f32) -string(f32 + f64) -string(f32 + i32) -string(f32 + i64) -string(f32 - 0.5) -string(f32 - 1) -string(f32 - i64) -string(f32 / 0.5) -string(f32 / f64) -string(f32 / i64) -string(f32 < f32) -string(f32 <= i) -string(f32 <= i32) -string(f32 == 0.5) -string(f32 == i) -string(f32 > 0.5) -string(f32 > f64) -string(f32) -string(f32) in foo -string(f64 != 1) -string(f64 != i) +string(concat(array)) +string(count($env, false)) +string(f64 != $env) +string(f64 != f64) string(f64 != nil) -string(f64 * 0.5) -string(f64 * i) -string(f64 * i32) -string(f64 * i64) -string(f64 ** 0.5) -string(f64 ** f64) -string(f64 ** i) -string(f64 + 0.5) +string(f64 * 1) +string(f64 * f64) +string(f64 ** 0) +string(f64 ** 1.0) string(f64 + 1) -string(f64 + f32) -string(f64 - 0.5) +string(f64 + 1.0) +string(f64 + f64) string(f64 - 1) -string(f64 - i) -string(f64 / 0.5) -string(f64 < f32) -string(f64 < i) -string(f64 <= 1) -string(f64 <= f32) -string(f64 <= f64) -string(f64 == 1) -string(f64 == f32) -string(f64 == i) -string(f64 == i64) +string(f64 < 1.0) +string(f64 < f64) +string(f64 == $env) +string(f64 == 1.0) +string(f64 == nil) +string(f64 > 0) string(f64 > 1) -string(f64 >= f32) +string(f64 > 1.0) +string(f64 > f64) +string(f64 >= 0) +string(f64 >= 1.0) string(f64 >= i) -string(f64 ^ 0.5) -string(f64 ^ f32) +string(f64 ^ 1.0) string(f64 ^ i) -string(f64 in array) -string(f64 not in array) string(f64) -string(false != nil) -string(false != ok) +string(f64) + str +string(f64) < str +string(false != $env) +string(false != false) string(false != true) -string(false ? array : 0.5) -string(false ? f64 : i32) -string(false ? false : i) -string(false ? greet : f64) -string(false ? half : "bar") -string(false ? half : i) -string(false ? i : i) -string(false ? nil : nil) -string(false and ok) -string(false) endsWith toBase64("foo") -string(filter(array, false)) -string(filter(array, ok)) -string(filter(array, true)) -string(filter(list, false)) -string(find(array, ok)) -string(find(array, true)) -string(find(list, ok)) -string(findIndex(array, true)) -string(findLast(array, false)) -string(findLast(array, ok)) -string(findLast(array, true)) -string(findLastIndex(array, ok)) +string(false && $env) +string(false && ok) +string(false == $env) +string(false == nil) +string(false ? foo : 1) +string(false ?: i) +string(false and false) +string(false or $env) +string(false or false) +string(false or ok) +string(false || $env) +string(false) not contains str +string(false) | greet() +string(find(array, false)) +string(find(list, true)) +string(findIndex($env, true)) +string(findIndex(list, false)) +string(findLast(list, ok)) +string(findLastIndex($env, false)) +string(findLastIndex(list, false)) +string(findLastIndex(list, ok)) +string(first($env)) string(first(array)) string(first(list)) -string(float(0.5)) -string(float(1)) +string(flatten(list)) +string(float(0)) +string(float(1.0)) string(float(f64)) string(float(i)) -string(float(i64)) -string(floor(0.5)) -string(floor(f32)) +string(floor(0)) +string(floor(1)) +string(floor(1.0)) string(floor(f64)) string(floor(i)) -string(floor(i32)) -string(floor(i64)) +string(foo != $env) +string(foo != foo) +string(foo != nil) +string(foo == $env) string(foo == foo) string(foo == nil) +string(foo in list) string(foo not in list) string(foo) +string(foo) != $env?.Bar +string(foo) != $env?.foobar +string(foo) < str +string(foo) > str +string(foo) contains str +string(foo) not endsWith type(str) +string(foo) startsWith str +string(foo) | greet() string(foo.Bar) -string(foo.Qux) string(foo.String()) string(foo.String) string(foo?.Bar) -string(foo?.Qux) +string(foo?.Bar) not in foo string(foo?.String()) string(foo?.String) -string(get(array, i)) -string(get(array, i64)) -string(get(list, 1)) -string(get(list, i32)) -string(get(list, i64)) -string(greet != nil) -string(greet == greet) -string(greet == nil) -string(greet("bar")) -string(greet("foo")) +string(greet(str)) string(greet) -string(greet) == nil ? 0.5 : i -string(groupBy(array, #)) -string(groupBy(array, 1)) -string(groupBy(array, f32)) -string(groupBy(array, false)) -string(groupBy(array, i32)) -string(groupBy(list, #)) -string(groupBy(list, 0.5)) -string(groupBy(list, 1)) -string(groupBy(list, f64)) -string(groupBy(list, false)) -string(groupBy(list, i)) -string(half != nil) -string(half == nil) -string(half(0.5)) -string(half(1)) -string(half(f64)) -string(half) +string(greet) not matches str +string(groupBy(list, ok)?.greet) +string(groupBy(list, str)) +string(i != 0) string(i != 1) -string(i != i64) +string(i != 1.0) +string(i != nil) string(i % 1) -string(i % i32) -string(i % i64) -string(i * 1) -string(i * f64) -string(i ** f32) -string(i ** f64) -string(i ** i64) -string(i + 0.5) -string(i + i) -string(i - f32) +string(i * 1.0) +string(i ** 1.0) +string(i + 0) +string(i + 1) +string(i + 1.0) +string(i + f64) +string(i - 1) +string(i - 1.0) +string(i - f64) +string(i - i) string(i .. 1) -string(i .. i) -string(i .. i32) -string(i / 1) -string(i / f32) +string(i / 0) string(i / f64) -string(i / i32) -string(i / i64) -string(i < 0.5) -string(i < 1) -string(i < i32) -string(i <= f32) -string(i <= i) -string(i == 1) -string(i == i) -string(i > 0.5) -string(i > 1) -string(i > f32) -string(i >= 0.5) -string(i >= i64) +string(i <= f64) +string(i == $env) +string(i == f64) +string(i > 0) +string(i >= 1.0) string(i ^ 1) -string(i ^ f32) +string(i ^ f64) string(i ^ i) -string(i ^ i64) +string(i not in array) +string(i | bitshr(i)) +string(i | min(1.0, 1.0)) string(i) -string(i) in foo -string(i32 != 0.5) -string(i32 != 1) -string(i32 != f64) -string(i32 != i32) -string(i32 != nil) -string(i32 % 1) -string(i32 % i) -string(i32 % i64) -string(i32 * 1) -string(i32 * f32) -string(i32 * f64) -string(i32 * i) -string(i32 ** 0.5) -string(i32 ** f64) -string(i32 + 0.5) -string(i32 - 0.5) -string(i32 - 1) -string(i32 - f32) -string(i32 - f64) -string(i32 - i32) -string(i32 - i64) -string(i32 .. 1) -string(i32 .. i) -string(i32 / 0.5) -string(i32 < 1) -string(i32 < f64) -string(i32 < i64) -string(i32 == f32) -string(i32 == i64) -string(i32 == nil) -string(i32 > 1) -string(i32 > i) -string(i32 >= 0.5) -string(i32 >= 1) -string(i32 >= i) -string(i32 ^ f32) -string(i32 ^ f64) -string(i32 ^ i32) -string(i32 in array) -string(i32 not in array) -string(i32) -string(i32) not startsWith trimSuffix("foo") -string(i64 != 1) -string(i64 != i) -string(i64 != i32) -string(i64 != i64) -string(i64 % i32) -string(i64 * 1) -string(i64 * f32) -string(i64 * i) -string(i64 ** 0.5) -string(i64 + i64) -string(i64 - i) -string(i64 - i32) -string(i64 - i64) -string(i64 .. 1) -string(i64 .. i) -string(i64 .. i32) -string(i64 / f64) -string(i64 / i) -string(i64 / i64) -string(i64 < 0.5) -string(i64 < i) -string(i64 <= i64) -string(i64 == 0.5) -string(i64 == i) -string(i64 > 0.5) -string(i64 > i64) -string(i64 >= 0.5) -string(i64 >= 1) -string(i64 ^ 0.5) -string(i64 ^ f64) -string(i64 in array) -string(i64) -string(i64) matches greet("bar") -string(i64) not in foo -string(int(0.5)) +string(i) not in foo +string(i) | indexOf(str) +string(if false { foo } else { false }) +string(if false { ok } else { i }) +string(if ok { 1 } else { 1.0 }) +string(if true { 1 } else { $env }) +string(if true { 1.0 } else { foo }) +string(if true { list } else { 0 }) +string(int(0)) string(int(1)) -string(int(i32)) -string(int(i64)) +string(int(1.0)) +string(int(f64)) +string(int(i)) +string(keys($env)) +string(last($env)) string(last(array)) -string(last(list).String()) -string(len("bar")) +string(last(list)) +string(len($env)) string(len(array)) string(len(list)) +string(len(str)) +string(list != $env) +string(list != list) string(list != nil) string(list == array) string(list == list) -string(list == nil) +string(list | count(true)) +string(list | groupBy(#)) +string(list | groupBy(1)) +string(list | map(.Bar)) +string(list | map(greet)) +string(list | map(i)) +string(list | one(false)) +string(list | reduce(#)) +string(list | reduce(#index)) +string(list | reduce(.String)) +string(list | reduce(1)) +string(list | reduce(false)) +string(list | sortBy(1.0)) string(list) -string(list[1]) -string(list[i32]) -string(list[i64]) -string(list[i]) -string(map(array, #)) -string(map(array, 0.5)) +string(list) not contains str +string(list) startsWith str +string(list?.[0]) +string(list?.[i]) +string(list[1:]) +string(list[:0]) +string(list[i:]) +string(lower(str)) +string(map($env, $env)) +string(map($env, 1.0)) +string(map($env, add)) +string(map($env, f64)) +string(map($env, false)) +string(map($env, foo)) +string(map($env, i)) +string(map($env, true)) string(map(array, add)) -string(map(array, div)) -string(map(array, i)) -string(map(array, i32)) -string(map(array, true)) -string(map(list, "bar")) -string(map(list, "foo")) -string(map(list, #)) -string(map(list, 0.5)) -string(map(list, 1)) -string(map(list, array)) -string(map(list, half)) -string(map(list, i32)) -string(map(list, i64)) -string(max(0.5)) -string(max(0.5, f32)) +string(map(array, f64)) +string(map(array, greet)) +string(map(list, $env)) +string(map(list, greet)) +string(map(list, list)) +string(max($env)) +string(max(0)) string(max(1)) -string(max(f32)) -string(max(f64)) +string(max(1.0)) +string(max(array)) string(max(i)) -string(max(i64)) +string(mean(0)) +string(mean(1.0)) string(mean(array)) -string(min(0.5)) -string(min(f32)) +string(mean(i)) +string(median(0)) +string(median(1.0)) +string(median(array)) +string(median(f64)) +string(median(i)) +string(min($env)) +string(min(0)) +string(min(0, 1.0)) +string(min(1)) +string(min(1.0, 0)) +string(min(array)) +string(min(f64)) string(min(i)) -string(min(i32)) -string(min(i64)) -string(nil != "bar") -string(nil != div) -string(nil != false) -string(nil != greet) -string(nil != half) -string(nil != i) +string(nil != $env) +string(nil != 0) +string(nil != 1.0) +string(nil != foo) string(nil != ok) -string(nil == "bar") -string(nil == 0.5) -string(nil == 1) -string(nil == div) +string(nil != str) +string(nil == 0) +string(nil == array) +string(nil == f64) string(nil == foo) +string(nil == greet) string(nil == list) string(nil == nil) -string(nil == ok) -string(nil == score) -string(nil in list) +string(nil == nil) <= str +string(nil == true) +string(nil in $env) +string(nil in array) +string(nil not in $env) string(nil not in list) -string(nil) <= list[i].Bar -string(none(array, ok)) -string(none(list, false)) -string(none(list, ok)) -string(not !false) -string(not (i64 == 0.5)) -string(not false) -string(not ok) -string(not true) -string(ok != nil) -string(ok != true) -string(ok ? 0.5 : nil) -string(ok ? 0.5 : true) -string(ok ? 1 : array) -string(ok ? 1 : f32) -string(ok ? array : add) -string(ok ? div : array) -string(ok ? half : score) -string(ok ? i : 1) -string(ok ? nil : half) -string(ok ? nil : list) -string(ok or false) +string(nil) != $env?.[String] +string(nil) == toJSON(nil) +string(nil) >= str +string(nil) contains str +string(nil) in foo +string(nil) not matches greet(str) +string(nil) not startsWith str +string(nil) | greet() +string(nil) | trimSuffix(str) +string(nil)[i:] +string(ok != ok) +string(ok && $env) +string(ok && ok) +string(ok && true) +string(ok == false) +string(ok == nil) +string(ok ? $env : str) +string(ok ? foo : ok) +string(ok ? true : $env) +string(ok ?: add) +string(ok ?: f64) +string(ok and true) +string(ok or ok) +string(ok || $env) string(ok || false) string(ok) -string(one(array, true)) -string(one(list, true)) +string(ok) >= str +string(ok) contains str +string(ok) in foo +string(ok) matches str +string(ok) | greet() +string(ok) | indexOf(str) +string(ok)[:] +string(one($env, false)) string(reduce(array, #)) -string(reduce(array, 0.5)) -string(reduce(array, 1)) -string(reduce(array, f64)) -string(reduce(array, greet)) -string(reduce(array, half)) -string(reduce(array, i64)) +string(reduce(array, foo)) string(reduce(array, list)) -string(reduce(array, score)) -string(reduce(list, "bar")) -string(reduce(list, #)) -string(reduce(list, 1)) -string(reduce(list, add)) -string(reduce(list, div)) string(reduce(list, foo)) -string(reduce(list, i)) -string(reduce(list, i64)) -string(reduce(list, list)) -string(round(0.5)) +string(reduce(list, greet)) +string(reduce(list, ok, 1.0)) +string(round(0)) string(round(1)) -string(round(ceil(i32))) +string(round(1.0)) string(round(f64)) -string(round(i64)) -string(score != nil) -string(score == nil) -string(score(1 % 1)) -string(score(1)) -string(score(i)) -string(score) +string(round(i)) +string(sort($env)) string(sort(array)) -string(sortBy(array, "foo")) -string(string("bar")) -string(string("foo")) -string(string(0.5)) -string(string(1)) -string(string(array)) -string(string(div)) -string(string(f32)) -string(string(f64)) +string(sortBy(array, #)) +string(sortBy(list, f64)) +string(str <= str) +string(str == $env) +string(str == nil) +string(str == str) +string(str in $env) +string(str in foo) +string(str not in $env) +string(str not in foo) +string(str not matches str) +string(str) +string(str) + str +string(str) contains str +string(str) in foo +string(str) matches str +string(str) not contains str +string(str)[:] +string(str[:1]) +string(str[:i]) +string(string($env)) +string(string(0)) +string(string(1.0)) +string(string(add)) string(string(false)) +string(string(foo)) string(string(greet)) -string(string(half)) string(string(i)) -string(string(i64)) -string(string(nil)) +string(string(list)) string(string(ok)) -string(string(score)) +string(string(str)) +string(string(true)) +string(sum($env, 0)) +string(sum($env, 1.0)) string(sum(array)) -string(toBase64("foo")) -string(toJSON("bar")) -string(toJSON(0.5)) +string(sum(list, 0)) +string(toBase64(str)) +string(toJSON(0)) string(toJSON(1)) +string(toJSON(1.0)) string(toJSON(array)) -string(toJSON(f32)) string(toJSON(f64)) string(toJSON(false)) -string(toJSON(i)) -string(toJSON(i32)) -string(toJSON(i64)) -string(toJSON(list)) +string(toJSON(foo)) string(toJSON(nil)) string(toJSON(ok)) +string(toJSON(str)) string(toJSON(true)) -string(trim("bar")) -string(trim(type(nil))) -string(trimPrefix("foo")) -string(trimSuffix("foo")) +string(toPairs($env)) +string(trim(str)) +string(trimPrefix(str)) string(true != false) -string(true && ok) +string(true != nil) +string(true != ok) +string(true != true) +string(true && $env) +string(true && false) +string(true == false) string(true == nil) -string(true ? 0.5 : true) -string(true ? f64 : score) -string(true ? false : nil) -string(true ? greet : i) -string(true ? list : ok) -string(true and false) -string(true or false) +string(true ? $env : f64) +string(true ? add : nil) +string(true ? false : greet) +string(true ? foo : $env) +string(true ? str : add) +string(true ?: $env) +string(true and ok) string(true or ok) +string(true || $env) string(true || true) -string(type("bar")) -string(type("foo")) -string(type(-i64)) -string(type(0.5)) +string(true) + str +string(type($env)) +string(type(0)) string(type(1)) +string(type(1.0)) +string(type(add)) string(type(array)) -string(type(f32)) -string(type(f64)) +string(type(false)) string(type(foo)) string(type(greet)) -string(type(half)) -string(type(i)) -string(type(i32)) -string(type(i64)) string(type(list)) string(type(nil)) string(type(ok)) -string(type(score)) -string(upper("foo")) -string({"bar": "foo", "foo": half}) -string({"bar": f32, "foo": i32}) -string({"bar": f32}) -string({"bar": true}) -string({"foo": add}) -string({"foo": array, "foo": list}) +string(type(str)) +string(type(true)) +string(uniq(array)) +string(upper(str)) +string(values($env)) +string({foo: $env, foo: nil}) +string({foo: 0}) +string({foo: 1.0, foo: list}) +string({foo: 1.0}) +string({foo: add}) +string({foo: array, foo: 1.0, foo: list}) +string({foo: f64, foo: 1.0, foo: foo}) +string({foo: f64, foo: 1.0}) +string({foo: f64}) +string({foo: false, foo: array}) +string({foo: false}) +string({foo: foo, foo: str}) +string({foo: foo}) +string({foo: greet, foo: 1.0}) +string({foo: greet, foo: foo}) +string({foo: greet}) +string({foo: i, foo: $env}) +string({foo: i}) +string({foo: list}) +string({foo: nil, foo: 1}) +string({foo: nil, foo: foo}) +string({foo: nil, foo: list}) +string({foo: nil, foo: ok}) +string({foo: nil}) +string({foo: ok, foo: ok, foo: array}) +string({foo: ok, foo: str}) +string({foo: ok}) +string({foo: str}) +string({foo: true}) +sum($env | filter(false)) +sum($env | filter(false), reduce(#, #)) +sum($env | map(#index)) +sum($env | map(0)) +sum($env | map(1)) +sum($env | map(1.0)) +sum($env | map(i)) +sum($env | reduce(array, 0)) +sum($env, 0) in array +sum($env, 1) >= 1.0 >= 1.0 +sum($env, 1) >= i +sum($env, 1.0) >= f64 +sum($env, f64) | max(i) +sum($env.array) +sum($env.array, # ** #) +sum($env.array, #) +sum($env.array, f64) +sum($env.list, i) +sum($env?.[str]) +sum($env?.[str], #) +sum($env?.array) +sum($env?.array, #) +sum($env?.array, i) +sum($env?.list, f64 + 1.0) +sum(0 .. 0) +sum(0 .. 1) +sum(0 .. i) +sum(0..i) +sum(1 .. 0) sum(1 .. 1) sum(1 .. i) -sum(1 .. i32) -sum(1 .. i64) -sum([0.5]) -sum([f32]) +sum(1..i) +sum(1..i, f64) +sum([$env, add], f64) +sum([0]) +sum([1, 1.0]) +sum([1.0, 1]) +sum([1.0, 1], f64) +sum([1.0, f64]) +sum([1.0]) +sum([1]) +sum([f64, 1.0]) +sum([f64]) +sum([f64], i) +sum([foo], f64) +sum([i]) +sum([ok], f64) +sum([str, str]) +sum(array | filter(false)) +sum(array | filter(ok)) +sum(array | filter(true)) +sum(array | map(#)) +sum(array | map(0)) +sum(array | map(1.0)) +sum(array | map(f64)) +sum(array | sortBy(#)) +sum(array | sortBy(0)) +sum(array | sortBy(1)) +sum(array | sortBy(1.0)) +sum(array | sortBy(str)) +sum(array | take(0)) sum(array) -sum(array) != f32 +sum(array) != f64 +sum(array) != i +sum(array) != i ** 1.0 sum(array) % i -sum(array) % i64 -sum(array) - f32 -sum(array) / -f64 +sum(array) * i +sum(array) ** f64 +sum(array) + $env.f64 +sum(array) + f64 +sum(array) + i +sum(array) - 0 > 1.0 +sum(array) - ceil(0) +sum(array) - f64 +sum(array) - i +sum(array) .. i +sum(array) / f64 +sum(array) < f64 sum(array) < i -sum(array) == i64 - i +sum(array) <= f64 +sum(array) <= i || $env +sum(array) == f64 +sum(array) == i +sum(array) > f64 +sum(array) >= f64 != true sum(array) ^ f64 +sum(array) ^ i +sum(array) ^ round(1) +sum(array) not in $env.array sum(array) not in array -sum(filter(array, ok)) -sum(groupBy(array, i32).String) -sum(i32 .. 1) -sum(i64 .. i32) -sum(i64 .. i64) -sum(list[i:1]) +sum(array) | bitxor(0) +sum(array) | mean(1) +sum(array) | mean(1.0) +sum(array)..i +sum(array); f64 +sum(array, # % #) +sum(array, # ** #) +sum(array, # / f64) +sum(array, #) +sum(array, #) * i +sum(array, #) ** f64 +sum(array, #) <= i +sum(array, #) not in array +sum(array, $env.f64) +sum(array, $env.i) +sum(array, $env?.f64) +sum(array, $env?.i) +sum(array, 0 ** f64) +sum(array, 1 - #) +sum(array, 1) .. array?.[i] +sum(array, 1.0 ** #) +sum(array, 1.0) - f64 +sum(array, 1.0) == f64 +sum(array, array | reduce(f64)) +sum(array, array?.[i]) +sum(array, bitnot(#)) +sum(array, bitshr(#, #)) +sum(array, ceil(f64)) +sum(array, f64) +sum(array, f64) + int(i) +sum(array, f64) > i +sum(array, f64) ^ i +sum(array, float(#)) +sum(array, float(1.0)) +sum(array, floor(f64)) +sum(array, i + 1.0) +sum(array, i) +sum(array, mean(array)) +sum(array, round(1.0)) +sum(array, sum(array, #)) +sum(array[0:]) +sum(array[1:]) +sum(array[:0]) +sum(array[:1]) +sum(array[:i]) +sum(array[i:]) +sum(concat(array)) +sum(false ? $env : $env, f64) +sum(false ? $env : array) +sum(false ? i : str) +sum(false ? nil : array) +sum(false ? str : array) +sum(false ?: array) +sum(false ?: str) +sum(filter($env, false)) +sum(filter($env, false), .add?.str(false, false)) +sum(filter(array, false)) +sum(filter(array, ok), f64) +sum(filter(array, ok), i) +sum(filter(array, true)) +sum(flatten(array)) +sum(flatten(array), max(#)) +sum(get($env, str)) +sum(i .. 0) +sum(i .. 1) +sum(i..i) +sum(if false { 1 } else { array }) +sum(if false { array } else { array }) +sum(if ok { str } else { f64 }) +sum(if true { array } else { 1.0 }) +sum(if true { array } else { list }) +sum(let foobar = array; foobar) +sum(list | filter(false)) +sum(list | map(0)) +sum(list | map(1)) +sum(list | map(1.0)) +sum(list | map(greet), i) +sum(list | reduce($env), i) +sum(list | reduce(array)) +sum(list | sortBy(str), f64) +sum(list, $env.f64) +sum(list, $env.i) +sum(list, $env?.f64) +sum(list, $env?.i) +sum(list, 0) ** f64 +sum(list, 1) | bitxor(0) +sum(list, 1.0 / 1.0) +sum(list, f64 * 0) +sum(list, f64 ** 0) +sum(list, f64 - f64) +sum(list, f64) +sum(list, i + 0) +sum(list, i / 0) +sum(list, i) +sum(list, int(i)) +sum(list, len(str)) +sum(list, list | sum(1.0)) +sum(list, max(0)) +sum(map($env, #index)) +sum(map($env, $env), i) +sum(map($env, 0) | sortBy(1.0)) +sum(map($env, 0)) +sum(map($env, 1)) +sum(map($env, 1.0)) +sum(map($env, f64)) +sum(map($env, i)) sum(map(array, #)) -sum(map(array, f32)) -sum(map(list, 0.5)) -sum(map(list, f32)) -sum(map(list, i32)) -sum(ok ? array : i64) +sum(map(array, #index)) +sum(map(array, 0)) +sum(map(array, 1)) +sum(map(array, 1.0)) +sum(map(array, f64)) +sum(map(list, 0)) +sum(map(list, 1.0)) +sum(map(list, f64)) +sum(min($env), f64) +sum(ok ? array : foo) +sum(reduce($env, array, $env)) sum(reduce(array, array)) sum(reduce(list, array)) +sum(reverse(array)) +sum(sort($env)) +sum(sort($env), #.add not in #.add) +sum(sort($env), $env == #) sum(sort(array)) -sum(true ? array : i32) +sum(sort(ok ? i : 1.0)) +sum(sortBy(array, #)) +sum(sortBy(array, 0)) +sum(sortBy(array, 1)) +sum(sortBy(array, 1.0)) +sum(sortBy(array, f64)) +sum(sortBy(array, i)) +sum(sortBy(array, str)) +sum(take(array, i)) +sum(toPairs($env), i) +sum(true ? str : 1.0) +sum(true ? str : add) +sum(true ? str : foo) +sum(uniq(array)) +sum(uniq(array), 1.0 - 0) take(array, i) -take(array, i32) -take(array, i64) take(list, i) -take(list, i32) -take(list, i64) -take(map(array, #), i) -toBase64("bar" + "bar") -toBase64("bar" + "foo") -toBase64("bar") startsWith type(score) -toBase64("foo" + "bar") +toBase64($env.foo?.Bar) +toBase64($env.str) +toBase64($env?.[str]) +toBase64($env?.str) toBase64(foo.Bar) toBase64(foo.String()) toBase64(foo?.Bar) toBase64(foo?.String()) -toBase64(greet("bar")) -toBase64(greet("foo")) -toBase64(lower("bar")) -toBase64(lower("foo")) -toBase64(ok ? "bar" : f64) -toBase64(reduce(list, "bar")) -toBase64(string("foo")) -toBase64(string(0.5)) +toBase64(greet(str)) +toBase64(lower(str)) +toBase64(str + str) +toBase64(str) +toBase64(str) > str +toBase64(str) >= str +toBase64(str) not contains $env?.str +toBase64(str) not startsWith str +toBase64(str) | greet() +toBase64(str) | repeat(i) +toBase64(str)[i:] +toBase64(str[:0]) +toBase64(string($env)) +toBase64(string(0)) toBase64(string(1)) -toBase64(string(add)) +toBase64(string(1.0)) toBase64(string(array)) -toBase64(string(f32)) toBase64(string(f64)) +toBase64(string(false)) toBase64(string(foo)) toBase64(string(greet)) -toBase64(string(half)) toBase64(string(i)) toBase64(string(list)) +toBase64(string(nil)) toBase64(string(ok)) -toBase64(toBase64("bar")) -toBase64(toJSON("bar")) -toBase64(toJSON(0.5)) -toBase64(toJSON(1)) -toBase64(toJSON(f32)) +toBase64(string(str)) +toBase64(toBase64(str)) +toBase64(toJSON(0)) +toBase64(toJSON(1.0)) +toBase64(toJSON(array)) toBase64(toJSON(f64)) +toBase64(toJSON(false)) toBase64(toJSON(foo)) -toBase64(toJSON(i64)) +toBase64(toJSON(i / 1)) +toBase64(toJSON(i)) toBase64(toJSON(list)) toBase64(toJSON(nil)) toBase64(toJSON(ok)) toBase64(toJSON(true)) -toBase64(trim("bar")) -toBase64(trimPrefix("foo")) -toBase64(trimSuffix("foo")) -toBase64(type(0.5)) +toBase64(trimPrefix(str)) +toBase64(trimSuffix(str)) +toBase64(type($env)) +toBase64(type(0)) toBase64(type(1)) +toBase64(type(1.0 < 1.0)) +toBase64(type(1.0)) toBase64(type(add)) -toBase64(type(div)) -toBase64(type(f32)) +toBase64(type(array)) toBase64(type(f64)) toBase64(type(false)) toBase64(type(foo)) toBase64(type(greet)) -toBase64(type(half)) toBase64(type(i)) -toBase64(type(i32)) -toBase64(type(i64)) toBase64(type(list)) toBase64(type(nil)) -toBase64(type(score)) -toBase64(upper("foo")) -toJSON(!false) -toJSON(!ok) -toJSON(!true) -toJSON("bar" < "foo") -toJSON("bar" >= "bar") -toJSON("bar" endsWith "bar") -toJSON("bar" matches "foo") -toJSON("bar" not in foo) -toJSON("bar" not matches "bar") -toJSON("bar" not startsWith "foo") -toJSON("bar" startsWith "bar") -toJSON("bar") not in foo -toJSON("foo" != "bar") -toJSON("foo" != "foo") -toJSON("foo" < "foo") -toJSON("foo" == "bar") -toJSON("foo" > "foo") -toJSON("foo" >= "foo") -toJSON("foo" startsWith "bar") -toJSON(-0.5) -toJSON(-1) -toJSON(-f32) -toJSON(-f64) -toJSON(-i) -toJSON(-i32) -toJSON(-i64) -toJSON(0.5 != 1) -toJSON(0.5 != f64) -toJSON(0.5 != nil) -toJSON(0.5 * i) -toJSON(0.5 * i32) -toJSON(0.5 * i64) -toJSON(0.5 ** 0.5) -toJSON(0.5 ** 1) -toJSON(0.5 ** f32) -toJSON(0.5 ** f64) -toJSON(0.5 ** i) -toJSON(0.5 ** i32) -toJSON(0.5 + 0.5) -toJSON(0.5 + 1) -toJSON(0.5 + f32) -toJSON(0.5 - 0.5) -toJSON(0.5 - 1) -toJSON(0.5 - f32) -toJSON(0.5 - f64) -toJSON(0.5 - i) -toJSON(0.5 - i32) -toJSON(0.5 / 1) -toJSON(0.5 / f32) -toJSON(0.5 / f64) -toJSON(0.5 / i32) -toJSON(0.5 < 1) -toJSON(0.5 < f32) -toJSON(0.5 < f64) -toJSON(0.5 < i) -toJSON(0.5 <= 0.5) -toJSON(0.5 <= 1) -toJSON(0.5 <= f32) -toJSON(0.5 <= i64) -toJSON(0.5 == 0.5) -toJSON(0.5 == f64) -toJSON(0.5 == i) -toJSON(0.5 == i32) -toJSON(0.5 == i64) -toJSON(0.5 >= 0.5) -toJSON(0.5 >= 1) -toJSON(0.5 >= f32) -toJSON(0.5 ^ f32) -toJSON(0.5 ^ i32) -toJSON(0.5 ^ i64) -toJSON(0.5) not in foo -toJSON(1 != 0.5) -toJSON(1 != f32) +toBase64(type(ok)) +toBase64(type(true)) +toBase64(upper(str)) +toJSON($env != 0) +toJSON($env != add) +toJSON($env != array) +toJSON($env != false) +toJSON($env != foo) +toJSON($env != greet) +toJSON($env != list) +toJSON($env != nil) +toJSON($env != str) +toJSON($env != true) +toJSON($env == $env) +toJSON($env == 0) +toJSON($env == 1) +toJSON($env == f64) +toJSON($env == false) +toJSON($env == foo) +toJSON($env == list) +toJSON($env == nil) +toJSON($env == str) +toJSON($env == true) +toJSON($env in list) +toJSON($env not in list) +toJSON($env or true) +toJSON($env | all(false)) +toJSON($env | count(false)) +toJSON($env | findIndex(ok)) +toJSON($env | map(array)) +toJSON($env | map(f64)) +toJSON($env | map(list)) +toJSON($env | map(str)) +toJSON($env | map(true)) +toJSON($env | reduce(#index, nil)) +toJSON($env | reduce(false, 1)) +toJSON($env | sum(0)) +toJSON($env | sum(1)) +toJSON($env | sum(1.0)) +toJSON($env || true) +toJSON($env.array) +toJSON($env.f64) +toJSON($env.foo) +toJSON($env.i) +toJSON($env.list) +toJSON($env.ok) +toJSON($env.str) +toJSON($env?.$env) +toJSON($env?.Bar) +toJSON($env?.Bar?.[greet]) +toJSON($env?.String) +toJSON($env?.[Bar]) +toJSON($env?.[String]) +toJSON($env?.[foobar]) +toJSON($env?.[foobar]?.i()) +toJSON($env?.[nil]) +toJSON($env?.[str]) +toJSON($env?.array) +toJSON($env?.f64) +toJSON($env?.false) +toJSON($env?.foo) +toJSON($env?.foobar) +toJSON($env?.i) +toJSON($env?.list) +toJSON($env?.nil) +toJSON($env?.ok) +toJSON($env?.str) +toJSON(0 != $env) +toJSON(0 != nil) +toJSON(0 % 1) +toJSON(0 % i) +toJSON(0 * 1.0) +toJSON(0 ** 1.0) +toJSON(0 ** f64) +toJSON(0 + 0) +toJSON(0 + 1) +toJSON(0 + 1.0) +toJSON(0 - 1) +toJSON(0 - 1.0) +toJSON(0 - f64) +toJSON(0 .. i) +toJSON(0 / 1.0) +toJSON(0 / f64) +toJSON(0 < 1.0) +toJSON(0 <= 1.0) +toJSON(0 <= f64) +toJSON(0 == 1.0) +toJSON(0 == f64) +toJSON(0 == nil) +toJSON(0 > i) +toJSON(0 >= 0) +toJSON(0 >= 1) +toJSON(0 >= 1.0) +toJSON(0 ^ 1.0) +toJSON(0 ^ f64) +toJSON(0 ^ i) +toJSON(0 in array) +toJSON(0 not in array) +toJSON(0 | bitshl(0)) +toJSON(0 | bitshr(0)) +toJSON(0) + str +toJSON(0) > str +toJSON(0) >= str +toJSON(0..i) +toJSON(0.0) +toJSON(1 != $env) +toJSON(1 != i) toJSON(1 != nil) -toJSON(1 % 1) -toJSON(1 % i) -toJSON(1 % i32) -toJSON(1 * f64) -toJSON(1 * i32) -toJSON(1 * i64) -toJSON(1 ** 0.5) -toJSON(1 ** 1) -toJSON(1 ** i32) -toJSON(1 + 0.5) +toJSON(1 * 1.0) +toJSON(1 * i) +toJSON(1 ** i) toJSON(1 + 1) +toJSON(1 + 1.0) toJSON(1 + f64) -toJSON(1 + i) -toJSON(1 + i32) -toJSON(1 - i) -toJSON(1 - i32) -toJSON(1 .. i32) -toJSON(1 .. i64) -toJSON(1 / 1) +toJSON(1 - f64) +toJSON(1 .. 0) +toJSON(1 .. 1) +toJSON(1 .. i) toJSON(1 / f64) -toJSON(1 / i64) -toJSON(1 < 0.5) -toJSON(1 < 1) -toJSON(1 < f64) -toJSON(1 < i) -toJSON(1 <= 0.5) -toJSON(1 <= f32) -toJSON(1 <= f64) -toJSON(1 == 0.5) -toJSON(1 == 1) -toJSON(1 == f64) -toJSON(1 == i) -toJSON(1 == i32) +toJSON(1 / i) +toJSON(1 < 0) +toJSON(1 < 1.0) +toJSON(1 <= 0) +toJSON(1 <= 1) +toJSON(1 <= i) +toJSON(1 == 0) +toJSON(1 == 1.0) toJSON(1 == nil) -toJSON(1 > f32) +toJSON(1 > 0) +toJSON(1 > 1) toJSON(1 > i) -toJSON(1 >= 1) -toJSON(1 >= f32) -toJSON(1 >= i32) -toJSON(1 ^ 1) -toJSON(1 ^ f32) -toJSON(1 ^ i32) -toJSON(1 ^ i64) -toJSON(1) > reduce(list, "bar") -toJSON(1) not contains string(true) -toJSON([f64]) +toJSON(1 >= f64) +toJSON(1 >= i) +toJSON(1 ^ 1.0) +toJSON(1 not in array) +toJSON(1) != str +toJSON(1) endsWith str +toJSON(1) not contains str +toJSON(1) not in $env?.true +toJSON(1) | greet() +toJSON(1.0 != $env) +toJSON(1.0 != 0) +toJSON(1.0 != 1) +toJSON(1.0 != 1.0) +toJSON(1.0 != i) +toJSON(1.0 != nil) +toJSON(1.0 * 1) +toJSON(1.0 * 1.0) +toJSON(1.0 * f64) +toJSON(1.0 * i) +toJSON(1.0 ** 1) +toJSON(1.0 ** 1.0) +toJSON(1.0 ** i) +toJSON(1.0 + 0) +toJSON(1.0 + 1) +toJSON(1.0 + 1.0) +toJSON(1.0 - 0) +toJSON(1.0 - 1) +toJSON(1.0 - 1.0) +toJSON(1.0 - f64) +toJSON(1.0 / 1) +toJSON(1.0 / 1.0) +toJSON(1.0 / i) +toJSON(1.0 < i) +toJSON(1.0 <= 0) +toJSON(1.0 <= 1.0) +toJSON(1.0 <= f64) +toJSON(1.0 <= i) +toJSON(1.0 == $env) +toJSON(1.0 == 1) +toJSON(1.0 == 1.0) +toJSON(1.0 == f64) +toJSON(1.0 > 0) +toJSON(1.0 > 1.0) +toJSON(1.0 > i) +toJSON(1.0 >= 0) +toJSON(1.0 >= 1) +toJSON(1.0 >= 1.0) +toJSON(1.0 >= i) +toJSON(1.0 ^ 1) +toJSON(1.0 ^ 1.0) +toJSON(1.0 ^ f64) +toJSON(1.0 ^ i) +toJSON(1.0 in array) +toJSON(1.0 not in array) +toJSON(1.0) + str +toJSON(1.0) <= str +toJSON(1.0) matches str +toJSON(1.0) not in foo +toJSON(1.0) | greet() +toJSON(1.0) | indexOf(str) +toJSON([0]) +toJSON([1, 1]) +toJSON([1.0]) +toJSON([1]) +toJSON([array, 0]) +toJSON([array]) +toJSON([f64, nil]) toJSON([false]) +toJSON([foo, list]) toJSON([foo]) toJSON([nil]) +toJSON([ok]) +toJSON([str]) toJSON([true]) -toJSON(abs(0.5)) +toJSON(abs(0)) toJSON(abs(1)) -toJSON(abs(f32)) +toJSON(abs(1.0)) toJSON(abs(f64)) -toJSON(abs(i)) -toJSON(abs(i32)) -toJSON(abs(i64)) +toJSON(add != $env) toJSON(add == add) +toJSON(add == nil) +toJSON(all(list, true)) toJSON(any(array, false)) +toJSON(array != $env) +toJSON(array != array) +toJSON(array != list) toJSON(array == array) toJSON(array == list) -toJSON(array == nil) +toJSON(array | count(ok)) +toJSON(array | count(true)) +toJSON(array | find(true)) +toJSON(array | map(#)) +toJSON(array | max(i)) +toJSON(array | min(i)) +toJSON(array | none(false)) +toJSON(array | sortBy(#)) +toJSON(array | sortBy(0)) +toJSON(array | sum(i)) toJSON(array) -toJSON(array[1:i64]) -toJSON(array[1]) -toJSON(array[i]) +toJSON(array) + str +toJSON(array) < str +toJSON(array) == greet(str) +toJSON(array) not contains str +toJSON(array) | greet() +toJSON(array?.[0]) +toJSON(array?.[1]) +toJSON(array?.[i]) +toJSON(array[1:]) +toJSON(bitand(0, 0)) +toJSON(bitnot(0)) toJSON(bitnot(1)) toJSON(bitnot(i)) -toJSON(bitnot(i32)) -toJSON(bitnot(i64)) -toJSON(bitshl(i, i32)) +toJSON(ceil(0)) toJSON(ceil(1)) +toJSON(ceil(1.0)) toJSON(ceil(f64)) toJSON(ceil(i)) -toJSON(ceil(i32)) -toJSON(ceil(i64)) -toJSON(count(array, ok)) -toJSON(div != div) -toJSON(div == div) -toJSON(f32 != 0.5) -toJSON(f32 != 1 || ok) -toJSON(f32 != f32) -toJSON(f32 != i32) -toJSON(f32 * f32) -toJSON(f32 ** 0.5) -toJSON(f32 ** 1) -toJSON(f32 ** f64) -toJSON(f32 ** i32) -toJSON(f32 + 0.5) -toJSON(f32 + f32) -toJSON(f32 - 0.5) -toJSON(f32 - f32) -toJSON(f32 - f64) -toJSON(f32 - i64) -toJSON(f32 < 0.5) -toJSON(f32 < i) -toJSON(f32 < i64) -toJSON(f32 <= 0.5) -toJSON(f32 <= 1) -toJSON(f32 <= i64) -toJSON(f32 == f64) -toJSON(f32 == i) -toJSON(f32 == nil) -toJSON(f32 > i) -toJSON(f32 > i32) -toJSON(f32 >= 0.5) -toJSON(f32 ^ i64) -toJSON(f32) -toJSON(f32) in foo -toJSON(f64 != 0.5) -toJSON(f64 != f32) -toJSON(f64 != i) -toJSON(f64 != i32) +toJSON(concat(array)) +toJSON(concat(list)) +toJSON(count(array, true)) +toJSON(count(list, false)) +toJSON(count(list, true)) +toJSON(f64 != 1) +toJSON(f64 != 1.0) +toJSON(f64 != f64) toJSON(f64 != nil) -toJSON(f64 * 1) +toJSON(f64 * 0) toJSON(f64 * f64) -toJSON(f64 * i64) -toJSON(f64 ** 0.5) -toJSON(f64 ** f32) -toJSON(f64 + 0.5) -toJSON(f64 + f32) -toJSON(f64 + i32) -toJSON(f64 - f64) -toJSON(f64 - i) -toJSON(f64 - i64) -toJSON(f64 / 1) -toJSON(f64 < f64) -toJSON(f64 <= 0.5) -toJSON(f64 == f64) -toJSON(f64 >= 1) -toJSON(f64 >= f64) -toJSON(f64 ^ f32) +toJSON(f64 ** f64) +toJSON(f64 + 1.0) +toJSON(f64 - 1.0) +toJSON(f64 / 1.0) +toJSON(f64 < 0) +toJSON(f64 < 1) +toJSON(f64 < 1.0) +toJSON(f64 <= 0) +toJSON(f64 <= 1) +toJSON(f64 <= 1.0) +toJSON(f64 == $env) +toJSON(f64 == 0) +toJSON(f64 == 1.0) +toJSON(f64 == nil) +toJSON(f64 >= 1.0) +toJSON(f64 >= i) +toJSON(f64 ^ 0) +toJSON(f64 ^ f64) +toJSON(f64 ^ i) +toJSON(f64 in array) +toJSON(f64 | median(i)) toJSON(f64) +toJSON(f64) > str +toJSON(f64) in reduce(array, $env, array) +toJSON(f64) not in foo +toJSON(false != $env) +toJSON(false != false) +toJSON(false != nil) toJSON(false != ok) -toJSON(false ? 0.5 : "foo") -toJSON(false ? add : f64) -toJSON(false ? array : 1) -toJSON(false ? false : foo) -toJSON(false ? nil : ok) -toJSON(false ? ok : i32) -toJSON(filter(list, true)) -toJSON(find(list, ok)) -toJSON(findIndex(map(array, list), ok)) -toJSON(first(array)) +toJSON(false && $env) +toJSON(false && $env?.[greet]) +toJSON(false == nil) +toJSON(false == true) +toJSON(false or false) +toJSON(false || false) +toJSON(false || ok) +toJSON(false) not endsWith str +toJSON(false) startsWith first($env) +toJSON(findIndex($env, false)) +toJSON(findIndex($env, true)) +toJSON(findIndex(list, false)) +toJSON(findLastIndex($env, false)) +toJSON(first($env)) toJSON(first(list)) -toJSON(float(0.5)) +toJSON(flatten(array)) +toJSON(flatten(list)) +toJSON(float(0)) toJSON(float(1)) -toJSON(float(f32)) +toJSON(float(1.0)) toJSON(float(f64)) toJSON(float(i)) -toJSON(float(i64)) -toJSON(floor(0.5)) +toJSON(floor(0)) +toJSON(floor(1.0)) toJSON(floor(f64)) toJSON(floor(i)) -toJSON(floor(i32)) +toJSON(foo != $env) +toJSON(foo != foo) toJSON(foo != nil) +toJSON(foo == $env) +toJSON(foo == foo) +toJSON(foo == nil) toJSON(foo in list) +toJSON(foo not in list) toJSON(foo) +toJSON(foo) < str +toJSON(foo) > str +toJSON(foo) not in $env?.String +toJSON(foo) not matches str +toJSON(foo) | greet() +toJSON(foo) | repeat(i) toJSON(foo.Bar) toJSON(foo.String()) toJSON(foo?.Bar) toJSON(foo?.String()) -toJSON(get(array, i32)) -toJSON(get(array, i64)) -toJSON(get(list, 1)) -toJSON(get(list, i)) -toJSON(get(list, i32)) -toJSON(get(list, i64)) +toJSON(greet != $env) +toJSON(greet != greet) toJSON(greet != nil) -toJSON(greet == greet) -toJSON(greet == nil) -toJSON(greet("bar")) -toJSON(greet("foo")) -toJSON(groupBy(array, #)?.div) -toJSON(groupBy(array, ok)?.foo) -toJSON(groupBy(list, #)?.foo) -toJSON(half(0.5)) -toJSON(half(1)) -toJSON(half(f64)) -toJSON(i != 0.5) -toJSON(i != 1) -toJSON(i % i) -toJSON(i % i32) -toJSON(i * 0.5) +toJSON(greet == $env) +toJSON(greet(str)) +toJSON(groupBy(array, 1.0)?.Bar) +toJSON(i != 1.0) +toJSON(i != f64) +toJSON(i != i) +toJSON(i != nil) +toJSON(i % 1) +toJSON(i * 0) toJSON(i * 1) -toJSON(i * f32) -toJSON(i * i) -toJSON(i * i32) -toJSON(i ** f32) -toJSON(i ** i) -toJSON(i + 0.5) -toJSON(i + 1) -toJSON(i + i) -toJSON(i - 1) -toJSON(i - f32) -toJSON(i .. i) -toJSON(i .. i32) -toJSON(i / i64) -toJSON(i < f32) -toJSON(i < f64) -toJSON(i < i) -toJSON(i < i32) +toJSON(i * 1.0) +toJSON(i * f64) +toJSON(i ** f64) +toJSON(i + 1 .. 0) +toJSON(i - i) +toJSON(i .. 1) +toJSON(i / f64) +toJSON(i / i) +toJSON(i < 1) +toJSON(i < 1.0) toJSON(i <= 1) -toJSON(i <= f32) -toJSON(i <= f64) -toJSON(i <= i) -toJSON(i <= i32) -toJSON(i <= i64) -toJSON(i == 0.5) -toJSON(i == 1) -toJSON(i == i32) +toJSON(i == 0) +toJSON(i == 1.0) toJSON(i == nil) -toJSON(i > 0.5) -toJSON(i > i) -toJSON(i > i32) -toJSON(i > i64) -toJSON(i >= f64) -toJSON(i >= i32) -toJSON(i ^ i64) +toJSON(i == nil) <= str +toJSON(i > f64) +toJSON(i >= 0) +toJSON(i >= i) +toJSON(i ^ 0) +toJSON(i ^ 1.0) +toJSON(i in array) toJSON(i not in array) toJSON(i) -toJSON(i) matches string("bar") -toJSON(i32 != i) -toJSON(i32 != i64) -toJSON(i32 % 1) -toJSON(i32 * 0.5) -toJSON(i32 * i) -toJSON(i32 * i32) -toJSON(i32 * i64) -toJSON(i32 ** f64) -toJSON(i32 ** i64) -toJSON(i32 + 0.5) -toJSON(i32 + 1) -toJSON(i32 + f64) -toJSON(i32 .. i) -toJSON(i32 .. i64) -toJSON(i32 / 0.5) -toJSON(i32 / f32) -toJSON(i32 / f64) -toJSON(i32 / i64) -toJSON(i32 < 0.5) -toJSON(i32 < 1) -toJSON(i32 < i) -toJSON(i32 < i32) -toJSON(i32 <= 0.5) -toJSON(i32 > f64) -toJSON(i32 > i) -toJSON(i32 > i32) -toJSON(i32 >= f64) -toJSON(i32 ^ 0.5) -toJSON(i32 ^ f32) -toJSON(i32 ^ f64) -toJSON(i32 ^ i32) -toJSON(i32 in array) -toJSON(i32 not in array) -toJSON(i32) -toJSON(i32) contains foo.Bar -toJSON(i64 != 1) -toJSON(i64 != i) -toJSON(i64 != i32) -toJSON(i64 % i32) -toJSON(i64 * 0.5) -toJSON(i64 * f64) -toJSON(i64 ** f64) -toJSON(i64 ** i) -toJSON(i64 ** i32) -toJSON(i64 + 1) -toJSON(i64 - i32) -toJSON(i64 .. 1) -toJSON(i64 .. i32) -toJSON(i64 / f64) -toJSON(i64 / i) -toJSON(i64 / i64) -toJSON(i64 < 1) -toJSON(i64 < f64) -toJSON(i64 < i32) -toJSON(i64 <= 1) -toJSON(i64 <= i64) -toJSON(i64 == 0.5) -toJSON(i64 > 0.5) -toJSON(i64 > 1) -toJSON(i64 > i) -toJSON(i64 > i32) -toJSON(i64 > i64) -toJSON(i64 >= 1) -toJSON(i64 >= i) -toJSON(i64 >= i64) -toJSON(i64 ^ 0.5) -toJSON(i64 ^ f32) -toJSON(i64 ^ i32) -toJSON(i64 in array) -toJSON(i64) -toJSON(int(0.5)) +toJSON(i) + str +toJSON(i) <= str +toJSON(i) not contains string(0) +toJSON(if false { add } else { ok }) +toJSON(if false { str } else { str }) +toJSON(if true { ok } else { f64 }) +toJSON(int(0)) toJSON(int(1)) -toJSON(int(i)) -toJSON(int(i32)) -toJSON(int(i64)) -toJSON(len("bar")) -toJSON(len(array)) -toJSON(len(greet("foo"))) +toJSON(int(1.0)) +toJSON(int(f64)) +toJSON(keys($env)) +toJSON(last($env)) +toJSON(last(list)) +toJSON(len($env)) toJSON(len(list)) -toJSON(list != array) +toJSON(len(str)) +toJSON(let foobar = array; foobar) +toJSON(let foobar = false; foobar) +toJSON(list != list) toJSON(list != nil) +toJSON(list == $env) +toJSON(list == $env.list) toJSON(list == array) toJSON(list == list) +toJSON(list == nil) +toJSON(list | all(false)) +toJSON(list | find(false)) +toJSON(list | find(ok)) +toJSON(list | findIndex(true)) +toJSON(list | map(#)) +toJSON(list | map(#.Bar)) +toJSON(list | map(0)) +toJSON(list | map(true)) +toJSON(list | none(true)) +toJSON(list | reduce(#)) +toJSON(list | reduce(0)) +toJSON(list | reduce(foo)) toJSON(list) -toJSON(list[1]) -toJSON(lower("bar")) +toJSON(list) == str +toJSON(list) startsWith str +toJSON(list) | greet() +toJSON(list?.[0]) +toJSON(list?.[i]) +toJSON(lower(str)) +toJSON(map($env, 0)) +toJSON(map($env, array)) +toJSON(map($env, foo)) +toJSON(map($env, list)) toJSON(map(array, #)) -toJSON(map(array, -#)) -toJSON(map(array, array)) -toJSON(map(array, false)) -toJSON(map(array, i)) -toJSON(map(array, i64)) -toJSON(map(array, list)) +toJSON(map(array, 0)) toJSON(map(list, #)) -toJSON(map(list, 0.5)) -toJSON(map(list, 1)) -toJSON(map(list, foo)) -toJSON(map(list, i32)) -toJSON(map(list, i64)) -toJSON(map(list, list)) -toJSON(map(list, ok)) +toJSON(map(list, .Bar)) +toJSON(map(list, f64)) +toJSON(max(0)) toJSON(max(1)) -toJSON(max(f32)) +toJSON(max(1.0)) +toJSON(max(1.0, 0)) +toJSON(max(1.0, 1)) toJSON(max(f64)) -toJSON(max(i32)) -toJSON(mean(array)) +toJSON(max(i)) +toJSON(mean(0)) +toJSON(mean(1)) +toJSON(mean(1.0)) +toJSON(mean(f64)) +toJSON(mean(i)) +toJSON(median(0)) +toJSON(median(1)) +toJSON(median(1, 0)) +toJSON(median(1.0)) toJSON(median(array)) -toJSON(min(0.5)) +toJSON(median(array, array)) +toJSON(median(f64)) +toJSON(median(i)) +toJSON(min(0)) toJSON(min(1)) -toJSON(min(f32)) +toJSON(min(1.0)) +toJSON(min(array)) toJSON(min(f64)) -toJSON(min(f64, f64)) -toJSON(min(i)) -toJSON(min(i32)) -toJSON(min(i64)) -toJSON(nil != 0.5) +toJSON(nil != $env) +toJSON(nil != 0) toJSON(nil != 1) +toJSON(nil != 1.0) toJSON(nil != add) toJSON(nil != array) -toJSON(nil != f32) toJSON(nil != false) -toJSON(nil != foo) toJSON(nil != greet) -toJSON(nil != half) -toJSON(nil == 0.5) -toJSON(nil == 1) -toJSON(nil == div) -toJSON(nil == f64) -toJSON(nil == half) +toJSON(nil != i) +toJSON(nil != nil) +toJSON(nil != true) +toJSON(nil == $env) +toJSON(nil == 0) +toJSON(nil == 1.0) +toJSON(nil == array) +toJSON(nil == foo) +toJSON(nil == greet) toJSON(nil == i) -toJSON(nil == i64) toJSON(nil == list) toJSON(nil == nil) toJSON(nil == ok) toJSON(nil in array) -toJSON(nil) + foo.Bar -toJSON(none(array, ok)) -toJSON(none(array, true)) +toJSON(nil in list) +toJSON(nil not in $env) +toJSON(nil not in list) +toJSON(nil) < str +toJSON(nil) <= str +toJSON(nil) not matches foo?.Bar +toJSON(nil) not startsWith str +toJSON(nil) | greet() +toJSON(none($env, true)) toJSON(none(list, false)) -toJSON(none(list, ok)) -toJSON(not ("foo" not in foo)) -toJSON(not (f32 != 1)) -toJSON(not false) -toJSON(not ok) -toJSON(not true) -toJSON(ok != false) -toJSON(ok && false) +toJSON(ok != nil) +toJSON(ok != ok) toJSON(ok && ok) -toJSON(ok == nil) -toJSON(ok == ok) -toJSON(ok ? "foo" : f32) -toJSON(ok ? 0.5 : f32) -toJSON(ok ? f64 : 0.5) -toJSON(ok ? i : false) -toJSON(ok ? nil : i) -toJSON(ok ? nil : true) -toJSON(ok ? true : greet) -toJSON(ok and ok) -toJSON(ok or true) +toJSON(ok && true) +toJSON(ok == false) +toJSON(ok ? foo : ok) +toJSON(ok ?: foo) +toJSON(ok or false) toJSON(ok) -toJSON(one(array, false)) -toJSON(one(array, true)) -toJSON(reduce(array, #)) -toJSON(reduce(array, 0.5)) -toJSON(reduce(array, array)) -toJSON(reduce(array, foo)) -toJSON(reduce(array, i64)) -toJSON(reduce(array, list)) -toJSON(reduce(array, score(i32 * i64))) +toJSON(ok) not startsWith str +toJSON(one($env, true)) +toJSON(one(list, ok)) +toJSON(reduce($env, 1.0, 0)) +toJSON(reduce(array, #index)) +toJSON(reduce(array, 0)) +toJSON(reduce(array, f64)) toJSON(reduce(list, #)) -toJSON(reduce(list, 1)) -toJSON(reduce(list, f32)) -toJSON(reduce(list, false)) -toJSON(reduce(list, i)) -toJSON(reduce(list, i32)) -toJSON(reduce(list, list)) +toJSON(reduce(list, #.Bar)) +toJSON(reduce(list, 1.0)) +toJSON(reduce(list, foo)) toJSON(reduce(list, ok)) -toJSON(reduce(list, true)) +toJSON(reverse(array)) +toJSON(reverse(list)) +toJSON(round(0)) toJSON(round(1)) +toJSON(round(1.0)) toJSON(round(f64)) -toJSON(round(i32)) -toJSON(score != score) -toJSON(score(1)) -toJSON(score(1, 1)) -toJSON(score(i)) +toJSON(round(i)) +toJSON(sort($env)) toJSON(sort(array)) -toJSON(string("bar")) -toJSON(string(0.5)) +toJSON(sortBy(array, #)) +toJSON(sortBy(array, f64)) +toJSON(sortBy(list, 0)) +toJSON(sortBy(list, i)) +toJSON(str != nil) +toJSON(str <= str) +toJSON(str == nil) +toJSON(str > str) +toJSON(str contains str) +toJSON(str in $env) +toJSON(str in foo) +toJSON(str not endsWith str) +toJSON(str not in $env) +toJSON(str not in [add, array, foo]) +toJSON(str not in foo) +toJSON(str) +toJSON(str) | greet() +toJSON(str[0:]) +toJSON(str[:0]) +toJSON(string($env | one(true))) +toJSON(string($env)) +toJSON(string($env?.[str])) +toJSON(string(0)) toJSON(string(1)) +toJSON(string(1.0)) +toJSON(string(add)) toJSON(string(array)) -toJSON(string(f32)) toJSON(string(f64)) toJSON(string(false)) toJSON(string(foo)) -toJSON(string(half)) -toJSON(string(i)) -toJSON(string(i32)) -toJSON(string(i64)) toJSON(string(list)) toJSON(string(nil)) -toJSON(string(ok)) -toJSON(string(score)) +toJSON(string(str)) toJSON(string(true)) +toJSON(string(values($env))) +toJSON(sum($env, 1.0)) toJSON(sum(array)) -toJSON(take(array, i32)) -toJSON(toBase64("bar")) -toJSON(toJSON("bar")) +toJSON(sum(array, #)) +toJSON(toBase64(str)) +toJSON(toJSON(1)) +toJSON(toJSON(1.0)) toJSON(toJSON(array)) -toJSON(toJSON(f32)) toJSON(toJSON(f64)) toJSON(toJSON(false)) toJSON(toJSON(foo)) toJSON(toJSON(i)) -toJSON(toJSON(i32)) -toJSON(toJSON(i64)) toJSON(toJSON(list)) toJSON(toJSON(nil)) toJSON(toJSON(ok)) -toJSON(trim("bar")) -toJSON(trimPrefix("foo")) -toJSON(trimSuffix("bar")) -toJSON(true != true) +toJSON(toJSON(str)) +toJSON(toJSON(true)) +toJSON(trim(str)) +toJSON(trimPrefix($env?.[str])) +toJSON(trimSuffix($env?.str)) +toJSON(trimSuffix(str)) +toJSON(true != $env) +toJSON(true != nil) +toJSON(true && false) toJSON(true && ok) -toJSON(true == ok) -toJSON(true ? "bar" : "bar") -toJSON(true ? nil : score) -toJSON(true and false) +toJSON(true ? foo : 1.0) +toJSON(true ? foo : f64) +toJSON(true ? nil : false) +toJSON(true ?: nil) toJSON(true and true) -toJSON(true) in foo -toJSON(type("foo")) +toJSON(true or $env) +toJSON(true or ok) +toJSON(true || ok) +toJSON(true || true) +toJSON(true) + str | trimPrefix(str) +toJSON(true) < str +toJSON(true) > str +toJSON(true) not endsWith greet(str) +toJSON(true) not startsWith str +toJSON(true) | greet() +toJSON(true) | repeat(i) +toJSON(true); f64 +toJSON(type($env)) +toJSON(type(0)) +toJSON(type(1.0)) toJSON(type(add)) toJSON(type(array)) -toJSON(type(f32)) toJSON(type(f64)) toJSON(type(false)) toJSON(type(foo)) +toJSON(type(greet)) toJSON(type(i)) -toJSON(type(i32)) -toJSON(type(i64)) toJSON(type(list)) +toJSON(type(nil)) toJSON(type(ok)) -toJSON(type(score)) -toJSON(type(true)) -toJSON(upper("bar")) -toJSON({"bar": 1, "bar": array}) -toJSON({"bar": 1}) -toJSON({"bar": f64}) -toJSON({"bar": list}) -toJSON({"foo": i}) -toJSON({"foo": nil}) -toPairs(groupBy(array, # / #)) -toPairs(groupBy(array, #)) -toPairs(groupBy(array, 0.5)) -toPairs(groupBy(array, 1)) -toPairs(groupBy(array, false)) -toPairs(groupBy(array, foo)) -toPairs(groupBy(array, i)) -toPairs(groupBy(array, i32)) -toPairs(groupBy(array, ok)) -toPairs(groupBy(array, true)) +toJSON(type(str)) +toJSON(uniq(array)) +toJSON(uniq(list)) +toJSON(upper(str)) +toJSON({foo: 0, foo: f64}.i) +toJSON({foo: 1, foo: true}) +toJSON({foo: 1.0}) +toJSON({foo: 1.0}.f64) +toJSON({foo: 1}) +toJSON({foo: false}) +toJSON({foo: foo, foo: str}) +toJSON({foo: foo, foo: true}) +toJSON({foo: foo}) +toJSON({foo: i, foo: foo}) +toJSON({foo: i}) +toJSON({foo: list}) +toJSON({foo: nil, foo: 1.0}) +toJSON({foo: nil, foo: i}) +toJSON({foo: nil}) +toJSON({foo: ok}) +toJSON({foo: str}) +toJSON({foo: true}) +toPairs($env) != array +toPairs($env) == array +toPairs($env) == list +toPairs($env) not in $env?.Bar +toPairs($env) | concat(array) +toPairs($env) | findLast(ok) +toPairs($env) | findLastIndex(true) +toPairs($env) | groupBy(1.0) +toPairs($env) | groupBy(i) +toPairs($env) | map(#) +toPairs($env) | map(1.0) +toPairs($env) | one(false) +toPairs($env) | one(true) +toPairs($env) | reduce(#) +toPairs($env) | reduce(1.0) +toPairs($env) | reduce(add) +toPairs($env) | reduce(foo) +toPairs($env) | reduce(greet) +toPairs($env) | reduce(i) +toPairs($env)?.[i] +toPairs(array | groupBy(f64)) +toPairs(array | groupBy(ok)) +toPairs(false ? $env : $env) +toPairs(groupBy(array, 1.0)) toPairs(groupBy(list, #)) -toPairs(groupBy(list, 1)) -toPairs(groupBy(list, f32)) -toPairs(groupBy(list, i)) -toPairs(groupBy(list, ok)) -toPairs({"bar": f32}) -toPairs({"foo": i32, "bar": score}) -toPairs({"foo": nil}) -trim("bar") not in foo -trim(false ? "bar" : "bar") +toPairs(list | groupBy(#)) +toPairs(list | groupBy(false)) +toPairs(max($env)) +toPairs(min($env)) +toPairs(reduce(array, $env)) +toPairs({foo: $env, foo: true}) +toPairs({foo: $env}) +toPairs({foo: 0}) +toPairs({foo: 1, foo: $env}) +toPairs({foo: 1.0 - 1.0}) +toPairs({foo: 1.0, foo: 1}) +toPairs({foo: 1.0}) +toPairs({foo: 1}) +toPairs({foo: add, foo: add}) +toPairs({foo: add}) +toPairs({foo: array}) +toPairs({foo: f64}) +toPairs({foo: foo, foo: greet}) +toPairs({foo: foo, foo: ok}) +toPairs({foo: foo, foo: str}) +toPairs({foo: foo}) +toPairs({foo: greet}) +toPairs({foo: i}) +toPairs({foo: list}) +toPairs({foo: nil, foo: str}) +toPairs({foo: nil}) +toPairs({foo: ok}) +toPairs({foo: str}) +toPairs({foo: true}) +trim($env.str) +trim($env?.[str]) +trim($env?.[str], str) +trim($env?.str) +trim(false ? foo : str) trim(foo.Bar) trim(foo.String()) trim(foo?.Bar) trim(foo?.String()) -trim(greet("bar")) -trim(greet("foo")) -trim(lower("bar")) -trim(lower("foo")) -trim(reduce(list, "bar")) -trim(string("bar")) -trim(string(-f64)) -trim(string(0.5)) -trim(string(1)) -trim(string(add)) +trim(greet(foo?.Bar)) +trim(greet(str)) +trim(list | reduce(.Bar)) +trim(lower(str)) +trim(reduce($env, str, greet)) +trim(str | greet()) +trim(str) +trim(str) >= str +trim(str) matches str +trim(str) not endsWith $env?.[str] +trim(str) not in list?.[i] +trim(str) not matches foo.String() +trim(str) | greet() +trim(str, foo.Bar) +trim(str, str) +trim(str, toJSON(ok)) +trim(str[0:]) +trim(string($env)) +trim(string($env.ok)) +trim(string($env?.Bar)) +trim(string(0)) +trim(string(1.0)) trim(string(array)) -trim(string(f32)) +trim(string(f64)) +trim(string(false)) trim(string(foo)) -trim(string(i64)) trim(string(list)) trim(string(nil)) -trim(toJSON("bar")) +trim(string(ok)) +trim(string(str)) +trim(string(true)) +trim(string(upper(str))) +trim(toBase64(str)) +trim(toJSON($env.list)) +trim(toJSON(0)) trim(toJSON(1)) -trim(toJSON(f32)) -trim(toJSON(false)) +trim(toJSON(1.0)) +trim(toJSON(array)) +trim(toJSON(f64)) trim(toJSON(foo)) -trim(toJSON(i32)) -trim(toJSON(i64)) +trim(toJSON(list)) +trim(toJSON(nil)) trim(toJSON(ok)) trim(toJSON(true)) -trim(trim("bar")) -trim(trimPrefix("foo")) -trim(trimSuffix("bar")) -trim(true ? "foo" : greet) -trim(type("bar")) -trim(type("foo")) -trim(type(0.5)) -trim(type(1)) -trim(type(add)) -trim(type(div)) -trim(type(f32)) -trim(type(f64)) +trim(trim(str)) +trim(trimPrefix(str)) +trim(trimSuffix(str)) +trim(type($env)) +trim(type(1.0)) +trim(type(array)) +trim(type(false)) +trim(type(foo)) trim(type(greet)) trim(type(i)) -trim(type(list)) trim(type(nil)) -trim(type(ok)) -trim(type(score)) -trim(type(true)) -trimPrefix("bar" + "foo") -trimPrefix("foo" + "bar") -trimPrefix(false ? 1 : "bar") +trim(type(str)) +trimPrefix($env.str) +trimPrefix($env?.[str]) +trimPrefix($env?.str) +trimPrefix($env?.str, str) +trimPrefix(false ? greet : str) trimPrefix(foo.Bar) trimPrefix(foo.String()) trimPrefix(foo?.Bar) trimPrefix(foo?.String()) -trimPrefix(greet("bar")) -trimPrefix(greet("foo")) -trimPrefix(greet(type(0.5))) -trimPrefix(lower("bar")) -trimPrefix(string("foo")) -trimPrefix(string(0.5)) +trimPrefix(greet(str)) +trimPrefix(greet(toJSON(false))) +trimPrefix(lower(str)) +trimPrefix(reduce(list, str)) +trimPrefix(str) +trimPrefix(str) <= str +trimPrefix(str, false ? i : str) +trimPrefix(str, foo?.Bar) +trimPrefix(str, str) +trimPrefix(str, type(true)) +trimPrefix(str[0:]) +trimPrefix(str[:i]) +trimPrefix(string($env)) +trimPrefix(string(0)) trimPrefix(string(1)) -trimPrefix(string(add)) +trimPrefix(string(1.0)) trimPrefix(string(array)) -trimPrefix(string(div)) -trimPrefix(string(f32)) -trimPrefix(string(f64)) +trimPrefix(string(false)) trimPrefix(string(foo)) trimPrefix(string(greet)) -trimPrefix(string(half)) trimPrefix(string(i)) -trimPrefix(string(i32)) -trimPrefix(string(i64)) +trimPrefix(string(list)) trimPrefix(string(nil)) -trimPrefix(string(score)) +trimPrefix(string(ok)) +trimPrefix(string(str)) trimPrefix(string(true)) -trimPrefix(string({"bar": greet})) -trimPrefix(toBase64("bar")) -trimPrefix(toJSON("foo")) -trimPrefix(toJSON(1)) +trimPrefix(toBase64(str)) +trimPrefix(toJSON(0)) +trimPrefix(toJSON(1.0)) trimPrefix(toJSON(array)) -trimPrefix(toJSON(f32)) +trimPrefix(toJSON(f64)) +trimPrefix(toJSON(false)) trimPrefix(toJSON(foo)) -trimPrefix(toJSON(i32)) -trimPrefix(toJSON(i64)) -trimPrefix(toJSON(list)) +trimPrefix(toJSON(i)) trimPrefix(toJSON(nil)) +trimPrefix(toJSON(ok)) +trimPrefix(toJSON(str)) trimPrefix(toJSON(true)) -trimPrefix(trimPrefix("foo")) -trimPrefix(type("bar")) -trimPrefix(type(0.5)) -trimPrefix(type(1)) +trimPrefix(trim(str)) +trimPrefix(trimPrefix(str)) +trimPrefix(trimPrefix(str, str)) +trimPrefix(trimSuffix(str)) +trimPrefix(type($env)) +trimPrefix(type(0)) +trimPrefix(type(1.0)) +trimPrefix(type(add)) trimPrefix(type(array)) -trimPrefix(type(f32)) trimPrefix(type(f64)) -trimPrefix(type(greet)) -trimPrefix(type(half)) +trimPrefix(type(false)) +trimPrefix(type(foo)) trimPrefix(type(i)) -trimPrefix(type(i32)) -trimPrefix(type(i64)) -trimPrefix(type(list)) trimPrefix(type(nil)) -trimPrefix(type(ok)) trimPrefix(type(true)) -trimPrefix(upper("bar")) -trimPrefix(upper("foo")) -trimSuffix("bar" + "foo") -trimSuffix("bar") not contains reduce(list, "bar") -trimSuffix("foo" + "bar") -trimSuffix(false ? i64 : "foo") +trimPrefix(upper(str)) +trimSuffix($env.str) +trimSuffix($env?.[str]) +trimSuffix($env?.str) +trimSuffix(array | reduce(str, foo)) trimSuffix(foo.Bar) trimSuffix(foo.String()) trimSuffix(foo?.Bar) +trimSuffix(foo?.Bar, str) trimSuffix(foo?.String()) -trimSuffix(greet("bar")) -trimSuffix(greet("foo")) -trimSuffix(lower("bar")) -trimSuffix(reduce(array, "foo")) -trimSuffix(reduce(list, #)?.Bar) -trimSuffix(string("bar")) -trimSuffix(string("foo")) -trimSuffix(string(0.5)) +trimSuffix(greet(foo?.String())) +trimSuffix(greet(str)) +trimSuffix(greet(str), str) +trimSuffix(greet(string(add))) +trimSuffix(lower(str)) +trimSuffix(str | greet()) +trimSuffix(str) +trimSuffix(str) != str +trimSuffix(str) <= greet(str) +trimSuffix(str) | greet() +trimSuffix(str, str) +trimSuffix(string($env), str) +trimSuffix(string(0)) +trimSuffix(string(1.0)) trimSuffix(string(add)) trimSuffix(string(array)) -trimSuffix(string(div)) trimSuffix(string(f64)) trimSuffix(string(false)) trimSuffix(string(foo)) -trimSuffix(string(half)) +trimSuffix(string(foo.Bar)) +trimSuffix(string(greet)) trimSuffix(string(i)) -trimSuffix(string(i32)) -trimSuffix(string(i64)) trimSuffix(string(list)) trimSuffix(string(nil)) trimSuffix(string(ok)) -trimSuffix(string(true)) -trimSuffix(toBase64("bar")) -trimSuffix(toBase64("foo")) -trimSuffix(toJSON(1 > f64)) -trimSuffix(toJSON(1)) -trimSuffix(toJSON(f32)) +trimSuffix(toBase64($env?.[str])) +trimSuffix(toBase64($env?.str)) +trimSuffix(toBase64(str)) +trimSuffix(toJSON(1.0)) +trimSuffix(toJSON(array)) trimSuffix(toJSON(f64)) trimSuffix(toJSON(false)) trimSuffix(toJSON(foo)) -trimSuffix(toJSON(i)) -trimSuffix(toJSON(i32)) -trimSuffix(toJSON(i64)) trimSuffix(toJSON(list)) trimSuffix(toJSON(nil)) +trimSuffix(toJSON(ok)) +trimSuffix(toJSON(str)) trimSuffix(toJSON(true)) -trimSuffix(trim("bar")) -trimSuffix(trim("foo")) -trimSuffix(trimPrefix("bar")) -trimSuffix(trimPrefix("foo")) -trimSuffix(trimSuffix("bar")) +trimSuffix(trim(str)) +trimSuffix(trimPrefix(str)) +trimSuffix(trimSuffix(str)) +trimSuffix(type($env)) +trimSuffix(type(0)) trimSuffix(type(1)) +trimSuffix(type(1.0)) trimSuffix(type(add)) trimSuffix(type(array)) -trimSuffix(type(div)) -trimSuffix(type(f32)) +trimSuffix(type(false)) trimSuffix(type(foo)) trimSuffix(type(greet)) -trimSuffix(type(half)) -trimSuffix(type(i32)) +trimSuffix(type(i)) trimSuffix(type(list)) trimSuffix(type(nil)) trimSuffix(type(ok)) -trimSuffix(upper("foo")) -true != nil || true == true -true != ok != ok -true == ok == ok -true ? 0.5 : i <= f32 -true ? 1 : foo?.Bar -true ? 1 : ok or i64 == 0.5 -true ? add : foo?.Bar -true ? array : 0.5 >= i32 +trimSuffix(type(str)) +trimSuffix(upper(str)) +true != $env || $env >= 1.0 +true != $env.ok +true != $env?.Bar +true != $env?.String +true != $env?.String?.String +true != $env?.[Bar] +true != $env?.[String] +true != $env?.[String]?.Bar +true != $env?.[foobar?.[greet]] +true != $env?.[foobar] +true != $env?.[str] +true != $env?.ok +true != false == ok +true != nil and ok +true != true ?: foo +true && $env != list +true && $env == list?.[i] +true && $env == str +true && $env.ok +true && $env?.Bar +true && $env?.String +true && $env?.[Bar] +true && $env?.[Bar]?.str +true && $env?.[String] +true && $env?.[foobar] +true && $env?.[str] +true && $env?.foobar +true && $env?.ok +true && 0 * i < 1 +true && 1.0 == f64 +true && 1.0 >= f64 +true && false && ok +true && greet == greet +true && nil == ok +true && nil == str +true && ok ?: str +true && str startsWith $env?.String +true == $env == ok +true == $env || $env != ok +true == $env || 1.0 >= f64 +true == $env.ok +true == $env?.Bar +true == $env?.String +true == $env?.[Bar] +true == $env?.[String] +true == $env?.[foobar] +true == $env?.[str] +true == $env?.ok +true == nil == ok +true == ok && ok +true ? $env : $env.f64 +true ? $env : $env.foo +true ? $env : $env.str +true ? $env : $env?.Bar +true ? $env : $env?.[array] +true ? $env : foo.String +true ? 0 : $env?.Bar?.greet +true ? 0 : $env?.String +true ? 0 : $env?.[Bar] +true ? 0 : $env[:list(foobar)] +true ? 1 : $env?.i +true ? 1 : 1.0 / 1 == f64 +true ? 1.0 : $env.greet +true ? 1.0 : $env.str +true ? 1.0 : $env?.[i] +true ? 1.0 : $env?.[str] +true ? 1.0 : $env?.ok +true ? 1.0 : str >= $env?.[Bar] +true ? add : $env ^ 0 != $env +true ? add : $env.f64 +true ? add : $env?.Bar +true ? array : $env?.foo true ? array : foo.String -true ? array : foo?.Bar -true ? array : foo?.String -true ? array : i32 ** f64 -true ? div : i64 ** 1 ^ i32 -true ? false : 0.5 > i -true ? false : foo.Qux -true ? foo : 0.5 + -1 -true ? foo : foo.Bar -true ? foo : i64 / f32 -true ? greet : foo.Bar -true ? greet : ok == ok -true ? half : 0.5 / i32 -true ? half : foo.String -true ? i : 1 * i64 -true ? i32 : i32 - f32 -true ? i32 : i32 >= f32 -true ? i64 : f64 != i -true ? list : f32 != i -true ? nil : foo.String -true ? nil : foo?.String -true ? nil : i32 != f64 + 1 -true ? ok : foo.Qux -true ? ok : foo?.String -true ? score : ok or f64 < f32 -true and nil not in list -true and ok or ok -true and true || ok -true or 0.5 not in array -true || f32 not in groupBy(list, #) -true || false ? half : half -type(!false) -type(!ok) -type(!true) -type("bar" != "bar") -type("bar" < "foo") -type("bar" <= "bar") -type("bar" == "foo") -type("bar" >= "bar") -type("bar" not endsWith "foo") -type("bar" startsWith "bar") -type("bar") startsWith greet("bar") -type("foo" != nil) -type("foo" + "bar") -type("foo" not startsWith "bar") -type("foo") not in foo -type(-0.5) -type(-1) -type(-f32) -type(-f64) -type(-i) -type(-i32) -type(-i64) -type(-int(f64)) -type(0.5 != f64) -type(0.5 != i32) -type(0.5 != nil) -type(0.5 * 0.5) -type(0.5 * f32) -type(0.5 * f64) -type(0.5 * i64) -type(0.5 ** 0.5) -type(0.5 ** 1) -type(0.5 ** f32) -type(0.5 ** f64) -type(0.5 ** i) -type(0.5 ** i32) -type(0.5 + 0.5) -type(0.5 + 1) -type(0.5 + f32) -type(0.5 + f64) -type(0.5 + i) -type(0.5 + i64) -type(0.5 - 1) -type(0.5 - f64) -type(0.5 - i32) -type(0.5 / 1) -type(0.5 / f32) -type(0.5 / i) -type(0.5 / i32) -type(0.5 / i64) -type(0.5 < 1) -type(0.5 < f32) -type(0.5 < i32) -type(0.5 < i64) -type(0.5 <= 1) -type(0.5 <= f32) -type(0.5 <= i64) -type(0.5 == 0.5) -type(0.5 == f32) -type(0.5 == f64) -type(0.5 == i32) -type(0.5 > 0.5) -type(0.5 > f32) -type(0.5 > i) -type(0.5 > i32) -type(0.5 > i64) -type(0.5 >= 0.5) -type(0.5 >= i) -type(0.5 >= i32) -type(0.5 ^ 0.5) -type(0.5 ^ i) -type(0.5 ^ i32) -type(0.5 ^ i64) -type(0.5 not in array) -type(0.5) in foo -type(1 != i32) +true ? f64 : $env.add +true ? f64 : $env?.[i] +true ? f64 : $env?.greet +true ? f64 : $env?.i +true ? f64 : $env[foo?.[String]:] +true ? false : $env | count($env) +true ? false : $env?.f64 +true ? false : array != array +true ? foo : $env.array +true ? foo : $env.foo +true ? foo : $env?.[String] +true ? foo : $env?.[str] +true ? foo : $env?.array +true ? foo : $env?.str +true ? foo : 1.0 + i +true ? foo : foo?.Bar +true ? foo : i .. i +true ? greet : $env | sum(.greet) +true ? greet : $env.greet +true ? greet : $env?.[add].foo +true ? greet : $env?.str +true ? greet : nil != none($env, #) +true ? i : $env?.[Bar] +true ? list : $env?.String +true ? list : $env?.[greet] +true ? list : $env?.[ok] +true ? list : $env?.ok +true ? list : foo.Bar +true ? list : foo?.Bar +true ? list : foo?.String +true ? nil : $env.str +true ? nil : $env?.[f64] +true ? nil : $env?.foo +true ? nil : foo.Bar +true ? ok : $env.foo +true ? ok : $env?.[str] +true ? ok : foo.String +true ? str : foo?.Bar +true ? str : i + i +true ? true : $env?.String.str +true ? true : $env?.greet +true ? true : 1.0 == $env?.Bar +true ? true : array | date(false, foo) +true ? true : foo?.Bar +true ? true : list | sum(#) +true ?: $env != 0 ^ $env +true ?: $env % i +true ?: $env | count(.list) +true ?: $env | find(#) +true ?: $env | groupBy(1.0) +true ?: $env | reduce(#.list) +true ?: $env | reduce(1.0) +true ?: $env.add +true ?: $env.array +true ?: $env.foo +true ?: $env.greet +true ?: $env.i +true ?: $env.list +true ?: $env.ok +true ?: $env.str +true ?: $env?.[Bar] +true ?: $env?.[String()] +true ?: $env?.[array] +true ?: $env?.[i] +true ?: $env?.[list] +true ?: $env?.add +true ?: $env?.array +true ?: $env?.f64 +true ?: $env?.foo +true ?: $env?.greet +true ?: $env?.ok +true ?: $env[:foobar] +true ?: 1.0 == f64 +true ?: foo.Bar +true ?: foo.String +true ?: foo?.String +true ?: nil != f64 +true ?: nil == $env?.str +true and $env == f64 +true and $env startsWith $env?.Bar +true and $env.ok +true and $env?.Bar +true and $env?.Bar?.Bar +true and $env?.String +true and $env?.String?.ok +true and $env?.[Bar] +true and $env?.[String] +true and $env?.[str] +true and $env?.foobar +true and $env?.foobar?.array() +true and $env?.ok +true and 1 > f64 +true and 1 > i +true and 1 in sort($env) +true and 1.0 > f64 +true and array != list +true and f64 < f64 +true and false || ok +true and i == i +true and nil != greet +true and nil == greet +true and str != str +true and true || $env >= $env +true in $env?.Bar +true in $env?.String +true in $env?.[Bar] +true in $env?.[String] +true in $env?.[foobar] +true not in $env?.Bar +true not in $env?.String +true not in $env?.[Bar] +true not in $env?.[Bar]?.String +true not in $env?.[Bar]?.foo +true not in $env?.[String] +true not in $env?.[String]?.[list] +true not in $env?.[foobar] +true or $env in str +true or $env startsWith str +true or $env.ok +true or $env?.Bar +true or $env?.Bar() +true or $env?.String +true or $env?.String() +true or $env?.String?.ok +true or $env?.[0 | one(1.0)] +true or $env?.[Bar] +true or $env?.[String] +true or $env?.[add] +true or $env?.[add]?.str +true or $env?.[array] +true or $env?.[array]?.greet?.Bar +true or $env?.[array]?.str() +true or $env?.[f64] +true or $env?.[foo] +true or $env?.[greet] +true or $env?.[greet]?.[add] +true or $env?.[i.f64] +true or $env?.[i] +true or $env?.[list] +true or $env?.[ok(foobar)] +true or $env?.[ok] +true or $env?.[str.greet] +true or $env?.[str] +true or $env?.[str].ok +true or $env?.foobar +true or $env?.min(1.0) +true or $env?.ok +true or $env?.sortBy(foo, 1.0)?.foo() +true or $env[:1.0 or list] +true or $env[:Bar] +true or $env[:array ?: foo] +true or $env[:bitnand(greet, foobar)] +true or $env[:foobar?.String(foobar, foobar)] +true or $env[:greet] +true or $env[:true || foobar] +true or $env[foobar?.[array]:] +true or 0 < f64 +true or 0 <= $env?.[f64]?.[foo] +true or 1 > f64 +true or 1 >= $env in $env +true or 1.0 > i +true or 1.0 >= f64 +true or f64 + $env?.[add] +true or false ?: sum($env, .Bar) +true or false or ok +true or i not in $env * f64 +true or nil == str in $env +true or nil not in list +true or ok and foo == $env?.[String] +true or str contains $env?.str +true or str not in foo +true || $env != 1.0 - $env +true || $env != i +true || $env == greet +true || $env contains str +true || $env in str +true || $env not contains $env?.[foo] +true || $env.ok +true || $env?.Bar +true || $env?.Bar() +true || $env?.Bar?.i() +true || $env?.String +true || $env?.String() +true || $env?.String(false > foobar, array(foobar)) +true || $env?.String(map(foobar | findIndex(#.str), .greet)) +true || $env?.String(reduce(foobar, #.list).i) +true || $env?.String?.list +true || $env?.[Bar(nil, 0)] +true || $env?.[Bar] +true || $env?.[String] +true || $env?.[add] +true || $env?.[add].f64 +true || $env?.[add].f64.list +true || $env?.[array?.array()] +true || $env?.[array] +true || $env?.[f64] +true || $env?.[foo] +true || $env?.[foobar | findIndex(add)] +true || $env?.[foobar] +true || $env?.[greet] +true || $env?.[i] +true || $env?.[list] +true || $env?.[ok] +true || $env?.[ok]?.[ok] +true || $env?.[str] +true || $env?.foobar +true || $env?.ok +true || $env?.reduce($env) +true || $env[:String == foo] +true || $env[:foobar] +true || $env[:ok ? false : add] +true || $env[:str] +true || $env[String.Bar(foobar):add()] +true || $env[duration(String):] +true || $env[false | bitand(str):] +true || $env[foobar:] +true || $env[foobar?.[str]:str()] +true || $env[list endsWith str:foobar] +true || 0 != $env?.f64 +true || 0 <= $env?.String(str) +true || 1.0 < find($env, #) +true || 1.0 <= i +true || 1.0 > f64 == true +true || add != add +true || i > f64 +true || nil != f64 +true || nil == foo +true || nil == ok +type($env != $env) +type($env != 0) +type($env != add) +type($env != f64) +type($env != foo) +type($env != greet) +type($env != list) +type($env != nil) +type($env && true) +type($env == $env) +type($env == 1) +type($env == 1.0) +type($env == add) +type($env == f64) +type($env == false) +type($env == foo) +type($env == nil) +type($env and true) +type($env in array) +type($env in list) +type($env not in array) +type($env not in list) +type($env or true) +type($env | all(true)) +type($env | any(ok)) +type($env | any(true)) +type($env | count(ok)) +type($env | findLastIndex(ok)) +type($env | map(#index)) +type($env | map(foo)) +type($env | none(true)) +type($env | one(false)) +type($env | sum(0)) +type($env | sum(1.0)) +type($env || false) +type($env) != foo?.Bar +type($env) not contains toJSON(true) +type($env) not in foo +type($env) not matches str +type($env) | greet() +type($env.add) +type($env.array) +type($env.f64) +type($env.foo) +type($env.greet) +type($env.i) +type($env.list) +type($env.ok) +type($env.str) +type($env?.$env) +type($env?.Bar) +type($env?.String) +type($env?.String?.add) +type($env?.[Bar]) +type($env?.[Bar]) | trimPrefix(str) +type($env?.[String]) +type($env?.[String]?.[i]) +type($env?.[String]?.i) +type($env?.[foobar]) +type($env?.[nil]) +type($env?.[str]) +type($env?.add) +type($env?.add) | greet() +type($env?.array) +type($env?.f64) +type($env?.foo) +type($env?.foobar) +type($env?.greet) +type($env?.i) +type($env?.list) +type($env?.nil) +type($env?.ok) +type($env?.str) +type($env?.true) +type(0 != $env) +type(0 != 0) +type(0 != 1.0) +type(0 != f64) +type(0 != i) +type(0 != nil) +type(0 % i) +type(0 * 0) +type(0 + 0) +type(0 + 1) +type(0 + i) +type(0 - 1) +type(0 - f64) +type(0 .. 0) +type(0 .. 1) +type(0 .. i) +type(0 / 1) +type(0 / 1.0) +type(0 / i) +type(0 < 1.0) +type(0 <= 1) +type(0 <= i) +type(0 == 1) +type(0 == 1.0) +type(0 == i) +type(0 == nil) +type(0 > 1.0) +type(0 ^ 1.0) +type(0 ^ i) +type(0 | median(1, 1.0)) +type(0 | min(0)) +type(0 | min(i)) +type(0) != str +type(0) in foo +type(0) not startsWith str +type(0)[i:] +type(0..i) +type(1 != $env) +type(1 != f64) type(1 != nil) type(1 % 1) -type(1 % i) -type(1 * 0.5) -type(1 * f32) +type(1 * 0) +type(1 * 1.0) +type(1 * f64) type(1 * i) -type(1 * i32) -type(1 ** 0.5) +type(1 ** 1.0) type(1 ** f64) -type(1 ** i) -type(1 ** i64) -type(1 + 0.5) +type(1 + 0) type(1 + 1) -type(1 + f32) -type(1 + i64) -type(1 - 0.5) -type(1 - 1) -type(1 - i64) -type(1 .. 1) -type(1 .. i64) -type(1 / f64) +type(1 + 1.0) +type(1 .. 0) +type(1 / 1) type(1 / i) -type(1 < i32) -type(1 < i64) -type(1 <= 0.5) +type(1 <= 0) type(1 <= 1) -type(1 <= f64) +type(1 <= 1.0) type(1 <= i) -type(1 == f32) -type(1 == f64) type(1 == i) -type(1 == i32) -type(1 == i64) -type(1 > i) -type(1 >= 0.5) +type(1 == nil) +type(1 > 0) +type(1 > 1) +type(1 > 1.0) +type(1 > f64) +type(1 >= 0) +type(1 >= 1.0) type(1 >= i) -type(1 >= i64) +type(1 ^ 0) type(1 ^ 1) -type(1 ^ i) -type(1 ^ i64) -type(1) endsWith foo.Bar -type(1) in reduce(list, #) -type(1) not endsWith "bar" ? i64 : nil -type(1) not startsWith string(0.5) -type([div]) -type([f32]) -type(abs(0.5)) -type(abs(f32)) -type(abs(f64)) +type(1 ^ 1.0) +type(1 in array) +type(1 not in array) +type(1) not in foo +type(1) startsWith reduce(list, #.Bar) +type(1) | greet() +type(1.0 != $env) +type(1.0 != $env?.i) +type(1.0 != 1) +type(1.0 != 1.0) +type(1.0 != f64) +type(1.0 != i) +type(1.0 != nil) +type(1.0 * 0) +type(1.0 * 1) +type(1.0 * 1.0) +type(1.0 * f64) +type(1.0 * i) +type(1.0 ** 1) +type(1.0 ** 1.0) +type(1.0 ** f64) +type(1.0 + 0) +type(1.0 + 1) +type(1.0 + 1.0) +type(1.0 + i) +type(1.0 - 0) +type(1.0 - 1.0) +type(1.0 - f64) +type(1.0 - i) +type(1.0 / 1) +type(1.0 / 1.0) +type(1.0 / f64) +type(1.0 < 0) +type(1.0 < 1) +type(1.0 < 1.0) +type(1.0 < i) +type(1.0 <= 0) +type(1.0 <= 1.0) +type(1.0 == $env) +type(1.0 == 1.0) +type(1.0 == f64) +type(1.0 == i) +type(1.0 == nil) +type(1.0 > 1.0) +type(1.0 > i) +type(1.0 >= 1) +type(1.0 >= 1.0) +type(1.0 >= i) +type(1.0 ^ 0) +type(1.0 ^ 1.0) +type(1.0 ^ f64) +type(1.0 | max(0)) +type(1.0 | mean(1.0)) +type(1.0) +type(1.0) + str +type(1.0) >= str +type(1.0) contains str +type(1.0) not endsWith foo.Bar +type(1.0) not endsWith str +type(1.0) not matches str +type(1.0) startsWith str +type(1.0) | greet() +type(1.0)[:i] +type([$env]) +type([0]) +type([1.0, foo]) +type([1.0]) +type([1]) +type([add]) +type([array]) +type([f64]) +type([false]) +type([foo, i]) +type([foo]) +type([greet]) +type([i]) +type([list, 1.0, true]) +type([list, ok]) +type([list]) +type([nil, foo]) +type([nil]) +type([ok, f64]) +type([ok]) +type([str]) +type([true, foo]) +type([true]) +type(abs(0)) +type(abs(1)) +type(abs(1.0)) type(abs(i)) -type(abs(i32)) -type(abs(i64)) +type(add != $env) +type(add != add) +type(add == nil) +type(add(i, 0)) type(add) -type(all(array, ok)) -type(all(list, ok)) +type(add) != str +type(add) == foo.Bar +type(add) matches str +type(add) not matches str +type(add) | greet() +type(add)[:] +type(all(array, false)) type(all(list, true)) -type(any(array, false)) +type(any(array, 1 > #)) type(any(array, ok)) -type(any(list, false)) -type(array != list) -type(array != nil) -type(array == array) +type(array == $env) +type(array == nil) +type(array | find(false)) +type(array | findIndex(false)) +type(array | findIndex(ok)) +type(array | groupBy(ok)) +type(array | min(array)) +type(array | none(false)) +type(array | none(ok)) +type(array | reduce(#)) +type(array | reduce(#, foo)) +type(array | reduce(1.0, list)) +type(array | reduce(1.0, ok)) +type(array | reduce(false)) +type(array | reduce(foo)) +type(array | sortBy(#)) +type(array | sum(i)) type(array) -type(array) >= trimPrefix("foo") -type(array[1]) -type(array[i32]) -type(array[i]) -type(bitand(1, i)) +type(array) < str +type(array) == str +type(array) endsWith $env?.[Bar]?.[str] +type(array) in foo +type(array) not in foo +type(array) | repeat(1) +type(array?.[i]) +type(array[1:]) +type(array[:0]) +type(bitnand(i, 0)) +type(bitnot(0)) +type(bitnot(1)) type(bitnot(i)) -type(bitnot(i32)) -type(bitnot(i64)) -type(bitxor(i64, 1)) -type(ceil(0.5)) -type(ceil(f32)) +type(bitshr(i, 1)) +type(bitxor(i, i)) +type(ceil(0)) +type(ceil(1)) +type(ceil(1.0)) type(ceil(f64)) -type(ceil(i64)) -type(count(array, true)) -type(div != div) -type(div == div) -type(div) -type(f32 != 0.5) -type(f32 != 1) -type(f32 * 1) -type(f32 * i) -type(f32 * i32) -type(f32 ** f32) -type(f32 + 1) -type(f32 + i) -type(f32 - f32) -type(f32 - i32) -type(f32 / 1) -type(f32 / f32) -type(f32 < 1) -type(f32 < f32) -type(f32 <= f64) -type(f32 == 0.5) -type(f32 == f64) -type(f32 == i) -type(f32 == i32) -type(f32 == i64) -type(f32 > 1) -type(f32 >= f32) -type(f32 >= i) -type(f32 >= i32) -type(f32 ^ i64) -type(f32 not in array) -type(f32) -type(f64 != 0.5) -type(f64 != i) -type(f64 * 0.5) -type(f64 * 1) -type(f64 * f32) -type(f64 ** 1) -type(f64 + f32) -type(f64 + i32) -type(f64 - 0.5) -type(f64 - 1) -type(f64 - f64) -type(f64 - i) -type(f64 / 1) -type(f64 / f32) -type(f64 / i64) -type(f64 < 0.5) -type(f64 < f32) -type(f64 < f64) -type(f64 < i32) -type(f64 < i64) -type(f64 <= 0.5) -type(f64 <= f64) -type(f64 <= i64) -type(f64 == 0.5) -type(f64 == f32) -type(f64 == i64) +type(ceil(i)) +type(concat(array)) +type(concat(list)) +type(count($env, ok)) +type(count([true])) +type(f64 != 1) +type(f64 != 1.0) +type(f64 * 1.0) +type(f64 * f64) +type(f64 * i) +type(f64 ** 1.0) +type(f64 ** i) +type(f64 + 1) +type(f64 + 1.0) +type(f64 + i) +type(f64 - 0) +type(f64 / 1.0) +type(f64 < 1.0) +type(f64 <= 1) +type(f64 == 0) +type(f64 == f64) type(f64 == nil) +type(f64 > 1) +type(f64 > 1.0) +type(f64 > f64) type(f64 > i) -type(f64 > i32) -type(f64 >= 0.5) -type(f64 >= i) -type(f64 ^ 0.5) +type(f64 >= 1.0) +type(f64 ^ 1) +type(f64 ^ 1.0) +type(f64 ^ i) type(f64 not in array) type(f64) -type(false != nil) +type(f64) > str +type(f64) not startsWith str +type(false != false) type(false != ok) -type(false && true) -type(false ? "bar" : score) -type(false ? div : f64) -type(false ? half : greet) -type(false ? true : foo) -type(false || true) -type(false) startsWith "bar" ? ok : f32 +type(false && $env) +type(false == $env) +type(false == false) +type(false ? f64 : 1) +type(false ? foo : add) +type(false ? foo : list) +type(false ? list : foo) +type(false or true) +type(false || $env) +type(false || false) +type(false) == str +type(false) > str +type(filter($env, false)) type(find(array, false)) -type(find(array, true)) -type(find(list, true)) -type(findIndex(array, ok)) -type(findLast(array, false)) -type(findLast(array, ok)) -type(findLastIndex(array, false)) -type(findLastIndex(list, false)) -type(findLastIndex(list, ok)) -type(findLastIndex(list, true)) +type(findIndex($env, ok)) +type(findLast($env, false)) +type(findLast(list, ok)) +type(first($env)) +type(first(array)) type(first(list)) -type(float(f32)) -type(float(i32)) -type(floor(0.5)) -type(floor(1)) +type(flatten(list)) +type(float(0)) +type(float(1)) +type(float(1.0)) +type(float(f64)) +type(float(i)) +type(floor(0)) +type(floor(1.0)) type(floor(f64)) -type(floor(i64)) +type(foo != $env) +type(foo != $env?.foo) type(foo != foo) type(foo != nil) +type(foo == $env) +type(foo == foo) +type(foo == nil) type(foo in list) type(foo) +type(foo) != $env?.foobar +type(foo) <= str +type(foo) matches $env?.String?.[greet] +type(foo) matches str +type(foo) not endsWith str +type(foo) not in $env and false +type(foo) not in foo and $env +type(foo) not startsWith str +type(foo) | greet() +type(foo)[:] type(foo.Bar) -type(foo.Qux) type(foo.String()) type(foo.String) type(foo?.Bar) -type(foo?.Qux) type(foo?.String()) type(foo?.String) -type(get(array, 1)) -type(get(array, i64)) -type(get(list, 1)) -type(get(list, i)) -type(get(list, i32)) -type(get(list, i64)) -type(greet("bar")) -type(greet("foo")) +type(greet != $env) +type(greet != greet) +type(greet == $env) +type(greet == greet) +type(greet == nil) +type(greet(str)) type(greet) type(groupBy(array, #)) -type(groupBy(array, #).score) -type(groupBy(array, 0.5)) -type(groupBy(array, false)?.add) -type(groupBy(array, i)) -type(groupBy(array, i32)) -type(groupBy(array, i64)) -type(groupBy(list, "bar")) +type(groupBy(array, 0)) +type(groupBy(array, 1.0)) +type(groupBy(array, false)) +type(groupBy(array, foo)) type(groupBy(list, #)) -type(groupBy(list, #)?.Bar) -type(groupBy(list, 1)) -type(groupBy(list, i64)) -type(groupBy(list, true)) -type(half(0.5)) -type(half(1)) -type(half(f64)) -type(half) -type(half) not in foo -type(i % 1) -type(i % i32) -type(i * 0.5) -type(i * i32) -type(i ** f32) -type(i ** f64) -type(i ** i) -type(i + i32) -type(i - 0.5) +type(groupBy(list, .Bar)) +type(groupBy(list, 1.0)) +type(groupBy(list, false)) +type(i != $env) +type(i != array?.[i]) +type(i != i) +type(i != nil) +type(i * 0) +type(i * 1) +type(i * f64) +type(i ** 1.0) +type(i + 0) +type(i + 1) +type(i + 1.0) +type(i + f64) +type(i + i) +type(i - 0) type(i - 1) -type(i - i) -type(i - i64) +type(i .. 0) type(i .. i) -type(i / 0.5) -type(i / i32) -type(i < 0.5) -type(i < 1) -type(i <= 0.5) +type(i / 1.0) +type(i < i) +type(i <= 0) type(i <= 1) -type(i == 1) -type(i > 0.5) -type(i > 1) -type(i > f32) -type(i > i64) -type(i >= i32) -type(i ^ 1) +type(i <= 1.0 + 1.0 == $env) +type(i <= 1.0) +type(i <= f64) +type(i <= i) +type(i == $env) +type(i == 1.0) +type(i == nil) +type(i > f64) +type(i >= f64) type(i ^ i) -type(i ^ i32) -type(i ^ i64) +type(i | bitushr(i)) type(i) -type(i) + foo.Bar -type(i32 != 1) -type(i32 != f64) -type(i32 * 0.5) -type(i32 * i) -type(i32 ** 0.5) -type(i32 ** f64) -type(i32 ** i) -type(i32 + 1) -type(i32 - 1) -type(i32 .. i32) -type(i32 / 0.5) -type(i32 / f64) -type(i32 < 0.5) -type(i32 <= 0.5) -type(i32 <= f64) -type(i32 <= i32) -type(i32 == 1) -type(i32 == nil) -type(i32 > 0.5) -type(i32 > f64) -type(i32 > i64) -type(i32 >= 1) -type(i32 >= f32) -type(i32 >= i64) -type(i32 ^ 1) -type(i32 ^ f32) -type(i32 ^ f64) -type(i32 ^ i) -type(i32 not in array) -type(i32) -type(i32) in foo -type(i32) not matches trim("foo") -type(i64 != 1) -type(i64 != f64) -type(i64 % 1) -type(i64 * f32) -type(i64 * i64) -type(i64 ** 0.5) -type(i64 ** f64) -type(i64 ** i32) -type(i64 + 0.5) -type(i64 + 1) -type(i64 + i64) -type(i64 - 0.5) -type(i64 - f32) -type(i64 - f64) -type(i64 - i32) -type(i64 .. i32) -type(i64 / 0.5) -type(i64 / f32) -type(i64 / i64) -type(i64 < 0.5) -type(i64 < f32) -type(i64 < f64) -type(i64 < i) -type(i64 < i64) -type(i64 <= 0.5) -type(i64 <= 1) -type(i64 <= f32) -type(i64 <= i) -type(i64 == 1) -type(i64 == f64) -type(i64 > i64) -type(i64 >= 1) -type(i64 ^ f64) -type(i64 ^ i) -type(i64 not in array) -type(i64) -type(int(0.5)) -type(int(f32)) +type(i) <= str +type(i) | splitAfter(str) +type(if false { nil } else { foo }) +type(if false { nil } else { nil }) +type(if false { true } else { array }) +type(if ok { 1 } else { false }) +type(if ok { foo } else { foo }) +type(if ok { nil } else { str }) +type(int(1)) +type(int(1.0)) type(int(f64)) type(int(i)) -type(int(i32)) -type(int(i64)) +type(keys($env)) +type(last($env)) +type(last($env)?.String) +type(last($env?.Bar)) type(last(array)) -type(last(list)) +type(len($env)) type(len(array)) type(len(list)) +type(len(str)) +type(let foobar = 1; foobar) +type(list != $env) type(list != nil) -type(list == array) +type(list == $env) type(list == nil) +type(list | groupBy(#)) +type(list | groupBy(0)) +type(list | map(#)) +type(list | map(#index)) +type(list | map(0)) +type(list | map(greet)) +type(list | one(false)) +type(list | one(ok)) +type(list | reduce(#, nil)) +type(list | reduce(#.Bar)) +type(list | reduce(i)) +type(list | reduce(ok, add)) type(list) -type(list[1]) -type(list[i32]) -type(list[i64]) -type(list[i]) -type(map(array, "bar")) -type(map(array, "foo")) -type(map(array, #)) +type(list) == str +type(list) >= string(0) +type(list) | hasSuffix(str) +type(list?.[i]) +type(list[0:]) +type(lower(str)) +type(map($env, $env)) +type(map($env, 1)) +type(map($env, add)) +type(map($env, f64)) +type(map($env, foo)) +type(map($env, i)) +type(map(array, 0)) type(map(array, 1)) -type(map(array, div)) -type(map(array, f32)) -type(map(array, foo)) -type(map(array, greet)) -type(map(array, ok)) -type(map(array, true)) -type(map(list, "bar")) +type(map(array, false)) type(map(list, #)) -type(map(list, array)) -type(map(list, greet)) -type(map(list, i64)) -type(map(list, list)) -type(map(list, ok)) -type(max(0.5)) -type(max(0.5, f64)) +type(map(list, 1.0)) +type(map(list, foo)) +type(max($env)) +type(max(0)) +type(max(0, array)) type(max(1)) -type(max(1, i32)) +type(max(1.0)) +type(max(array)) type(max(f64)) -type(max(i64)) +type(mean(0)) +type(mean(1)) +type(mean(1.0)) +type(mean(array)) +type(mean(array, 1.0)) +type(mean(i)) +type(median($env.i)) +type(median(0)) +type(median(0, 1)) +type(median(1.0)) type(median(array)) +type(median(i)) +type(median(min(f64))) +type(min($env)) +type(min(0)) type(min(1)) -type(min(f32)) +type(min(1.0)) +type(min(array)) +type(min(f64)) type(min(i)) -type(min(i32)) -type(min(i64)) -type(nil != "foo") -type(nil != 0.5) +type(nil != $env) +type(nil != 0) type(nil != 1) +type(nil != 1.0) +type(nil != add) +type(nil != array) +type(nil != false) +type(nil != foo) type(nil != greet) -type(nil != half) -type(nil != i32) -type(nil != i64) +type(nil != i) +type(nil != list) type(nil != nil) -type(nil != score) -type(nil == "foo") +type(nil != str) +type(nil == $env) +type(nil == 0) +type(nil == 1) +type(nil == 1.0) +type(nil == add) type(nil == array) -type(nil == f32) +type(nil == f64) type(nil == false) type(nil == foo) -type(nil == greet) +type(nil == list) type(nil == nil) -type(nil == score) +type(nil == ok) +type(nil in $env) type(nil in array) type(nil in list) -type(nil not in array) -type(nil not in list) +type(nil not in $env) +type(nil) <= str +type(nil) matches str +type(nil) matches string(foo) +type(nil) not in {foo: false} +type(nil) | greet() +type(nil)[:] +type(none(list, false)) type(none(list, ok)) -type(none(list, true)) -type(not (f64 <= i)) -type(not false) -type(not ok) -type(not true) -type(ok != false) type(ok != nil) -type(ok != true) -type(ok && false) +type(ok == $env) type(ok == nil) -type(ok ? "bar" : half) -type(ok ? 1 : "bar") -type(ok ? array : i64) -type(ok ? array : score) -type(ok ? i : "bar") -type(ok ? i : nil) -type(ok ? nil : 0.5) -type(ok ? nil : div) -type(ok and ok) +type(ok == true) +type(ok ? 1 : 1.0) +type(ok ? list : foo) +type(ok ?: array) +type(ok ?: greet) +type(ok and $env) +type(ok or $env) type(ok or false) +type(ok or true) type(ok || false) +type(ok || ok) +type(ok || true) type(ok) -type(one(array, false)) -type(one(array, true)) -type(one(list, false)) -type(one(list, true)) -type(reduce(array, "bar")) +type(ok) contains str +type(ok) in {foo: true} +type(ok) | greet() +type(one($env, false)) +type(one($env, true)) type(reduce(array, #)) -type(reduce(array, 1)) +type(reduce(array, $env)) +type(reduce(array, add)) +type(reduce(array, f64)) type(reduce(array, foo)) -type(reduce(array, greet)) -type(reduce(array, i)) type(reduce(array, ok)) -type(reduce(list, "foo")) type(reduce(list, #)) -type(reduce(list, array)) -type(reduce(list, i64)) -type(reduce(list, ok)) -type(round(0.5)) +type(reduce(list, #.String)) +type(reduce(list, #index)) +type(reduce(list, 0)) +type(reduce(list, add)) +type(reverse(array)) +type(reverse(list)) +type(round(0)) type(round(1)) +type(round(1.0)) type(round(f64)) -type(round(i)) -type(round(i64)) -type(score != score) -type(score == nil) -type(score(1)) -type(score(1, 1)) -type(score(i)) -type(score) -type(sort(array)) -type(string(0.5)) +type(sort($env)) +type(sortBy(array, #)) +type(sortBy(array, 0)) +type(sortBy(array, 1.0)) +type(sortBy(list, i)) +type(str <= str) +type(str == $env) +type(str > str) +type(str >= str) +type(str in $env) +type(str in foo) +type(str not in $env) +type(str not in foo) +type(str) +type(str) <= trim(str) +type(str) == str +type(str) >= str +type(str) contains $env?.String +type(str[:]) +type(str[i:]) +type(string($env)) +type(string(0)) type(string(1)) +type(string(1.0)) type(string(add)) -type(string(div)) -type(string(f32)) +type(string(array)) type(string(f64)) +type(string(false != nil)) type(string(false)) +type(string(foo)) type(string(greet)) -type(string(i32)) -type(string(i64)) type(string(list)) -type(string(nil)) -type(string(ok)) -type(string(score)) -type(toBase64("bar")) -type(toJSON("bar")) -type(toJSON("foo")) -type(toJSON(0.5)) +type(string(map($env, 1))) +type(string(true)) +type(sum(array)) +type(sum(array, #)) +type(sum(array, 1)) +type(sum(list, 1.0)) +type(toJSON(0)) type(toJSON(1)) +type(toJSON(1.0)) type(toJSON(array)) +type(toJSON(f64)) type(toJSON(false)) +type(toJSON(foo)) type(toJSON(i)) -type(toJSON(i32)) -type(toJSON(i64)) type(toJSON(list)) +type(toJSON(median(i))) type(toJSON(nil)) -type(trim("foo")) -type(trimPrefix("bar")) +type(toJSON(ok)) +type(toJSON(str)) +type(toJSON(true)) +type(toPairs($env)) +type(trimPrefix(str)) +type(trimSuffix(str)) type(true != nil) +type(true && $env) type(true == false) -type(true == nil) -type(true ? array : false) -type(true ? array : half) -type(true ? div : add) -type(true ? f64 : i32) -type(true ? ok : 1) -type(true and false) -type(true and true) -type(true or true) -type(true || ok) +type(true == ok) +type(true ? $env : add) +type(true or false) +type(true or ok) +type(true || false) type(true || true) -type(true) in foo -type(true) matches string(list) -type(type(0.5)) +type(true) <= str +type(true) | greet() +type(type($env)) +type(type(0)) type(type(1)) +type(type(1.0)) type(type(add)) -type(type(div)) +type(type(array)) +type(type(f64)) +type(type(false)) type(type(foo)) type(type(greet)) -type(type(half)) type(type(i)) -type(type(i32)) -type(type(i64)) -type(type(nil)) -type(type(ok)) +type(type(list)) +type(type(str)) type(type(true)) -type(upper("foo")) -type({"bar": 1}) -type({"bar": array}) -type({"foo": "foo"}) -type({"foo": f64}) -type({"foo": false, "foo": foo}.Bar) -upper("bar") not in foo -upper("foo" + "foo") -upper("foo") == toJSON("bar") +type(uniq(array)) +type(uniq(list)) +type(upper(str)) +type(values($env)) +type({foo: $env}) +type({foo: 0, foo: 1.0}) +type({foo: 0, foo: false}) +type({foo: 0, foo: foo}) +type({foo: 0, foo: i}) +type({foo: 0}) +type({foo: 0}.greet) +type({foo: 1, foo: str}) +type({foo: 1.0, foo: greet, foo: ok}) +type({foo: 1.0}) +type({foo: 1}) +type({foo: add}) +type({foo: array, foo: array | reduce(#, i)}) +type({foo: array, foo: foo}) +type({foo: array}) +type({foo: f64, foo: add}) +type({foo: f64}) +type({foo: false, foo: foo}) +type({foo: false}) +type({foo: foo, foo: 1}) +type({foo: foo, foo: foo}) +type({foo: foo, foo: i}) +type({foo: foo}) +type({foo: i, foo: ok}) +type({foo: i}) +type({foo: list}) +type({foo: nil}) +type({foo: ok, foo: 0}) +type({foo: ok}) +type({foo: str}) +type({foo: true}) +uniq($env | filter(false)) +uniq($env | map(#index)) +uniq($env | map(0)) +uniq($env | map(1.0)) +uniq($env | map(f64)) +uniq($env | map(ok)) +uniq($env | map(str)) +uniq($env.array) +uniq($env.list) +uniq($env?.array) +uniq($env?.list) +uniq($env?.list[i:]) +uniq(0 .. 0) +uniq(0 .. i) +uniq(1 .. 0) +uniq([$env]) +uniq([0]) +uniq([1.0, ok]) +uniq([1.0]) +uniq([1]) +uniq([add, 1.0]) +uniq([add]) +uniq([array, true]) +uniq([array]) +uniq([f64]) +uniq([false, str]) +uniq([false, true]) +uniq([false]) +uniq([foo, foo]) +uniq([foo]) +uniq([i]) +uniq([list]) +uniq([nil]) +uniq([ok]) +uniq([str, 1.0]) +uniq([str, true]) +uniq([str]) +uniq([true]) +uniq(array | filter(ok)) +uniq(array | map(#)) +uniq(array | sortBy(1)) +uniq(array) +uniq(array) == array +uniq(array) | count(false) +uniq(array) | groupBy(1) +uniq(array) | groupBy(1.0) +uniq(array) | groupBy(ok) +uniq(array) | map(1) +uniq(array) | map(true) +uniq(array) | min(i) +uniq(array) | reduce(1.0) +uniq(array) | reduce(false) +uniq(array) | reduce(greet) +uniq(array) | reduce(i) +uniq(array) | sortBy(#) +uniq(array) | sortBy(1) +uniq(array); str +uniq(array)?.[i] +uniq(array)[:i] +uniq(array)[i:] +uniq(array[1:i]) +uniq(array[:1]) +uniq(concat(list)) +uniq(false ? 0 : array) +uniq(filter(array, true)) +uniq(filter(list, false)) +uniq(flatten(array)) +uniq(keys($env)) +uniq(list | map(1.0)) +uniq(list | map(add)) +uniq(list | sortBy(#.Bar)) +uniq(list | sortBy(1.0)) +uniq(list) +uniq(list) != array +uniq(list) | all(false) +uniq(list) | all(true) +uniq(list) | findIndex(false) +uniq(list) | groupBy(ok) +uniq(list) | map(#) +uniq(list) | map(.String) +uniq(list) | map(greet) +uniq(list) | reduce(ok) +uniq(list) | reduce(true, 1.0) +uniq(list) | sortBy(0) +uniq(list)?.[i] +uniq(list)[$env.i:] +uniq(list[i:]) +uniq(map($env, array)) +uniq(map($env, list)) +uniq(map($env, ok)) +uniq(map($env, str)) +uniq(map($env, true)) +uniq(map(array, #)) +uniq(map(array, 1.0)) +uniq(map(array, greet)) +uniq(map(array, ok)) +uniq(map(list, #)) +uniq(reverse(array)) +uniq(reverse(list)) +uniq(sort($env)) +uniq(sort(array)) +uniq(sortBy(array, #)) +uniq(sortBy(array, 0)) +uniq(sortBy(list, 1.0)) +uniq(toPairs($env)) +uniq(uniq(array)) +uniq(values($env)) +upper($env | reduce(str, nil)) +upper($env.str) +upper($env?.[str]) +upper($env?.str) +upper(array | reduce(str, list)) upper(foo.Bar) upper(foo.String()) upper(foo?.Bar) upper(foo?.String()) -upper(greet("bar")) -upper(greet("foo")) -upper(last(list).Bar) -upper(lower("bar")) -upper(lower("foo")) -upper(reduce(list, #)?.Bar) -upper(string("foo")) -upper(string(0.5)) +upper(greet(str)) +upper(list | reduce(#.Bar)) +upper(lower(str)) +upper(str) +upper(str) in foo +upper(str) matches str +upper(str) not endsWith str +upper(str) not in foo +upper(str[1:]) +upper(str[:0]) +upper(string($env)) +upper(string(0)) upper(string(1)) upper(string(add)) upper(string(array)) -upper(string(f32)) -upper(string(i32)) -upper(string(i64)) +upper(string(f64)) +upper(string(foo)) +upper(string(foo.Bar)) +upper(string(i)) upper(string(list)) upper(string(nil)) -upper(string(score)) +upper(string(ok)) +upper(string(str)) upper(string(true)) -upper(toBase64("bar")) -upper(toBase64("foo")) -upper(toJSON("foo")) -upper(toJSON(1)) -upper(toJSON(f32)) +upper(toBase64(str)) +upper(toJSON(1.0)) +upper(toJSON(array)) +upper(toJSON(f64)) upper(toJSON(false)) upper(toJSON(foo)) upper(toJSON(i)) -upper(toJSON(i32)) upper(toJSON(list)) upper(toJSON(nil)) +upper(toJSON(ok)) +upper(toJSON(str)) upper(toJSON(true)) -upper(trim("bar")) -upper(trim("foo")) -upper(trimSuffix("bar")) -upper(trimSuffix("foo")) -upper(type("bar")) -upper(type("foo")) +upper(trim(str)) +upper(trimPrefix(str)) +upper(type(0)) +upper(type(1)) +upper(type(1.0)) +upper(type(add)) upper(type(array)) -upper(type(div)) -upper(type(f32)) -upper(type(foo.Bar)) +upper(type(f64)) +upper(type(false)) +upper(type(foo)) upper(type(greet)) -upper(type(i)) -upper(type(i32)) upper(type(list)) upper(type(nil)) upper(type(ok)) -upper(type(score)) +upper(type(str)) upper(type(true)) -upper(upper("foo")) -values(groupBy(array, "bar")) -values(groupBy(array, "foo")) -values(groupBy(array, #)) -values(groupBy(array, 0.5)) -values(groupBy(array, 1)) +upper(upper(str)) +values($env) | findIndex(true) +values($env) | findLast(ok) +values($env) | findLastIndex(ok) +values($env) | groupBy(f64) +values($env) | groupBy(foo) +values($env) | groupBy(str) +values($env) | map(add) +values($env) | map(f64) +values($env) | map(greet) +values($env) | one(true) +values($env) | reduce(#) +values($env) | reduce(#index) +values($env) | reduce(1) +values($env) | reduce(add, nil) +values($env) | reduce(array) +values($env) | reduce(foo, nil) +values($env) | reduce(i) +values($env) | sortBy(i) +values($env) | sum(1) +values($env)?.[i] +values(array | groupBy(#)) +values(array | groupBy(0)) +values(array | groupBy(1)) +values(array | groupBy(false)) +values(groupBy(array, 0)) values(groupBy(array, foo)) -values(groupBy(array, i)) -values(groupBy(list, #)) -values(groupBy(list, 1)) -values(groupBy(list, i)) -values(groupBy(list, i32)) -values(groupBy(list, true)) -values({"bar": "bar"}) -values({"bar": array}) -values({"foo": add, "bar": div}) -values({"foo": ok}) -{"bar": "bar" <= "foo"} -{"bar": "bar", "bar": half}.add -{"bar": "bar", "bar": i}.Qux -{"bar": "bar", "bar": i}.String -{"bar": "bar", "foo": 0.5}.i64 -{"bar": "bar", "foo": i64}?.Qux -{"bar": "bar", "foo": score}.f32 -{"bar": "bar"}.String?.foo -{"bar": "bar"}.array -{"bar": "bar"}.f64 -{"bar": "bar"}.greet -{"bar": "bar"}.list -{"bar": "bar"}.ok -{"bar": "bar"}?.Qux -{"bar": "bar"}?.array -{"bar": "bar"}?.half -{"bar": "bar"}?.list -{"bar": "foo", "bar": div}.half -{"bar": "foo", "foo": f32}.String -{"bar": "foo", "foo": i64}.ok?.f64 -{"bar": "foo", "foo": ok}?.i64 -{"bar": "foo"}.Bar -{"bar": "foo"}.f32 -{"bar": "foo"}.foo -{"bar": "foo"}.half -{"bar": "foo"}.i -{"bar": "foo"}.i64 -{"bar": "foo"}?.String -{"bar": "foo"}?.f32 -{"bar": "foo"}?.foo -{"bar": "foo"}?.greet -{"bar": "foo"}?.i -{"bar": "foo"}?.i32 -{"bar": "foo"}?.i?.String() -{"bar": "foo"}?.list -{"bar": "foo"}?.ok -{"bar": -0.5} -{"bar": -f32} -{"bar": -f64} -{"bar": -i32} -{"bar": 0.5 != nil} -{"bar": 0.5 * 1}.foo -{"bar": 0.5, "bar": 0.5}.half -{"bar": 0.5, "bar": add, "foo": i32}.list -{"bar": 0.5, "bar": i}?.add -{"bar": 0.5, "bar": list}?.div -{"bar": 0.5, "bar": nil, "bar": nil}.i32 -{"bar": 0.5, "bar": ok, "foo": 1}?.String -{"bar": 0.5, "bar": true}.score -{"bar": 0.5, "foo": 0.5}?.f32 -{"bar": 0.5, "foo": array}?.list -{"bar": 0.5, "foo": f32}.i32?.Bar -{"bar": 0.5, "foo": ok}?.array -{"bar": 0.5}.Qux -{"bar": 0.5}.String -{"bar": 0.5}.add -{"bar": 0.5}.array -{"bar": 0.5}.f32 -{"bar": 0.5}.f64 -{"bar": 0.5}.half -{"bar": 0.5}.i -{"bar": 0.5}.i32 -{"bar": 0.5}.i64 -{"bar": 0.5}.ok -{"bar": 0.5}?.Bar -{"bar": 0.5}?.Qux -{"bar": 0.5}?.String -{"bar": 0.5}?.div -{"bar": 0.5}?.foo -{"bar": 0.5}?.greet -{"bar": 0.5}?.half -{"bar": 0.5}?.i -{"bar": 0.5}?.i32 -{"bar": 0.5}?.i64 -{"bar": 0.5}?.list -{"bar": 0.5}?.score -{"bar": 1 * i} -{"bar": 1 ** 0.5} -{"bar": 1 / 0.5} -{"bar": 1 / f32} -{"bar": 1 ^ 1} -{"bar": 1, "bar": add, "foo": "bar"}?.add -{"bar": 1, "bar": add}.div -{"bar": 1, "bar": f32}?.Bar -{"bar": 1, "bar": f64, "foo": array}.ok -{"bar": 1, "foo": "bar"}.half -{"bar": 1, "foo": array, "bar": score}?.i -{"bar": 1, "foo": i}?.list -{"bar": 1, "foo": i}?.ok -{"bar": 1, "foo": ok}?.f32 -{"bar": 1, "foo": score}.f64 -{"bar": 1}.String -{"bar": 1}.add -{"bar": 1}.f32 -{"bar": 1}.foo -{"bar": 1}.greet -{"bar": 1}.half -{"bar": 1}.i -{"bar": 1}.i32 -{"bar": 1}.list -{"bar": 1}.score -{"bar": 1}?.Qux -{"bar": 1}?.add -{"bar": 1}?.div -{"bar": 1}?.f32 -{"bar": 1}?.f64 -{"bar": 1}?.i -{"bar": 1}?.i32 -{"bar": 1}?.i64 -{"bar": 1}?.list -{"bar": 1}?.ok -{"bar": add, "bar": half}.div -{"bar": add, "bar": i, "bar": ok}?.foo -{"bar": add, "bar": list} -{"bar": add, "bar": ok, "foo": 1}?.ok -{"bar": add, "foo": "foo"}?.f64 -{"bar": add} -{"bar": add}.Qux -{"bar": add}.String -{"bar": add}.add -{"bar": add}.array -{"bar": add}.div -{"bar": add}.half -{"bar": add}?.Qux -{"bar": add}?.String -{"bar": add}?.add -{"bar": add}?.array -{"bar": add}?.div -{"bar": add}?.f64 -{"bar": add}?.f64 != half -{"bar": add}?.half -{"bar": add}?.ok -{"bar": add}?.score?.div -{"bar": array, "bar": "bar"}?.i -{"bar": array, "bar": array}?.foo -{"bar": array, "bar": f32} -{"bar": array, "bar": nil}.i64 -{"bar": array, "foo": f32}?.String -{"bar": array, "foo": f64} -{"bar": array, "foo": half}?.add -{"bar": array, "foo": i32} -{"bar": array, "foo": score} -{"bar": array} -{"bar": array}.Bar -{"bar": array}.div -{"bar": array}.div?.Qux -{"bar": array}.greet -{"bar": array}.i -{"bar": array}.i64 -{"bar": array}.list -{"bar": array}.score -{"bar": array}?.add?.ok -{"bar": array}?.div -{"bar": array}?.f64 -{"bar": array}?.greet -{"bar": array}?.half -{"bar": array}?.i64 -{"bar": array}?.ok -{"bar": div, "bar": array, "bar": 0.5}.i64 -{"bar": div, "bar": div}?.f32 -{"bar": div, "bar": foo}.foo -{"bar": div, "bar": ok} -{"bar": div, "foo": 1, "bar": ok}.Qux -{"bar": div, "foo": false}?.String -{"bar": div, "foo": foo, "foo": score}.Bar -{"bar": div, "foo": greet}.i -{"bar": div, "foo": greet}?.ok -{"bar": div, "foo": score} -{"bar": div} -{"bar": div}.array -{"bar": div}.f32 -{"bar": div}.f64 -{"bar": div}.i64?.Qux -{"bar": div}.list -{"bar": div}.ok -{"bar": div}?.Bar -{"bar": div}?.array -{"bar": div}?.f64 -{"bar": div}?.greet -{"bar": div}?.half -{"bar": div}?.list -{"bar": div}?.ok -{"bar": div}?.score -{"bar": f32 ** i} -{"bar": f32 - 0.5} -{"bar": f32 >= 0.5} -{"bar": f32 ^ 1} -{"bar": f32, "bar": "foo"}.add -{"bar": f32, "bar": false}?.Bar -{"bar": f32, "bar": true}?.String -{"bar": f32, "foo": add, "foo": false}?.String -{"bar": f32, "foo": f32}.ok -{"bar": f32, "foo": f64} -{"bar": f32, "foo": half, "foo": ok} -{"bar": f32, "foo": half} -{"bar": f32, "foo": list}?.f32 -{"bar": f32, "foo": nil}?.f64?.foo -{"bar": f32} -{"bar": f32}.Qux -{"bar": f32}.div -{"bar": f32}.f64 -{"bar": f32}.greet -{"bar": f32}.i -{"bar": f32}.i32 -{"bar": f32}.i64 -{"bar": f32}?.Bar -{"bar": f32}?.String -{"bar": f32}?.array -{"bar": f32}?.f64 -{"bar": f32}?.half -{"bar": f32}?.list -{"bar": f64 + 1} -{"bar": f64 == i32} -{"bar": f64 > 0.5} -{"bar": f64 ^ i32} -{"bar": f64, "bar": "bar"}.i -{"bar": f64, "bar": foo}?.i -{"bar": f64, "bar": i64}?.i64 -{"bar": f64, "bar": i}.f64 -{"bar": f64, "bar": true}?.i -{"bar": f64, "foo": 0.5, "foo": score}.ok -{"bar": f64, "foo": 1}.f32 -{"bar": f64, "foo": f64}?.score -{"bar": f64, "foo": i}?.Qux?.f64 -{"bar": f64} -{"bar": f64}.array -{"bar": f64}.f32?.Bar -{"bar": f64}.f64 -{"bar": f64}.foo -{"bar": f64}.i -{"bar": f64}.i32 -{"bar": f64}.ok -{"bar": f64}?.Bar -{"bar": f64}?.Bar?.Qux -{"bar": f64}?.add -{"bar": f64}?.div -{"bar": f64}?.f32 -{"bar": f64}?.foo -{"bar": f64}?.i -{"bar": f64}?.i64 -{"bar": f64}?.list -{"bar": f64}?.ok -{"bar": false, "bar": array}?.list -{"bar": false, "bar": i32}?.div -{"bar": false, "bar": i}?.i64 -{"bar": false, "bar": nil}.ok -{"bar": false}.Bar -{"bar": false}.Qux -{"bar": false}.array -{"bar": false}.f32 -{"bar": false}.f64 -{"bar": false}.half -{"bar": false}.i -{"bar": false}.i32 -{"bar": false}.ok -{"bar": false}.score -{"bar": false}?.Bar -{"bar": false}?.array -{"bar": false}?.div -{"bar": false}?.foo -{"bar": false}?.half -{"bar": false}?.i -{"bar": false}?.list -{"bar": false}?.ok -{"bar": filter(list, ok)} -{"bar": float(0.5)} -{"bar": floor(0.5)}.score -{"bar": floor(i32)} -{"bar": foo != nil, "foo": array} -{"bar": foo, "bar": "foo", "bar": score}?.score -{"bar": foo, "bar": 1, "bar": score}?.ok -{"bar": foo, "bar": greet} -{"bar": foo, "bar": i}?.i -{"bar": foo, "bar": score}?.ok -{"bar": foo, "foo": 0.5, "foo": ok}?.half -{"bar": foo, "foo": 0.5}.score -{"bar": foo, "foo": 1, "foo": i}?.add -{"bar": foo, "foo": f64} -{"bar": foo, "foo": f64}.Bar -{"bar": foo.Bar} -{"bar": foo.String()} -{"bar": foo?.Qux, "bar": f32} -{"bar": foo?.String} -{"bar": foo} -{"bar": foo}.Bar -{"bar": foo}.array -{"bar": foo}.f32 -{"bar": foo}.half -{"bar": foo}.i -{"bar": foo}.list -{"bar": foo}.ok -{"bar": foo}?.Bar -{"bar": foo}?.add -{"bar": foo}?.greet -{"bar": foo}?.i -{"bar": foo}?.i32 -{"bar": foo}?.i64 -{"bar": foo}?.list -{"bar": foo}?.ok -{"bar": foo}?.score -{"bar": get(list, i32)} -{"bar": greet("foo")} -{"bar": greet, "bar": 0.5}.i32 -{"bar": greet, "bar": 1}.Bar -{"bar": greet, "bar": f32}.Bar -{"bar": greet, "bar": i32} -{"bar": greet, "bar": not ok} -{"bar": greet, "foo": "bar"}.ok -{"bar": greet, "foo": f64} -{"bar": greet, "foo": false, "bar": ok}.i32 -{"bar": greet, "foo": i32} -{"bar": greet} -{"bar": greet}.Bar -{"bar": greet}.array -{"bar": greet}.f32 -{"bar": greet}.greet -{"bar": greet}.half -{"bar": greet}.list -{"bar": greet}?.Qux -{"bar": greet}?.div -{"bar": greet}?.f32 -{"bar": greet}?.f64 -{"bar": greet}?.greet -{"bar": greet}?.half -{"bar": greet}?.i32 -{"bar": greet}?.ok -{"bar": greet}?.score -{"bar": groupBy(array, f32)} -{"bar": half == nil} -{"bar": half(f64)} -{"bar": half, "bar": add, "bar": f64}?.i32 -{"bar": half, "bar": foo} -{"bar": half, "bar": list} -{"bar": half, "bar": score} -{"bar": half, "foo": 1}?.i64 -{"bar": half, "foo": list} -{"bar": half, "foo": ok, "bar": i} -{"bar": half, "foo": ok}.Qux -{"bar": half, "foo": true}?.String -{"bar": half} -{"bar": half}.Bar?.i -{"bar": half}.Qux -{"bar": half}.String -{"bar": half}.div?.i -{"bar": half}.f32 -{"bar": half}.foo -{"bar": half}.half -{"bar": half}.i32 -{"bar": half}.list -{"bar": half}.list?.String() -{"bar": half}?.Bar -{"bar": half}?.String -{"bar": half}?.array -{"bar": half}?.f32 -{"bar": half}?.greet -{"bar": half}?.i32 -{"bar": half}?.list -{"bar": i % i32} -{"bar": i ** f64} -{"bar": i < 1}?.half -{"bar": i, "bar": 1}.add -{"bar": i, "bar": 1}?.i64 -{"bar": i, "bar": array}?.half -{"bar": i, "bar": div}.ok -{"bar": i, "bar": f64, "bar": "foo"}?.foo -{"bar": i, "bar": f64, "bar": nil}.i32 -{"bar": i, "bar": score} -{"bar": i, "foo": half} -{"bar": i, "foo": i32}?.score -{"bar": i, "foo": nil}?.String -{"bar": i32 ^ 0.5} -{"bar": i32 ^ f64} -{"bar": i32, "bar": list} -{"bar": i32, "foo": "bar"}.i64 -{"bar": i32, "foo": array}.div -{"bar": i32, "foo": f64, "foo": add}.f64 -{"bar": i32, "foo": foo}?.add -{"bar": i32, "foo": ok}.ok -{"bar": i32} -{"bar": i32}.Qux -{"bar": i32}.f64 -{"bar": i32}.i -{"bar": i32}.i32 -{"bar": i32}.list -{"bar": i32}.ok -{"bar": i32}.score -{"bar": i32}?.Qux -{"bar": i32}?.add -{"bar": i32}?.array -{"bar": i32}?.div -{"bar": i32}?.f32 -{"bar": i32}?.i32 -{"bar": i32}?.list -{"bar": i32}?.ok -{"bar": i64 + 1} -{"bar": i64 <= 0.5} -{"bar": i64 == 0.5} -{"bar": i64 in array} -{"bar": i64, "bar": !ok} -{"bar": i64, "bar": 0.5}.f32 -{"bar": i64, "bar": greet}.array -{"bar": i64, "bar": score}.ok -{"bar": i64, "foo": nil}?.i32 -{"bar": i64, "foo": ok} -{"bar": i64, "foo": ok}?.f32 -{"bar": i64} -{"bar": i64}.array?.Bar -{"bar": i64}.div -{"bar": i64}.f32 -{"bar": i64}.f64 -{"bar": i64}.i -{"bar": i64}.list -{"bar": i64}.ok -{"bar": i64}.score -{"bar": i64}?.div -{"bar": i64}?.f32 -{"bar": i64}?.f64 -{"bar": i64}?.half -{"bar": i64}?.i -{"bar": i64}?.i32 -{"bar": i64}?.i?.ok -{"bar": i64}?.list -{"bar": int(f64)} -{"bar": i} -{"bar": i}.add -{"bar": i}.array -{"bar": i}.div?.Qux.div -{"bar": i}.f64 -{"bar": i}.half -{"bar": i}.i -{"bar": i}.i64 -{"bar": i}.list -{"bar": i}?.String -{"bar": i}?.array -{"bar": i}?.f64 -{"bar": i}?.foo -{"bar": i}?.greet -{"bar": i}?.i -{"bar": i}?.i32 -{"bar": i}?.i64 -{"bar": i}?.score -{"bar": list == nil} -{"bar": list, "bar": half}?.Bar -{"bar": list, "bar": score} -{"bar": list, "foo": "foo"}.String -{"bar": list, "foo": 1, "foo": nil}.score -{"bar": list, "foo": 1, "foo": score}?.array -{"bar": list, "foo": array}?.i64 -{"bar": list, "foo": f64}.div?.Qux -{"bar": list, "foo": f64}.list -{"bar": list, "foo": half}?.f32 -{"bar": list, "foo": i64}?.array -{"bar": list, "foo": nil}.i64 -{"bar": list[i32:i32]} -{"bar": list} -{"bar": list}.String -{"bar": list}.add -{"bar": list}.array -{"bar": list}.array?.i64 -{"bar": list}.f64 -{"bar": list}.greet -{"bar": list}.i -{"bar": list}.list -{"bar": list}?.Bar -{"bar": list}?.Qux -{"bar": list}?.add -{"bar": list}?.div -{"bar": list}?.f64 -{"bar": list}?.i64 -{"bar": list}?.score -{"bar": lower("bar")} -{"bar": map(array, #)} -{"bar": map(array, i)} -{"bar": map(list, #)} -{"bar": nil != "bar"} -{"bar": nil != nil} -{"bar": nil == 0.5} -{"bar": nil == nil} -{"bar": nil, "bar": "bar"}?.i32 -{"bar": nil, "bar": add, "bar": i}.add -{"bar": nil, "bar": foo}?.list -{"bar": nil, "foo": "foo"}.f64 -{"bar": nil, "foo": 1, "foo": add}.ok -{"bar": nil, "foo": foo}?.add -{"bar": nil, "foo": i}?.f64 -{"bar": nil, "foo": list}?.f32 -{"bar": nil}.Bar -{"bar": nil}.add -{"bar": nil}.div -{"bar": nil}.f32 -{"bar": nil}.foo -{"bar": nil}.greet -{"bar": nil}.half -{"bar": nil}.i -{"bar": nil}.i32 -{"bar": nil}.i32?.greet -{"bar": nil}.i64 -{"bar": nil}.i?.f64 -{"bar": nil}.list -{"bar": nil}.ok -{"bar": nil}?.Qux -{"bar": nil}?.String -{"bar": nil}?.add -{"bar": nil}?.div -{"bar": nil}?.f32 -{"bar": nil}?.f64 -{"bar": nil}?.half -{"bar": nil}?.i -{"bar": nil}?.i32 -{"bar": nil}?.list -{"bar": nil}?.ok -{"bar": none(list, ok)} -{"bar": not true} -{"bar": ok ? "bar" : i} -{"bar": ok ? i32 : "foo"} -{"bar": ok ? nil : greet} -{"bar": ok, "bar": 1, "foo": f64}.half -{"bar": ok, "bar": array} -{"bar": ok, "bar": i64, "foo": 1}?.Qux -{"bar": ok, "bar": i} -{"bar": ok, "bar": list}?.div -{"bar": ok, "bar": ok}.f32 -{"bar": ok, "foo": 0.5}?.score -{"bar": ok, "foo": 1}.i -{"bar": ok, "foo": greet} -{"bar": ok, "foo": half} -{"bar": ok, "foo": list} -{"bar": ok, "foo": list}?.f64 -{"bar": ok, "foo": nil}?.i32 -{"bar": ok, "foo": ok}.div -{"bar": ok} -{"bar": ok}.Bar -{"bar": ok}.div -{"bar": ok}.f32 -{"bar": ok}.greet -{"bar": ok}.i32 -{"bar": ok}.i64 -{"bar": ok}.list -{"bar": ok}.ok -{"bar": ok}.score -{"bar": ok}?.Qux -{"bar": ok}?.add -{"bar": ok}?.f32 -{"bar": ok}?.i32 -{"bar": ok}?.i64 -{"bar": ok}?.list -{"bar": ok}?.score -{"bar": one(list, false)} -{"bar": reduce(array, i)}.i64 -{"bar": reduce(list, half)} -{"bar": score(i)} -{"bar": score, "bar": "bar", "bar": "foo"}?.f32 -{"bar": score, "bar": add}.String -{"bar": score, "bar": i64}.f32 -{"bar": score, "bar": nil}.i -{"bar": score, "foo": div} -{"bar": score, "foo": foo}.i -{"bar": score, "foo": half, "foo": i}?.array -{"bar": score, "foo": half} -{"bar": score, "foo": score}?.greet -{"bar": score} -{"bar": score}.add -{"bar": score}.array -{"bar": score}.div -{"bar": score}.f64 -{"bar": score}.foo -{"bar": score}.half -{"bar": score}.list -{"bar": score}?.String -{"bar": score}?.array -{"bar": score}?.f32 -{"bar": score}?.foo -{"bar": score}?.half -{"bar": score}?.i -{"bar": score}?.i32 -{"bar": score}?.list -{"bar": score}?.score -{"bar": string(0.5)} -{"bar": string(i64)} -{"bar": string(ok)} -{"bar": toJSON(list)} -{"bar": true == false} -{"bar": true, "bar": f64}?.score -{"bar": true, "bar": i32}.array -{"bar": true, "foo": nil}?.f32 -{"bar": true}.Bar -{"bar": true}.Qux -{"bar": true}.String -{"bar": true}.div -{"bar": true}.half -{"bar": true}.i32 -{"bar": true}?.Bar -{"bar": true}?.add -{"bar": true}?.array -{"bar": true}?.div -{"bar": true}?.half -{"bar": true}?.i32 -{"bar": true}?.i64 -{"bar": type(greet)}.Bar -{"bar": type(half)} -{"bar": type(score)} -{"foo": !ok} -{"foo": "bar" < "bar"} -{"foo": "bar" > "bar"} -{"foo": "bar", "bar": list}.div -{"foo": "bar", "bar": nil}.f64 -{"foo": "bar", "foo": 0.5}?.add -{"foo": "bar", "foo": 0.5}?.list -{"foo": "bar", "foo": array}?.f64?.list() -{"foo": "bar", "foo": list}.list -{"foo": "bar"}.Bar -{"foo": "bar"}.Qux -{"foo": "bar"}.String -{"foo": "bar"}.foo -{"foo": "bar"}.half -{"foo": "bar"}.i -{"foo": "bar"}.i64 -{"foo": "bar"}?.Bar -{"foo": "bar"}?.String -{"foo": "bar"}?.add -{"foo": "bar"}?.array -{"foo": "bar"}?.div -{"foo": "bar"}?.f32 -{"foo": "bar"}?.f64 -{"foo": "bar"}?.foo -{"foo": "bar"}?.half -{"foo": "bar"}?.i32 -{"foo": "bar"}?.score -{"foo": "foo" <= "foo"} -{"foo": "foo" endsWith "foo"} -{"foo": "foo", "bar": false}.greet -{"foo": "foo", "bar": half}?.String -{"foo": "foo", "bar": list, "bar": div}?.String -{"foo": "foo", "foo": add}?.f32 -{"foo": "foo"}.Qux -{"foo": "foo"}.div -{"foo": "foo"}.f32 -{"foo": "foo"}.i -{"foo": "foo"}.i32 -{"foo": "foo"}.list -{"foo": "foo"}?.div -{"foo": "foo"}?.f32 -{"foo": "foo"}?.foo -{"foo": "foo"}?.i -{"foo": "foo"}?.i32 -{"foo": "foo"}?.score -{"foo": -0.5} -{"foo": -1} -{"foo": -f64} -{"foo": -i64} -{"foo": 0.5 != 0.5} -{"foo": 0.5 ** f64} -{"foo": 0.5 < i64}.div -{"foo": 0.5 <= 0.5} -{"foo": 0.5, "bar": 0.5}.String -{"foo": 0.5, "bar": 0.5}.foo -{"foo": 0.5, "bar": 0.5}?.score -{"foo": 0.5, "bar": 1}?.div -{"foo": 0.5, "bar": i64}.i32 -{"foo": 0.5, "bar": list}?.i64 -{"foo": 0.5, "foo": 1}.Qux -{"foo": 0.5, "foo": array}.i64 -{"foo": 0.5, "foo": f64}.i -{"foo": 0.5, "foo": false, "bar": list}.add -{"foo": 0.5, "foo": greet}.i32 -{"foo": 0.5, "foo": score}.foo -{"foo": 0.5}.Qux?.half -{"foo": 0.5}.String -{"foo": 0.5}.add -{"foo": 0.5}.array -{"foo": 0.5}.div -{"foo": 0.5}.f32 -{"foo": 0.5}.half -{"foo": 0.5}.i64 -{"foo": 0.5}.list -{"foo": 0.5}.score -{"foo": 0.5}?.Bar -{"foo": 0.5}?.String -{"foo": 0.5}?.div -{"foo": 0.5}?.f32 -{"foo": 0.5}?.f64 -{"foo": 0.5}?.half -{"foo": 0.5}?.i -{"foo": 0.5}?.list -{"foo": 0.5}?.ok -{"foo": 1 / i64} -{"foo": 1 == f32} -{"foo": 1, "bar": nil}?.add -{"foo": 1, "bar": score}.greet -{"foo": 1, "foo": 1}.f64 -{"foo": 1, "foo": f64}.i -{"foo": 1, "foo": false}?.f32 -{"foo": 1, "foo": half}?.f32 -{"foo": 1, "foo": ok}.Bar -{"foo": 1, "foo": ok}.f32 -{"foo": 1, "foo": ok}.i32 -{"foo": 1, "foo": score}.half -{"foo": 1}.Bar -{"foo": 1}.add -{"foo": 1}.div -{"foo": 1}.f32 -{"foo": 1}.f64 -{"foo": 1}.foo -{"foo": 1}.greet -{"foo": 1}.half -{"foo": 1}.i -{"foo": 1}.i64 -{"foo": 1}.list -{"foo": 1}?.String -{"foo": 1}?.add -{"foo": 1}?.f64 -{"foo": 1}?.greet -{"foo": 1}?.half -{"foo": 1}?.list -{"foo": 1}?.ok -{"foo": abs(i64)} -{"foo": add, "bar": half} -{"foo": add, "bar": nil}.i -{"foo": add, "bar": nil}?.i -{"foo": add, "bar": ok, "foo": array}?.i32 -{"foo": add, "foo": 1, "bar": i32}.add -{"foo": add, "foo": array}?.f32 -{"foo": add, "foo": foo}?.i64 -{"foo": add, "foo": half} -{"foo": add, "foo": score, "bar": i32}.list -{"foo": add} -{"foo": add}.array -{"foo": add}.div -{"foo": add}.f32 -{"foo": add}.foo -{"foo": add}.half -{"foo": add}.i -{"foo": add}.i32 -{"foo": add}.i?.score -{"foo": add}.list -{"foo": add}?.Bar -{"foo": add}?.Qux -{"foo": add}?.String -{"foo": add}?.div -{"foo": add}?.f32 -{"foo": add}?.foo -{"foo": add}?.greet -{"foo": add}?.half -{"foo": add}?.i -{"foo": add}?.i64 -{"foo": add}?.score -{"foo": array, "bar": "bar"}.add -{"foo": array, "bar": 0.5}?.div -{"foo": array, "bar": add}.ok -{"foo": array, "bar": array}.f32 -{"foo": array, "bar": i64}?.add -{"foo": array, "bar": list} -{"foo": array, "bar": nil}.half -{"foo": array, "bar": ok, "bar": i} -{"foo": array, "foo": "foo"}.array -{"foo": array, "foo": array} -{"foo": array, "foo": f32, "foo": half}.ok -{"foo": array, "foo": f64} -{"foo": array, "foo": list} -{"foo": array} -{"foo": array}.Bar -{"foo": array}.Qux -{"foo": array}.f32 -{"foo": array}.foo -{"foo": array}.greet -{"foo": array}.i -{"foo": array}.i32 -{"foo": array}.i64 -{"foo": array}.score -{"foo": array}?.Qux -{"foo": array}?.add -{"foo": array}?.array -{"foo": array}?.greet -{"foo": array}?.i64?.add -{"foo": array}?.list -{"foo": array}?.ok -{"foo": div, "bar": "foo"}.array -{"foo": div, "bar": array} -{"foo": div, "bar": foo, "foo": true}?.i64 -{"foo": div, "bar": half} -{"foo": div, "bar": i64} -{"foo": div, "foo": array} -{"foo": div, "foo": f32} -{"foo": div, "foo": greet}?.i64 -{"foo": div} -{"foo": div}.Qux -{"foo": div}.array -{"foo": div}.div -{"foo": div}.f32 -{"foo": div}.greet?.i -{"foo": div}.i32 -{"foo": div}.i64 -{"foo": div}?.Bar -{"foo": div}?.Qux -{"foo": div}?.String -{"foo": div}?.div -{"foo": div}?.greet -{"foo": div}?.half -{"foo": div}?.i32 -{"foo": div}?.i64 -{"foo": div}?.list -{"foo": div}?.score -{"foo": f32 > 1} -{"foo": f32 >= 1} -{"foo": f32, "bar": 0.5}.list -{"foo": f32, "bar": div} -{"foo": f32, "bar": f32} -{"foo": f32, "bar": f64} -{"foo": f32, "bar": greet}.greet -{"foo": f32, "bar": half} -{"foo": f32, "bar": ok}?.add -{"foo": f32, "bar": score}?.i64 -{"foo": f32, "foo": "foo"}.ok -{"foo": f32, "foo": add}?.half?.f64() -{"foo": f32, "foo": foo}?.half -{"foo": f32} -{"foo": f32}.Qux -{"foo": f32}.add -{"foo": f32}.f32 -{"foo": f32}.foo -{"foo": f32}.greet -{"foo": f32}.half -{"foo": f32}.i -{"foo": f32}.i32 -{"foo": f32}.i64 -{"foo": f32}.list -{"foo": f32}.score?.greet -{"foo": f32}?.Bar -{"foo": f32}?.String -{"foo": f32}?.array -{"foo": f32}?.f64?.i -{"foo": f32}?.i -{"foo": f32}?.ok -{"foo": f64 < f64} -{"foo": f64 > f32} -{"foo": f64 >= 0.5} -{"foo": f64 >= f32} -{"foo": f64 in array} -{"foo": f64, "bar": 0.5}.greet -{"foo": f64, "bar": add, "foo": greet}.Bar -{"foo": f64, "bar": list}.i64 -{"foo": f64, "bar": sum(array)} -{"foo": f64, "bar": true}?.greet -{"foo": f64, "foo": list, "foo": i}?.add -{"foo": f64} -{"foo": f64}.Bar -{"foo": f64}.Qux -{"foo": f64}.div -{"foo": f64}.f32 -{"foo": f64}.f64 -{"foo": f64}.greet -{"foo": f64}.i32 -{"foo": f64}.list -{"foo": f64}.ok -{"foo": f64}?.String -{"foo": f64}?.f32 -{"foo": f64}?.f64 -{"foo": f64}?.foo -{"foo": f64}?.greet -{"foo": f64}?.i32 -{"foo": f64}?.i64 -{"foo": f64}?.ok -{"foo": f64}?.ok?.ok -{"foo": f64}?.score -{"foo": false or false}.array -{"foo": false, "bar": 0.5, "foo": add}.score -{"foo": false, "foo": foo, "bar": half}.array -{"foo": false, "foo": score, "foo": nil}?.div -{"foo": false, "foo": true}?.i32 -{"foo": false}.array -{"foo": false}.i -{"foo": false}.ok -{"foo": false}?.f32 -{"foo": false}?.f64 -{"foo": false}?.list -{"foo": foo == nil} -{"foo": foo, "bar": div} -{"foo": foo, "bar": foo} -{"foo": foo, "bar": ok}.i32 -{"foo": foo, "bar": {"foo": 1}} -{"foo": foo, "foo": add} -{"foo": foo, "foo": half} -{"foo": foo, "foo": i} -{"foo": foo, "foo": ok} -{"foo": foo, "foo": score, "foo": f64}.i -{"foo": foo.Bar} -{"foo": foo.String, "bar": foo} -{"foo": foo.String} -{"foo": foo?.Bar} -{"foo": foo?.Qux} -{"foo": foo?.String()} -{"foo": foo?.String} -{"foo": foo} -{"foo": foo}.Bar?.Bar -{"foo": foo}.Qux -{"foo": foo}.String -{"foo": foo}.String?.String -{"foo": foo}.f32 -{"foo": foo}.greet -{"foo": foo}.half -{"foo": foo}.i64 -{"foo": foo}?.Qux -{"foo": foo}?.add -{"foo": foo}?.array -{"foo": foo}?.array?.Bar -{"foo": foo}?.f64 -{"foo": foo}?.greet -{"foo": foo}?.i32 -{"foo": foo}?.list -{"foo": foo}?.ok -{"foo": greet("foo")} -{"foo": greet, "bar": "bar"}?.i32 -{"foo": greet, "bar": i64} -{"foo": greet, "bar": i}.list -{"foo": greet, "foo": add}.String -{"foo": greet, "foo": nil}?.add -{"foo": greet} -{"foo": greet}.Bar -{"foo": greet}.Qux -{"foo": greet}.String -{"foo": greet}.add -{"foo": greet}.array -{"foo": greet}.f32 -{"foo": greet}.i -{"foo": greet}.i32 -{"foo": greet}.i64 -{"foo": greet}.i64?.greet -{"foo": greet}.ok -{"foo": greet}.score -{"foo": greet}?.Qux -{"foo": greet}?.array -{"foo": greet}?.div -{"foo": greet}?.f32 -{"foo": greet}?.f64 -{"foo": greet}?.i32 -{"foo": greet}?.i64 -{"foo": greet}?.list -{"foo": greet}?.ok -{"foo": greet}?.score -{"foo": groupBy(array, 1)} -{"foo": groupBy(list, #)} -{"foo": half, "bar": "foo"}?.half -{"foo": half, "bar": add, "foo": true}?.array -{"foo": half, "bar": array}.half -{"foo": half, "bar": greet}?.half -{"foo": half, "bar": half}?.i -{"foo": half, "bar": list, "foo": 1}?.f64 -{"foo": half, "bar": list} -{"foo": half, "bar": true}?.Qux -{"foo": half, "foo": 1}?.i32 -{"foo": half, "foo": div, "foo": array}?.i32 -{"foo": half, "foo": f64} -{"foo": half, "foo": list, "foo": half}.half -{"foo": half, "foo": score, "foo": list}.String -{"foo": half} -{"foo": half}.Bar -{"foo": half}.String -{"foo": half}.add -{"foo": half}.div -{"foo": half}.f32 -{"foo": half}.foo -{"foo": half}.half -{"foo": half}.i -{"foo": half}.i64 -{"foo": half}.ok -{"foo": half}.score -{"foo": half}?.Bar -{"foo": half}?.Qux -{"foo": half}?.String -{"foo": half}?.div -{"foo": half}?.f32 -{"foo": half}?.foo -{"foo": half}?.i32 -{"foo": half}?.i64 -{"foo": half}?.score -{"foo": i != 1} -{"foo": i - f64} -{"foo": i / 1} -{"foo": i ^ 1} -{"foo": i, "bar": 0.5}?.half -{"foo": i, "bar": f32} -{"foo": i, "bar": foo} -{"foo": i, "bar": list}.foo -{"foo": i, "foo": "bar"}?.div?.f32 -{"foo": i, "foo": 1}.list -{"foo": i, "foo": 1}?.list -{"foo": i, "foo": add} -{"foo": i, "foo": array, "bar": 0.5}?.f32 -{"foo": i, "foo": half}?.list -{"foo": i, "foo": score} -{"foo": i, "foo": score}?.f32 -{"foo": i32 != i} -{"foo": i32 * 0.5} -{"foo": i32 + 1} -{"foo": i32 - f32}.foo -{"foo": i32 - f64} -{"foo": i32 / 1} -{"foo": i32 < 1} -{"foo": i32, "bar": 0.5, "bar": foo}.i64 -{"foo": i32, "bar": foo}?.score -{"foo": i32, "bar": nil}?.ok -{"foo": i32, "foo": false, "bar": f32}?.foo -{"foo": i32, "foo": greet}?.greet -{"foo": i32} -{"foo": i32}.i -{"foo": i32}.ok -{"foo": i32}?.Bar -{"foo": i32}?.String -{"foo": i32}?.add -{"foo": i32}?.f32 -{"foo": i32}?.f64 -{"foo": i32}?.i -{"foo": i32}?.i32 -{"foo": i32}?.i64 -{"foo": i32}?.list -{"foo": i32}?.score -{"foo": i64 % 1} -{"foo": i64 * f32} -{"foo": i64 .. i64} -{"foo": i64, "bar": array} -{"foo": i64, "foo": array}.f32 -{"foo": i64, "foo": f32} -{"foo": i64, "foo": i32}?.foo -{"foo": i64, "foo": i64, "bar": f64}.foo -{"foo": i64, "foo": i64} -{"foo": i64, "foo": i64}.greet -{"foo": i64, "foo": i64}?.foo -{"foo": i64} -{"foo": i64}.Bar -{"foo": i64}.array -{"foo": i64}.div -{"foo": i64}.foo -{"foo": i64}.greet -{"foo": i64}.half -{"foo": i64}.i -{"foo": i64}.i32 -{"foo": i64}.list -{"foo": i64}?.Qux -{"foo": i64}?.add -{"foo": i64}?.array -{"foo": i64}?.f32 -{"foo": i64}?.f64 -{"foo": i64}?.half -{"foo": i64}?.i32 -{"foo": i64}?.i32?.f32 -{"foo": i64}?.i64 -{"foo": i64}?.score?.list -{"foo": int(i)} -{"foo": int(i32)} -{"foo": int(i64)} -{"foo": i} -{"foo": i}.Bar -{"foo": i}.String -{"foo": i}.add -{"foo": i}.array -{"foo": i}.f64 -{"foo": i}.greet -{"foo": i}.i -{"foo": i}.ok -{"foo": i}?.div -{"foo": i}?.greet -{"foo": i}?.i -{"foo": i}?.i32 -{"foo": i}?.i64 -{"foo": i}?.score -{"foo": last(list)} -{"foo": len(list)} -{"foo": list, "bar": add} -{"foo": list, "bar": all(list, false)} -{"foo": list, "bar": array} -{"foo": list, "bar": f32}.f64 -{"foo": list, "bar": half} -{"foo": list, "bar": i32, "bar": score}.array -{"foo": list, "bar": true}?.foo -{"foo": list} -{"foo": list}.Qux -{"foo": list}.String -{"foo": list}.add -{"foo": list}.div -{"foo": list}.f32 -{"foo": list}.greet -{"foo": list}.half -{"foo": list}.i -{"foo": list}.i32 -{"foo": list}?.String -{"foo": list}?.div -{"foo": list}?.f32 -{"foo": list}?.foo -{"foo": list}?.i -{"foo": list}?.i32 -{"foo": list}?.i64 -{"foo": list}?.ok -{"foo": list}?.score -{"foo": map(array, #)} -{"foo": map(array, i64)} -{"foo": nil, "bar": 0.5}.ok -{"foo": nil, "bar": add, "bar": f32}?.list -{"foo": nil, "bar": div, "bar": 1}.i64 -{"foo": nil, "bar": f32}.score -{"foo": nil, "bar": foo}?.String -{"foo": nil, "bar": score}?.ok?.div -{"foo": nil, "foo": "foo"}.Bar -{"foo": nil, "foo": greet}.String -{"foo": nil, "foo": half}.f64 -{"foo": nil, "foo": i64, "bar": f64}?.list -{"foo": nil, "foo": i}.div -{"foo": nil, "foo": list}.add -{"foo": nil, "foo": list}?.array -{"foo": nil, "foo": nil}.ok -{"foo": nil}.array?.half() -{"foo": nil}.div -{"foo": nil}.f32 -{"foo": nil}.f64 -{"foo": nil}.half -{"foo": nil}.i -{"foo": nil}.i32 -{"foo": nil}.i64?.Bar() -{"foo": nil}.list -{"foo": nil}.ok -{"foo": nil}.score -{"foo": nil}?.Bar -{"foo": nil}?.Bar?.score -{"foo": nil}?.add -{"foo": nil}?.array -{"foo": nil}?.f64 -{"foo": nil}?.foo -{"foo": nil}?.half -{"foo": nil}?.i32 -{"foo": nil}?.i64 -{"foo": nil}?.list -{"foo": ok == false} -{"foo": ok, "bar": "foo"}?.i64 -{"foo": ok, "bar": add}.String -{"foo": ok, "bar": f32} -{"foo": ok, "foo": half}.ok -{"foo": ok, "foo": list} -{"foo": ok} -{"foo": ok}.Bar -{"foo": ok}.Bar?.i -{"foo": ok}.String -{"foo": ok}.array -{"foo": ok}.div -{"foo": ok}.f64 -{"foo": ok}.foo -{"foo": ok}.i32 -{"foo": ok}.i64 -{"foo": ok}.ok -{"foo": ok}?.Qux -{"foo": ok}?.String -{"foo": ok}?.String?.Bar -{"foo": ok}?.array -{"foo": ok}?.f32 -{"foo": ok}?.foo -{"foo": ok}?.greet -{"foo": ok}?.half -{"foo": ok}?.i32 -{"foo": ok}?.i64 -{"foo": ok}?.list -{"foo": reduce(array, "foo")} -{"foo": reduce(array, #)} -{"foo": reduce(list, #).String()} -{"foo": reduce(list, #)} -{"foo": reduce(list, #)}?.list -{"foo": score, "bar": add}.add -{"foo": score, "bar": div} -{"foo": score, "bar": f64} -{"foo": score, "bar": false}?.array -{"foo": score, "bar": false}?.i -{"foo": score, "bar": true}.div?.i -{"foo": score, "foo": 0.5}?.String -{"foo": score, "foo": 1}.array -{"foo": score, "foo": add} -{"foo": score, "foo": array}.array -{"foo": score, "foo": f32} -{"foo": score, "foo": greet} +values(groupBy(list, ok)) +values(if ok { $env } else { str }) +values(list | groupBy(false)) +values(max($env)) +values(min($env)) +values(ok ? $env : nil) +values(reduce(array, $env)) +values(reduce(list, $env)) +values({foo: $env}) +values({foo: $env}?.foo) +values({foo: 0, foo: 0}) +values({foo: 0}) +values({foo: 1, foo: 0}) +values({foo: 1.0}) +values({foo: 1}) +values({foo: array, foo: foo}) +values({foo: array}) +values({foo: f64}) +values({foo: false, foo: false}) +values({foo: false}) +values({foo: foo, foo: list}) +values({foo: foo}) +values({foo: greet, foo: 0}) +values({foo: greet, foo: foo}) +values({foo: greet}) +values({foo: i}) +values({foo: list}) +values({foo: nil, foo: ok}) +values({foo: nil}) +values({foo: ok, foo: $env}) +values({foo: ok, foo: 1.0}) +values({foo: ok, foo: list}) +values({foo: ok}) +values({foo: str}) +{foo: $env != $env} +{foo: $env != 0} +{foo: $env != 1.0} +{foo: $env != 1} +{foo: $env != add} +{foo: $env != f64, foo: foo} +{foo: $env != foo} +{foo: $env != greet} +{foo: $env != greet}.Bar +{foo: $env != list} +{foo: $env != nil} +{foo: $env != ok} +{foo: $env != str} +{foo: $env == $env} +{foo: $env == 0} +{foo: $env == 0}.array +{foo: $env == 1.0} +{foo: $env == 1} +{foo: $env == add} +{foo: $env == false} +{foo: $env == foo} +{foo: $env == foo}.i +{foo: $env == greet} +{foo: $env == i} +{foo: $env == nil} +{foo: $env == ok} +{foo: $env == str} +{foo: $env == true} +{foo: $env and false} +{foo: $env and true} +{foo: $env in array} +{foo: $env in list} +{foo: $env or false} +{foo: $env or true} +{foo: $env | any(ok)} +{foo: $env | any(true)} +{foo: $env | map(#index)} +{foo: $env | map($env)} +{foo: $env | map(0)} +{foo: $env | map(add), foo: i} +{foo: $env | map(f64)} +{foo: $env | map(foo)} +{foo: $env | map(list)} +{foo: $env | none(false)} +{foo: $env | none(true)} +{foo: $env | one(true)} +{foo: $env | reduce($env, foo)}?.f64 +{foo: $env | reduce(1, $env)} +{foo: $env | reduce(foo, 1.0)} +{foo: $env | sum(0)} +{foo: $env | sum(1.0)} +{foo: $env || true} +{foo: $env, foo: $env, foo: true}?.add +{foo: $env, foo: $env}.Bar +{foo: $env, foo: $env}.add +{foo: $env, foo: $env}.f64 +{foo: $env, foo: $env}.greet +{foo: $env, foo: $env}.i?.[ok] +{foo: $env, foo: $env}?.String +{foo: $env, foo: $env}?.array +{foo: $env, foo: $env}?.foobar +{foo: $env, foo: $env}?.ok +{foo: $env, foo: 0}.Bar +{foo: $env, foo: 0}.add +{foo: $env, foo: 0}.greet +{foo: $env, foo: 0}.ok +{foo: $env, foo: 0}?.Bar +{foo: $env, foo: 0}?.false?.ok +{foo: $env, foo: 0}?.list +{foo: $env, foo: 1.0, foo: foo}.ok +{foo: $env, foo: 1.0}.String +{foo: $env, foo: 1.0}.add +{foo: $env, foo: 1.0}.greet +{foo: $env, foo: 1.0}.list +{foo: $env, foo: 1.0}?.array +{foo: $env, foo: 1.0}?.foo +{foo: $env, foo: 1.0}?.i +{foo: $env, foo: 1.0}?.ok +{foo: $env, foo: 1.0}?.str +{foo: $env, foo: 1}.String +{foo: $env, foo: 1}.f64 +{foo: $env, foo: 1}.ok +{foo: $env, foo: 1}?.[str] +{foo: $env, foo: 1}?.f64 +{foo: $env, foo: 1}?.greet +{foo: $env, foo: 1}?.i +{foo: $env, foo: add}.foo?.list +{foo: $env, foo: add}.i +{foo: $env, foo: add}.list +{foo: $env, foo: add}.str +{foo: $env, foo: add}?.add +{foo: $env, foo: add}?.foo +{foo: $env, foo: add}?.ok +{foo: $env, foo: array}.array +{foo: $env, foo: array}.foo +{foo: $env, foo: array}.greet +{foo: $env, foo: array}.i +{foo: $env, foo: array}.list +{foo: $env, foo: array}?.f64 +{foo: $env, foo: array}?.foo +{foo: $env, foo: array}?.greet +{foo: $env, foo: array}?.str +{foo: $env, foo: f64}.String +{foo: $env, foo: f64}.String?.array +{foo: $env, foo: f64}?.foo +{foo: $env, foo: f64}?.i +{foo: $env, foo: false, foo: foo}?.str +{foo: $env, foo: false}.add +{foo: $env, foo: false}.array +{foo: $env, foo: false}.str +{foo: $env, foo: false}?.[str] +{foo: $env, foo: false}?.array +{foo: $env, foo: foo, foo: $env}?.greet +{foo: $env, foo: foo, foo: list}.String +{foo: $env, foo: foo}.String +{foo: $env, foo: foo}.array +{foo: $env, foo: foo}.foobar +{foo: $env, foo: foo}.greet +{foo: $env, foo: foo}.i +{foo: $env, foo: foo}.list +{foo: $env, foo: foo}.str +{foo: $env, foo: foo}?.Bar +{foo: $env, foo: foo}?.String +{foo: $env, foo: foo}?.array +{foo: $env, foo: foo}?.ok +{foo: $env, foo: greet, foo: 0}.greet +{foo: $env, foo: greet}.add +{foo: $env, foo: greet}.foo +{foo: $env, foo: greet}?.Bar +{foo: $env, foo: greet}?.add +{foo: $env, foo: greet}?.f64 +{foo: $env, foo: i}.greet +{foo: $env, foo: i}?.add +{foo: $env, foo: i}?.foo +{foo: $env, foo: list, foo: 1}?.[str] +{foo: $env, foo: list}.Bar +{foo: $env, foo: list}.array +{foo: $env, foo: list}.greet +{foo: $env, foo: list}?.Bar?.greet +{foo: $env, foo: list}?.[str] +{foo: $env, foo: list}?.list +{foo: $env, foo: nil}.Bar +{foo: $env, foo: nil}.foo +{foo: $env, foo: nil}.foobar?.i +{foo: $env, foo: nil}.greet +{foo: $env, foo: nil}.str +{foo: $env, foo: nil}?.add +{foo: $env, foo: nil}?.f64 +{foo: $env, foo: nil}?.foobar +{foo: $env, foo: nil}?.list +{foo: $env, foo: nil}?.str +{foo: $env, foo: ok}.array +{foo: $env, foo: ok}.f64 +{foo: $env, foo: str, foo: f64}?.i +{foo: $env, foo: str}.array +{foo: $env, foo: str}?.Bar +{foo: $env, foo: str}?.greet +{foo: $env, foo: true, foo: 1.0}?.list +{foo: $env, foo: true}.foobar +{foo: $env, foo: true}.list +{foo: $env, foo: true}.str?.list +{foo: $env, foo: true}?.[str] +{foo: $env, foo: true}?.greet +{foo: $env, foo: true}?.ok +{foo: $env.add, foo: $env.ok} +{foo: $env.add} +{foo: $env.add}.String +{foo: $env.add}.array +{foo: $env.array, foo: add} +{foo: $env.array, foo: {foo: array}} +{foo: $env.array} +{foo: $env.f64, foo: str} +{foo: $env.f64} +{foo: $env.f64}?.add +{foo: $env.f64}?.array +{foo: $env.foo, foo: f64}?.list +{foo: $env.foo} +{foo: $env.foo}?.String +{foo: $env.greet, foo: array} +{foo: $env.greet, foo: i} +{foo: $env.greet} +{foo: $env.i, foo: add} +{foo: $env.i, foo: array} +{foo: $env.i, foo: ok != $env} +{foo: $env.i} +{foo: $env.list, foo: 1.0 == 1.0} +{foo: $env.list} +{foo: $env.ok, foo: add} +{foo: $env.ok} +{foo: $env.ok}?.str +{foo: $env.str} +{foo: $env.str}.ok +{foo: $env?.$env} +{foo: $env?.Bar, foo: if false { foo } else { 0 }} +{foo: $env?.Bar, foo: ok} +{foo: $env?.Bar?.Bar} +{foo: $env?.Bar?.[greet]} +{foo: $env?.Bar?.list} +{foo: $env?.Bar} +{foo: $env?.Bar}.Bar +{foo: $env?.Bar}?.list +{foo: $env?.String} +{foo: $env?.[Bar], foo: i} +{foo: $env?.[Bar], foo: str} +{foo: $env?.[Bar]?.Bar} +{foo: $env?.[Bar]?.[add]} +{foo: $env?.[Bar]} +{foo: $env?.[Bar]}?.greet +{foo: $env?.[Bar]}?.ok +{foo: $env?.[String], foo: ok} +{foo: $env?.[String]?.array} +{foo: $env?.[String]} +{foo: $env?.[String]}.f64 +{foo: $env?.[foobar]?.add} +{foo: $env?.[foobar]} +{foo: $env?.[nil]} +{foo: $env?.[str]} +{foo: $env?.[str]}?.add +{foo: $env?.add, foo: add} +{foo: $env?.add} +{foo: $env?.add}.greet +{foo: $env?.add}?.foo +{foo: $env?.array, foo: add} +{foo: $env?.array} +{foo: $env?.array}.ok +{foo: $env?.f64} +{foo: $env?.f64}?.greet +{foo: $env?.foo.String()} +{foo: $env?.foobar, foo: greet} +{foo: $env?.foobar} +{foo: $env?.foo} +{foo: $env?.foo}.str +{foo: $env?.greet} +{foo: $env?.greet}.foo +{foo: $env?.greet}?.add +{foo: $env?.i, foo: string(i)} +{foo: $env?.i, foo: str} +{foo: $env?.i} +{foo: $env?.i}?.f64 +{foo: $env?.i}?.greet +{foo: $env?.list, foo: [1.0]} +{foo: $env?.list} +{foo: $env?.list}.f64 +{foo: $env?.nil?.[add]} +{foo: $env?.nil?.[i]} +{foo: $env?.nil} +{foo: $env?.ok} +{foo: $env?.ok}.f64 +{foo: $env?.ok}?.foo +{foo: $env?.ok}?.list +{foo: $env?.str, foo: $env?.ok} +{foo: $env?.str, foo: array} +{foo: $env?.str} +{foo: $env?.str}.f64 +{foo: $env?.str}?.Bar +{foo: $env} == nil or false +{foo: $env}.Bar +{foo: $env}.Bar?.[str] +{foo: $env}.Bar?.add +{foo: $env}.String +{foo: $env}.add +{foo: $env}.add?.[array] +{foo: $env}.add?.[foo] +{foo: $env}.add?.[ok] +{foo: $env}.add?.array +{foo: $env}.add?.list +{foo: $env}.array +{foo: $env}.array?.i +{foo: $env}.array?.str +{foo: $env}.f64 +{foo: $env}.foo +{foo: $env}.foo?.i +{foo: $env}.foobar +{foo: $env}.greet +{foo: $env}.greet?.Bar +{foo: $env}.i +{foo: $env}.list +{foo: $env}.list?.greet +{foo: $env}.ok +{foo: $env}.ok?.[ok] +{foo: $env}.str +{foo: $env}.str?.Bar +{foo: $env}?.Bar +{foo: $env}?.Bar?.i +{foo: $env}?.String +{foo: $env}?.String?.[add] +{foo: $env}?.String?.str() +{foo: $env}?.[str] +{foo: $env}?.add +{foo: $env}?.array +{foo: $env}?.array?.[greet] +{foo: $env}?.f64 +{foo: $env}?.foo +{foo: $env}?.foo.Bar +{foo: $env}?.foo.ok +{foo: $env}?.foobar +{foo: $env}?.foobar?.greet(nil) +{foo: $env}?.greet +{foo: $env}?.greet?.list() +{foo: $env}?.greet?.ok +{foo: $env}?.i +{foo: $env}?.i?.[array] +{foo: $env}?.list +{foo: $env}?.list?.[foo] +{foo: $env}?.list?.greet?.[i] +{foo: $env}?.ok +{foo: $env}?.ok?.[str] +{foo: $env}?.str +{foo: $env}?.str?.[ok] +{foo: $env}?.str?.array +{foo: $env}?.str?.foo +{foo: 0 != $env.i} +{foo: 0 != $env} +{foo: 0 != 0} +{foo: 0 != f64} +{foo: 0 != nil} +{foo: 0 % i} +{foo: 0 * 0} +{foo: 0 * 1.0} +{foo: 0 * 1} +{foo: 0 * i} +{foo: 0 ** 1} +{foo: 0 ** i} +{foo: 0 + 1.0} +{foo: 0 + f64} +{foo: 0 - 1.0} +{foo: 0 - 1} +{foo: 0 - f64} +{foo: 0 .. 1} +{foo: 0 .. i} +{foo: 0 / 0} +{foo: 0 / 1.0} +{foo: 0 < 0, foo: i} +{foo: 0 < 1.0} +{foo: 0 < 1} +{foo: 0 < f64} +{foo: 0 <= 0} +{foo: 0 <= 1.0} +{foo: 0 == 0} +{foo: 0 == 1.0} +{foo: 0 == i} +{foo: 0 == nil} +{foo: 0 > 1.0} +{foo: 0 > 1} +{foo: 0 >= 1} +{foo: 0 ^ 0} +{foo: 0 ^ 1.0} +{foo: 0 ^ i} +{foo: 0 in array} +{foo: 0 | bitshl(i)} +{foo: 0, foo: $env, foo: 1.0}?.greet +{foo: 0, foo: $env}.String +{foo: 0, foo: $env}.foo +{foo: 0, foo: $env}.list +{foo: 0, foo: $env}.str +{foo: 0, foo: $env}?.add +{foo: 0, foo: $env}?.array +{foo: 0, foo: 0, foo: false}?.list +{foo: 0, foo: 0}.String +{foo: 0, foo: 0}.add +{foo: 0, foo: 0}?.f64 +{foo: 0, foo: 0}?.ok +{foo: 0, foo: 1.0}.Bar +{foo: 0, foo: 1.0}.array +{foo: 0, foo: 1.0}.ok +{foo: 0, foo: 1.0}?.f64 +{foo: 0, foo: 1.0}?.i +{foo: 0, foo: 1}.Bar +{foo: 0, foo: 1}.array +{foo: 0, foo: 1}.greet +{foo: 0, foo: 1}?.ok +{foo: 0, foo: add}.array +{foo: 0, foo: add}?.[str] +{foo: 0, foo: add}?.foobar +{foo: 0, foo: add}?.greet +{foo: 0, foo: array}.Bar +{foo: 0, foo: array}.array +{foo: 0, foo: array}?.foo +{foo: 0, foo: array}?.not +{foo: 0, foo: f64}.foo +{foo: 0, foo: f64}.greet +{foo: 0, foo: f64}?.foo +{foo: 0, foo: false, foo: 1}.add +{foo: 0, foo: false}?.f64 +{foo: 0, foo: false}?.foo +{foo: 0, foo: foo, foo: add}.array +{foo: 0, foo: foo, foo: false}?.greet +{foo: 0, foo: foo}.Bar +{foo: 0, foo: foo}.foobar +{foo: 0, foo: foo}?.array +{foo: 0, foo: foo}?.f64 +{foo: 0, foo: foo}?.ok +{foo: 0, foo: greet}.f64 +{foo: 0, foo: greet}.greet +{foo: 0, foo: greet}.ok +{foo: 0, foo: greet}?.add +{foo: 0, foo: greet}?.str +{foo: 0, foo: i}.add +{foo: 0, foo: i}.array +{foo: 0, foo: i}.f64 +{foo: 0, foo: list}?.[str] +{foo: 0, foo: nil}.Bar +{foo: 0, foo: nil}.String?.i() +{foo: 0, foo: nil}.array +{foo: 0, foo: nil}.greet +{foo: 0, foo: nil}.ok +{foo: 0, foo: ok}.f64 +{foo: 0, foo: ok}.ok +{foo: 0, foo: str}.Bar +{foo: 0, foo: str}?.foo +{foo: 0, foo: str}?.greet +{foo: 0, foo: str}?.ok +{foo: 0..i} +{foo: 0}.Bar +{foo: 0}.String +{foo: 0}.String?.[f64] +{foo: 0}.String?.ok() +{foo: 0}.add +{foo: 0}.array +{foo: 0}.f64 +{foo: 0}.foo +{foo: 0}.greet +{foo: 0}.greet?.[list] +{foo: 0}.i +{foo: 0}.list +{foo: 0}.list?.[foo].String +{foo: 0}.ok +{foo: 0}.ok?.[array] +{foo: 0}.ok?.f64 +{foo: 0}.ok?.foo?.[i] +{foo: 0}.str +{foo: 0}.str?.String +{foo: 0}?.Bar +{foo: 0}?.String +{foo: 0}?.[str] +{foo: 0}?.add +{foo: 0}?.array +{foo: 0}?.f64 +{foo: 0}?.foo +{foo: 0}?.foobar == foo +{foo: 0}?.greet +{foo: 0}?.i +{foo: 0}?.list +{foo: 0}?.ok +{foo: 0}?.ok?.[str] +{foo: 0}?.str +{foo: 0}?.str?.Bar +{foo: 0}?.str?.str +{foo: 1 != $env} +{foo: 1 != 1.0} +{foo: 1 != 1} +{foo: 1 != f64} +{foo: 1 != f64}.f64 +{foo: 1 != i} +{foo: 1 != nil} +{foo: 1 % 1} +{foo: 1 * 0} +{foo: 1 * 1.0} +{foo: 1 * 1} +{foo: 1 * f64} +{foo: 1 * i} +{foo: 1 ** 0} +{foo: 1 ** 1.0}.f64 +{foo: 1 ** 1.0}.i +{foo: 1 ** 1} +{foo: 1 + 0} +{foo: 1 + i} +{foo: 1 - 1.0} +{foo: 1 - f64} +{foo: 1 - i} +{foo: 1 .. i} +{foo: 1 / 1.0} +{foo: 1 / 1} +{foo: 1 / f64} +{foo: 1 < 1.0} +{foo: 1 < 1} +{foo: 1 < i} +{foo: 1 <= 1} +{foo: 1 == $env} +{foo: 1 == 0} +{foo: 1 == 1.0} +{foo: 1 == 1} +{foo: 1 == nil} +{foo: 1 > 0} +{foo: 1 > 1.0} +{foo: 1 > i} +{foo: 1 >= 1} +{foo: 1 >= f64} +{foo: 1 >= i} +{foo: 1 ^ 0} +{foo: 1 ^ 1.0} +{foo: 1 ^ f64} +{foo: 1 in array} +{foo: 1 not in $env?.array} +{foo: 1, foo: $env, foo: add}?.ok +{foo: 1, foo: $env}.String +{foo: 1, foo: $env}.array +{foo: 1, foo: $env}.greet +{foo: 1, foo: $env}.str +{foo: 1, foo: $env}?.greet +{foo: 1, foo: $env}?.str +{foo: 1, foo: 0, foo: add}?.array +{foo: 1, foo: 0}.add +{foo: 1, foo: 0}.foo +{foo: 1, foo: 0}.list +{foo: 1, foo: 1.0}.String +{foo: 1, foo: 1.0}?.Bar +{foo: 1, foo: 1.0}?.foobar +{foo: 1, foo: 1.0}?.greet +{foo: 1, foo: 1.0}?.str?.array() +{foo: 1, foo: 1}.f64 +{foo: 1, foo: 1}.greet +{foo: 1, foo: 1}?.f64 +{foo: 1, foo: add}.array +{foo: 1, foo: add}.greet +{foo: 1, foo: add}?.Bar +{foo: 1, foo: add}?.list +{foo: 1, foo: array}?.ok +{foo: 1, foo: f64}?.f64 +{foo: 1, foo: f64}?.i +{foo: 1, foo: false}.f64 +{foo: 1, foo: false}.foo +{foo: 1, foo: false}.foobar?.foo() +{foo: 1, foo: false}?.add +{foo: 1, foo: false}?.ok +{foo: 1, foo: foo, foo: $env}?.[str] +{foo: 1, foo: foo}.Bar +{foo: 1, foo: foo}.f64 +{foo: 1, foo: foo}.foo +{foo: 1, foo: foo}?.[str] +{foo: 1, foo: foo}?.foo +{foo: 1, foo: foo}?.foobar +{foo: 1, foo: foo}?.greet +{foo: 1, foo: foo}?.list +{foo: 1, foo: greet}.String +{foo: 1, foo: greet}.greet +{foo: 1, foo: greet}.i +{foo: 1, foo: greet}.ok?.String +{foo: 1, foo: greet}?.greet +{foo: 1, foo: i, foo: list}?.[str] +{foo: 1, foo: list}.f64 +{foo: 1, foo: list}?.Bar +{foo: 1, foo: list}?.add +{foo: 1, foo: nil, foo: greet}.foo +{foo: 1, foo: nil}.i +{foo: 1, foo: nil}.ok +{foo: 1, foo: nil}?.Bar +{foo: 1, foo: nil}?.String +{foo: 1, foo: nil}?.add +{foo: 1, foo: nil}?.list +{foo: 1, foo: nil}?.str +{foo: 1, foo: ok}.foo +{foo: 1, foo: ok}.list +{foo: 1, foo: ok}?.String +{foo: 1, foo: ok}?.[str] +{foo: 1, foo: ok}?.str +{foo: 1, foo: str, foo: 0}.i +{foo: 1, foo: str}.f64 +{foo: 1, foo: str}.list +{foo: 1, foo: str}?.str +{foo: 1, foo: true}.String +{foo: 1, foo: true}.ok +{foo: 1.0 != 1.0} +{foo: 1.0 != 1} +{foo: 1.0 != f64} +{foo: 1.0 != i} +{foo: 1.0 * 1.0} +{foo: 1.0 * 1} +{foo: 1.0 ** 1.0} +{foo: 1.0 ** f64} +{foo: 1.0 ** i} +{foo: 1.0 + 1.0} +{foo: 1.0 + 1} +{foo: 1.0 + f64} +{foo: 1.0 + i} +{foo: 1.0 - 0} +{foo: 1.0 - 1.0} +{foo: 1.0 - 1} +{foo: 1.0 - i} +{foo: 1.0 / 0} +{foo: 1.0 / 1.0} +{foo: 1.0 / 1} +{foo: 1.0 / f64} +{foo: 1.0 / i} +{foo: 1.0 < 1.0} +{foo: 1.0 < 1.0}.String +{foo: 1.0 <= 0} +{foo: 1.0 <= 1.0} +{foo: 1.0 <= 1} +{foo: 1.0 <= f64} +{foo: 1.0 <= i} +{foo: 1.0 == $env} +{foo: 1.0 == 0} +{foo: 1.0 == 1.0} +{foo: 1.0 == 1} +{foo: 1.0 == f64}.foo +{foo: 1.0 == i} +{foo: 1.0 == nil} +{foo: 1.0 == nil}?.String +{foo: 1.0 > 1.0} +{foo: 1.0 > 1} +{foo: 1.0 > f64} +{foo: 1.0 > f64}.array +{foo: 1.0 > i} +{foo: 1.0 >= 0} +{foo: 1.0 >= 1.0} +{foo: 1.0 >= 1} +{foo: 1.0 >= f64} +{foo: 1.0 >= i, foo: greet} +{foo: 1.0 >= i} +{foo: 1.0 ^ 0} +{foo: 1.0 ^ 1.0} +{foo: 1.0 ^ 1} +{foo: 1.0 ^ i} +{foo: 1.0 in array} +{foo: 1.0 not in array} +{foo: 1.0 | max(1.0)} +{foo: 1.0 | min(1)} +{foo: 1.0, foo: $env, foo: foo}.f64 +{foo: 1.0, foo: $env, foo: str}?.i?.[add] +{foo: 1.0, foo: $env}.array +{foo: 1.0, foo: $env}.foobar +{foo: 1.0, foo: $env}.greet +{foo: 1.0, foo: $env}?.add +{foo: 1.0, foo: $env}?.greet +{foo: 1.0, foo: $env}?.ok +{foo: 1.0, foo: 0, foo: $env}?.i +{foo: 1.0, foo: 0, foo: array}.String +{foo: 1.0, foo: 0}.Bar +{foo: 1.0, foo: 0}.String +{foo: 1.0, foo: 0}.String?.String +{foo: 1.0, foo: 0}.i +{foo: 1.0, foo: 0}.list +{foo: 1.0, foo: 0}?.foo +{foo: 1.0, foo: 0}?.str +{foo: 1.0, foo: 1.0}.Bar +{foo: 1.0, foo: 1.0}.add +{foo: 1.0, foo: 1.0}.array +{foo: 1.0, foo: 1.0}.foo +{foo: 1.0, foo: 1.0}.greet +{foo: 1.0, foo: 1.0}.list +{foo: 1.0, foo: 1.0}.ok +{foo: 1.0, foo: 1.0}.str +{foo: 1.0, foo: 1.0}?.add +{foo: 1.0, foo: 1.0}?.f64 +{foo: 1.0, foo: 1.0}?.greet +{foo: 1.0, foo: 1}.foo +{foo: 1.0, foo: 1}?.Bar +{foo: 1.0, foo: 1}?.add +{foo: 1.0, foo: 1}?.greet +{foo: 1.0, foo: 1}?.i +{foo: 1.0, foo: add}.Bar +{foo: 1.0, foo: add}?.String +{foo: 1.0, foo: add}?.f64 +{foo: 1.0, foo: add}?.f64?.str?.[array] +{foo: 1.0, foo: add}?.greet +{foo: 1.0, foo: add}?.list +{foo: 1.0, foo: array}.foo +{foo: 1.0, foo: array}.str +{foo: 1.0, foo: array}?.Bar +{foo: 1.0, foo: array}?.f64 +{foo: 1.0, foo: array}?.list +{foo: 1.0, foo: f64}.add +{foo: 1.0, foo: f64}.greet +{foo: 1.0, foo: f64}.list +{foo: 1.0, foo: f64}.ok +{foo: 1.0, foo: f64}.str +{foo: 1.0, foo: f64}?.add +{foo: 1.0, foo: false}.String +{foo: 1.0, foo: false}.array +{foo: 1.0, foo: false}.array?.add +{foo: 1.0, foo: false}.i +{foo: 1.0, foo: false}.str +{foo: 1.0, foo: false}?.array +{foo: 1.0, foo: false}?.list +{foo: 1.0, foo: foo, foo: list}?.f64 +{foo: 1.0, foo: foo, foo: true}.Bar +{foo: 1.0, foo: foo}.foo +{foo: 1.0, foo: foo}.greet +{foo: 1.0, foo: foo}.list +{foo: 1.0, foo: foo}.ok +{foo: 1.0, foo: foo}.str +{foo: 1.0, foo: foo}?.Bar +{foo: 1.0, foo: foo}?.String +{foo: 1.0, foo: foo}?.add +{foo: 1.0, foo: foo}?.f64 +{foo: 1.0, foo: foo}?.foo +{foo: 1.0, foo: foo}?.greet +{foo: 1.0, foo: foo}?.list +{foo: 1.0, foo: foo}?.ok +{foo: 1.0, foo: greet}.Bar +{foo: 1.0, foo: greet}.array +{foo: 1.0, foo: greet}.i +{foo: 1.0, foo: greet}.list +{foo: 1.0, foo: greet}?.[str] +{foo: 1.0, foo: greet}?.foo +{foo: 1.0, foo: greet}?.greet +{foo: 1.0, foo: i}.String +{foo: 1.0, foo: i}.ok +{foo: 1.0, foo: i}?.Bar +{foo: 1.0, foo: i}?.String +{foo: 1.0, foo: i}?.add +{foo: 1.0, foo: i}?.f64 +{foo: 1.0, foo: i}?.foobar +{foo: 1.0, foo: i}?.greet +{foo: 1.0, foo: i}?.i +{foo: 1.0, foo: list}.f64 +{foo: 1.0, foo: list}.i +{foo: 1.0, foo: list}.list +{foo: 1.0, foo: list}?.array +{foo: 1.0, foo: list}?.ok +{foo: 1.0, foo: nil}.Bar +{foo: 1.0, foo: nil}.array +{foo: 1.0, foo: nil}.foo +{foo: 1.0, foo: nil}.i +{foo: 1.0, foo: nil}.ok +{foo: 1.0, foo: nil}?.Bar +{foo: 1.0, foo: nil}?.String +{foo: 1.0, foo: nil}?.[str] +{foo: 1.0, foo: nil}?.add +{foo: 1.0, foo: nil}?.f64 +{foo: 1.0, foo: nil}?.foobar +{foo: 1.0, foo: nil}?.str +{foo: 1.0, foo: ok}.String +{foo: 1.0, foo: ok}.add +{foo: 1.0, foo: ok}.f64 +{foo: 1.0, foo: ok}.i +{foo: 1.0, foo: ok}.str +{foo: 1.0, foo: ok}?.String +{foo: 1.0, foo: ok}?.f64 +{foo: 1.0, foo: ok}?.greet +{foo: 1.0, foo: ok}?.list?.ok +{foo: 1.0, foo: ok}?.str +{foo: 1.0, foo: str}.array +{foo: 1.0, foo: str}.str +{foo: 1.0, foo: str}?.str +{foo: 1.0, foo: true}.greet +{foo: 1.0, foo: true}?.Bar +{foo: 1.0, foo: true}?.array +{foo: 1.0, foo: true}?.f64 +{foo: 1.0, foo: true}?.ok +{foo: 1.0} +{foo: 1.0} | get(str) +{foo: 1.0}.Bar +{foo: 1.0}.Bar?.str +{foo: 1.0}.String +{foo: 1.0}.String?.[foo] +{foo: 1.0}.String?.foo +{foo: 1.0}.add +{foo: 1.0}.add?.Bar +{foo: 1.0}.add?.f64 +{foo: 1.0}.add?.list +{foo: 1.0}.array +{foo: 1.0}.f64 +{foo: 1.0}.f64?.[add] +{foo: 1.0}.f64?.greet() +{foo: 1.0}.foo +{foo: 1.0}.foobar +{foo: 1.0}.foobar == 1.0 +{foo: 1.0}.greet +{foo: 1.0}.greet?.foo +{foo: 1.0}.i +{foo: 1.0}.i == ok +{foo: 1.0}.list +{foo: 1.0}.list?.i +{foo: 1.0}.ok +{foo: 1.0}.str +{foo: 1.0}.str?.[list]?.foo +{foo: 1.0}?.$env?.[add] +{foo: 1.0}?.Bar +{foo: 1.0}?.Bar?.[ok] +{foo: 1.0}?.Bar?.add +{foo: 1.0}?.Bar?.list(array, ok) +{foo: 1.0}?.Bar?.list(foobar) +{foo: 1.0}?.String +{foo: 1.0}?.String?.[f64].str +{foo: 1.0}?.[str] +{foo: 1.0}?.add +{foo: 1.0}?.add?.[i] +{foo: 1.0}?.array +{foo: 1.0}?.array?.greet +{foo: 1.0}?.f64 +{foo: 1.0}?.f64?.foo +{foo: 1.0}?.foo +{foo: 1.0}?.foobar +{foo: 1.0}?.foobar?.String +{foo: 1.0}?.greet +{foo: 1.0}?.greet?.list +{foo: 1.0}?.i +{foo: 1.0}?.list +{foo: 1.0}?.list?.[str] +{foo: 1.0}?.not +{foo: 1.0}?.ok +{foo: 1.0}?.str +{foo: 1} == $env?.[String] +{foo: 1}.Bar +{foo: 1}.String +{foo: 1}.String?.[greet] +{foo: 1}.add +{foo: 1}.add?.str() +{foo: 1}.array +{foo: 1}.f64 +{foo: 1}.foo +{foo: 1}.foobar +{foo: 1}.greet +{foo: 1}.greet?.[list] +{foo: 1}.i +{foo: 1}.list +{foo: 1}.list?.foo +{foo: 1}.ok +{foo: 1}.ok?.add +{foo: 1}.str +{foo: 1}.str?.[f64] +{foo: 1}?.Bar +{foo: 1}?.String +{foo: 1}?.String not startsWith $env +{foo: 1}?.[str] +{foo: 1}?.[str] startsWith str +{foo: 1}?.[str]?.String +{foo: 1}?.add +{foo: 1}?.add?.[str] +{foo: 1}?.array +{foo: 1}?.f64 +{foo: 1}?.f64?.[ok] +{foo: 1}?.foo +{foo: 1}?.foobar +{foo: 1}?.foobar?.i.array +{foo: 1}?.greet +{foo: 1}?.i +{foo: 1}?.list +{foo: 1}?.list?.[ok] +{foo: 1}?.nil?.str(nil) +{foo: 1}?.ok +{foo: 1}?.str +{foo: 1}?.str?.[i] +{foo: 1}?.str?.[ok] +{foo: [$env, false], foo: f64} +{foo: [$env, ok]} +{foo: [$env]} +{foo: [$env]}?.String +{foo: [0 + 0, list]} +{foo: [0]} +{foo: [1.0, $env]} +{foo: [1.0], foo: greet} +{foo: [1.0]} +{foo: [1]} +{foo: [1]}.list +{foo: [add, 1]} +{foo: [add]} +{foo: [array]} +{foo: [ceil(f64)]} +{foo: [f64]} +{foo: [false, f64]} +{foo: [false]} +{foo: [foo, $env]} +{foo: [foo, i]} +{foo: [foo, nil]} +{foo: [foo]} +{foo: [greet, array]} +{foo: [greet]} +{foo: [greet]}.Bar +{foo: [i]} +{foo: [list]} +{foo: [nil, array]} +{foo: [nil, nil]} +{foo: [nil, true]} +{foo: [nil]} +{foo: [ok, foo]} +{foo: [ok]} +{foo: [str]} +{foo: [true, nil]}.i +{foo: [true]} +{foo: abs(0)} +{foo: abs(1)} +{foo: abs(1.0)} +{foo: abs(1.0)}?.str +{foo: abs(f64)} +{foo: abs(i)} +{foo: add != $env} +{foo: add != add} +{foo: add != nil} +{foo: add == $env} +{foo: add(1, 0)} +{foo: add(i, 0)} +{foo: add(i, i)} +{foo: add, foo: $env.f64} +{foo: add, foo: $env}.$env == f64 +{foo: add, foo: $env}.ok +{foo: add, foo: $env}?.Bar +{foo: add, foo: $env}?.String +{foo: add, foo: $env}?.foo +{foo: add, foo: $env}?.i +{foo: add, foo: 0, foo: 0}.ok +{foo: add, foo: 0}.list +{foo: add, foo: 1 ** i} +{foo: add, foo: 1 < f64} +{foo: add, foo: 1.0 / 1.0} +{foo: add, foo: 1.0 > f64} +{foo: add, foo: 1.0}.String +{foo: add, foo: 1.0}.list +{foo: add, foo: 1.0}.str +{foo: add, foo: 1.0}?.Bar +{foo: add, foo: 1.0}?.greet +{foo: add, foo: 1.0}?.list +{foo: add, foo: 1.0}?.ok +{foo: add, foo: 1}.add +{foo: add, foo: add} +{foo: add, foo: add}.array +{foo: add, foo: add}.foo +{foo: add, foo: add}?.f64 +{foo: add, foo: add}?.i +{foo: add, foo: add}?.ok +{foo: add, foo: add}?.str +{foo: add, foo: array} +{foo: add, foo: array}.i +{foo: add, foo: array}?.array +{foo: add, foo: f64} +{foo: add, foo: f64}.array +{foo: add, foo: f64}.foo +{foo: add, foo: f64}.greet +{foo: add, foo: f64}.nil?.f64(foobar) +{foo: add, foo: f64}?.[str] +{foo: add, foo: f64}?.ok +{foo: add, foo: false}.i +{foo: add, foo: false}?.Bar +{foo: add, foo: false}?.String +{foo: add, foo: false}?.[str] +{foo: add, foo: false}?.ok +{foo: add, foo: false}?.str +{foo: add, foo: foo.String()} +{foo: add, foo: foo.String} +{foo: add, foo: foo} +{foo: add, foo: foo}.array +{foo: add, foo: foo}.f64 +{foo: add, foo: foo}.greet +{foo: add, foo: foo}.ok +{foo: add, foo: foo}?.Bar +{foo: add, foo: foo}?.f64 +{foo: add, foo: foo}?.foo +{foo: add, foo: foo}?.i +{foo: add, foo: foo}?.list +{foo: add, foo: foo}?.ok +{foo: add, foo: greet} +{foo: add, foo: greet}.Bar?.String +{foo: add, foo: greet}.String +{foo: add, foo: greet}.greet +{foo: add, foo: greet}?.f64 +{foo: add, foo: greet}?.greet +{foo: add, foo: greet}?.str +{foo: add, foo: i} +{foo: add, foo: i}.array +{foo: add, foo: i}.greet +{foo: add, foo: i}.str +{foo: add, foo: i}?.f64 +{foo: add, foo: i}?.str +{foo: add, foo: list} +{foo: add, foo: list}.str +{foo: add, foo: list}?.list +{foo: add, foo: nil}.greet +{foo: add, foo: nil}.str +{foo: add, foo: nil}?.[str] +{foo: add, foo: nil}?.add +{foo: add, foo: nil}?.greet +{foo: add, foo: nil}?.list +{foo: add, foo: nil}?.ok +{foo: add, foo: nil}?.ok?.Bar +{foo: add, foo: ok} +{foo: add, foo: ok}?.String +{foo: add, foo: ok}?.list +{foo: add, foo: str} +{foo: add, foo: str}.String +{foo: add, foo: str}.foo +{foo: add, foo: str}?.String +{foo: add, foo: str}?.foo +{foo: add, foo: true}.foo +{foo: add, foo: true}.i +{foo: add, foo: true}.list +{foo: add, foo: true}?.f64 +{foo: add, foo: true}?.i +{foo: add} +{foo: add}.Bar +{foo: add}.String +{foo: add}.add +{foo: add}.array +{foo: add}.f64 +{foo: add}.foo +{foo: add}.greet +{foo: add}.greet?.i +{foo: add}.i +{foo: add}.i?.[greet] +{foo: add}.i?.greet +{foo: add}.list +{foo: add}.list?.add()?.Bar +{foo: add}.ok +{foo: add}.ok?.Bar(ok) +{foo: add}.str +{foo: add}?.Bar +{foo: add}?.Bar?.i(foobar) +{foo: add}?.String +{foo: add}?.String?.String +{foo: add}?.[str] +{foo: add}?.add +{foo: add}?.array +{foo: add}?.array?.[list] +{foo: add}?.array?.find(nil, true).String +{foo: add}?.f64 +{foo: add}?.f64?.[str] +{foo: add}?.foo +{foo: add}?.greet +{foo: add}?.i +{foo: add}?.list +{foo: add}?.list?.[array].list +{foo: add}?.list?.add +{foo: add}?.list?.list +{foo: add}?.ok +{foo: add}?.str +{foo: all(array, ok)}.Bar +{foo: any($env, false)} +{foo: any($env, ok)} +{foo: any($env, true)} +{foo: array != list} +{foo: array != nil} +{foo: array == $env} +{foo: array == array} +{foo: array == nil} +{foo: array | all(false)} +{foo: array | groupBy(1.0)} +{foo: array | map(#)} +{foo: array | map(1)}?.list +{foo: array | map(false)} +{foo: array | map(greet)} +{foo: array | map(list)} +{foo: array | mean(i)} +{foo: array | min(f64)} +{foo: array | one(ok)} +{foo: array | reduce(#)} +{foo: array | reduce(0)} +{foo: array | reduce(foo)} +{foo: array | reduce(i)} +{foo: array | reduce(i, f64)} +{foo: array | sum(i)} +{foo: array, foo: $env.add} +{foo: array, foo: $env}.String +{foo: array, foo: $env}.foo +{foo: array, foo: $env}?.Bar +{foo: array, foo: $env}?.array +{foo: array, foo: $env}?.foo +{foo: array, foo: 0}.Bar +{foo: array, foo: 0}?.ok +{foo: array, foo: 1.0 <= 0} +{foo: array, foo: 1.0}.String +{foo: array, foo: 1.0}.add +{foo: array, foo: 1.0}.list +{foo: array, foo: 1.0}?.array +{foo: array, foo: 1.0}?.greet +{foo: array, foo: 1.0}?.list +{foo: array, foo: 1.0}?.ok +{foo: array, foo: 1.0}?.str +{foo: array, foo: 1}.Bar +{foo: array, foo: 1}.i?.ok +{foo: array, foo: 1}.ok +{foo: array, foo: 1}?.String +{foo: array, foo: 1}?.[str] +{foo: array, foo: add} +{foo: array, foo: add}?.foo +{foo: array, foo: array, foo: $env}.ok +{foo: array, foo: array} +{foo: array, foo: array}.Bar +{foo: array, foo: array}.array?.Bar(nil) +{foo: array, foo: array}.f64 +{foo: array, foo: array}.list +{foo: array, foo: array}?.str +{foo: array, foo: f64, foo: 1.0}?.f64 +{foo: array, foo: f64} +{foo: array, foo: f64}.Bar +{foo: array, foo: f64}.list +{foo: array, foo: f64}.str +{foo: array, foo: f64}?.foo +{foo: array, foo: false}.f64 +{foo: array, foo: false}.foo +{foo: array, foo: false}?.f64 +{foo: array, foo: foo} +{foo: array, foo: foo}.add +{foo: array, foo: foo}.i +{foo: array, foo: foo}?.Bar +{foo: array, foo: foo}?.String +{foo: array, foo: foo}?.greet +{foo: array, foo: foo}?.i +{foo: array, foo: foo}?.list +{foo: array, foo: foo}?.ok +{foo: array, foo: greet} +{foo: array, foo: greet}?.greet +{foo: array, foo: greet}?.str +{foo: array, foo: groupBy(list, false)} +{foo: array, foo: i} +{foo: array, foo: i}.list +{foo: array, foo: i}?.String +{foo: array, foo: list} +{foo: array, foo: list}.String +{foo: array, foo: list}.array +{foo: array, foo: list}.false?.[i] +{foo: array, foo: list}.list +{foo: array, foo: list}?.String +{foo: array, foo: list}?.add +{foo: array, foo: list}?.foo +{foo: array, foo: list}?.greet +{foo: array, foo: list}?.list +{foo: array, foo: list}?.ok +{foo: array, foo: nil}.Bar +{foo: array, foo: nil}.Bar?.[f64] +{foo: array, foo: nil}.array +{foo: array, foo: nil}.list +{foo: array, foo: nil}.str +{foo: array, foo: nil}?.add +{foo: array, foo: nil}?.foo +{foo: array, foo: nil}?.greet +{foo: array, foo: nil}?.i +{foo: array, foo: nil}?.list +{foo: array, foo: nil}?.str +{foo: array, foo: ok, foo: false}?.String?.String() +{foo: array, foo: ok} +{foo: array, foo: ok}?.Bar +{foo: array, foo: ok}?.ok +{foo: array, foo: reduce(array, #)}?.ok +{foo: array, foo: str} +{foo: array, foo: str}.Bar +{foo: array, foo: str}.f64 +{foo: array, foo: toJSON(1.0)} +{foo: array, foo: true}.str +{foo: array, foo: true}?.Bar +{foo: array?.[i], foo: list} +{foo: array?.[i]} +{foo: array[1:]} +{foo: array[:]} +{foo: array} +{foo: array}.Bar +{foo: array}.Bar?.[array] +{foo: array}.Bar?.[i] +{foo: array}.Bar?.[ok] +{foo: array}.String +{foo: array}.add +{foo: array}.array +{foo: array}.array?.add +{foo: array}.array?.list +{foo: array}.f64 +{foo: array}.f64?.[i] +{foo: array}.foo +{foo: array}.foobar +{foo: array}.greet +{foo: array}.i +{foo: array}.i?.[list] +{foo: array}.i?.[ok] +{foo: array}.i?.foo +{foo: array}.list +{foo: array}.list?.[f64] +{foo: array}.ok +{foo: array}.str +{foo: array}.str?.[greet] +{foo: array}?.Bar +{foo: array}?.Bar?.[array] +{foo: array}?.String +{foo: array}?.String?.[list] +{foo: array}?.[str] +{foo: array}?.[str]?.String() +{foo: array}?.[str]?.[add] +{foo: array}?.add +{foo: array}?.array +{foo: array}?.array?.foobar +{foo: array}?.f64 +{foo: array}?.f64?.ok +{foo: array}?.foo +{foo: array}?.foobar +{foo: array}?.foobar?.array +{foo: array}?.greet +{foo: array}?.i +{foo: array}?.list +{foo: array}?.list?.add +{foo: array}?.ok +{foo: array}?.ok?.ok() +{foo: array}?.str +{foo: array}?.str?.[f64] +{foo: bitnand(i, 1)} +{foo: bitnot(0)} +{foo: bitnot(i)} +{foo: bitor(0, 0)} +{foo: bitor(i, i)} +{foo: bitxor(i, 1)} +{foo: ceil(0), foo: array} +{foo: ceil(0)} +{foo: ceil(1)} +{foo: ceil(1.0)} +{foo: ceil(f64)} +{foo: ceil(i)} +{foo: concat(array)} +{foo: concat(list)} +{foo: count($env, true), foo: f64} +{foo: count(list, ok)} +{foo: f64 != $env} +{foo: f64 != 1.0} +{foo: f64 != 1} +{foo: f64 != f64} +{foo: f64 != i} +{foo: f64 != nil} +{foo: f64 * 1.0} +{foo: f64 ** i} +{foo: f64 + 1.0} +{foo: f64 + 1} +{foo: f64 + f64} +{foo: f64 / 0} +{foo: f64 / f64} +{foo: f64 / i} +{foo: f64 < i} +{foo: f64 <= 1.0} +{foo: f64 <= i} +{foo: f64 == 1.0} +{foo: f64 == 1} +{foo: f64 == nil} +{foo: f64 > 0, foo: floor(1.0)} +{foo: f64 > 0} +{foo: f64 > f64} +{foo: f64 >= 0} +{foo: f64 >= 1} +{foo: f64 ^ 1.0} +{foo: f64 in array} +{foo: f64 not in array} +{foo: f64 not in array}.f64 +{foo: f64, foo: $env == array} +{foo: f64, foo: $env?.[foobar]} +{foo: f64, foo: $env?.list} +{foo: f64, foo: $env}.String +{foo: f64, foo: $env}?.i +{foo: f64, foo: $env}?.ok +{foo: f64, foo: 0, foo: 1.0}.f64 +{foo: f64, foo: 0}.Bar +{foo: f64, foo: 0}.list +{foo: f64, foo: 0}.str +{foo: f64, foo: 0}?.foo +{foo: f64, foo: 1 != $env} +{foo: f64, foo: 1 / 0} +{foo: f64, foo: 1, foo: $env}?.i +{foo: f64, foo: 1, foo: nil}.String +{foo: f64, foo: 1.0}.f64 +{foo: f64, foo: 1.0}.i +{foo: f64, foo: 1.0}?.Bar +{foo: f64, foo: 1.0}?.f64 +{foo: f64, foo: 1.0}?.ok +{foo: f64, foo: 1.0}?.str +{foo: f64, foo: 1}?.greet +{foo: f64, foo: add} +{foo: f64, foo: add}.add +{foo: f64, foo: add}.foo +{foo: f64, foo: add}?.f64 +{foo: f64, foo: add}?.foo +{foo: f64, foo: add}?.greet +{foo: f64, foo: array} +{foo: f64, foo: array}.Bar +{foo: f64, foo: array}.add +{foo: f64, foo: array}?.str +{foo: f64, foo: f64} +{foo: f64, foo: f64}.String +{foo: f64, foo: f64}.ok +{foo: f64, foo: f64}?.Bar +{foo: f64, foo: foo, foo: foo}?.add +{foo: f64, foo: foo} +{foo: f64, foo: foo}.array +{foo: f64, foo: foo}.f64 +{foo: f64, foo: foo}.foo +{foo: f64, foo: foo}.greet +{foo: f64, foo: foo}.list +{foo: f64, foo: foo}?.[str] +{foo: f64, foo: foo}?.add +{foo: f64, foo: foo}?.array +{foo: f64, foo: foo}?.greet +{foo: f64, foo: foo}?.i +{foo: f64, foo: foo}?.str +{foo: f64, foo: greet, foo: i}?.str +{foo: f64, foo: greet} +{foo: f64, foo: greet}.add +{foo: f64, foo: greet}?.ok +{foo: f64, foo: i, foo: add}.ok +{foo: f64, foo: if ok { foo } else { nil }}.foo +{foo: f64, foo: i} +{foo: f64, foo: i}?.[str] +{foo: f64, foo: list} +{foo: f64, foo: list}.array +{foo: f64, foo: list}.foo +{foo: f64, foo: list}.list +{foo: f64, foo: list}?.i?.[i] +{foo: f64, foo: nil, foo: $env}?.f64 +{foo: f64, foo: nil, foo: 1.0}.array +{foo: f64, foo: nil}.String +{foo: f64, foo: nil}.array +{foo: f64, foo: nil}.f64 +{foo: f64, foo: nil}.foobar +{foo: f64, foo: nil}?.[str] +{foo: f64, foo: nil}?.str +{foo: f64, foo: ok, foo: 1.0}?.str +{foo: f64, foo: ok} +{foo: f64, foo: ok}?.String +{foo: f64, foo: ok}?.f64?.[i] +{foo: f64, foo: str} +{foo: f64, foo: str}?.[str] +{foo: f64, foo: str}?.add +{foo: f64, foo: sum(array)} +{foo: f64, foo: toJSON(1)} +{foo: f64, foo: true}.add +{foo: f64} +{foo: f64}.Bar +{foo: f64}.String +{foo: f64}.String?.foo +{foo: f64}.add +{foo: f64}.array +{foo: f64}.f64 +{foo: f64}.foo +{foo: f64}.foobar +{foo: f64}.greet +{foo: f64}.i +{foo: f64}.list +{foo: f64}.list?.list() +{foo: f64}.ok +{foo: f64}.str +{foo: f64}?.Bar +{foo: f64}?.String +{foo: f64}?.[str] +{foo: f64}?.[str]?.Bar?.f64.String +{foo: f64}?.add +{foo: f64}?.add?.[array] +{foo: f64}?.add?.add +{foo: f64}?.array +{foo: f64}?.f64 +{foo: f64}?.f64?.array +{foo: f64}?.foo +{foo: f64}?.foobar +{foo: f64}?.greet +{foo: f64}?.i +{foo: f64}?.i?.add +{foo: f64}?.list +{foo: f64}?.ok +{foo: f64}?.str +{foo: f64}?.str?.i +{foo: false != $env} +{foo: false != false} +{foo: false != nil} +{foo: false && $env} +{foo: false == false} +{foo: false == nil} +{foo: false == true} +{foo: false ? foo : i} +{foo: false ? foo : ok} +{foo: false ? greet : nil} +{foo: false ? list : 1} +{foo: false ? list : f64} +{foo: false ? ok : f64} +{foo: false ?: foo} +{foo: false and $env} +{foo: false and false} +{foo: false or $env} +{foo: false or ok} +{foo: false or true} +{foo: false || $env} +{foo: false, foo: $env, foo: true}.foo +{foo: false, foo: $env}.String +{foo: false, foo: $env}.foo +{foo: false, foo: $env}.greet +{foo: false, foo: $env}?.String +{foo: false, foo: $env}?.[str] +{foo: false, foo: $env}?.list +{foo: false, foo: 0, foo: $env}?.list +{foo: false, foo: 0, foo: 0}.str +{foo: false, foo: 1.0, foo: $env}.add +{foo: false, foo: 1.0}.Bar +{foo: false, foo: 1.0}.array +{foo: false, foo: 1.0}.greet +{foo: false, foo: 1.0}?.String +{foo: false, foo: 1.0}?.[str] +{foo: false, foo: 1.0}?.ok +{foo: false, foo: 1.0}?.str?.[f64] +{foo: false, foo: 1}.add +{foo: false, foo: 1}.i +{foo: false, foo: 1}.list?.[greet] +{foo: false, foo: 1}.ok +{foo: false, foo: 1}?.String +{foo: false, foo: 1}?.i +{foo: false, foo: add}?.String +{foo: false, foo: add}?.f64 +{foo: false, foo: add}?.foo +{foo: false, foo: array, foo: foo}?.Bar +{foo: false, foo: array}.foo +{foo: false, foo: array}?.Bar +{foo: false, foo: array}?.greet +{foo: false, foo: array}?.ok +{foo: false, foo: array}?.str?.greet +{foo: false, foo: f64, foo: 1.0}.list +{foo: false, foo: f64}.greet +{foo: false, foo: f64}.i +{foo: false, foo: f64}?.str?.f64 +{foo: false, foo: false, foo: foo}?.Bar +{foo: false, foo: false}?.f64 +{foo: false, foo: false}?.foo +{foo: false, foo: false}?.ok +{foo: false, foo: foo, foo: foo}.str +{foo: false, foo: foo, foo: greet}.f64 +{foo: false, foo: foo}.Bar +{foo: false, foo: foo}.array +{foo: false, foo: foo}.f64 +{foo: false, foo: foo}.i +{foo: false, foo: foo}.list +{foo: false, foo: foo}.str +{foo: false, foo: foo}?.Bar +{foo: false, foo: foo}?.[str] +{foo: false, foo: foo}?.add +{foo: false, foo: foo}?.foo +{foo: false, foo: greet}.array +{foo: false, foo: greet}.greet +{foo: false, foo: greet}.str +{foo: false, foo: greet}?.array +{foo: false, foo: greet}?.foobar +{foo: false, foo: greet}?.str +{foo: false, foo: i}.str +{foo: false, foo: i}?.Bar +{foo: false, foo: i}?.greet +{foo: false, foo: list, foo: list}?.array +{foo: false, foo: list}.foobar +{foo: false, foo: list}?.[str] +{foo: false, foo: list}?.array?.foo +{foo: false, foo: nil}.Bar +{foo: false, foo: nil}.String +{foo: false, foo: nil}.add +{foo: false, foo: nil}.foobar?.str +{foo: false, foo: nil}.greet +{foo: false, foo: nil}?.String?.array +{foo: false, foo: nil}?.add +{foo: false, foo: nil}?.foo +{foo: false, foo: nil}?.list +{foo: false, foo: ok}.list +{foo: false, foo: ok}?.String +{foo: false, foo: ok}?.greet +{foo: false, foo: str}.array +{foo: false, foo: str}?.Bar +{foo: false, foo: str}?.[str] +{foo: false, foo: true}.Bar +{foo: false, foo: true}.add +{foo: false, foo: true}.ok +{foo: false, foo: true}?.array +{foo: false, foo: true}?.list +{foo: false, foo: true}?.ok +{foo: false}.Bar +{foo: false}.String +{foo: false}.String?.[i] +{foo: false}.add +{foo: false}.array +{foo: false}.array?.greet(foobar) +{foo: false}.f64 +{foo: false}.f64?.Bar +{foo: false}.foo +{foo: false}.foobar +{foo: false}.greet +{foo: false}.i +{foo: false}.list +{foo: false}.ok +{foo: false}.ok == i +{foo: false}.str +{foo: false}?.$env?.array +{foo: false}?.Bar +{foo: false}?.String +{foo: false}?.[str] +{foo: false}?.add +{foo: false}?.array +{foo: false}?.f64 +{foo: false}?.foo +{foo: false}?.foobar +{foo: false}?.greet +{foo: false}?.i +{foo: false}?.list +{foo: false}?.ok +{foo: false}?.str +{foo: false}?.str?.[list] +{foo: filter($env, false)} +{foo: filter(list, ok)} +{foo: filter(list, true)} +{foo: find(array, false)} +{foo: find(array, true)} +{foo: find(list, true), foo: foo} +{foo: findIndex($env, ok)} +{foo: findIndex($env, true)} +{foo: findIndex(array, ok)} +{foo: findIndex(list, true)} +{foo: first($env)} +{foo: first($env)}?.foo +{foo: first(array)} +{foo: first(list)} +{foo: flatten(array)} +{foo: flatten(list)} +{foo: float(0)} +{foo: float(1)} +{foo: float(1.0)} +{foo: float(1.0)}.i +{foo: float(1.0)}?.String +{foo: float(f64)} +{foo: float(i)} +{foo: floor(0)} +{foo: floor(1)} +{foo: floor(1.0)} +{foo: floor(f64)} +{foo: floor(f64)}.add +{foo: floor(i)} +{foo: foo != $env} +{foo: foo != foo} +{foo: foo != nil} +{foo: foo == $env} +{foo: foo == foo} +{foo: foo == nil} +{foo: foo not in list} +{foo: foo, foo: $env, foo: ok}?.array +{foo: foo, foo: $env.f64}.greet +{foo: foo, foo: $env?.f64} +{foo: foo, foo: $env}.Bar +{foo: foo, foo: $env}.array +{foo: foo, foo: $env}.foo +{foo: foo, foo: $env}.list +{foo: foo, foo: $env}.nil?.[foo] +{foo: foo, foo: $env}.ok +{foo: foo, foo: $env}?.Bar +{foo: foo, foo: $env}?.String +{foo: foo, foo: $env}?.[str] +{foo: foo, foo: $env}?.array +{foo: foo, foo: $env}?.f64 +{foo: foo, foo: $env}?.foo +{foo: foo, foo: $env}?.i +{foo: foo, foo: $env}?.ok +{foo: foo, foo: $env}?.str != foo +{foo: foo, foo: 0}.foo +{foo: foo, foo: 0}?.Bar +{foo: foo, foo: 0}?.add +{foo: foo, foo: 0}?.f64 +{foo: foo, foo: 0}?.greet +{foo: foo, foo: 1, foo: greet}?.str +{foo: foo, foo: 1, foo: list}?.str +{foo: foo, foo: 1.0, foo: array}.str +{foo: foo, foo: 1.0}.Bar +{foo: foo, foo: 1.0}.add +{foo: foo, foo: 1.0}.array +{foo: foo, foo: 1.0}.f64 +{foo: foo, foo: 1.0}.foo +{foo: foo, foo: 1.0}.greet +{foo: foo, foo: 1.0}.i +{foo: foo, foo: 1.0}.list +{foo: foo, foo: 1.0}.ok +{foo: foo, foo: 1.0}.str +{foo: foo, foo: 1.0}?.String +{foo: foo, foo: 1.0}?.[str] +{foo: foo, foo: 1.0}?.add +{foo: foo, foo: 1.0}?.array +{foo: foo, foo: 1.0}?.f64 +{foo: foo, foo: 1.0}?.foo +{foo: foo, foo: 1.0}?.greet +{foo: foo, foo: 1.0}?.list +{foo: foo, foo: 1}.Bar +{foo: foo, foo: 1}.String +{foo: foo, foo: 1}.add +{foo: foo, foo: 1}.f64 +{foo: foo, foo: 1}.foo +{foo: foo, foo: 1}.i +{foo: foo, foo: 1}.list +{foo: foo, foo: 1}.ok +{foo: foo, foo: 1}?.f64 +{foo: foo, foo: 1}?.str +{foo: foo, foo: [$env?.add]} +{foo: foo, foo: add, foo: nil}.f64 +{foo: foo, foo: add} +{foo: foo, foo: add}.array +{foo: foo, foo: add}.f64 +{foo: foo, foo: add}.i +{foo: foo, foo: add}.list +{foo: foo, foo: add}?.String +{foo: foo, foo: add}?.f64 +{foo: foo, foo: array, foo: i}.f64 +{foo: foo, foo: array} +{foo: foo, foo: array}.String +{foo: foo, foo: array}.foo +{foo: foo, foo: array}.greet +{foo: foo, foo: array}.list +{foo: foo, foo: array}?.String +{foo: foo, foo: array}?.[str] +{foo: foo, foo: array}?.foo +{foo: foo, foo: array}?.greet +{foo: foo, foo: array}?.i +{foo: foo, foo: f64, foo: 1.0}?.array +{foo: foo, foo: f64} +{foo: foo, foo: f64}.String +{foo: foo, foo: f64}.array +{foo: foo, foo: f64}.list +{foo: foo, foo: f64}.list?.[i] +{foo: foo, foo: f64}?.add +{foo: foo, foo: f64}?.f64 +{foo: foo, foo: f64}?.foo +{foo: foo, foo: false}.String +{foo: foo, foo: false}.f64 +{foo: foo, foo: false}.str +{foo: foo, foo: false}?.foo +{foo: foo, foo: false}?.i +{foo: foo, foo: foo, foo: foo}.greet +{foo: foo, foo: foo, foo: greet} +{foo: foo, foo: foo, foo: ok}?.str +{foo: foo, foo: foo.Bar} +{foo: foo, foo: foo} +{foo: foo, foo: foo}.Bar +{foo: foo, foo: foo}.String +{foo: foo, foo: foo}.add +{foo: foo, foo: foo}.array +{foo: foo, foo: foo}.f64 +{foo: foo, foo: foo}.foo +{foo: foo, foo: foo}.greet +{foo: foo, foo: foo}.list +{foo: foo, foo: foo}.ok +{foo: foo, foo: foo}.str +{foo: foo, foo: foo}?.String +{foo: foo, foo: foo}?.[str] +{foo: foo, foo: foo}?.add +{foo: foo, foo: foo}?.array +{foo: foo, foo: foo}?.f64 +{foo: foo, foo: foo}?.greet +{foo: foo, foo: foo}?.list?.f64 +{foo: foo, foo: foo}?.ok +{foo: foo, foo: foo}?.str +{foo: foo, foo: greet, foo: 1.0}.list +{foo: foo, foo: greet} +{foo: foo, foo: greet}.Bar +{foo: foo, foo: greet}.String +{foo: foo, foo: greet}.array +{foo: foo, foo: greet}.foo +{foo: foo, foo: greet}.greet +{foo: foo, foo: greet}.i +{foo: foo, foo: greet}.str +{foo: foo, foo: greet}?.array +{foo: foo, foo: greet}?.f64 +{foo: foo, foo: greet}?.foo +{foo: foo, foo: greet}?.list +{foo: foo, foo: i / f64} +{foo: foo, foo: i, foo: 0}.ok +{foo: foo, foo: i, foo: 1.0}.array +{foo: foo, foo: i} +{foo: foo, foo: i}.Bar +{foo: foo, foo: i}.String +{foo: foo, foo: i}.String?.String +{foo: foo, foo: i}.add +{foo: foo, foo: i}.foo +{foo: foo, foo: i}?.[str] +{foo: foo, foo: i}?.f64 +{foo: foo, foo: i}?.greet +{foo: foo, foo: i}?.ok +{foo: foo, foo: i}?.str +{foo: foo, foo: list, foo: false and false} +{foo: foo, foo: list, foo: greet}?.f64 +{foo: foo, foo: list} +{foo: foo, foo: list}.add?.[i] +{foo: foo, foo: list}.array +{foo: foo, foo: list}.array?.Bar +{foo: foo, foo: list}.f64 +{foo: foo, foo: list}.greet +{foo: foo, foo: list}.ok +{foo: foo, foo: list}.str +{foo: foo, foo: list}?.Bar +{foo: foo, foo: list}?.add +{foo: foo, foo: list}?.greet +{foo: foo, foo: list}?.list +{foo: foo, foo: list}?.str +{foo: foo, foo: nil in $env} +{foo: foo, foo: nil, foo: 0}.f64 +{foo: foo, foo: nil, foo: 0}?.f64?.i() +{foo: foo, foo: nil, foo: nil}.f64 +{foo: foo, foo: nil, foo: ok}?.list +{foo: foo, foo: nil}.String +{foo: foo, foo: nil}.add +{foo: foo, foo: nil}.array +{foo: foo, foo: nil}.f64 +{foo: foo, foo: nil}.foo +{foo: foo, foo: nil}.i +{foo: foo, foo: nil}.ok +{foo: foo, foo: nil}.ok?.array() +{foo: foo, foo: nil}.str +{foo: foo, foo: nil}?.[str] +{foo: foo, foo: nil}?.add +{foo: foo, foo: nil}?.greet +{foo: foo, foo: nil}?.i +{foo: foo, foo: nil}?.list +{foo: foo, foo: ok} +{foo: foo, foo: ok}.add +{foo: foo, foo: ok}?.String +{foo: foo, foo: ok}?.[str] +{foo: foo, foo: ok}?.add +{foo: foo, foo: ok}?.array +{foo: foo, foo: ok}?.f64 +{foo: foo, foo: str, foo: 1.0}.Bar +{foo: foo, foo: str, foo: list}?.String +{foo: foo, foo: str} +{foo: foo, foo: str}.String +{foo: foo, foo: str}.i +{foo: foo, foo: str}.ok +{foo: foo, foo: str}?.Bar +{foo: foo, foo: str}?.add +{foo: foo, foo: str}?.array +{foo: foo, foo: str}?.f64?.ok +{foo: foo, foo: str}?.foo +{foo: foo, foo: str}?.greet +{foo: foo, foo: str}?.str +{foo: foo, foo: true, foo: $env}?.add +{foo: foo, foo: true, foo: nil}?.Bar +{foo: foo, foo: true, foo: nil}?.i +{foo: foo, foo: true}.Bar +{foo: foo, foo: true}.add +{foo: foo, foo: true}.foo +{foo: foo, foo: true}?.String +{foo: foo, foo: true}?.[str] +{foo: foo, foo: true}?.add +{foo: foo, foo: true}?.f64 +{foo: foo, foo: true}?.list +{foo: foo, foo: true}?.str?.i +{foo: foo, foo: {foo: foo}} +{foo: foo.Bar, foo: false ? foo : str}?.ok +{foo: foo.Bar, foo: greet} +{foo: foo.Bar} +{foo: foo.Bar}.greet +{foo: foo.Bar}?.f64 +{foo: foo.String() not matches str} +{foo: foo.String()} +{foo: foo.String, foo: ok} +{foo: foo.String} +{foo: foo.String}.String +{foo: foo.String}.add +{foo: foo.String}.array +{foo: foo.String}.str +{foo: foo?.Bar} +{foo: foo?.Bar}?.list +{foo: foo?.String()} +{foo: foo?.String, foo: f64} +{foo: foo?.String, foo: greet} +{foo: foo?.String, foo: str} +{foo: foo?.String} +{foo: foo?.String}.array +{foo: foo?.String}?.Bar +{foo: foo} +{foo: foo}.Bar +{foo: foo}.String +{foo: foo}.add +{foo: foo}.array +{foo: foo}.array?.[str] +{foo: foo}.array?.greet() +{foo: foo}.array?.i +{foo: foo}.f64 +{foo: foo}.f64?.[array] +{foo: foo}.f64?.i +{foo: foo}.false?.f64 +{foo: foo}.foo +{foo: foo}.foobar +{foo: foo}.foobar?.greet +{foo: foo}.greet +{foo: foo}.greet != f64 +{foo: foo}.greet?.[f64] +{foo: foo}.greet?.[ok] +{foo: foo}.i +{foo: foo}.list +{foo: foo}.list?.[f64] +{foo: foo}.list?.[str]?.foobar +{foo: foo}.ok +{foo: foo}.ok?.[add].add() +{foo: foo}.ok?.f64 +{foo: foo}.str +{foo: foo}?.Bar +{foo: foo}?.String +{foo: foo}?.String?.Bar +{foo: foo}?.String?.String() +{foo: foo}?.[str] +{foo: foo}?.[str]?.String +{foo: foo}?.add +{foo: foo}?.add?.f64(foobar, foobar) +{foo: foo}?.array +{foo: foo}?.array?.i +{foo: foo}?.f64 +{foo: foo}?.f64?.str +{foo: foo}?.foo +{foo: foo}?.foobar +{foo: foo}?.foobar == foo +{foo: foo}?.foobar?.greet(foobar) +{foo: foo}?.greet +{foo: foo}?.greet?.[f64] +{foo: foo}?.greet?.[i] +{foo: foo}?.i +{foo: foo}?.list +{foo: foo}?.list?.[add]?.str +{foo: foo}?.ok +{foo: foo}?.ok?.Bar +{foo: foo}?.ok?.[i] +{foo: foo}?.ok?.f64() +{foo: foo}?.ok?.greet()?.f64() +{foo: foo}?.ok?.ok +{foo: foo}?.str +{foo: foo}?.str?.add +{foo: foo}?.str?.f64 +{foo: greet != $env} +{foo: greet != nil} +{foo: greet == $env} +{foo: greet == greet} +{foo: greet($env?.[str])} +{foo: greet(str)} +{foo: greet(str)}.str +{foo: greet, foo: $env.f64} +{foo: greet, foo: $env?.ok} +{foo: greet, foo: $env?.str} +{foo: greet, foo: $env}.String +{foo: greet, foo: $env}.add +{foo: greet, foo: $env}.str +{foo: greet, foo: $env}?.String +{foo: greet, foo: $env}?.array +{foo: greet, foo: $env}?.greet +{foo: greet, foo: $env}?.ok +{foo: greet, foo: 0}.foo +{foo: greet, foo: 0}?.Bar +{foo: greet, foo: 0}?.add +{foo: greet, foo: 0}?.f64 +{foo: greet, foo: 0}?.ok +{foo: greet, foo: 1.0}.String +{foo: greet, foo: 1.0}.i +{foo: greet, foo: 1.0}.ok +{foo: greet, foo: 1.0}.str +{foo: greet, foo: 1.0}?.Bar +{foo: greet, foo: 1.0}?.String +{foo: greet, foo: 1.0}?.array +{foo: greet, foo: 1.0}?.list +{foo: greet, foo: 1.0}?.str +{foo: greet, foo: 1}?.[str] +{foo: greet, foo: 1}?.ok +{foo: greet, foo: [$env]} +{foo: greet, foo: add} +{foo: greet, foo: add}.foo +{foo: greet, foo: add}?.f64 +{foo: greet, foo: array} +{foo: greet, foo: array}.array +{foo: greet, foo: array}?.array +{foo: greet, foo: f64} +{foo: greet, foo: false, foo: foo}.String +{foo: greet, foo: false}.f64 +{foo: greet, foo: false}.greet +{foo: greet, foo: false}.str +{foo: greet, foo: false}?.f64 +{foo: greet, foo: false}?.str +{foo: greet, foo: float(f64)} +{foo: greet, foo: foo != foo} +{foo: greet, foo: foo, foo: array} +{foo: greet, foo: foo, foo: greet}?.add +{foo: greet, foo: foo} +{foo: greet, foo: foo}.String +{foo: greet, foo: foo}.add +{foo: greet, foo: foo}.f64 +{foo: greet, foo: foo}.foo +{foo: greet, foo: foo}.greet +{foo: greet, foo: foo}.i +{foo: greet, foo: foo}.list +{foo: greet, foo: foo}.ok +{foo: greet, foo: foo}?.add +{foo: greet, foo: foo}?.foo +{foo: greet, foo: foo}?.i +{foo: greet, foo: foo}?.list +{foo: greet, foo: greet} +{foo: greet, foo: greet}?.str +{foo: greet, foo: i == 1.0} +{foo: greet, foo: i} +{foo: greet, foo: i}?.String +{foo: greet, foo: list} +{foo: greet, foo: list}.list +{foo: greet, foo: nil}?.[str] +{foo: greet, foo: nil}?.greet +{foo: greet, foo: nil}?.ok +{foo: greet, foo: ok} +{foo: greet, foo: ok}?.array +{foo: greet, foo: ok}?.list +{foo: greet, foo: ok}?.ok +{foo: greet, foo: ok}?.str +{foo: greet, foo: str} +{foo: greet, foo: str}.Bar +{foo: greet, foo: str}?.f64 +{foo: greet, foo: trimPrefix(str)} +{foo: greet, foo: true}?.String +{foo: greet, foo: true}?.greet +{foo: greet} +{foo: greet}.Bar +{foo: greet}.Bar?.ok +{foo: greet}.String +{foo: greet}.String?.str() +{foo: greet}.add +{foo: greet}.array +{foo: greet}.f64 +{foo: greet}.f64?.String +{foo: greet}.foo +{foo: greet}.foobar +{foo: greet}.foobar?.[1.0] +{foo: greet}.foobar?.[foo] +{foo: greet}.greet +{foo: greet}.greet?.i +{foo: greet}.i +{foo: greet}.list +{foo: greet}.ok +{foo: greet}.ok?.Bar +{foo: greet}.ok?.add +{foo: greet}.str +{foo: greet}?.Bar +{foo: greet}?.String +{foo: greet}?.[str] +{foo: greet}?.add +{foo: greet}?.array +{foo: greet}?.array?.[array] +{foo: greet}?.f64 +{foo: greet}?.foo +{foo: greet}?.foobar +{foo: greet}?.foobar?.[foo] +{foo: greet}?.foobar?.[ok] +{foo: greet}?.greet +{foo: greet}?.i +{foo: greet}?.i?.[str] +{foo: greet}?.list +{foo: greet}?.list?.f64() +{foo: greet}?.list?.i +{foo: greet}?.ok +{foo: greet}?.ok?.[foo] +{foo: greet}?.str +{foo: groupBy(array, #)} +{foo: groupBy(array, f64)} +{foo: groupBy(array, false)} +{foo: groupBy(array, foo)} +{foo: groupBy(list, #)} +{foo: groupBy(list, foo)} +{foo: groupBy(list, i)} +{foo: groupBy(list, ok)} +{foo: i != $env}?.String +{foo: i != 1.0} +{foo: i % 1} +{foo: i * 0} +{foo: i * 1.0} +{foo: i * f64} +{foo: i * i} +{foo: i ** 1, foo: ok}.f64 +{foo: i ** 1.0} +{foo: i ** 1} +{foo: i ** f64} +{foo: i + 0} +{foo: i + f64} +{foo: i - 1} +{foo: i .. 1, foo: i} +{foo: i .. i} +{foo: i / 0} +{foo: i / 1, foo: string(false)} +{foo: i / 1.0} +{foo: i < 0} +{foo: i < 1.0} +{foo: i < 1} +{foo: i <= 1.0} +{foo: i <= f64} +{foo: i == $env}?.Bar +{foo: i == nil} +{foo: i > 0, foo: 1 >= f64} +{foo: i >= 1.0} +{foo: i >= 1} +{foo: i >= f64}.str +{foo: i ^ 0} +{foo: i ^ 1.0} +{foo: i ^ 1} +{foo: i ^ i} +{foo: i not in array} +{foo: i not in array}?.greet +{foo: i | bitnand(1)} +{foo: i | bitor(i)} +{foo: i | bitxor(i)} +{foo: i, foo: $env != foo} +{foo: i, foo: $env, foo: nil}?.add +{foo: i, foo: $env?.[Bar]} +{foo: i, foo: $env}.foo +{foo: i, foo: $env}.ok +{foo: i, foo: 0}.greet +{foo: i, foo: 0}?.ok?.str +{foo: i, foo: 1 - f64} +{foo: i, foo: 1.0, foo: foo}?.[str] +{foo: i, foo: 1.0, foo: foo}?.str +{foo: i, foo: 1.0}.Bar +{foo: i, foo: 1.0}.String +{foo: i, foo: 1.0}.f64 +{foo: i, foo: 1.0}.f64?.ok +{foo: i, foo: 1.0}.foobar?.ok +{foo: i, foo: 1.0}.i +{foo: i, foo: 1.0}.ok +{foo: i, foo: 1.0}?.String +{foo: i, foo: 1.0}?.f64 +{foo: i, foo: 1.0}?.str +{foo: i, foo: 1}.f64 +{foo: i, foo: 1}?.array +{foo: i, foo: add} +{foo: i, foo: add}.i +{foo: i, foo: add}.str +{foo: i, foo: add}?.str +{foo: i, foo: array} +{foo: i, foo: array}.greet +{foo: i, foo: array}.i +{foo: i, foo: array}.list +{foo: i, foo: array}.str +{foo: i, foo: f64} +{foo: i, foo: f64}.f64 +{foo: i, foo: f64}.foo +{foo: i, foo: f64}.foobar?.f64(foo) +{foo: i, foo: f64}?.i +{foo: i, foo: false}.array +{foo: i, foo: false}.str +{foo: i, foo: false}?.Bar +{foo: i, foo: false}?.String +{foo: i, foo: false}?.str +{foo: i, foo: foo, foo: $env}.ok +{foo: i, foo: foo} +{foo: i, foo: foo}.list +{foo: i, foo: foo}?.String +{foo: i, foo: foo}?.list +{foo: i, foo: foo}?.list == foo +{foo: i, foo: foo}?.str +{foo: i, foo: greet(str)} +{foo: i, foo: greet} +{foo: i, foo: greet}.foo +{foo: i, foo: i >= 1} +{foo: i, foo: i} +{foo: i, foo: i}.f64 +{foo: i, foo: i}.foo +{foo: i, foo: i}?.[str] +{foo: i, foo: list} +{foo: i, foo: list}?.list +{foo: i, foo: map(list, foo)} +{foo: i, foo: nil}.array +{foo: i, foo: nil}.foo +{foo: i, foo: nil}.list +{foo: i, foo: nil}?.Bar +{foo: i, foo: nil}?.[str] +{foo: i, foo: nil}?.foo +{foo: i, foo: nil}?.list +{foo: i, foo: ok, foo: 1.0}?.ok +{foo: i, foo: ok} +{foo: i, foo: str} +{foo: i, foo: str}.array +{foo: i, foo: str}.foo +{foo: i, foo: str}.foobar?.i() +{foo: i, foo: str}?.add?.[str] +{foo: i, foo: str}?.f64 +{foo: i, foo: str}?.list +{foo: i, foo: true}.foo +{foo: i, foo: true}?.f64 +{foo: i, foo: {foo: str}} +{foo: if false { foo } else { $env }} +{foo: if false { str } else { array }} +{foo: if true { $env } else { array }} +{foo: if true { 1.0 } else { foo }} +{foo: if true { foo } else { greet }} +{foo: if true { ok } else { foo }} +{foo: int(0)} +{foo: int(1)} +{foo: int(1.0)} +{foo: int(f64)} +{foo: int(f64)}?.foobar?.list() +{foo: int(i)} +{foo: i} +{foo: i}.$env?.Bar(Bar) +{foo: i}.Bar +{foo: i}.String +{foo: i}.String?.i +{foo: i}.add +{foo: i}.add?.add +{foo: i}.array +{foo: i}.array?.Bar +{foo: i}.array?.[str] +{foo: i}.f64 +{foo: i}.f64?.[foo] +{foo: i}.f64?.[list] +{foo: i}.foo +{foo: i}.foobar +{foo: i}.greet +{foo: i}.greet?.add +{foo: i}.i +{foo: i}.list +{foo: i}.nil?.array +{foo: i}.not +{foo: i}.ok +{foo: i}.str +{foo: i}?.Bar +{foo: i}?.Bar?.String +{foo: i}?.String +{foo: i}?.[str] +{foo: i}?.add +{foo: i}?.array +{foo: i}?.array?.[foo] +{foo: i}?.array?.greet +{foo: i}?.f64 +{foo: i}?.foo +{foo: i}?.foo == add +{foo: i}?.foobar +{foo: i}?.greet +{foo: i}?.greet?.ok +{foo: i}?.i +{foo: i}?.i?.f64 +{foo: i}?.list +{foo: i}?.ok +{foo: i}?.str +{foo: keys($env), foo: list} +{foo: keys($env)} +{foo: keys($env)}?.list +{foo: last($env)?.String} +{foo: last($env)} +{foo: last(array)} +{foo: last(list)} +{foo: len($env)} +{foo: len(array)} +{foo: len(list)} +{foo: let foobar = false; foobar} +{foo: let foobar = str; foobar} +{foo: list != $env} +{foo: list != list} +{foo: list != nil} +{foo: list == $env?.[str]} +{foo: list == $env} +{foo: list == list} +{foo: list == nil} +{foo: list | count(false)} +{foo: list | findIndex(true)}.add +{foo: list | groupBy(#)} +{foo: list | groupBy(foo)} +{foo: list | groupBy(ok)} +{foo: list | groupBy(str)} +{foo: list | one(false)} +{foo: list | reduce(#.Bar, nil)} +{foo: list | reduce(#.String, nil)} +{foo: list | reduce(0)} +{foo: list | reduce(false)} +{foo: list | reduce(foo)} +{foo: list | sortBy(.Bar)} +{foo: list | sum(1.0)} +{foo: list, foo: $env}.i +{foo: list, foo: $env}.list +{foo: list, foo: $env}.ok +{foo: list, foo: $env}.str +{foo: list, foo: $env}?.Bar +{foo: list, foo: $env}?.add +{foo: list, foo: $env}?.ok +{foo: list, foo: $env}?.str +{foo: list, foo: 0, foo: 0}?.add +{foo: list, foo: 0, foo: nil}.add +{foo: list, foo: 1.0 == 1.0} +{foo: list, foo: 1.0}.foo +{foo: list, foo: 1.0}.list +{foo: list, foo: 1.0}?.[str] +{foo: list, foo: 1.0}?.greet +{foo: list, foo: 1.0}?.ok +{foo: list, foo: 1}.list +{foo: list, foo: 1}?.String +{foo: list, foo: 1}?.foo +{foo: list, foo: 1}?.greet +{foo: list, foo: 1}?.i +{foo: list, foo: add} +{foo: list, foo: add}.array +{foo: list, foo: add}.i +{foo: list, foo: add}?.array +{foo: list, foo: add}?.f64 +{foo: list, foo: array} +{foo: list, foo: array}.greet +{foo: list, foo: array}.i +{foo: list, foo: array}?.array +{foo: list, foo: array}?.ok +{foo: list, foo: f64 - f64} +{foo: list, foo: f64} +{foo: list, foo: f64}.greet +{foo: list, foo: f64}?.Bar +{foo: list, foo: false}.foobar +{foo: list, foo: false}?.add +{foo: list, foo: false}?.f64 +{foo: list, foo: foo, foo: list}.Bar +{foo: list, foo: foo?.String()} +{foo: list, foo: foo} +{foo: list, foo: foo}.add +{foo: list, foo: foo}.array +{foo: list, foo: foo}.f64 +{foo: list, foo: foo}?.Bar +{foo: list, foo: foo}?.add +{foo: list, foo: foo}?.foo +{foo: list, foo: greet} +{foo: list, foo: greet}.list +{foo: list, foo: greet}?.greet +{foo: list, foo: i, foo: 1.0}?.list +{foo: list, foo: i} +{foo: list, foo: i}.array +{foo: list, foo: i}?.String?.add() +{foo: list, foo: i}?.foo +{foo: list, foo: i}?.list +{foo: list, foo: list} +{foo: list, foo: list}.Bar +{foo: list, foo: list}.String +{foo: list, foo: list}.foo +{foo: list, foo: list}?.String +{foo: list, foo: list}?.foo +{foo: list, foo: list}?.list +{foo: list, foo: list}?.ok +{foo: list, foo: max(0)} +{foo: list, foo: median(array)} +{foo: list, foo: nil}.String +{foo: list, foo: nil}.list +{foo: list, foo: nil}?.[str] +{foo: list, foo: nil}?.str +{foo: list, foo: ok} +{foo: list, foo: ok}.add +{foo: list, foo: ok}?.Bar +{foo: list, foo: ok}?.[str] +{foo: list, foo: str} +{foo: list, foo: str}.array +{foo: list, foo: str}?.String +{foo: list, foo: str}?.ok +{foo: list, foo: sum(array)} +{foo: list, foo: true, foo: add}?.ok +{foo: list, foo: true, foo: foo}.list +{foo: list, foo: true}.ok +{foo: list, foo: true}?.array +{foo: list?.[0]} +{foo: list?.[1]}?.add +{foo: list?.[i], foo: list} +{foo: list?.[i], foo: ok} +{foo: list?.[i]} +{foo: list?.[i]}.ok +{foo: list[:0]} +{foo: list} +{foo: list}.Bar +{foo: list}.String +{foo: list}.add +{foo: list}.add?.str +{foo: list}.array +{foo: list}.array?.f64 +{foo: list}.f64 +{foo: list}.f64?.greet().list() +{foo: list}.foo +{foo: list}.foobar +{foo: list}.foobar != true +{foo: list}.greet +{foo: list}.greet?.[str] +{foo: list}.i +{foo: list}.i?.[array] +{foo: list}.list +{foo: list}.list?.[greet] +{foo: list}.ok +{foo: list}.ok?.Bar +{foo: list}.str +{foo: list}?.Bar +{foo: list}?.Bar?.[foo] +{foo: list}?.Bar?.[list] +{foo: list}?.String +{foo: list}?.String?.list() +{foo: list}?.[str] +{foo: list}?.[str]?.[i] +{foo: list}?.[str]?.list +{foo: list}?.add +{foo: list}?.array +{foo: list}?.f64 +{foo: list}?.f64?.ok +{foo: list}?.foo +{foo: list}?.foobar +{foo: list}?.greet +{foo: list}?.greet?.list +{foo: list}?.i +{foo: list}?.list +{foo: list}?.ok +{foo: list}?.ok?.[ok] +{foo: list}?.str +{foo: list}?.str?.[list] +{foo: lower(str)} +{foo: map($env, $env)} +{foo: map($env, 1)} +{foo: map($env, 1.0)} +{foo: map($env, array)} +{foo: map($env, foo)} +{foo: map($env, greet)} +{foo: map($env, i)} +{foo: map($env, i)}?.add +{foo: map($env, list)} +{foo: map($env, ok)} +{foo: map(array, #)} +{foo: map(array, $env)} +{foo: map(array, 1)} +{foo: map(array, array)} +{foo: map(array, foo)} +{foo: map(list, #)} +{foo: map(list, #.Bar)} +{foo: map(list, $env)} +{foo: map(list, add)} +{foo: map(list, foo)} +{foo: map(list, greet)} +{foo: map(list, ok)} +{foo: max($env)} +{foo: max($env)}.i +{foo: max(1)} +{foo: max(1.0)} +{foo: max(array)} +{foo: max(f64)} +{foo: max(i)} +{foo: mean(0)} +{foo: mean(1.0 * 1.0)} +{foo: mean(1.0), foo: array} +{foo: mean(1.0)} +{foo: mean(1.0)}.ok +{foo: mean(array)} +{foo: mean(array, array)} +{foo: mean(array, i)} +{foo: mean(f64)} +{foo: mean(i)} +{foo: median(0)} +{foo: median(1)} +{foo: median(1.0)} +{foo: median(f64)} +{foo: median(flatten(array))} +{foo: median(i)} +{foo: median(i, array)}.Bar +{foo: min($env)?.String} +{foo: min($env)} +{foo: min(1), foo: ok} +{foo: min(1)} +{foo: min(1.0)} +{foo: min(1.0)}?.String +{foo: min(array)} +{foo: min(f64)} +{foo: min(i)} +{foo: min(i)}.list +{foo: nil != $env} +{foo: nil != 0} +{foo: nil != 1.0} +{foo: nil != add} +{foo: nil != array} +{foo: nil != f64} +{foo: nil != foo} +{foo: nil != greet} +{foo: nil != list} +{foo: nil != nil, foo: list} +{foo: nil != nil} +{foo: nil != ok} +{foo: nil != str} +{foo: nil != true} +{foo: nil == $env} +{foo: nil == 0} +{foo: nil == 1.0} +{foo: nil == add} +{foo: nil == array} +{foo: nil == false} +{foo: nil == foo} +{foo: nil == list}?.Bar +{foo: nil == nil} +{foo: nil == ok} +{foo: nil in $env} +{foo: nil in array} +{foo: nil in list} +{foo: nil not in $env} +{foo: nil, foo: $env}.Bar +{foo: nil, foo: $env}.String +{foo: nil, foo: $env}.add +{foo: nil, foo: $env}.f64 +{foo: nil, foo: $env}.foo +{foo: nil, foo: $env}.foobar +{foo: nil, foo: $env}.greet +{foo: nil, foo: $env}.list +{foo: nil, foo: $env}?.Bar +{foo: nil, foo: $env}?.Bar?.[f64] +{foo: nil, foo: $env}?.String +{foo: nil, foo: $env}?.foo +{foo: nil, foo: $env}?.list +{foo: nil, foo: $env}?.str +{foo: nil, foo: 0, foo: 0}.greet +{foo: nil, foo: 0, foo: true}?.[str] +{foo: nil, foo: 0}.f64 +{foo: nil, foo: 0}.list +{foo: nil, foo: 0}?.Bar +{foo: nil, foo: 0}?.String?.[f64] +{foo: nil, foo: 0}?.add +{foo: nil, foo: 0}?.greet +{foo: nil, foo: 1, foo: false}?.String +{foo: nil, foo: 1, foo: foo}.ok +{foo: nil, foo: 1.0}.array +{foo: nil, foo: 1.0}.foo +{foo: nil, foo: 1.0}.greet +{foo: nil, foo: 1.0}.list +{foo: nil, foo: 1.0}?.String +{foo: nil, foo: 1.0}?.[str] +{foo: nil, foo: 1.0}?.array +{foo: nil, foo: 1.0}?.f64 +{foo: nil, foo: 1.0}?.greet +{foo: nil, foo: 1.0}?.i +{foo: nil, foo: 1.0}?.ok +{foo: nil, foo: 1.0}?.str +{foo: nil, foo: 1}.String +{foo: nil, foo: 1}.array +{foo: nil, foo: 1}.f64 +{foo: nil, foo: 1}.list +{foo: nil, foo: 1}?.foo +{foo: nil, foo: add}.i +{foo: nil, foo: add}.list +{foo: nil, foo: add}?.String +{foo: nil, foo: add}?.foo +{foo: nil, foo: add}?.i +{foo: nil, foo: array, foo: add}?.add +{foo: nil, foo: array}.str +{foo: nil, foo: array}?.[str] +{foo: nil, foo: array}?.array +{foo: nil, foo: array}?.f64 +{foo: nil, foo: array}?.foobar +{foo: nil, foo: array}?.greet +{foo: nil, foo: f64}.String +{foo: nil, foo: f64}.add +{foo: nil, foo: f64}.greet +{foo: nil, foo: f64}?.ok +{foo: nil, foo: false}.Bar +{foo: nil, foo: false}.f64 +{foo: nil, foo: false}?.f64 +{foo: nil, foo: false}?.greet +{foo: nil, foo: false}?.i +{foo: nil, foo: false}?.ok +{foo: nil, foo: foo, foo: false}?.array +{foo: nil, foo: foo, foo: i}?.i +{foo: nil, foo: foo, foo: list}.Bar +{foo: nil, foo: foo}.String +{foo: nil, foo: foo}.add +{foo: nil, foo: foo}.array +{foo: nil, foo: foo}.foo +{foo: nil, foo: foo}.ok +{foo: nil, foo: foo}.str +{foo: nil, foo: foo}?.Bar +{foo: nil, foo: foo}?.[str] +{foo: nil, foo: foo}?.f64 +{foo: nil, foo: foo}?.i +{foo: nil, foo: foo}?.ok +{foo: nil, foo: greet}.String +{foo: nil, foo: greet}?.f64 +{foo: nil, foo: greet}?.foo +{foo: nil, foo: greet}?.greet +{foo: nil, foo: greet}?.str +{foo: nil, foo: i, foo: greet}?.String +{foo: nil, foo: i}.f64 +{foo: nil, foo: i}.foo +{foo: nil, foo: i}.i +{foo: nil, foo: i}.ok +{foo: nil, foo: i}?.array +{foo: nil, foo: list, foo: add}.Bar +{foo: nil, foo: list, foo: nil}.f64 +{foo: nil, foo: list}.Bar +{foo: nil, foo: list}.f64 +{foo: nil, foo: list}.f64?.str +{foo: nil, foo: list}?.Bar +{foo: nil, foo: nil, foo: greet}?.[str] +{foo: nil, foo: nil, foo: true}?.greet +{foo: nil, foo: nil}.array +{foo: nil, foo: nil}.foo +{foo: nil, foo: nil}.greet +{foo: nil, foo: nil}.ok +{foo: nil, foo: nil}?.Bar +{foo: nil, foo: nil}?.String +{foo: nil, foo: nil}?.add +{foo: nil, foo: nil}?.foo +{foo: nil, foo: nil}?.str +{foo: nil, foo: ok, foo: nil}.String +{foo: nil, foo: ok}.String +{foo: nil, foo: ok}.array +{foo: nil, foo: ok}.f64 +{foo: nil, foo: ok}.i +{foo: nil, foo: ok}?.Bar?.[add] +{foo: nil, foo: str}.String +{foo: nil, foo: str}.f64 +{foo: nil, foo: str}.i +{foo: nil, foo: str}.ok +{foo: nil, foo: str}.str +{foo: nil, foo: str}?.f64 +{foo: nil, foo: true}.String +{foo: nil, foo: true}.f64 +{foo: nil, foo: true}.ok +{foo: nil, foo: true}?.i +{foo: nil, foo: true}?.ok +{foo: nil}.Bar +{foo: nil}.Bar?.f64 +{foo: nil}.String +{foo: nil}.String?.[i] +{foo: nil}.String?.array +{foo: nil}.String?.greet +{foo: nil}.add +{foo: nil}.add?.[ok] +{foo: nil}.array +{foo: nil}.array?.[array] +{foo: nil}.array?.[foo] +{foo: nil}.array?.[str] +{foo: nil}.array?.str +{foo: nil}.f64 +{foo: nil}.foo +{foo: nil}.foo?.[list] +{foo: nil}.foobar?.i +{foo: nil}.greet +{foo: nil}.greet?.[foo] +{foo: nil}.i +{foo: nil}.list +{foo: nil}.not +{foo: nil}.ok +{foo: nil}.str +{foo: nil}?.Bar +{foo: nil}?.String +{foo: nil}?.[str] +{foo: nil}?.[str]?.[list] +{foo: nil}?.[str]?.[str] +{foo: nil}?.[str]?.ok +{foo: nil}?.add +{foo: nil}?.array +{foo: nil}?.f64 +{foo: nil}?.f64?.[i] +{foo: nil}?.foo +{foo: nil}?.foo?.[f64] +{foo: nil}?.foo?.i +{foo: nil}?.foobar?.add +{foo: nil}?.greet +{foo: nil}?.i +{foo: nil}?.i?.[greet] +{foo: nil}?.list +{foo: nil}?.list?.f64(foobar) +{foo: nil}?.ok +{foo: nil}?.str +{foo: none(list, ok)} +{foo: ok != $env} +{foo: ok != nil} +{foo: ok && false} +{foo: ok && ok} +{foo: ok == $env} +{foo: ok == $env}.String +{foo: ok == nil} +{foo: ok == true} +{foo: ok ? add : f64} +{foo: ok ? foo : 0} +{foo: ok ? greet : list} +{foo: ok ? nil : foo} +{foo: ok ?: array} +{foo: ok and $env} +{foo: ok or $env} +{foo: ok or false} +{foo: ok || $env} +{foo: ok, foo: $env.add} +{foo: ok, foo: $env?.i, foo: str} +{foo: ok, foo: $env}?.Bar +{foo: ok, foo: $env}?.String +{foo: ok, foo: $env}?.add +{foo: ok, foo: $env}?.f64 +{foo: ok, foo: $env}?.str +{foo: ok, foo: 0 > i} +{foo: ok, foo: 0, foo: 1.0}.String +{foo: ok, foo: 0}.Bar +{foo: ok, foo: 0}.ok +{foo: ok, foo: 0}?.list +{foo: ok, foo: 0}?.str +{foo: ok, foo: 1, foo: nil}?.str +{foo: ok, foo: 1.0 - i} +{foo: ok, foo: 1.0}.f64 +{foo: ok, foo: 1.0}.greet +{foo: ok, foo: 1.0}.list +{foo: ok, foo: 1.0}.ok +{foo: ok, foo: 1.0}.str +{foo: ok, foo: 1.0}?.Bar +{foo: ok, foo: 1.0}?.foo +{foo: ok, foo: 1.0}?.greet +{foo: ok, foo: 1.0}?.ok +{foo: ok, foo: 1}.array +{foo: ok, foo: 1}?.[str] +{foo: ok, foo: 1}?.add?.String +{foo: ok, foo: add} +{foo: ok, foo: add}.greet +{foo: ok, foo: add}.i +{foo: ok, foo: add}?.foo +{foo: ok, foo: add}?.greet?.ok +{foo: ok, foo: array} +{foo: ok, foo: array}.String +{foo: ok, foo: array}?.String +{foo: ok, foo: array}?.foo +{foo: ok, foo: array}?.list +{foo: ok, foo: f64} +{foo: ok, foo: f64}.greet +{foo: ok, foo: f64}.i +{foo: ok, foo: f64}?.Bar +{foo: ok, foo: f64}?.array +{foo: ok, foo: f64}?.f64 +{foo: ok, foo: f64}?.foo +{foo: ok, foo: f64}?.greet +{foo: ok, foo: false}?.String +{foo: ok, foo: false}?.ok +{foo: ok, foo: foo?.Bar} +{foo: ok, foo: foo} +{foo: ok, foo: foo}.Bar +{foo: ok, foo: foo}.f64 +{foo: ok, foo: foo}.i +{foo: ok, foo: foo}.ok +{foo: ok, foo: foo}.str +{foo: ok, foo: foo}?.Bar +{foo: ok, foo: greet} +{foo: ok, foo: greet}.i +{foo: ok, foo: greet}?.greet +{foo: ok, foo: i, foo: true}.foo +{foo: ok, foo: i} +{foo: ok, foo: i}.Bar +{foo: ok, foo: i}?.list +{foo: ok, foo: list} +{foo: ok, foo: list}?.array +{foo: ok, foo: list}?.foo +{foo: ok, foo: mean(0)} +{foo: ok, foo: nil, foo: $env}?.ok +{foo: ok, foo: nil, foo: greet}.i +{foo: ok, foo: nil, foo: greet}?.add +{foo: ok, foo: nil}.add +{foo: ok, foo: nil}.foo +{foo: ok, foo: nil}.greet +{foo: ok, foo: nil}.i +{foo: ok, foo: nil}?.foo +{foo: ok, foo: nil}?.ok +{foo: ok, foo: nil}?.str +{foo: ok, foo: ok} +{foo: ok, foo: ok}.f64 +{foo: ok, foo: ok}?.list +{foo: ok, foo: str} +{foo: ok, foo: str}.f64 +{foo: ok, foo: str}?.f64 +{foo: ok, foo: str}?.list +{foo: ok, foo: true}.true?.add +{foo: ok, foo: true}?.Bar +{foo: ok, foo: true}?.array?.greet +{foo: ok, foo: true}?.list +{foo: ok, foo: true}?.ok +{foo: ok} +{foo: ok}.Bar +{foo: ok}.String +{foo: ok}.add +{foo: ok}.array +{foo: ok}.f64 +{foo: ok}.foo +{foo: ok}.foobar +{foo: ok}.greet +{foo: ok}.i +{foo: ok}.i?.[list] +{foo: ok}.list +{foo: ok}.ok +{foo: ok}.ok?.greet +{foo: ok}.str +{foo: ok}?.Bar +{foo: ok}?.Bar?.[list] +{foo: ok}?.String +{foo: ok}?.String?.[i] +{foo: ok}?.String?.[str] +{foo: ok}?.[str] +{foo: ok}?.add +{foo: ok}?.add?.String?.ok +{foo: ok}?.array +{foo: ok}?.array?.i +{foo: ok}?.array?.str +{foo: ok}?.f64 +{foo: ok}?.foo +{foo: ok}?.greet +{foo: ok}?.i +{foo: ok}?.i?.ok +{foo: ok}?.list +{foo: ok}?.ok +{foo: ok}?.str +{foo: one(array, true)} +{foo: one(list, false)} +{foo: one(list, ok)} +{foo: reduce($env, #acc, foo)} +{foo: reduce(array, #)} +{foo: reduce(list, #)} +{foo: reduce(list, #.String)} +{foo: reduce(list, $env)} +{foo: reduce(list, 1.0)} +{foo: reduce(list, add)} +{foo: reduce(list, f64)} +{foo: reduce(list, false), foo: 1.0 * f64} +{foo: reduce(list, foo)} +{foo: reduce(list, str)} +{foo: reverse(array)} +{foo: round(0)} +{foo: round(1)} +{foo: round(1.0), foo: str} +{foo: round(1.0)} +{foo: round(f64)} +{foo: round(i)} +{foo: round(i)}?.ok +{foo: sort($env)} +{foo: sort(array)} +{foo: sortBy(array, #)} +{foo: sortBy(array, 0)} +{foo: sortBy(array, 1.0)} +{foo: sortBy(list, 1.0)} +{foo: sortBy(list, i)} +{foo: sortBy(list, str)} +{foo: str != $env?.[Bar]} +{foo: str == nil} +{foo: str == str} +{foo: str >= str, foo: str} +{foo: str in $env} +{foo: str in foo} +{foo: str matches str} +{foo: str not contains str} +{foo: str not endsWith str} +{foo: str not in $env} +{foo: str not in foo} +{foo: str not matches str} +{foo: str startsWith str} +{foo: str, foo: $env != 0} +{foo: str, foo: $env, foo: nil}.str +{foo: str, foo: $env.f64} +{foo: str, foo: $env.greet} +{foo: str, foo: $env}.foo +{foo: str, foo: $env}.greet +{foo: str, foo: $env}.list +{foo: str, foo: $env}.str +{foo: str, foo: $env}?.[str] +{foo: str, foo: 0}.add +{foo: str, foo: 0}?.array +{foo: str, foo: 0}?.ok +{foo: str, foo: 1.0}.foo +{foo: str, foo: 1.0}.greet +{foo: str, foo: 1.0}.i +{foo: str, foo: 1.0}.str +{foo: str, foo: 1.0}?.[str] +{foo: str, foo: 1.0}?.add +{foo: str, foo: 1.0}?.foo +{foo: str, foo: 1.0}?.ok +{foo: str, foo: 1.0}?.str +{foo: str, foo: 1}.Bar +{foo: str, foo: 1}.foo +{foo: str, foo: 1}.str +{foo: str, foo: 1}?.list +{foo: str, foo: [f64]} +{foo: str, foo: add, foo: f64}?.ok +{foo: str, foo: add} +{foo: str, foo: add}.Bar +{foo: str, foo: add}.f64 +{foo: str, foo: add}.greet +{foo: str, foo: add}.i +{foo: str, foo: add}?.[str] +{foo: str, foo: array} +{foo: str, foo: array}.greet +{foo: str, foo: array}.list +{foo: str, foo: array}.ok +{foo: str, foo: array}?.String +{foo: str, foo: array}?.foo +{foo: str, foo: array}?.i +{foo: str, foo: f64} +{foo: str, foo: f64}.add +{foo: str, foo: f64}?.String +{foo: str, foo: f64}?.add?.[add] +{foo: str, foo: f64}?.list +{foo: str, foo: false}.array +{foo: str, foo: false}.f64 +{foo: str, foo: false}?.[str] +{foo: str, foo: foo, foo: array}?.str +{foo: str, foo: foo} +{foo: str, foo: foo}.Bar +{foo: str, foo: foo}.f64?.foo +{foo: str, foo: foo}.ok +{foo: str, foo: foo}.str +{foo: str, foo: foo}?.[str]?.String() +{foo: str, foo: foo}?.add +{foo: str, foo: foo}?.f64 +{foo: str, foo: foo}?.f64?.f64 +{foo: str, foo: foo}?.greet +{foo: str, foo: greet(str)} +{foo: str, foo: greet} +{foo: str, foo: greet}.Bar +{foo: str, foo: greet}.ok +{foo: str, foo: greet}?.add +{foo: str, foo: i} +{foo: str, foo: i}.Bar +{foo: str, foo: i}.array +{foo: str, foo: i}?.list +{foo: str, foo: list} +{foo: str, foo: list}.String +{foo: str, foo: list}?.foo +{foo: str, foo: map($env, 0)} +{foo: str, foo: median(1.0)} +{foo: str, foo: nil}.add +{foo: str, foo: nil}?.Bar +{foo: str, foo: nil}?.i +{foo: str, foo: nil}?.list +{foo: str, foo: ok, foo: array} +{foo: str, foo: ok} +{foo: str, foo: ok}.list +{foo: str, foo: ok}?.Bar +{foo: str, foo: str} +{foo: str, foo: str}.add +{foo: str, foo: str}.foo +{foo: str, foo: str}?.greet +{foo: str, foo: true}.array +{foo: str, foo: true}.ok?.String +{foo: str, foo: true}?.Bar +{foo: str, foo: true}?.foo +{foo: str, foo: true}?.i +{foo: str[:1]} +{foo: string($env), foo: list} +{foo: string($env)} +{foo: string(0)} +{foo: string(1)} +{foo: string(1.0)} +{foo: string(array)} +{foo: string(array)}.foo +{foo: string(f64)} +{foo: string(foo)} +{foo: string(greet), foo: array} +{foo: string(greet)} +{foo: string(list), foo: i} +{foo: string(nil)} +{foo: string(ok)} +{foo: string(str)} +{foo: string(true)} +{foo: str} +{foo: str} != $env?.[Bar] +{foo: str}.Bar +{foo: str}.String +{foo: str}.add +{foo: str}.array +{foo: str}.f64 +{foo: str}.f64?.[list] +{foo: str}.foo +{foo: str}.foobar?.Bar +{foo: str}.greet +{foo: str}.greet?.array +{foo: str}.greet?.array?.i +{foo: str}.i +{foo: str}.list +{foo: str}.ok +{foo: str}.str +{foo: str}?.Bar +{foo: str}?.Bar?.String +{foo: str}?.String +{foo: str}?.String?.[i] +{foo: str}?.[str] +{foo: str}?.add +{foo: str}?.array +{foo: str}?.f64 +{foo: str}?.f64?.[f64] +{foo: str}?.foo +{foo: str}?.foobar +{foo: str}?.greet +{foo: str}?.greet?.Bar +{foo: str}?.greet?.greet +{foo: str}?.i +{foo: str}?.i in array +{foo: str}?.i?.[ok] +{foo: str}?.list +{foo: str}?.list?.[array] +{foo: str}?.nil?.Bar(true) +{foo: str}?.ok +{foo: str}?.ok not endsWith $env +{foo: str}?.ok?.[ok] +{foo: str}?.str +{foo: sum($env, 1)} +{foo: sum($env, 1.0)} +{foo: sum($env, f64)} +{foo: sum(array), foo: list} +{foo: sum(array), foo: ok} +{foo: sum(array)} +{foo: sum(array)}?.array +{foo: sum(array, #)} +{foo: sum(array, 1.0)} +{foo: toBase64(str)} +{foo: toJSON(0)} +{foo: toJSON(1)} +{foo: toJSON(1.0), foo: f64} +{foo: toJSON(1.0)} +{foo: toJSON(array)} +{foo: toJSON(f64), foo: array} +{foo: toJSON(f64)} +{foo: toJSON(false)} +{foo: toJSON(foo), foo: foo?.String} +{foo: toJSON(foo)} +{foo: toJSON(i), foo: add} +{foo: toJSON(i)} +{foo: toJSON(list)} +{foo: toJSON(nil)} +{foo: toJSON(ok)} +{foo: toJSON(str)} +{foo: toJSON(true)} +{foo: toPairs($env), foo: list} +{foo: toPairs($env)} +{foo: trim(str)} +{foo: trimPrefix(str)} +{foo: trimSuffix(str)} +{foo: trimSuffix(string(nil))} +{foo: true != $env} +{foo: true != false} +{foo: true != nil} +{foo: true && $env} +{foo: true && true} +{foo: true && true}.String +{foo: true == $env} +{foo: true == nil} +{foo: true == true} +{foo: true ? add : i} +{foo: true ? ok : 0} +{foo: true ?: foo} +{foo: true or $env} +{foo: true || $env} +{foo: true || false} +{foo: true || ok} +{foo: true, foo: $env, foo: 1.0}?.greet +{foo: true, foo: $env}.f64 +{foo: true, foo: $env}.i +{foo: true, foo: $env}.list +{foo: true, foo: $env}?.String +{foo: true, foo: $env}?.add +{foo: true, foo: $env}?.i +{foo: true, foo: $env}?.ok +{foo: true, foo: 0}?.array +{foo: true, foo: 1.0, foo: nil}.list +{foo: true, foo: 1.0}.Bar +{foo: true, foo: 1.0}.array +{foo: true, foo: 1.0}.i +{foo: true, foo: 1.0}.ok +{foo: true, foo: 1.0}?.i +{foo: true, foo: 1.0}?.ok +{foo: true, foo: 1}.Bar +{foo: true, foo: 1}.array +{foo: true, foo: 1}.foo +{foo: true, foo: 1}.i +{foo: true, foo: 1}?.[str] +{foo: true, foo: 1}?.foo +{foo: true, foo: 1}?.greet +{foo: true, foo: add}.f64 +{foo: true, foo: add}?.Bar +{foo: true, foo: add}?.String +{foo: true, foo: add}?.array +{foo: true, foo: add}?.greet +{foo: true, foo: array}.add +{foo: true, foo: array}.i +{foo: true, foo: f64}.greet +{foo: true, foo: f64}.i +{foo: true, foo: false}.Bar +{foo: true, foo: false}.i?.[ok] +{foo: true, foo: false}?.foo +{foo: true, foo: false}?.greet +{foo: true, foo: foo}.String +{foo: true, foo: foo}.greet +{foo: true, foo: foo}.ok +{foo: true, foo: foo}.str?.list() +{foo: true, foo: foo}?.[str] +{foo: true, foo: foo}?.add +{foo: true, foo: foo}?.f64 +{foo: true, foo: foo}?.greet +{foo: true, foo: foo}?.list +{foo: true, foo: foo}?.ok +{foo: true, foo: foo}?.str +{foo: true, foo: greet}.Bar +{foo: true, foo: greet}.f64 +{foo: true, foo: greet}.foo +{foo: true, foo: greet}?.[str] +{foo: true, foo: i}.String +{foo: true, foo: i}.add +{foo: true, foo: i}.i +{foo: true, foo: i}.str +{foo: true, foo: i}?.Bar +{foo: true, foo: i}?.array +{foo: true, foo: list}?.[str] +{foo: true, foo: list}?.greet +{foo: true, foo: nil, foo: list}?.[str] +{foo: true, foo: nil}.add +{foo: true, foo: nil}?.String +{foo: true, foo: nil}?.add +{foo: true, foo: ok}.Bar +{foo: true, foo: ok}.foo +{foo: true, foo: ok}.list +{foo: true, foo: ok}?.[str] +{foo: true, foo: str}.Bar +{foo: true, foo: str}.array +{foo: true, foo: str}.f64 +{foo: true, foo: str}.str +{foo: true, foo: str}?.array +{foo: true, foo: str}?.greet +{foo: true, foo: str}?.ok +{foo: true, foo: true}.list +{foo: true} not in $env?.String +{foo: true}.Bar +{foo: true}.Bar?.[add] +{foo: true}.String +{foo: true}.String?.[foo] +{foo: true}.add +{foo: true}.add?.i +{foo: true}.array +{foo: true}.f64 +{foo: true}.f64?.add +{foo: true}.false == add +{foo: true}.foo +{foo: true}.foo ? ok : nil +{foo: true}.foobar +{foo: true}.greet +{foo: true}.i +{foo: true}.list +{foo: true}.list?.[str] +{foo: true}.ok +{foo: true}.ok?.array +{foo: true}.str +{foo: true}?.Bar +{foo: true}?.Bar?.[list] +{foo: true}?.Bar?.list +{foo: true}?.String +{foo: true}?.String?.[ok] +{foo: true}?.[str] +{foo: true}?.add +{foo: true}?.add?.[foo] +{foo: true}?.add?.ok +{foo: true}?.array +{foo: true}?.array?.[ok] +{foo: true}?.f64 +{foo: true}?.foo +{foo: true}?.greet +{foo: true}?.greet?.[greet] +{foo: true}?.greet?.greet +{foo: true}?.i +{foo: true}?.i?.Bar +{foo: true}?.list +{foo: true}?.list?.[greet] +{foo: true}?.ok +{foo: true}?.ok?.Bar +{foo: true}?.str +{foo: true}?.str?.greet +{foo: type($env)} +{foo: type(0)} +{foo: type(1)} +{foo: type(1.0)} +{foo: type(1.0)}?.f64 +{foo: type(add)} +{foo: type(array)} +{foo: type(f64)} +{foo: type(false)} +{foo: type(foo), foo: f64} +{foo: type(foo)} +{foo: type(greet)} +{foo: type(i)} +{foo: type(list)} +{foo: type(nil)} +{foo: type(ok)} +{foo: type(str)} +{foo: type(true)} +{foo: uniq(array)} +{foo: uniq(list)} +{foo: upper(str)} +{foo: values($env)} +{foo: {foo: $env}} +{foo: {foo: 0, foo: 1.0}} +{foo: {foo: 0, foo: nil}} +{foo: {foo: 0}} +{foo: {foo: 0}}?.array +{foo: {foo: 0}}?.f64 +{foo: {foo: 1, foo: 0}} +{foo: {foo: 1.0, foo: true}} +{foo: {foo: 1.0}} +{foo: {foo: 1}} +{foo: {foo: add, foo: foo}} +{foo: {foo: add, foo: greet}} +{foo: {foo: array}} +{foo: {foo: f64}} +{foo: {foo: false, foo: $env}?.foo} +{foo: {foo: false}} +{foo: {foo: false}}.Bar +{foo: {foo: foo, foo: 1.0}} +{foo: {foo: foo}, foo: $env?.greet} +{foo: {foo: foo}?.ok} +{foo: {foo: foo}?.str} +{foo: {foo: foo}} +{foo: {foo: foo}}?.i +{foo: {foo: greet, foo: 0}} +{foo: {foo: greet, foo: i}} +{foo: {foo: greet}} +{foo: {foo: i, foo: array}} +{foo: {foo: i}} +{foo: {foo: list?.[0]}} +{foo: {foo: list}} +{foo: {foo: nil, foo: $env}} +{foo: {foo: nil, foo: foo}} +{foo: {foo: nil}} +{foo: {foo: ok, foo: nil}} +{foo: {foo: ok, foo: true}} +{foo: {foo: ok}} +{foo: {foo: ok}}.list +{foo: {foo: str}} +{foo: {foo: true}} From 646c17c96211377b1bcbf5dc35a0bfde9aae0198 Mon Sep 17 00:00:00 2001 From: Anton Medvedev Date: Fri, 21 Mar 2025 18:09:09 +0100 Subject: [PATCH 086/113] Add examples testing --- test/examples/examples_test.go | 55 ++++++++++ test/gen/gen_test.go | 2 +- testdata/examples.md | 129 +++++++++++++++++++++++ testdata/{examples.txt => generated.txt} | 0 4 files changed, 185 insertions(+), 1 deletion(-) create mode 100644 test/examples/examples_test.go create mode 100644 testdata/examples.md rename testdata/{examples.txt => generated.txt} (100%) diff --git a/test/examples/examples_test.go b/test/examples/examples_test.go new file mode 100644 index 000000000..ee6d1a3cb --- /dev/null +++ b/test/examples/examples_test.go @@ -0,0 +1,55 @@ +package main + +import ( + "flag" + "os" + "strings" + "testing" + + "github.com/expr-lang/expr" + "github.com/expr-lang/expr/internal/testify/require" +) + +func TestExamples(t *testing.T) { + flag.Parse() + + b, err := os.ReadFile("../../testdata/examples.md") + require.NoError(t, err) + examples := extractCodeBlocks(string(b)) + + for _, line := range examples { + line := line + t.Run(line, func(t *testing.T) { + program, err := expr.Compile(line, expr.Env(nil)) + require.NoError(t, err) + + _, err = expr.Run(program, nil) + require.NoError(t, err) + }) + } +} + +func extractCodeBlocks(markdown string) []string { + var blocks []string + var currentBlock []string + inBlock := false + + lines := strings.Split(markdown, "\n") + for _, line := range lines { + trimmed := strings.TrimSpace(line) + if strings.HasPrefix(trimmed, "```") { + if inBlock { + blocks = append(blocks, strings.Join(currentBlock, "\n")) + currentBlock = nil + inBlock = false + } else { + inBlock = true + } + continue + } + if inBlock { + currentBlock = append(currentBlock, line) + } + } + return blocks +} diff --git a/test/gen/gen_test.go b/test/gen/gen_test.go index cb6c08e00..4050fc6e9 100644 --- a/test/gen/gen_test.go +++ b/test/gen/gen_test.go @@ -16,7 +16,7 @@ var updateFlag = flag.Bool("update", false, "Drop failing lines from examples.tx func TestGenerated(t *testing.T) { flag.Parse() - b, err := os.ReadFile("../../testdata/examples.txt") + b, err := os.ReadFile("../../testdata/generated.txt") require.NoError(t, err) examples := strings.TrimSpace(string(b)) diff --git a/testdata/examples.md b/testdata/examples.md new file mode 100644 index 000000000..87b4fb1a8 --- /dev/null +++ b/testdata/examples.md @@ -0,0 +1,129 @@ +# Examples + +Character Frequency Grouping + +``` +let char = "0"; +1..100000 +| map(string(#)) +| groupBy(split(#, char) | len() - 1) +| toPairs() +| map({{ + count: #[0], + len: len(#[1]), + examples: [first(#[1]), last(#[1])], + }}) +| sortBy(.len, 'desc') +``` + +Log Filtering and Aggregation + +``` +let logs = [ + {timestamp: date("2023-08-14 08:30:00"), message: "User logged in", level: "info"}, + {timestamp: date("2023-08-14 09:00:00"), message: "Error processing payment", level: "error"}, + {timestamp: date("2023-08-14 10:15:00"), message: "User logged out", level: "info"}, + {timestamp: date("2023-08-14 11:00:00"), message: "Error connecting to database", level: "error"} +]; + +logs +| filter(.level == "error") +| map({{ + time: string(.timestamp), + detail: .message + }}) +| sortBy(.time) +``` + +Financial Data Analysis and Summary + +``` +let accounts = [ + {name: "Alice", balance: 1234.56, transactions: [100, -50, 200]}, + {name: "Bob", balance: 2345.67, transactions: [-200, 300, -150]}, + {name: "Charlie", balance: 3456.78, transactions: [400, -100, 50]} +]; + +{ + totalBalance: sum(accounts, .balance), + averageBalance: mean(map(accounts, .balance)), + totalTransactions: reduce(accounts, #acc + len(.transactions), 0), + accounts: map(accounts, {{ + name: .name, + final: .balance + sum(.transactions), + transactionCount: len(.transactions) + }}) +} +``` + +Bitwise Operations and Flags Decoding + +``` +let flags = [ + {name: "read", value: 0b0001}, + {name: "write", value: 0b0010}, + {name: "execute", value: 0b0100}, + {name: "admin", value: 0b1000} +]; + +let userPermissions = 0b1011; + +flags +| filter(userPermissions | bitand(.value) != 0) +| map(.name) +``` + +Nested Predicates with Optional Chaining + +``` +let users = [ + {id: 1, name: "Alice", posts: [{title: "Hello World", content: "Short post"}, {title: "Another Post", content: "This is a bit longer post"}]}, + {id: 2, name: "Bob", posts: nil}, + {id: 3, name: "Charlie", posts: [{title: "Quick Update", content: "Update content"}]} +]; + +users +| filter( + // Check if any post has content length greater than 10. + any(.posts ?? [], len(.content) > 10) + ) +| map({{name: .name, postCount: len(.posts ?? [])}}) +``` + +String Manipulation and Validation + +``` +" Apple, banana, Apple, orange, banana, kiwi " +| trim() +| split(",") +| map(trim(#)) +| map(lower(#)) +| uniq() +| sort() +| join(", ") +``` + +Date Difference + +``` +let startDate = date("2023-01-01"); +let endDate = date("2023-12-31"); +let diff = endDate - startDate; +{ + daysBetween: diff.Hours() / 24, + hoursBetween: diff.Hours() +} +``` + +Phone number filtering + +``` +let phone = filter(split("123-456-78901", ""), # in map(0..9, string(#)))[:10]; +join(concat(["("], phone[:3], [")"], phone[3:6], ["-"], phone[6:])) +``` + +Prime numbers + +``` +2..1000 | filter(let N = #; none(2..N-1, N % # == 0)) +``` diff --git a/testdata/examples.txt b/testdata/generated.txt similarity index 100% rename from testdata/examples.txt rename to testdata/generated.txt From 3a0a1da527d97b1bf115ef1d17f3e3d34772d0d9 Mon Sep 17 00:00:00 2001 From: Anton Medvedev Date: Mon, 24 Mar 2025 12:01:07 +0100 Subject: [PATCH 087/113] Refactor examples tests --- test/examples/examples_test.go | 47 +++++++-------------------- test/examples/markdown.go | 59 ++++++++++++++++++++++++++++++++++ 2 files changed, 71 insertions(+), 35 deletions(-) create mode 100644 test/examples/markdown.go diff --git a/test/examples/examples_test.go b/test/examples/examples_test.go index ee6d1a3cb..86de35d3f 100644 --- a/test/examples/examples_test.go +++ b/test/examples/examples_test.go @@ -1,26 +1,28 @@ package main import ( - "flag" "os" - "strings" "testing" "github.com/expr-lang/expr" "github.com/expr-lang/expr/internal/testify/require" ) -func TestExamples(t *testing.T) { - flag.Parse() +var examples []CodeBlock +func init() { b, err := os.ReadFile("../../testdata/examples.md") - require.NoError(t, err) - examples := extractCodeBlocks(string(b)) + if err != nil { + panic(err) + } + examples = extractCodeBlocksWithTitle(string(b)) +} - for _, line := range examples { - line := line - t.Run(line, func(t *testing.T) { - program, err := expr.Compile(line, expr.Env(nil)) +func TestExamples(t *testing.T) { + for _, code := range examples { + code := code + t.Run(code.Title, func(t *testing.T) { + program, err := expr.Compile(code.Content, expr.Env(nil)) require.NoError(t, err) _, err = expr.Run(program, nil) @@ -28,28 +30,3 @@ func TestExamples(t *testing.T) { }) } } - -func extractCodeBlocks(markdown string) []string { - var blocks []string - var currentBlock []string - inBlock := false - - lines := strings.Split(markdown, "\n") - for _, line := range lines { - trimmed := strings.TrimSpace(line) - if strings.HasPrefix(trimmed, "```") { - if inBlock { - blocks = append(blocks, strings.Join(currentBlock, "\n")) - currentBlock = nil - inBlock = false - } else { - inBlock = true - } - continue - } - if inBlock { - currentBlock = append(currentBlock, line) - } - } - return blocks -} diff --git a/test/examples/markdown.go b/test/examples/markdown.go new file mode 100644 index 000000000..c90bcb71b --- /dev/null +++ b/test/examples/markdown.go @@ -0,0 +1,59 @@ +package main + +import ( + "strings" +) + +// CodeBlock holds the optional title and content of a code block. +type CodeBlock struct { + Title string + Content string +} + +func extractCodeBlocksWithTitle(markdown string) []CodeBlock { + var blocks []CodeBlock + var currentBlock []string + var currentTitle string + inBlock := false + + // Split the markdown into lines. + lines := strings.Split(markdown, "\n") + for i, line := range lines { + trimmed := strings.TrimSpace(line) + // Check if the line starts with a code block fence. + if strings.HasPrefix(trimmed, "```") { + // If already inside a code block, this marks its end. + if inBlock { + blocks = append(blocks, CodeBlock{ + Title: currentTitle, + Content: strings.Join(currentBlock, "\n"), + }) + currentBlock = nil + inBlock = false + currentTitle = "" + } else { + // Not in a block: starting a new code block. + // Look backwards for the closest non-empty line that is not a code fence. + title := "" + for j := i - 1; j >= 0; j-- { + prev := strings.TrimSpace(lines[j]) + if prev == "" || strings.HasPrefix(prev, "```") { + continue + } + title = prev + break + } + currentTitle = title + inBlock = true + } + // Skip the fence line. + continue + } + + // If inside a code block, add the line. + if inBlock { + currentBlock = append(currentBlock, line) + } + } + return blocks +} From 6121e25ba004896f054266209a7b4781822c1722 Mon Sep 17 00:00:00 2001 From: Anton Medvedev Date: Mon, 24 Mar 2025 14:48:41 +0100 Subject: [PATCH 088/113] Make expr.Eval faster (#775) * Make expr.Eval faster * Add bench_call_test.go * Make parser config optional --- bench_test.go | 20 +++++++++++ builtin/builtin_test.go | 12 +++++-- compiler/compiler.go | 16 +++++---- expr.go | 8 ++++- expr_test.go | 2 +- parser/lexer/lexer_test.go | 14 ++++---- parser/parser.go | 18 +++++++--- test/bench/bench_call_test.go | 63 +++++++++++++++++++++++++++++++++++ 8 files changed, 130 insertions(+), 23 deletions(-) create mode 100644 test/bench/bench_call_test.go diff --git a/bench_test.go b/bench_test.go index de159bed9..c9f2b7182 100644 --- a/bench_test.go +++ b/bench_test.go @@ -31,6 +31,26 @@ func Benchmark_expr(b *testing.B) { require.True(b, out.(bool)) } +func Benchmark_expr_eval(b *testing.B) { + params := make(map[string]any) + params["Origin"] = "MOW" + params["Country"] = "RU" + params["Adults"] = 1 + params["Value"] = 100 + + var out any + var err error + + b.ResetTimer() + for n := 0; n < b.N; n++ { + out, err = expr.Eval(`(Origin == "MOW" || Country == "RU") && (Value >= 100 || Adults == 1)`, params) + } + b.StopTimer() + + require.NoError(b, err) + require.True(b, out.(bool)) +} + func Benchmark_expr_reuseVm(b *testing.B) { params := make(map[string]any) params["Origin"] = "MOW" diff --git a/builtin/builtin_test.go b/builtin/builtin_test.go index 71f775a49..6ca1e8fdd 100644 --- a/builtin/builtin_test.go +++ b/builtin/builtin_test.go @@ -246,9 +246,15 @@ func TestBuiltin_errors(t *testing.T) { } for _, test := range errorTests { t.Run(test.input, func(t *testing.T) { - _, err := expr.Eval(test.input, nil) - assert.Error(t, err) - assert.Contains(t, err.Error(), test.err) + program, err := expr.Compile(test.input) + if err != nil { + assert.Error(t, err) + assert.Contains(t, err.Error(), test.err) + } else { + _, err = expr.Run(program, nil) + assert.Error(t, err) + assert.Contains(t, err.Error(), test.err) + } }) } } diff --git a/compiler/compiler.go b/compiler/compiler.go index 90e54e54b..595355d28 100644 --- a/compiler/compiler.go +++ b/compiler/compiler.go @@ -776,12 +776,16 @@ func (c *compiler) CallNode(node *ast.CallNode) { } c.compile(node.Callee) - isMethod, _, _ := checker.MethodIndex(c.config.Env, node.Callee) - if index, ok := checker.TypedFuncIndex(node.Callee.Type(), isMethod); ok { - c.emit(OpCallTyped, index) - return - } else if checker.IsFastFunc(node.Callee.Type(), isMethod) { - c.emit(OpCallFast, len(node.Arguments)) + if c.config != nil { + isMethod, _, _ := checker.MethodIndex(c.config.Env, node.Callee) + if index, ok := checker.TypedFuncIndex(node.Callee.Type(), isMethod); ok { + c.emit(OpCallTyped, index) + return + } else if checker.IsFastFunc(node.Callee.Type(), isMethod) { + c.emit(OpCallFast, len(node.Arguments)) + } else { + c.emit(OpCall, len(node.Arguments)) + } } else { c.emit(OpCall, len(node.Arguments)) } diff --git a/expr.go b/expr.go index 5e60791e1..33b7cf354 100644 --- a/expr.go +++ b/expr.go @@ -13,6 +13,7 @@ import ( "github.com/expr-lang/expr/conf" "github.com/expr-lang/expr/file" "github.com/expr-lang/expr/optimizer" + "github.com/expr-lang/expr/parser" "github.com/expr-lang/expr/patcher" "github.com/expr-lang/expr/vm" ) @@ -240,7 +241,12 @@ func Eval(input string, env any) (any, error) { return nil, fmt.Errorf("misused expr.Eval: second argument (env) should be passed without expr.Env") } - program, err := Compile(input) + tree, err := parser.Parse(input) + if err != nil { + return nil, err + } + + program, err := compiler.Compile(tree, nil) if err != nil { return nil, err } diff --git a/expr_test.go b/expr_test.go index 4ebe6d4de..4d3736a97 100644 --- a/expr_test.go +++ b/expr_test.go @@ -1684,7 +1684,7 @@ func TestEval_exposed_error(t *testing.T) { fileError, ok := err.(*file.Error) require.True(t, ok, "error should be of type *file.Error") - require.Equal(t, "integer divide by zero (1:3)\n | 1 % 0\n | ..^", fileError.Error()) + require.Equal(t, "runtime error: integer divide by zero (1:3)\n | 1 % 0\n | ..^", fileError.Error()) require.Equal(t, 2, fileError.Column) require.Equal(t, 1, fileError.Line) } diff --git a/parser/lexer/lexer_test.go b/parser/lexer/lexer_test.go index f1cb3f28f..db02d2acf 100644 --- a/parser/lexer/lexer_test.go +++ b/parser/lexer/lexer_test.go @@ -311,13 +311,13 @@ func TestLex_location(t *testing.T) { tokens, err := Lex(source) require.NoError(t, err) require.Equal(t, []Token{ - {Location: file.Location{From: 0, To: 1}, Kind: "Number", Value: "1"}, - {Location: file.Location{From: 1, To: 3}, Kind: "Operator", Value: ".."}, - {Location: file.Location{From: 3, To: 4}, Kind: "Number", Value: "2"}, - {Location: file.Location{From: 5, To: 6}, Kind: "Number", Value: "3"}, - {Location: file.Location{From: 6, To: 8}, Kind: "Operator", Value: ".."}, - {Location: file.Location{From: 8, To: 9}, Kind: "Number", Value: "4"}, - {Location: file.Location{From: 8, To: 9}, Kind: "EOF", Value: ""}, + {Location: file.Location{From: 0, To: 1}, Kind: Number, Value: "1"}, + {Location: file.Location{From: 1, To: 3}, Kind: Operator, Value: ".."}, + {Location: file.Location{From: 3, To: 4}, Kind: Number, Value: "2"}, + {Location: file.Location{From: 5, To: 6}, Kind: Number, Value: "3"}, + {Location: file.Location{From: 6, To: 8}, Kind: Operator, Value: ".."}, + {Location: file.Location{From: 8, To: 9}, Kind: Number, Value: "4"}, + {Location: file.Location{From: 8, To: 9}, Kind: EOF, Value: ""}, }, tokens) } diff --git a/parser/parser.go b/parser/parser.go index 91c0fa8f8..0a463fed5 100644 --- a/parser/parser.go +++ b/parser/parser.go @@ -56,6 +56,13 @@ type parser struct { func (p *parser) checkNodeLimit() error { p.nodeCount++ + if p.config == nil { + if p.nodeCount > conf.DefaultMaxNodes { + p.error("compilation failed: expression exceeds maximum allowed nodes") + return nil + } + return nil + } if p.config.MaxNodes > 0 && p.nodeCount > p.config.MaxNodes { p.error("compilation failed: expression exceeds maximum allowed nodes") return nil @@ -91,9 +98,7 @@ type Tree struct { } func Parse(input string) (*Tree, error) { - return ParseWithConfig(input, &conf.Config{ - Disabled: map[string]bool{}, - }) + return ParseWithConfig(input, nil) } func ParseWithConfig(input string, config *conf.Config) (*Tree, error) { @@ -515,7 +520,10 @@ func (p *parser) toFloatNode(number float64) Node { func (p *parser) parseCall(token Token, arguments []Node, checkOverrides bool) Node { var node Node - isOverridden := p.config.IsOverridden(token.Value) + isOverridden := false + if p.config != nil { + isOverridden = p.config.IsOverridden(token.Value) + } isOverridden = isOverridden && checkOverrides if b, ok := predicates[token.Value]; ok && !isOverridden { @@ -562,7 +570,7 @@ func (p *parser) parseCall(token Token, arguments []Node, checkOverrides bool) N if node == nil { return nil } - } else if _, ok := builtin.Index[token.Value]; ok && !p.config.Disabled[token.Value] && !isOverridden { + } else if _, ok := builtin.Index[token.Value]; ok && (p.config == nil || !p.config.Disabled[token.Value]) && !isOverridden { node = p.createNode(&BuiltinNode{ Name: token.Value, Arguments: p.parseArguments(arguments), diff --git a/test/bench/bench_call_test.go b/test/bench/bench_call_test.go new file mode 100644 index 000000000..9c9c13226 --- /dev/null +++ b/test/bench/bench_call_test.go @@ -0,0 +1,63 @@ +package bench_test + +import ( + "testing" + + "github.com/expr-lang/expr" + "github.com/expr-lang/expr/internal/testify/require" + "github.com/expr-lang/expr/vm" +) + +type Env struct { + Fn func() bool +} + +func BenchmarkCall_callTyped(b *testing.B) { + code := `Fn()` + + p, err := expr.Compile(code, expr.Env(Env{})) + require.NoError(b, err) + require.Equal(b, p.Bytecode[1], vm.OpCallTyped) + + env := Env{ + Fn: func() bool { + return true + }, + } + + var out any + + b.ResetTimer() + for n := 0; n < b.N; n++ { + program, _ := expr.Compile(code, expr.Env(env)) + out, err = vm.Run(program, env) + } + b.StopTimer() + + require.NoError(b, err) + require.True(b, out.(bool)) +} + +func BenchmarkCall_eval(b *testing.B) { + code := `Fn()` + + p, err := expr.Compile(code) + require.NoError(b, err) + require.Equal(b, p.Bytecode[1], vm.OpCall) + + env := Env{ + Fn: func() bool { + return true + }, + } + + var out any + b.ResetTimer() + for n := 0; n < b.N; n++ { + out, err = expr.Eval(code, env) + } + b.StopTimer() + + require.NoError(b, err) + require.True(b, out.(bool)) +} From bb2a3e57f2482e427f994f4bbfca6af8de0d8809 Mon Sep 17 00:00:00 2001 From: Anton Medvedev Date: Fri, 28 Mar 2025 15:43:54 +0100 Subject: [PATCH 089/113] Add gotestfmt --- .github/workflows/test.yml | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/.github/workflows/test.yml b/.github/workflows/test.yml index 5d0b0744e..e0dfb3d3e 100644 --- a/.github/workflows/test.yml +++ b/.github/workflows/test.yml @@ -18,8 +18,12 @@ jobs: uses: actions/setup-go@v4 with: go-version: ${{ matrix.go-version }} + - name: Set up gotestfmt + run: go install github.com/gotesttools/gotestfmt/v2/cmd/gotestfmt@latest - name: Test - run: go test ./... + run: | + set -euo pipefail + go test ./... | gotestfmt debug: runs-on: ubuntu-latest From d0b5b37a4a6871cc275bf85bc619a9676f65e7d5 Mon Sep 17 00:00:00 2001 From: Anton Medvedev Date: Fri, 28 Mar 2025 15:45:20 +0100 Subject: [PATCH 090/113] Update gotestfmt --- .github/workflows/test.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/test.yml b/.github/workflows/test.yml index e0dfb3d3e..171868ee8 100644 --- a/.github/workflows/test.yml +++ b/.github/workflows/test.yml @@ -23,7 +23,7 @@ jobs: - name: Test run: | set -euo pipefail - go test ./... | gotestfmt + go test -json -v ./... 2>&1 | gotestfmt debug: runs-on: ubuntu-latest From 57fe809870a564fc60cb2176d19e20f975c3cb2d Mon Sep 17 00:00:00 2001 From: Anton Medvedev Date: Fri, 28 Mar 2025 15:48:24 +0100 Subject: [PATCH 091/113] Update test.yml --- .github/workflows/test.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/test.yml b/.github/workflows/test.yml index 171868ee8..27c536f65 100644 --- a/.github/workflows/test.yml +++ b/.github/workflows/test.yml @@ -23,7 +23,7 @@ jobs: - name: Test run: | set -euo pipefail - go test -json -v ./... 2>&1 | gotestfmt + go test -json -v ./... 2>&1 | gotestfmt -hide all debug: runs-on: ubuntu-latest From e190ea2e5dcab9c2e6b047876480bb014a45bb2f Mon Sep 17 00:00:00 2001 From: Anton Medvedev Date: Fri, 28 Mar 2025 15:49:42 +0100 Subject: [PATCH 092/113] Remove gotestfmt --- .github/workflows/test.yml | 4 +--- 1 file changed, 1 insertion(+), 3 deletions(-) diff --git a/.github/workflows/test.yml b/.github/workflows/test.yml index 27c536f65..c334b193c 100644 --- a/.github/workflows/test.yml +++ b/.github/workflows/test.yml @@ -18,12 +18,10 @@ jobs: uses: actions/setup-go@v4 with: go-version: ${{ matrix.go-version }} - - name: Set up gotestfmt - run: go install github.com/gotesttools/gotestfmt/v2/cmd/gotestfmt@latest - name: Test run: | set -euo pipefail - go test -json -v ./... 2>&1 | gotestfmt -hide all + go test ./... debug: runs-on: ubuntu-latest From 785630f7830056aa4fb84c989ead82e188ffe9e8 Mon Sep 17 00:00:00 2001 From: Anton Medvedev Date: Fri, 28 Mar 2025 15:50:33 +0100 Subject: [PATCH 093/113] Update test.yml --- .github/workflows/test.yml | 4 +--- 1 file changed, 1 insertion(+), 3 deletions(-) diff --git a/.github/workflows/test.yml b/.github/workflows/test.yml index c334b193c..5d0b0744e 100644 --- a/.github/workflows/test.yml +++ b/.github/workflows/test.yml @@ -19,9 +19,7 @@ jobs: with: go-version: ${{ matrix.go-version }} - name: Test - run: | - set -euo pipefail - go test ./... + run: go test ./... debug: runs-on: ubuntu-latest From 28d9b3d4575bc9bb3d4e92cb18a6f7924693a583 Mon Sep 17 00:00:00 2001 From: 2pac Date: Mon, 12 May 2025 18:32:48 +0200 Subject: [PATCH 094/113] fix(785): `get` to work when return is `nil` (#786) * fix(785): `get` to work when return is `nil` * improve testing --- builtin/lib.go | 4 ++++ expr_test.go | 21 +++++++++++++++++++ test/issues/785/issue_test.go | 38 +++++++++++++++++++++++++++++++++++ 3 files changed, 63 insertions(+) create mode 100644 test/issues/785/issue_test.go diff --git a/builtin/lib.go b/builtin/lib.go index 5a70a6b91..579393161 100644 --- a/builtin/lib.go +++ b/builtin/lib.go @@ -374,6 +374,10 @@ func get(params ...any) (out any, err error) { i := params[1] v := reflect.ValueOf(from) + if from == nil { + return nil, nil + } + if v.Kind() == reflect.Invalid { panic(fmt.Sprintf("cannot fetch %v from %T", i, from)) } diff --git a/expr_test.go b/expr_test.go index 4d3736a97..faa5cae6d 100644 --- a/expr_test.go +++ b/expr_test.go @@ -2724,3 +2724,24 @@ func TestExpr_wierd_cases(t *testing.T) { require.Error(t, err) require.Contains(t, err.Error(), "unknown name A") } + +func TestIssue785_get_nil(t *testing.T) { + exprStrs := []string{ + `get(nil, "a")`, + `get({}, "a")`, + `get(nil, "a")`, + `get({}, "a")`, + `({} | get("a") | get("b"))`, + } + + for _, exprStr := range exprStrs { + t.Run("get returns nil", func(t *testing.T) { + env := map[string]interface{}{} + + result, err := expr.Eval(exprStr, env) + require.NoError(t, err) + + require.Equal(t, nil, result) + }) + } +} diff --git a/test/issues/785/issue_test.go b/test/issues/785/issue_test.go new file mode 100644 index 000000000..4e4f9e53d --- /dev/null +++ b/test/issues/785/issue_test.go @@ -0,0 +1,38 @@ +package issue_test + +import ( + "testing" + + "github.com/expr-lang/expr" + "github.com/expr-lang/expr/internal/testify/require" +) + +func TestIssue785(t *testing.T) { + emptyMap := map[string]any{} + + env := map[string]interface{}{ + "empty_map": emptyMap, + } + + { + code := `get(empty_map, "non_existing_key") | get("some_key") | get("another_key") | get("yet_another_key") | get("last_key")` + + program, err := expr.Compile(code, expr.Env(env)) + require.NoError(t, err) + + output, err := expr.Run(program, env) + require.NoError(t, err) + require.Equal(t, nil, output) + } + + { + code := `{} | get("non_existing_key") | get("some_key") | get("another_key") | get("yet_another_key") | get("last_key")` + + program, err := expr.Compile(code, expr.Env(env)) + require.NoError(t, err) + + output, err := expr.Run(program, env) + require.NoError(t, err) + require.Equal(t, nil, output) + } +} From f974b88d463eba42e73c92af7cd23aba88f4a7d6 Mon Sep 17 00:00:00 2001 From: Vincent Bernat Date: Mon, 26 May 2025 10:03:53 +0200 Subject: [PATCH 095/113] Do not repeat patcher definition in ExamplePatch() (#792) I suppose at some point, godoc was not smart enough to display the definitions used in the body of examples in the documentation. This is not the case anymore: https://pkg.go.dev/github.com/expr-lang/expr#example-Patch --- expr_test.go | 14 -------------- 1 file changed, 14 deletions(-) diff --git a/expr_test.go b/expr_test.go index faa5cae6d..241767a09 100644 --- a/expr_test.go +++ b/expr_test.go @@ -504,20 +504,6 @@ func (p *patcher) Visit(node *ast.Node) { } func ExamplePatch() { - /* - type patcher struct{} - - func (p *patcher) Visit(node *ast.Node) { - switch n := (*node).(type) { - case *ast.MemberNode: - ast.Patch(node, &ast.CallNode{ - Callee: &ast.IdentifierNode{Value: "get"}, - Arguments: []ast.Node{n.Node, n.Property}, - }) - } - } - */ - program, err := expr.Compile( `greet.you.world + "!"`, expr.Patch(&patcher{}), From ebf0d8ba0eaee5e4a7631e014bc656fa280940bf Mon Sep 17 00:00:00 2001 From: Yigitkan Balci Date: Tue, 27 May 2025 13:13:35 +0300 Subject: [PATCH 096/113] Add check for non struct types to fetchField (#794) Co-authored-by: yigitkanbalci --- checker/checker_test.go | 25 +++++++++++++++++++++++++ checker/nature/utils.go | 5 +++++ 2 files changed, 30 insertions(+) diff --git a/checker/checker_test.go b/checker/checker_test.go index 4950c1a8e..2ec7c7cfc 100644 --- a/checker/checker_test.go +++ b/checker/checker_test.go @@ -1,6 +1,7 @@ package checker_test import ( + "context" "fmt" "reflect" "regexp" @@ -1078,6 +1079,30 @@ func TestCheck_builtin_without_call(t *testing.T) { } } +func TestCheck_EmbeddedInterface(t *testing.T) { + t.Run("embedded interface lookup returns compile-error not panic", func(t *testing.T) { + type Env struct { + context.Context + Country string + } + type Wrapper struct { + Ctx Env + } + + config := conf.New(Wrapper{ + Ctx: Env{ + Context: context.Background(), + Country: "TR", + }, + }) + expr.WithContext("Ctx")(config) + + _, err := checker.ParseCheck("Ctx.C", config) + require.Error(t, err) + require.Contains(t, err.Error(), "has no field C") + }) +} + func TestCheck_types(t *testing.T) { env := types.Map{ "foo": types.Map{ diff --git a/checker/nature/utils.go b/checker/nature/utils.go index c242f91a6..179459874 100644 --- a/checker/nature/utils.go +++ b/checker/nature/utils.go @@ -14,6 +14,11 @@ func fieldName(field reflect.StructField) string { } func fetchField(t reflect.Type, name string) (reflect.StructField, bool) { + // If t is not a struct, early return. + if t.Kind() != reflect.Struct { + return reflect.StructField{}, false + } + // First check all structs fields. for i := 0; i < t.NumField(); i++ { field := t.Field(i) From 6d7d7d68e13eb61a89c0591dbedf5f64574f3610 Mon Sep 17 00:00:00 2001 From: Anton Medvedev Date: Tue, 27 May 2025 12:22:06 +0200 Subject: [PATCH 097/113] Run diff / bench in parallel --- .github/workflows/diff.yml | 53 +++++++++++++++++++++++++++++++------- 1 file changed, 43 insertions(+), 10 deletions(-) diff --git a/.github/workflows/diff.yml b/.github/workflows/diff.yml index 3a81ba2e1..a0c55cba2 100644 --- a/.github/workflows/diff.yml +++ b/.github/workflows/diff.yml @@ -5,28 +5,61 @@ on: branches: [ master ] jobs: - bench: + benchmark: runs-on: ubuntu-latest + strategy: + matrix: + ref: [master, ${{ github.sha }}] + include: + - ref: master + name: old + - ref: ${{ github.sha }} + name: new steps: - name: Setup Go 1.18 uses: actions/setup-go@v4 with: go-version: 1.18 + + - name: Checkout code + uses: actions/checkout@v3 + with: + ref: ${{ matrix.ref }} + + - name: Run benchmark + run: go test -bench=. -benchmem -run=^$ -count=10 -timeout=30m | tee /tmp/${{ matrix.name }}.txt + + - name: Upload benchmark results + uses: actions/upload-artifact@v3 + with: + name: benchmark-${{ matrix.name }} + path: /tmp/${{ matrix.name }}.txt + + compare: + needs: benchmark + runs-on: ubuntu-latest + steps: + - name: Setup Go 1.18 + uses: actions/setup-go@v4 + with: + go-version: 1.18 + - name: Install benchstat # NOTE: benchstat@latest requires go 1.23 since 2025-02-14 - this is the last go 1.18 ref # https://cs.opensource.google/go/x/perf/+/c95ad7d5b636f67d322a7e4832e83103d0fdd292 run: go install golang.org/x/perf/cmd/benchstat@884df5810d2850d775c2cb4885a7ea339128a17d - - uses: actions/checkout@v3 - - name: Benchmark new code - run: go test -bench=. -benchmem -run=^$ -count=10 -timeout=30m | tee /tmp/new.txt + - name: Download old benchmark results + uses: actions/download-artifact@v3 + with: + name: benchmark-old + path: /tmp/ - - name: Checkout master - uses: actions/checkout@v3 + - name: Download new benchmark results + uses: actions/download-artifact@v3 with: - ref: master - - name: Benchmark master - run: go test -bench=. -benchmem -run=^$ -count=10 -timeout=30m | tee /tmp/old.txt + name: benchmark-new + path: /tmp/ - - name: Diff + - name: Compare benchmarks run: benchstat /tmp/old.txt /tmp/new.txt From 0bae5401b3f7a4e1303db30d9dcb4ffd384b36ee Mon Sep 17 00:00:00 2001 From: Anton Medvedev Date: Tue, 27 May 2025 12:34:11 +0200 Subject: [PATCH 098/113] Fix diff.yml --- .github/workflows/diff.yml | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/.github/workflows/diff.yml b/.github/workflows/diff.yml index a0c55cba2..ff7a08840 100644 --- a/.github/workflows/diff.yml +++ b/.github/workflows/diff.yml @@ -9,11 +9,10 @@ jobs: runs-on: ubuntu-latest strategy: matrix: - ref: [master, ${{ github.sha }}] include: - ref: master name: old - - ref: ${{ github.sha }} + - ref: ${{ github.event.pull_request.head.sha }} name: new steps: - name: Setup Go 1.18 From 1609a12ce65e179db1ffc0c38485eb5368a1c6e8 Mon Sep 17 00:00:00 2001 From: Anton Medvedev Date: Tue, 27 May 2025 12:39:33 +0200 Subject: [PATCH 099/113] Revert "Fix diff.yml" This reverts commit 0bae5401b3f7a4e1303db30d9dcb4ffd384b36ee. --- .github/workflows/diff.yml | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/.github/workflows/diff.yml b/.github/workflows/diff.yml index ff7a08840..a0c55cba2 100644 --- a/.github/workflows/diff.yml +++ b/.github/workflows/diff.yml @@ -9,10 +9,11 @@ jobs: runs-on: ubuntu-latest strategy: matrix: + ref: [master, ${{ github.sha }}] include: - ref: master name: old - - ref: ${{ github.event.pull_request.head.sha }} + - ref: ${{ github.sha }} name: new steps: - name: Setup Go 1.18 From 5fbfe7211cd667c622a69bf4609e55f2eade7f63 Mon Sep 17 00:00:00 2001 From: Anton Medvedev Date: Tue, 27 May 2025 12:39:33 +0200 Subject: [PATCH 100/113] Revert "Run diff / bench in parallel" This reverts commit 6d7d7d68e13eb61a89c0591dbedf5f64574f3610. --- .github/workflows/diff.yml | 53 +++++++------------------------------- 1 file changed, 10 insertions(+), 43 deletions(-) diff --git a/.github/workflows/diff.yml b/.github/workflows/diff.yml index a0c55cba2..3a81ba2e1 100644 --- a/.github/workflows/diff.yml +++ b/.github/workflows/diff.yml @@ -5,61 +5,28 @@ on: branches: [ master ] jobs: - benchmark: + bench: runs-on: ubuntu-latest - strategy: - matrix: - ref: [master, ${{ github.sha }}] - include: - - ref: master - name: old - - ref: ${{ github.sha }} - name: new steps: - name: Setup Go 1.18 uses: actions/setup-go@v4 with: go-version: 1.18 - - - name: Checkout code - uses: actions/checkout@v3 - with: - ref: ${{ matrix.ref }} - - - name: Run benchmark - run: go test -bench=. -benchmem -run=^$ -count=10 -timeout=30m | tee /tmp/${{ matrix.name }}.txt - - - name: Upload benchmark results - uses: actions/upload-artifact@v3 - with: - name: benchmark-${{ matrix.name }} - path: /tmp/${{ matrix.name }}.txt - - compare: - needs: benchmark - runs-on: ubuntu-latest - steps: - - name: Setup Go 1.18 - uses: actions/setup-go@v4 - with: - go-version: 1.18 - - name: Install benchstat # NOTE: benchstat@latest requires go 1.23 since 2025-02-14 - this is the last go 1.18 ref # https://cs.opensource.google/go/x/perf/+/c95ad7d5b636f67d322a7e4832e83103d0fdd292 run: go install golang.org/x/perf/cmd/benchstat@884df5810d2850d775c2cb4885a7ea339128a17d - - name: Download old benchmark results - uses: actions/download-artifact@v3 - with: - name: benchmark-old - path: /tmp/ + - uses: actions/checkout@v3 + - name: Benchmark new code + run: go test -bench=. -benchmem -run=^$ -count=10 -timeout=30m | tee /tmp/new.txt - - name: Download new benchmark results - uses: actions/download-artifact@v3 + - name: Checkout master + uses: actions/checkout@v3 with: - name: benchmark-new - path: /tmp/ + ref: master + - name: Benchmark master + run: go test -bench=. -benchmem -run=^$ -count=10 -timeout=30m | tee /tmp/old.txt - - name: Compare benchmarks + - name: Diff run: benchstat /tmp/old.txt /tmp/new.txt From eeb1b8b6259d9a34ad5fb06bdd8cde80841396ac Mon Sep 17 00:00:00 2001 From: Anton Medvedev Date: Tue, 3 Jun 2025 17:31:46 +0200 Subject: [PATCH 101/113] Add expr.MaxNodes() option (#799) * Add expr.MaxNodes() option * Fix error message * Add more tests and comments --- conf/config.go | 48 ++++++++++++++++---------------- expr.go | 9 ++++++ expr_test.go | 74 ++++++++++++++++++++++++++++++++++++-------------- vm/vm.go | 1 - 4 files changed, 86 insertions(+), 46 deletions(-) diff --git a/conf/config.go b/conf/config.go index d629958e5..2c14d9882 100644 --- a/conf/config.go +++ b/conf/config.go @@ -10,43 +10,41 @@ import ( "github.com/expr-lang/expr/vm/runtime" ) -const ( - // DefaultMemoryBudget represents an upper limit of memory usage +var ( + // DefaultMemoryBudget represents default maximum allowed memory usage by the vm.VM. DefaultMemoryBudget uint = 1e6 - // DefaultMaxNodes represents an upper limit of AST nodes - DefaultMaxNodes uint = 10000 + // DefaultMaxNodes represents default maximum allowed AST nodes by the compiler. + DefaultMaxNodes uint = 1e4 ) type FunctionsTable map[string]*builtin.Function type Config struct { - EnvObject any - Env nature.Nature - Expect reflect.Kind - ExpectAny bool - Optimize bool - Strict bool - Profile bool - MaxNodes uint - MemoryBudget uint - ConstFns map[string]reflect.Value - Visitors []ast.Visitor - Functions FunctionsTable - Builtins FunctionsTable - Disabled map[string]bool // disabled builtins + EnvObject any + Env nature.Nature + Expect reflect.Kind + ExpectAny bool + Optimize bool + Strict bool + Profile bool + MaxNodes uint + ConstFns map[string]reflect.Value + Visitors []ast.Visitor + Functions FunctionsTable + Builtins FunctionsTable + Disabled map[string]bool // disabled builtins } // CreateNew creates new config with default values. func CreateNew() *Config { c := &Config{ - Optimize: true, - MaxNodes: DefaultMaxNodes, - MemoryBudget: DefaultMemoryBudget, - ConstFns: make(map[string]reflect.Value), - Functions: make(map[string]*builtin.Function), - Builtins: make(map[string]*builtin.Function), - Disabled: make(map[string]bool), + Optimize: true, + MaxNodes: DefaultMaxNodes, + ConstFns: make(map[string]reflect.Value), + Functions: make(map[string]*builtin.Function), + Builtins: make(map[string]*builtin.Function), + Disabled: make(map[string]bool), } for _, f := range builtin.Builtins { c.Builtins[f.Name] = f diff --git a/expr.go b/expr.go index 33b7cf354..48298fe7e 100644 --- a/expr.go +++ b/expr.go @@ -195,6 +195,15 @@ func Timezone(name string) Option { }) } +// MaxNodes sets the maximum number of nodes allowed in the expression. +// By default, the maximum number of nodes is conf.DefaultMaxNodes. +// If MaxNodes is set to 0, the node budget check is disabled. +func MaxNodes(n uint) Option { + return func(c *conf.Config) { + c.MaxNodes = n + } +} + // Compile parses and compiles given input expression to bytecode program. func Compile(input string, ops ...Option) (*vm.Program, error) { config := conf.CreateNew() diff --git a/expr_test.go b/expr_test.go index 241767a09..57d2cfbbb 100644 --- a/expr_test.go +++ b/expr_test.go @@ -10,9 +10,11 @@ import ( "testing" "time" + "github.com/expr-lang/expr/conf" "github.com/expr-lang/expr/internal/testify/assert" "github.com/expr-lang/expr/internal/testify/require" "github.com/expr-lang/expr/types" + "github.com/expr-lang/expr/vm" "github.com/expr-lang/expr" "github.com/expr-lang/expr/ast" @@ -2225,26 +2227,6 @@ func TestEval_slices_out_of_bound(t *testing.T) { } } -func TestMemoryBudget(t *testing.T) { - tests := []struct { - code string - }{ - {`map(1..100, {map(1..100, {map(1..100, {0})})})`}, - {`len(1..10000000)`}, - } - - for _, tt := range tests { - t.Run(tt.code, func(t *testing.T) { - program, err := expr.Compile(tt.code) - require.NoError(t, err, "compile error") - - _, err = expr.Run(program, nil) - assert.Error(t, err, "run error") - assert.Contains(t, err.Error(), "memory budget exceeded") - }) - } -} - func TestExpr_custom_tests(t *testing.T) { f, err := os.Open("custom_tests.json") if os.IsNotExist(err) { @@ -2731,3 +2713,55 @@ func TestIssue785_get_nil(t *testing.T) { }) } } + +func TestMaxNodes(t *testing.T) { + maxNodes := uint(100) + + code := "" + for i := 0; i < int(maxNodes); i++ { + code += "1; " + } + + _, err := expr.Compile(code, expr.MaxNodes(maxNodes)) + require.Error(t, err) + assert.Contains(t, err.Error(), "exceeds maximum allowed nodes") + + _, err = expr.Compile(code, expr.MaxNodes(maxNodes+1)) + require.NoError(t, err) +} + +func TestMaxNodesDisabled(t *testing.T) { + code := "" + for i := 0; i < 2*int(conf.DefaultMaxNodes); i++ { + code += "1; " + } + + _, err := expr.Compile(code, expr.MaxNodes(0)) + require.NoError(t, err) +} + +func TestMemoryBudget(t *testing.T) { + tests := []struct { + code string + max int + }{ + {`map(1..100, {map(1..100, {map(1..100, {0})})})`, -1}, + {`len(1..10000000)`, -1}, + {`1..100`, 100}, + } + + for _, tt := range tests { + t.Run(tt.code, func(t *testing.T) { + program, err := expr.Compile(tt.code) + require.NoError(t, err, "compile error") + + vm := vm.VM{} + if tt.max > 0 { + vm.MemoryBudget = uint(tt.max) + } + _, err = vm.Run(program, nil) + require.Error(t, err, "run error") + assert.Contains(t, err.Error(), "memory budget exceeded") + }) + } +} diff --git a/vm/vm.go b/vm/vm.go index de13cade1..3018619d9 100644 --- a/vm/vm.go +++ b/vm/vm.go @@ -75,7 +75,6 @@ func (vm *VM) Run(program *Program, env any) (_ any, err error) { if len(vm.Variables) < program.variables { vm.Variables = make([]any, program.variables) } - if vm.MemoryBudget == 0 { vm.MemoryBudget = conf.DefaultMemoryBudget } From 98b0990dd3b9e5c37306e7999184de9a9cdaf25e Mon Sep 17 00:00:00 2001 From: Diego Augusto Molina Date: Mon, 30 Jun 2025 15:08:46 -0300 Subject: [PATCH 102/113] Improve parser and lexer (#811) * convert source to a struct and fix minor issue displaying error * lexer: add byte and char pos * improve parser to use string instead of []rune * add lexer benchmarks * make lexer work as an iterator * make parser use the new iterator API in lexer * allow reusing the parser * cleanup code * add parser benchmarks --- file/error.go | 57 +++++------ file/source.go | 52 ++++------ internal/ring/ring.go | 85 +++++++++++++++++ internal/ring/ring_test.go | 140 +++++++++++++++++++++++++++ parser/bench_test.go | 20 ++++ parser/lexer/lexer.go | 188 +++++++++++++++++++++---------------- parser/lexer/lexer_test.go | 1 + parser/lexer/state.go | 24 ++--- parser/lexer/token.go | 12 +-- parser/lexer/utils.go | 9 +- parser/parser.go | 159 ++++++++++++++++++------------- vm/vm_test.go | 25 ++--- 12 files changed, 529 insertions(+), 243 deletions(-) create mode 100644 internal/ring/ring.go create mode 100644 internal/ring/ring_test.go create mode 100644 parser/bench_test.go diff --git a/file/error.go b/file/error.go index 8ff85dfa5..04253b6f6 100644 --- a/file/error.go +++ b/file/error.go @@ -3,7 +3,6 @@ package file import ( "fmt" "strings" - "unicode/utf8" ) type Error struct { @@ -19,43 +18,47 @@ func (e *Error) Error() string { return e.format() } +var tabReplacer = strings.NewReplacer("\t", " ") + func (e *Error) Bind(source Source) *Error { + src := source.String() + + var runeCount, lineStart int e.Line = 1 - for i, r := range source { - if i == e.From { + e.Column = 0 + for i, r := range src { + if runeCount == e.From { break } if r == '\n' { + lineStart = i e.Line++ e.Column = 0 - } else { - e.Column++ } + runeCount++ + e.Column++ + } + + lineEnd := lineStart + strings.IndexByte(src[lineStart:], '\n') + if lineEnd < lineStart { + lineEnd = len(src) + } + if lineStart == lineEnd { + return e } - if snippet, found := source.Snippet(e.Line); found { - snippet := strings.Replace(snippet, "\t", " ", -1) - srcLine := "\n | " + snippet - var bytes = []byte(snippet) - var indLine = "\n | " - for i := 0; i < e.Column && len(bytes) > 0; i++ { - _, sz := utf8.DecodeRune(bytes) - bytes = bytes[sz:] - if sz > 1 { - goto noind - } else { - indLine += "." - } - } - if _, sz := utf8.DecodeRune(bytes); sz > 1 { - goto noind - } else { - indLine += "^" - } - srcLine += indLine - noind: - e.Snippet = srcLine + const prefix = "\n | " + line := src[lineStart:lineEnd] + snippet := new(strings.Builder) + snippet.Grow(2*len(prefix) + len(line) + e.Column + 1) + snippet.WriteString(prefix) + tabReplacer.WriteString(snippet, line) + snippet.WriteString(prefix) + for i := 0; i < e.Column; i++ { + snippet.WriteByte('.') } + snippet.WriteByte('^') + e.Snippet = snippet.String() return e } diff --git a/file/source.go b/file/source.go index 8e2b2d154..b11bb5f9d 100644 --- a/file/source.go +++ b/file/source.go @@ -1,48 +1,36 @@ package file -import ( - "strings" - "unicode/utf8" -) +import "strings" -type Source []rune +type Source struct { + raw string +} func NewSource(contents string) Source { - return []rune(contents) + return Source{ + raw: contents, + } } func (s Source) String() string { - return string(s) + return s.raw } func (s Source) Snippet(line int) (string, bool) { - if s == nil { + if s.raw == "" { return "", false } - lines := strings.Split(string(s), "\n") - lineOffsets := make([]int, len(lines)) - var offset int - for i, line := range lines { - offset = offset + utf8.RuneCountInString(line) + 1 - lineOffsets[i] = offset - } - charStart, found := getLineOffset(lineOffsets, line) - if !found || len(s) == 0 { - return "", false + var start int + for i := 1; i < line; i++ { + pos := strings.IndexByte(s.raw[start:], '\n') + if pos < 0 { + return "", false + } + start += pos + 1 } - charEnd, found := getLineOffset(lineOffsets, line+1) - if found { - return string(s[charStart : charEnd-1]), true - } - return string(s[charStart:]), true -} - -func getLineOffset(lineOffsets []int, line int) (int, bool) { - if line == 1 { - return 0, true - } else if line > 1 && line <= len(lineOffsets) { - offset := lineOffsets[line-2] - return offset, true + end := start + strings.IndexByte(s.raw[start:], '\n') + if end < start { + end = len(s.raw) } - return -1, false + return s.raw[start:end], true } diff --git a/internal/ring/ring.go b/internal/ring/ring.go new file mode 100644 index 000000000..cc9e727b0 --- /dev/null +++ b/internal/ring/ring.go @@ -0,0 +1,85 @@ +package ring + +// Ring is a very simple ring buffer implementation that uses a slice. The +// internal slice will only grow, never shrink. When it grows, it grows in +// chunks of "chunkSize" (given as argument in the [New] function). Pointer and +// reference types can be safely used because memory is cleared. +type Ring[T any] struct { + data []T + back, len, chunkSize int +} + +func New[T any](chunkSize int) *Ring[T] { + if chunkSize < 1 { + panic("chunkSize must be greater than zero") + } + return &Ring[T]{ + chunkSize: chunkSize, + } +} + +func (r *Ring[T]) Len() int { + return r.len +} + +func (r *Ring[T]) Cap() int { + return len(r.data) +} + +func (r *Ring[T]) Reset() { + var zero T + for i := range r.data { + r.data[i] = zero // clear mem, optimized by the compiler, in Go 1.21 the "clear" builtin can be used + } + r.back = 0 + r.len = 0 +} + +// Nth returns the n-th oldest value (zero-based) in the ring without making +// any change. +func (r *Ring[T]) Nth(n int) (v T, ok bool) { + if n < 0 || n >= r.len || len(r.data) == 0 { + return v, false + } + n = (n + r.back) % len(r.data) + return r.data[n], true +} + +// Dequeue returns the oldest value. +func (r *Ring[T]) Dequeue() (v T, ok bool) { + if r.len == 0 { + return v, false + } + v, r.data[r.back] = r.data[r.back], v // retrieve and clear mem + r.len-- + r.back = (r.back + 1) % len(r.data) + return v, true +} + +// Enqueue adds an item to the ring. +func (r *Ring[T]) Enqueue(v T) { + if r.len == len(r.data) { + r.grow() + } + writePos := (r.back + r.len) % len(r.data) + r.data[writePos] = v + r.len++ +} + +func (r *Ring[T]) grow() { + s := make([]T, len(r.data)+r.chunkSize) + if r.len > 0 { + chunk1 := r.back + r.len + if chunk1 > len(r.data) { + chunk1 = len(r.data) + } + copied := copy(s, r.data[r.back:chunk1]) + + if copied < r.len { // wrapped slice + chunk2 := r.len - copied + copy(s[copied:], r.data[:chunk2]) + } + } + r.back = 0 + r.data = s +} diff --git a/internal/ring/ring_test.go b/internal/ring/ring_test.go new file mode 100644 index 000000000..b7457cd70 --- /dev/null +++ b/internal/ring/ring_test.go @@ -0,0 +1,140 @@ +package ring + +import ( + "fmt" + "testing" +) + +func TestRing(t *testing.T) { + type op = ringOp[int] + testRing(t, New[int](3), + // noops on empty ring + op{cap: 0, opType: opRst, value: 0, items: []int{}}, + op{cap: 0, opType: opDeq, value: 0, items: []int{}}, + + // basic + op{cap: 3, opType: opEnq, value: 1, items: []int{1}}, + op{cap: 3, opType: opDeq, value: 1, items: []int{}}, + + // wrapping + op{cap: 3, opType: opEnq, value: 2, items: []int{2}}, + op{cap: 3, opType: opEnq, value: 3, items: []int{2, 3}}, + op{cap: 3, opType: opEnq, value: 4, items: []int{2, 3, 4}}, + op{cap: 3, opType: opDeq, value: 2, items: []int{3, 4}}, + op{cap: 3, opType: opDeq, value: 3, items: []int{4}}, + op{cap: 3, opType: opDeq, value: 4, items: []int{}}, + + // resetting + op{cap: 3, opType: opEnq, value: 2, items: []int{2}}, + op{cap: 3, opType: opRst, value: 0, items: []int{}}, + op{cap: 3, opType: opDeq, value: 0, items: []int{}}, + + // growing without wrapping + op{cap: 3, opType: opEnq, value: 5, items: []int{5}}, + op{cap: 3, opType: opEnq, value: 6, items: []int{5, 6}}, + op{cap: 3, opType: opEnq, value: 7, items: []int{5, 6, 7}}, + op{cap: 6, opType: opEnq, value: 8, items: []int{5, 6, 7, 8}}, + op{cap: 6, opType: opRst, value: 0, items: []int{}}, + op{cap: 6, opType: opDeq, value: 0, items: []int{}}, + + // growing and wrapping + op{cap: 6, opType: opEnq, value: 9, items: []int{9}}, + op{cap: 6, opType: opEnq, value: 10, items: []int{9, 10}}, + op{cap: 6, opType: opEnq, value: 11, items: []int{9, 10, 11}}, + op{cap: 6, opType: opEnq, value: 12, items: []int{9, 10, 11, 12}}, + op{cap: 6, opType: opEnq, value: 13, items: []int{9, 10, 11, 12, 13}}, + op{cap: 6, opType: opEnq, value: 14, items: []int{9, 10, 11, 12, 13, 14}}, + op{cap: 6, opType: opDeq, value: 9, items: []int{10, 11, 12, 13, 14}}, + op{cap: 6, opType: opDeq, value: 10, items: []int{11, 12, 13, 14}}, + op{cap: 6, opType: opEnq, value: 15, items: []int{11, 12, 13, 14, 15}}, + op{cap: 6, opType: opEnq, value: 16, items: []int{11, 12, 13, 14, 15, 16}}, + op{cap: 9, opType: opEnq, value: 17, items: []int{11, 12, 13, 14, 15, 16, 17}}, // grows wrapped + op{cap: 9, opType: opDeq, value: 11, items: []int{12, 13, 14, 15, 16, 17}}, + op{cap: 9, opType: opDeq, value: 12, items: []int{13, 14, 15, 16, 17}}, + op{cap: 9, opType: opDeq, value: 13, items: []int{14, 15, 16, 17}}, + op{cap: 9, opType: opDeq, value: 14, items: []int{15, 16, 17}}, + op{cap: 9, opType: opDeq, value: 15, items: []int{16, 17}}, + op{cap: 9, opType: opDeq, value: 16, items: []int{17}}, + op{cap: 9, opType: opDeq, value: 17, items: []int{}}, + op{cap: 9, opType: opDeq, value: 0, items: []int{}}, + ) + + t.Run("should panic on invalid chunkSize", func(t *testing.T) { + defer func() { + if r := recover(); r == nil { + t.Fatalf("should have panicked") + } + }() + New[int](0) + }) +} + +const ( + opEnq = iota // enqueue an item + opDeq // dequeue an item and an item was available + opRst // reset +) + +type ringOp[T comparable] struct { + cap int // expected values + opType int // opEnq or opDeq + value T // value to enqueue or value expected for dequeue; ignored for opRst + items []T // items left +} + +func testRing[T comparable](t *testing.T, r *Ring[T], ops ...ringOp[T]) { + for i, op := range ops { + testOK := t.Run(fmt.Sprintf("opIndex=%v", i), func(t *testing.T) { + testRingOp(t, r, op) + }) + if !testOK { + return + } + } +} + +func testRingOp[T comparable](t *testing.T, r *Ring[T], op ringOp[T]) { + var zero T + switch op.opType { + case opEnq: + r.Enqueue(op.value) + case opDeq: + shouldSucceed := r.Len() > 0 + v, ok := r.Dequeue() + switch { + case ok != shouldSucceed: + t.Fatalf("should have succeeded: %v", shouldSucceed) + case ok && v != op.value: + t.Fatalf("expected value: %v; got: %v", op.value, v) + case !ok && v != zero: + t.Fatalf("expected zero value; got: %v", v) + } + case opRst: + r.Reset() + } + if c := r.Cap(); c != op.cap { + t.Fatalf("expected cap: %v; got: %v", op.cap, c) + } + if l := r.Len(); l != len(op.items) { + t.Errorf("expected Len(): %v; got: %v", len(op.items), l) + } + var got []T + for i := 0; ; i++ { + v, ok := r.Nth(i) + if !ok { + break + } + got = append(got, v) + } + if l := len(got); l != len(op.items) { + t.Errorf("expected items: %v\ngot items: %v", op.items, got) + } + for i := range op.items { + if op.items[i] != got[i] { + t.Fatalf("expected items: %v\ngot items: %v", op.items, got) + } + } + if v, ok := r.Nth(len(op.items)); ok || v != zero { + t.Fatalf("expected no more items, got: v=%v; ok=%v", v, ok) + } +} diff --git a/parser/bench_test.go b/parser/bench_test.go new file mode 100644 index 000000000..0b9a69276 --- /dev/null +++ b/parser/bench_test.go @@ -0,0 +1,20 @@ +package parser + +import "testing" + +func BenchmarkParser(b *testing.B) { + const source = ` + /* + Showing worst case scenario + */ + let value = trim("contains escapes \n\"\\ \U0001F600 and non ASCII ñ"); // inline comment + len(value) == 0x2A + // let's introduce an error too + whatever + ` + b.ReportAllocs() + p := new(Parser) + for i := 0; i < b.N; i++ { + p.Parse(source, nil) + } +} diff --git a/parser/lexer/lexer.go b/parser/lexer/lexer.go index e6b06c09d..f417f02b6 100644 --- a/parser/lexer/lexer.go +++ b/parser/lexer/lexer.go @@ -2,152 +2,178 @@ package lexer import ( "fmt" + "io" "strings" + "unicode/utf8" "github.com/expr-lang/expr/file" + "github.com/expr-lang/expr/internal/ring" ) +const ringChunkSize = 10 + +// Lex will buffer and return the tokens of a disposable *[Lexer]. func Lex(source file.Source) ([]Token, error) { - l := &lexer{ - source: source, - tokens: make([]Token, 0), - start: 0, - end: 0, + tokens := make([]Token, 0, ringChunkSize) + l := New() + l.Reset(source) + for { + t, err := l.Next() + switch err { + case nil: + tokens = append(tokens, t) + case io.EOF: + return tokens, nil + default: + return nil, err + } } - l.commit() +} - for state := root; state != nil; { - state = state(l) +// New returns a reusable lexer. +func New() *Lexer { + return &Lexer{ + tokens: ring.New[Token](ringChunkSize), } +} - if l.err != nil { - return nil, l.err.Bind(source) +type Lexer struct { + state stateFn + source file.Source + tokens *ring.Ring[Token] + err *file.Error + start, end struct { + byte, rune int } + eof bool +} - return l.tokens, nil +func (l *Lexer) Reset(source file.Source) { + l.source = source + l.tokens.Reset() + l.state = root } -type lexer struct { - source file.Source - tokens []Token - start, end int - err *file.Error +func (l *Lexer) Next() (Token, error) { + for l.state != nil && l.err == nil && l.tokens.Len() == 0 { + l.state = l.state(l) + } + if l.err != nil { + return Token{}, l.err.Bind(l.source) + } + if t, ok := l.tokens.Dequeue(); ok { + return t, nil + } + return Token{}, io.EOF } const eof rune = -1 -func (l *lexer) commit() { +func (l *Lexer) commit() { l.start = l.end } -func (l *lexer) next() rune { - if l.end >= len(l.source) { - l.end++ +func (l *Lexer) next() rune { + if l.end.byte >= len(l.source.String()) { + l.eof = true return eof } - r := l.source[l.end] - l.end++ + r, sz := utf8.DecodeRuneInString(l.source.String()[l.end.byte:]) + l.end.rune++ + l.end.byte += sz return r } -func (l *lexer) peek() rune { - r := l.next() - l.backup() - return r +func (l *Lexer) peek() rune { + if l.end.byte < len(l.source.String()) { + r, _ := utf8.DecodeRuneInString(l.source.String()[l.end.byte:]) + return r + } + return eof } -func (l *lexer) backup() { - l.end-- +func (l *Lexer) peekByte() (byte, bool) { + if l.end.byte >= 0 && l.end.byte < len(l.source.String()) { + return l.source.String()[l.end.byte], true + } + return 0, false } -func (l *lexer) emit(t Kind) { +func (l *Lexer) backup() { + if l.eof { + l.eof = false + } else if l.end.rune > 0 { + _, sz := utf8.DecodeLastRuneInString(l.source.String()[:l.end.byte]) + l.end.byte -= sz + l.end.rune-- + } +} + +func (l *Lexer) emit(t Kind) { l.emitValue(t, l.word()) } -func (l *lexer) emitValue(t Kind, value string) { - l.tokens = append(l.tokens, Token{ - Location: file.Location{From: l.start, To: l.end}, +func (l *Lexer) emitValue(t Kind, value string) { + l.tokens.Enqueue(Token{ + Location: file.Location{From: l.start.rune, To: l.end.rune}, Kind: t, Value: value, }) l.commit() } -func (l *lexer) emitEOF() { - from := l.end - 2 +func (l *Lexer) emitEOF() { + from := l.end.rune - 1 if from < 0 { from = 0 } - to := l.end - 1 + to := l.end.rune - 0 if to < 0 { to = 0 } - l.tokens = append(l.tokens, Token{ + l.tokens.Enqueue(Token{ Location: file.Location{From: from, To: to}, Kind: EOF, }) l.commit() } -func (l *lexer) skip() { +func (l *Lexer) skip() { l.commit() } -func (l *lexer) word() string { - // TODO: boundary check is NOT needed here, but for some reason CI fuzz tests are failing. - if l.start > len(l.source) || l.end > len(l.source) { - return "__invalid__" - } - return string(l.source[l.start:l.end]) +func (l *Lexer) word() string { + return l.source.String()[l.start.byte:l.end.byte] } -func (l *lexer) accept(valid string) bool { - if strings.ContainsRune(valid, l.next()) { +func (l *Lexer) accept(valid string) bool { + if strings.ContainsRune(valid, l.peek()) { + l.next() return true } - l.backup() return false } -func (l *lexer) acceptRun(valid string) { - for strings.ContainsRune(valid, l.next()) { +func (l *Lexer) acceptRun(valid string) { + for l.accept(valid) { } - l.backup() } -func (l *lexer) skipSpaces() { - r := l.peek() - for ; r == ' '; r = l.peek() { - l.next() - } +func (l *Lexer) skipSpaces() { + l.acceptRun(" ") l.skip() } -func (l *lexer) acceptWord(word string) bool { - pos := l.end - - l.skipSpaces() - - for _, ch := range word { - if l.next() != ch { - l.end = pos - return false - } - } - if r := l.peek(); r != ' ' && r != eof { - l.end = pos - return false - } - - return true -} - -func (l *lexer) error(format string, args ...any) stateFn { +func (l *Lexer) error(format string, args ...any) stateFn { if l.err == nil { // show first error + end := l.end.rune + if l.eof { + end++ + } l.err = &file.Error{ Location: file.Location{ - From: l.end - 1, - To: l.end, + From: end - 1, + To: end, }, Message: fmt.Sprintf(format, args...), } @@ -167,7 +193,7 @@ func digitVal(ch rune) int { func lower(ch rune) rune { return ('a' - 'A') | ch } // returns lower-case ch iff ch is ASCII letter -func (l *lexer) scanDigits(ch rune, base, n int) rune { +func (l *Lexer) scanDigits(ch rune, base, n int) rune { for n > 0 && digitVal(ch) < base { ch = l.next() n-- @@ -178,7 +204,7 @@ func (l *lexer) scanDigits(ch rune, base, n int) rune { return ch } -func (l *lexer) scanEscape(quote rune) rune { +func (l *Lexer) scanEscape(quote rune) rune { ch := l.next() // read character after '/' switch ch { case 'a', 'b', 'f', 'n', 'r', 't', 'v', '\\', quote: @@ -198,7 +224,7 @@ func (l *lexer) scanEscape(quote rune) rune { return ch } -func (l *lexer) scanString(quote rune) (n int) { +func (l *Lexer) scanString(quote rune) (n int) { ch := l.next() // read character after quote for ch != quote { if ch == '\n' || ch == eof { @@ -215,7 +241,7 @@ func (l *lexer) scanString(quote rune) (n int) { return } -func (l *lexer) scanRawString(quote rune) (n int) { +func (l *Lexer) scanRawString(quote rune) (n int) { ch := l.next() // read character after back tick for ch != quote { if ch == eof { @@ -225,6 +251,6 @@ func (l *lexer) scanRawString(quote rune) (n int) { ch = l.next() n++ } - l.emitValue(String, string(l.source[l.start+1:l.end-1])) + l.emitValue(String, l.source.String()[l.start.byte+1:l.end.byte-1]) return } diff --git a/parser/lexer/lexer_test.go b/parser/lexer/lexer_test.go index db02d2acf..5171f4255 100644 --- a/parser/lexer/lexer_test.go +++ b/parser/lexer/lexer_test.go @@ -335,6 +335,7 @@ literal not terminated (1:10) früh ♥︎ unrecognized character: U+2665 '♥' (1:6) | früh ♥︎ + | .....^ ` func TestLex_error(t *testing.T) { diff --git a/parser/lexer/state.go b/parser/lexer/state.go index c694a2ca0..e5ad45bcd 100644 --- a/parser/lexer/state.go +++ b/parser/lexer/state.go @@ -6,9 +6,9 @@ import ( "github.com/expr-lang/expr/parser/utils" ) -type stateFn func(*lexer) stateFn +type stateFn func(*Lexer) stateFn -func root(l *lexer) stateFn { +func root(l *Lexer) stateFn { switch r := l.next(); { case r == eof: l.emitEOF() @@ -61,7 +61,7 @@ func root(l *lexer) stateFn { return root } -func number(l *lexer) stateFn { +func number(l *Lexer) stateFn { if !l.scanNumber() { return l.error("bad number syntax: %q", l.word()) } @@ -69,7 +69,7 @@ func number(l *lexer) stateFn { return root } -func (l *lexer) scanNumber() bool { +func (l *Lexer) scanNumber() bool { digits := "0123456789_" // Is it hex? if l.accept("0") { @@ -107,7 +107,7 @@ func (l *lexer) scanNumber() bool { return true } -func dot(l *lexer) stateFn { +func dot(l *Lexer) stateFn { l.next() if l.accept("0123456789") { l.backup() @@ -118,7 +118,7 @@ func dot(l *lexer) stateFn { return root } -func identifier(l *lexer) stateFn { +func identifier(l *Lexer) stateFn { loop: for { switch r := l.next(); { @@ -140,7 +140,7 @@ loop: return root } -func not(l *lexer) stateFn { +func not(l *Lexer) stateFn { l.emit(Operator) l.skipSpaces() @@ -167,13 +167,13 @@ func not(l *lexer) stateFn { return root } -func questionMark(l *lexer) stateFn { +func questionMark(l *Lexer) stateFn { l.accept(".?") l.emit(Operator) return root } -func slash(l *lexer) stateFn { +func slash(l *Lexer) stateFn { if l.accept("/") { return singleLineComment } @@ -184,7 +184,7 @@ func slash(l *lexer) stateFn { return root } -func singleLineComment(l *lexer) stateFn { +func singleLineComment(l *Lexer) stateFn { for { r := l.next() if r == eof || r == '\n' { @@ -195,7 +195,7 @@ func singleLineComment(l *lexer) stateFn { return root } -func multiLineComment(l *lexer) stateFn { +func multiLineComment(l *Lexer) stateFn { for { r := l.next() if r == eof { @@ -209,7 +209,7 @@ func multiLineComment(l *lexer) stateFn { return root } -func pointer(l *lexer) stateFn { +func pointer(l *Lexer) stateFn { l.accept("#") l.emit(Operator) for { diff --git a/parser/lexer/token.go b/parser/lexer/token.go index 459fa6905..c809c690e 100644 --- a/parser/lexer/token.go +++ b/parser/lexer/token.go @@ -31,17 +31,13 @@ func (t Token) String() string { } func (t Token) Is(kind Kind, values ...string) bool { - if len(values) == 0 { - return kind == t.Kind + if kind != t.Kind { + return false } - for _, v := range values { if v == t.Value { - goto found + return true } } - return false - -found: - return kind == t.Kind + return len(values) == 0 } diff --git a/parser/lexer/utils.go b/parser/lexer/utils.go index 5c9e6b59d..fdb8beaa1 100644 --- a/parser/lexer/utils.go +++ b/parser/lexer/utils.go @@ -36,7 +36,8 @@ func unescape(value string) (string, error) { if size >= math.MaxInt { return "", fmt.Errorf("too large string") } - buf := make([]byte, 0, size) + buf := new(strings.Builder) + buf.Grow(int(size)) for len(value) > 0 { c, multibyte, rest, err := unescapeChar(value) if err != nil { @@ -44,13 +45,13 @@ func unescape(value string) (string, error) { } value = rest if c < utf8.RuneSelf || !multibyte { - buf = append(buf, byte(c)) + buf.WriteByte(byte(c)) } else { n := utf8.EncodeRune(runeTmp[:], c) - buf = append(buf, runeTmp[:n]...) + buf.Write(runeTmp[:n]) } } - return string(buf), nil + return buf.String(), nil } // unescapeChar takes a string input and returns the following info: diff --git a/parser/parser.go b/parser/parser.go index 0a463fed5..e1dd111fc 100644 --- a/parser/parser.go +++ b/parser/parser.go @@ -1,7 +1,9 @@ package parser import ( + "errors" "fmt" + "io" "math" "strconv" "strings" @@ -10,6 +12,7 @@ import ( "github.com/expr-lang/expr/builtin" "github.com/expr-lang/expr/conf" "github.com/expr-lang/expr/file" + "github.com/expr-lang/expr/parser/lexer" . "github.com/expr-lang/expr/parser/lexer" "github.com/expr-lang/expr/parser/operator" "github.com/expr-lang/expr/parser/utils" @@ -44,17 +47,50 @@ var predicates = map[string]struct { "reduce": {[]arg{expr, predicate, expr | optional}}, } -type parser struct { - tokens []Token - current Token - pos int - err *file.Error - config *conf.Config - depth int // predicate call depth - nodeCount uint // tracks number of AST nodes created +// Parser is a reusable parser. The zero value is ready for use. +type Parser struct { + lexer *lexer.Lexer + current, stashed Token + hasStash bool + err *file.Error + config *conf.Config + depth int // predicate call depth + nodeCount uint // tracks number of AST nodes created } -func (p *parser) checkNodeLimit() error { +func (p *Parser) Parse(input string, config *conf.Config) (*Tree, error) { + if p.lexer == nil { + p.lexer = lexer.New() + } + p.config = config + source := file.NewSource(input) + p.lexer.Reset(source) + p.next() + node := p.parseSequenceExpression() + + if !p.current.Is(EOF) { + p.error("unexpected token %v", p.current) + } + + tree := &Tree{ + Node: node, + Source: source, + } + err := p.err + + // cleanup non-reusable pointer values and reset state + p.err = nil + p.config = nil + p.lexer.Reset(file.Source{}) + + if err != nil { + return tree, err.Bind(source) + } + + return tree, nil +} + +func (p *Parser) checkNodeLimit() error { p.nodeCount++ if p.config == nil { if p.nodeCount > conf.DefaultMaxNodes { @@ -70,7 +106,7 @@ func (p *parser) checkNodeLimit() error { return nil } -func (p *parser) createNode(n Node, loc file.Location) Node { +func (p *Parser) createNode(n Node, loc file.Location) Node { if err := p.checkNodeLimit(); err != nil { return nil } @@ -81,7 +117,7 @@ func (p *parser) createNode(n Node, loc file.Location) Node { return n } -func (p *parser) createMemberNode(n *MemberNode, loc file.Location) *MemberNode { +func (p *Parser) createMemberNode(n *MemberNode, loc file.Location) *MemberNode { if err := p.checkNodeLimit(); err != nil { return nil } @@ -102,42 +138,14 @@ func Parse(input string) (*Tree, error) { } func ParseWithConfig(input string, config *conf.Config) (*Tree, error) { - source := file.NewSource(input) - - tokens, err := Lex(source) - if err != nil { - return nil, err - } - - p := &parser{ - tokens: tokens, - current: tokens[0], - config: config, - } - - node := p.parseSequenceExpression() - - if !p.current.Is(EOF) { - p.error("unexpected token %v", p.current) - } - - tree := &Tree{ - Node: node, - Source: source, - } - - if p.err != nil { - return tree, p.err.Bind(source) - } - - return tree, nil + return new(Parser).Parse(input, config) } -func (p *parser) error(format string, args ...any) { +func (p *Parser) error(format string, args ...any) { p.errorAt(p.current, format, args...) } -func (p *parser) errorAt(token Token, format string, args ...any) { +func (p *Parser) errorAt(token Token, format string, args ...any) { if p.err == nil { // show first error p.err = &file.Error{ Location: token.Location, @@ -146,16 +154,32 @@ func (p *parser) errorAt(token Token, format string, args ...any) { } } -func (p *parser) next() { - p.pos++ - if p.pos >= len(p.tokens) { - p.error("unexpected end of expression") +func (p *Parser) next() { + if p.hasStash { + p.current = p.stashed + p.hasStash = false return } - p.current = p.tokens[p.pos] + + token, err := p.lexer.Next() + var e *file.Error + switch { + case err == nil: + p.current = token + case errors.Is(err, io.EOF): + p.error("unexpected end of expression") + case errors.As(err, &e): + p.err = e + default: + p.err = &file.Error{ + Location: p.current.Location, + Message: "unknown lexing error", + Prev: err, + } + } } -func (p *parser) expect(kind Kind, values ...string) { +func (p *Parser) expect(kind Kind, values ...string) { if p.current.Is(kind, values...) { p.next() return @@ -165,7 +189,7 @@ func (p *parser) expect(kind Kind, values ...string) { // parse functions -func (p *parser) parseSequenceExpression() Node { +func (p *Parser) parseSequenceExpression() Node { nodes := []Node{p.parseExpression(0)} for p.current.Is(Operator, ";") && p.err == nil { @@ -186,7 +210,7 @@ func (p *parser) parseSequenceExpression() Node { }, nodes[0].Location()) } -func (p *parser) parseExpression(precedence int) Node { +func (p *Parser) parseExpression(precedence int) Node { if p.err != nil { return nil } @@ -209,15 +233,16 @@ func (p *parser) parseExpression(precedence int) Node { // Handle "not *" operator, like "not in" or "not contains". if negate { - currentPos := p.pos + tokenBackup := p.current p.next() if operator.AllowedNegateSuffix(p.current.Value) { if op, ok := operator.Binary[p.current.Value]; ok && op.Precedence >= precedence { notToken = p.current opToken = p.current } else { - p.pos = currentPos - p.current = opToken + p.hasStash = true + p.stashed = p.current + p.current = tokenBackup break } } else { @@ -288,7 +313,7 @@ func (p *parser) parseExpression(precedence int) Node { return nodeLeft } -func (p *parser) parseVariableDeclaration() Node { +func (p *Parser) parseVariableDeclaration() Node { p.expect(Operator, "let") variableName := p.current p.expect(Identifier) @@ -303,7 +328,7 @@ func (p *parser) parseVariableDeclaration() Node { }, variableName.Location) } -func (p *parser) parseConditionalIf() Node { +func (p *Parser) parseConditionalIf() Node { p.next() nodeCondition := p.parseExpression(0) p.expect(Bracket, "{") @@ -322,7 +347,7 @@ func (p *parser) parseConditionalIf() Node { } -func (p *parser) parseConditional(node Node) Node { +func (p *Parser) parseConditional(node Node) Node { var expr1, expr2 Node for p.current.Is(Operator, "?") && p.err == nil { p.next() @@ -349,7 +374,7 @@ func (p *parser) parseConditional(node Node) Node { return node } -func (p *parser) parsePrimary() Node { +func (p *Parser) parsePrimary() Node { token := p.current if token.Is(Operator) { @@ -402,7 +427,7 @@ func (p *parser) parsePrimary() Node { return p.parseSecondary() } -func (p *parser) parseSecondary() Node { +func (p *Parser) parseSecondary() Node { var node Node token := p.current @@ -501,7 +526,7 @@ func (p *parser) parseSecondary() Node { return p.parsePostfixExpression(node) } -func (p *parser) toIntegerNode(number int64) Node { +func (p *Parser) toIntegerNode(number int64) Node { if number > math.MaxInt { p.error("integer literal is too large") return nil @@ -509,7 +534,7 @@ func (p *parser) toIntegerNode(number int64) Node { return p.createNode(&IntegerNode{Value: int(number)}, p.current.Location) } -func (p *parser) toFloatNode(number float64) Node { +func (p *Parser) toFloatNode(number float64) Node { if number > math.MaxFloat64 { p.error("float literal is too large") return nil @@ -517,7 +542,7 @@ func (p *parser) toFloatNode(number float64) Node { return p.createNode(&FloatNode{Value: number}, p.current.Location) } -func (p *parser) parseCall(token Token, arguments []Node, checkOverrides bool) Node { +func (p *Parser) parseCall(token Token, arguments []Node, checkOverrides bool) Node { var node Node isOverridden := false @@ -595,7 +620,7 @@ func (p *parser) parseCall(token Token, arguments []Node, checkOverrides bool) N return node } -func (p *parser) parseArguments(arguments []Node) []Node { +func (p *Parser) parseArguments(arguments []Node) []Node { // If pipe operator is used, the first argument is the left-hand side // of the operator, so we do not parse it as an argument inside brackets. offset := len(arguments) @@ -616,7 +641,7 @@ func (p *parser) parseArguments(arguments []Node) []Node { return arguments } -func (p *parser) parsePredicate() Node { +func (p *Parser) parsePredicate() Node { startToken := p.current withBrackets := false if p.current.Is(Bracket, "{") { @@ -648,7 +673,7 @@ func (p *parser) parsePredicate() Node { return predicateNode } -func (p *parser) parseArrayExpression(token Token) Node { +func (p *Parser) parseArrayExpression(token Token) Node { nodes := make([]Node, 0) p.expect(Bracket, "[") @@ -672,7 +697,7 @@ end: return node } -func (p *parser) parseMapExpression(token Token) Node { +func (p *Parser) parseMapExpression(token Token) Node { p.expect(Bracket, "{") nodes := make([]Node, 0) @@ -725,7 +750,7 @@ end: return node } -func (p *parser) parsePostfixExpression(node Node) Node { +func (p *Parser) parsePostfixExpression(node Node) Node { postfixToken := p.current for (postfixToken.Is(Operator) || postfixToken.Is(Bracket)) && p.err == nil { optional := postfixToken.Value == "?." @@ -855,7 +880,7 @@ func (p *parser) parsePostfixExpression(node Node) Node { } return node } -func (p *parser) parseComparison(left Node, token Token, precedence int) Node { +func (p *Parser) parseComparison(left Node, token Token, precedence int) Node { var rootNode Node for { comparator := p.parseExpression(precedence + 1) diff --git a/vm/vm_test.go b/vm/vm_test.go index 91752a419..817fc6cc2 100644 --- a/vm/vm_test.go +++ b/vm/vm_test.go @@ -8,6 +8,7 @@ import ( "testing" "time" + "github.com/expr-lang/expr/file" "github.com/expr-lang/expr/internal/testify/require" "github.com/expr-lang/expr" @@ -609,10 +610,10 @@ func TestVM_DirectCallOpcodes(t *testing.T) { for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { program := vm.NewProgram( - nil, // source - nil, // node - nil, // locations - 0, // variables + file.Source{}, // source + nil, // node + nil, // locations + 0, // variables tt.consts, tt.bytecode, tt.args, @@ -735,10 +736,10 @@ func TestVM_IndexAndCountOperations(t *testing.T) { for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { program := vm.NewProgram( - nil, // source - nil, // node - nil, // locations - 0, // variables + file.Source{}, // source + nil, // node + nil, // locations + 0, // variables tt.consts, tt.bytecode, tt.args, @@ -1176,10 +1177,10 @@ func TestVM_DirectBasicOpcodes(t *testing.T) { for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { program := vm.NewProgram( - nil, // source - nil, // node - nil, // locations - 0, // variables + file.Source{}, // source + nil, // node + nil, // locations + 0, // variables tt.consts, tt.bytecode, tt.args, From 85d0be85096d16dc1e06d8f893b353133daa008d Mon Sep 17 00:00:00 2001 From: Diego Augusto Molina Date: Mon, 30 Jun 2025 15:14:08 -0300 Subject: [PATCH 103/113] Ignoring fields with struct tag expr:"-" and make "in" return false for unexported fields (#806) * allow ignoring struct member using a - in expr struct tag * fix in operator * simplify logic * add regression test for #807 * fixes #807: make in operator return false for unexported struct fields --------- Co-authored-by: Anton Medvedev --- builtin/lib.go | 8 +++- checker/nature/utils.go | 20 +++++--- expr_test.go | 101 +++++++++++++++++++++++++++++++++++++++- vm/runtime/runtime.go | 14 ++++-- 4 files changed, 130 insertions(+), 13 deletions(-) diff --git a/builtin/lib.go b/builtin/lib.go index 579393161..6f6a3b6cd 100644 --- a/builtin/lib.go +++ b/builtin/lib.go @@ -421,10 +421,14 @@ func get(params ...any) (out any, err error) { fieldName := i.(string) value := v.FieldByNameFunc(func(name string) bool { field, _ := v.Type().FieldByName(name) - if field.Tag.Get("expr") == fieldName { + switch field.Tag.Get("expr") { + case "-": + return false + case fieldName: return true + default: + return name == fieldName } - return name == fieldName }) if value.IsValid() { return value.Interface(), nil diff --git a/checker/nature/utils.go b/checker/nature/utils.go index 179459874..c1551546c 100644 --- a/checker/nature/utils.go +++ b/checker/nature/utils.go @@ -6,11 +6,15 @@ import ( "github.com/expr-lang/expr/internal/deref" ) -func fieldName(field reflect.StructField) string { - if taggedName := field.Tag.Get("expr"); taggedName != "" { - return taggedName +func fieldName(field reflect.StructField) (string, bool) { + switch taggedName := field.Tag.Get("expr"); taggedName { + case "-": + return "", false + case "": + return field.Name, true + default: + return taggedName, true } - return field.Name } func fetchField(t reflect.Type, name string) (reflect.StructField, bool) { @@ -23,7 +27,7 @@ func fetchField(t reflect.Type, name string) (reflect.StructField, bool) { for i := 0; i < t.NumField(); i++ { field := t.Field(i) // Search all fields, even embedded structs. - if fieldName(field) == name { + if n, ok := fieldName(field); ok && n == name { return field, true } } @@ -69,7 +73,11 @@ func StructFields(t reflect.Type) map[string]Nature { } } - table[fieldName(f)] = Nature{ + name, ok := fieldName(f) + if !ok { + continue + } + table[name] = Nature{ Type: f.Type, FieldIndex: f.Index, } diff --git a/expr_test.go b/expr_test.go index 57d2cfbbb..32ec6dfb8 100644 --- a/expr_test.go +++ b/expr_test.go @@ -6,6 +6,7 @@ import ( "fmt" "os" "reflect" + "strings" "sync" "testing" "time" @@ -139,7 +140,86 @@ func ExampleEnv_tagged_field_names() { fmt.Printf("%v", output) - // Output : Hello World + // Output: Hello World +} + +func ExampleEnv_hidden_tagged_field_names() { + type Internal struct { + Visible string + Hidden string `expr:"-"` + } + type environment struct { + Visible string + Hidden string `expr:"-"` + HiddenInternal Internal `expr:"-"` + VisibleInternal Internal + } + + env := environment{ + Hidden: "First level secret", + HiddenInternal: Internal{ + Visible: "Second level secret", + Hidden: "Also hidden", + }, + VisibleInternal: Internal{ + Visible: "Not a secret", + Hidden: "Hidden too", + }, + } + + hiddenValues := []string{ + `Hidden`, + `HiddenInternal`, + `HiddenInternal.Visible`, + `HiddenInternal.Hidden`, + `VisibleInternal["Hidden"]`, + } + for _, expression := range hiddenValues { + output, err := expr.Eval(expression, env) + if err == nil || !strings.Contains(err.Error(), "cannot fetch") { + fmt.Printf("unexpected output: %v; err: %v\n", output, err) + return + } + fmt.Printf("%q is hidden as expected\n", expression) + } + + visibleValues := []string{ + `Visible`, + `VisibleInternal`, + `VisibleInternal["Visible"]`, + } + for _, expression := range visibleValues { + _, err := expr.Eval(expression, env) + if err != nil { + fmt.Printf("unexpected error: %v\n", err) + return + } + fmt.Printf("%q is visible as expected\n", expression) + } + + testWithIn := []string{ + `not ("Hidden" in $env)`, + `"Visible" in $env`, + `not ("Hidden" in VisibleInternal)`, + `"Visible" in VisibleInternal`, + } + for _, expression := range testWithIn { + val, err := expr.Eval(expression, env) + shouldBeTrue, ok := val.(bool) + if err != nil || !ok || !shouldBeTrue { + fmt.Printf("unexpected result; value: %v; error: %v\n", val, err) + return + } + } + + // Output: "Hidden" is hidden as expected + // "HiddenInternal" is hidden as expected + // "HiddenInternal.Visible" is hidden as expected + // "HiddenInternal.Hidden" is hidden as expected + // "VisibleInternal[\"Hidden\"]" is hidden as expected + // "Visible" is visible as expected + // "VisibleInternal" is visible as expected + // "VisibleInternal[\"Visible\"]" is visible as expected } func ExampleAsKind() { @@ -529,7 +609,7 @@ func ExamplePatch() { } fmt.Printf("%v", output) - // Output : Hello, you, world! + // Output: Hello, you, world! } func ExampleWithContext() { @@ -2765,3 +2845,20 @@ func TestMemoryBudget(t *testing.T) { }) } } + +func TestIssue807(t *testing.T) { + type MyStruct struct { + nonExported string + } + out, err := expr.Eval(` "nonExported" in $env `, MyStruct{}) + if err != nil { + t.Fatalf("unexpected error: %v", err) + } + b, ok := out.(bool) + if !ok { + t.Fatalf("expected boolean type, got %T: %v", b, b) + } + if b { + t.Fatalf("expected 'in' operator to return false for unexported field") + } +} diff --git a/vm/runtime/runtime.go b/vm/runtime/runtime.go index cd48a280d..fa14c4d0a 100644 --- a/vm/runtime/runtime.go +++ b/vm/runtime/runtime.go @@ -65,10 +65,14 @@ func Fetch(from, i any) any { fieldName := i.(string) value := v.FieldByNameFunc(func(name string) bool { field, _ := v.Type().FieldByName(name) - if field.Tag.Get("expr") == fieldName { + switch field.Tag.Get("expr") { + case "-": + return false + case fieldName: return true + default: + return name == fieldName } - return name == fieldName }) if value.IsValid() { return value.Interface() @@ -213,7 +217,11 @@ func In(needle any, array any) bool { if !n.IsValid() || n.Kind() != reflect.String { panic(fmt.Sprintf("cannot use %T as field name of %T", needle, array)) } - value := v.FieldByName(n.String()) + field, ok := v.Type().FieldByName(n.String()) + if !ok || !field.IsExported() || field.Tag.Get("expr") == "-" { + return false + } + value := v.FieldByIndex(field.Index) if value.IsValid() { return true } From f1c65fa312db6b2db3003d60fc514724b8223a4f Mon Sep 17 00:00:00 2001 From: Diego Augusto Molina Date: Mon, 30 Jun 2025 15:21:25 -0300 Subject: [PATCH 104/113] Fix runtime error not allowing to slice unaddressable array type (#803) * fix runtime error not allowing to slice unaddressable array type * simplify logic and move test * remove dead code --------- Signed-off-by: Anton Medvedev Co-authored-by: Anton Medvedev --- expr_test.go | 17 +++++++++++++++++ vm/runtime/runtime.go | 5 +++++ 2 files changed, 22 insertions(+) diff --git a/expr_test.go b/expr_test.go index 32ec6dfb8..14f6a15e7 100644 --- a/expr_test.go +++ b/expr_test.go @@ -2846,6 +2846,23 @@ func TestMemoryBudget(t *testing.T) { } } +func TestIssue802(t *testing.T) { + prog, err := expr.Compile(`arr[1:2][0]`) + if err != nil { + t.Fatalf("error compiling program: %v", err) + } + val, err := expr.Run(prog, map[string]any{ + "arr": [5]int{0, 1, 2, 3, 4}, + }) + if err != nil { + t.Fatalf("error running program: %v", err) + } + valInt, ok := val.(int) + if !ok || valInt != 1 { + t.Fatalf("invalid result, expected 1, got %v", val) + } +} + func TestIssue807(t *testing.T) { type MyStruct struct { nonExported string diff --git a/vm/runtime/runtime.go b/vm/runtime/runtime.go index fa14c4d0a..56759c531 100644 --- a/vm/runtime/runtime.go +++ b/vm/runtime/runtime.go @@ -166,6 +166,11 @@ func Slice(array, from, to any) any { if a > b { a = b } + if v.Kind() == reflect.Array && !v.CanAddr() { + newValue := reflect.New(v.Type()).Elem() + newValue.Set(v) + v = newValue + } value := v.Slice(a, b) if value.IsValid() { return value.Interface() From 11286428d375e5fcf9d76f598aaf7e58ba41e9a7 Mon Sep 17 00:00:00 2001 From: Diego Augusto Molina Date: Sat, 5 Jul 2025 08:46:48 -0300 Subject: [PATCH 105/113] fix VM not clearing memory references when reused (#813) --- vm/vm.go | 9 +++++++++ 1 file changed, 9 insertions(+) diff --git a/vm/vm.go b/vm/vm.go index 3018619d9..ed61d2f90 100644 --- a/vm/vm.go +++ b/vm/vm.go @@ -67,9 +67,11 @@ func (vm *VM) Run(program *Program, env any) (_ any, err error) { if vm.Stack == nil { vm.Stack = make([]any, 0, 2) } else { + clearSlice(vm.Stack) vm.Stack = vm.Stack[0:0] } if vm.Scopes != nil { + clearSlice(vm.Scopes) vm.Scopes = vm.Scopes[0:0] } if len(vm.Variables) < program.variables { @@ -614,3 +616,10 @@ func (vm *VM) Step() { func (vm *VM) Position() chan int { return vm.curr } + +func clearSlice[S ~[]E, E any](s S) { + var zero E + for i := range s { + s[i] = zero // clear mem, optimized by the compiler, in Go 1.21 the "clear" builtin can be used + } +} From 87df78319489e4c4e00bb3ac1256c63aa8bd63f1 Mon Sep 17 00:00:00 2001 From: David Klassen Date: Thu, 24 Jul 2025 13:29:13 +0700 Subject: [PATCH 106/113] Update README.md (#815) Add Naoma.AI to the list of companies Signed-off-by: David Klassen --- README.md | 1 + 1 file changed, 1 insertion(+) diff --git a/README.md b/README.md index c0778a84d..5afd743d8 100644 --- a/README.md +++ b/README.md @@ -150,6 +150,7 @@ func main() { * [ByteDance](https://bytedance.com) incorporates Expr into its internal business rule engine. * [Aviasales](https://aviasales.ru) utilizes Expr as a business rule engine for its flight search engine. * [Wish.com](https://www.wish.com) employs Expr in its decision-making rule engine for the Wish Assistant. +* [Naoma.AI](https://www.naoma.ai) uses Expr as a part of its call scoring engine. * [Argo](https://argoproj.github.io) integrates Expr into Argo Rollouts and Argo Workflows for Kubernetes. * [OpenTelemetry](https://opentelemetry.io) integrates Expr into the OpenTelemetry Collector. * [Philips Labs](https://github.com/philips-labs/tabia) employs Expr in Tabia, a tool designed to collect insights on their code bases. From bbcbc530f31620623b36750365ee883aa4b86d8f Mon Sep 17 00:00:00 2001 From: Diego Augusto Molina Date: Thu, 28 Aug 2025 06:06:51 -0300 Subject: [PATCH 107/113] Allow backticks to be quoted in string literals (#820) * allow backticks to be quoted in string literals * remove redundant empty string --- parser/lexer/lexer.go | 42 +++++++++++++++++++++++++++++++++----- parser/lexer/lexer_test.go | 36 ++++++++++++++++++++++++++++++++ 2 files changed, 73 insertions(+), 5 deletions(-) diff --git a/parser/lexer/lexer.go b/parser/lexer/lexer.go index f417f02b6..a8cf6a5be 100644 --- a/parser/lexer/lexer.go +++ b/parser/lexer/lexer.go @@ -242,15 +242,47 @@ func (l *Lexer) scanString(quote rune) (n int) { } func (l *Lexer) scanRawString(quote rune) (n int) { - ch := l.next() // read character after back tick - for ch != quote { - if ch == eof { + var escapedQuotes int +loop: + for { + ch := l.next() + for ch == quote && l.peek() == quote { + // skip current and next char which are the quote escape sequence + l.next() + ch = l.next() + escapedQuotes++ + } + switch ch { + case quote: + break loop + case eof: l.error("literal not terminated") return } - ch = l.next() n++ } - l.emitValue(String, l.source.String()[l.start.byte+1:l.end.byte-1]) + str := l.source.String()[l.start.byte+1 : l.end.byte-1] + + // handle simple case where no quoted backtick was found, then no allocation + // is needed for the new string + if escapedQuotes == 0 { + l.emitValue(String, str) + return + } + + var b strings.Builder + var skipped bool + b.Grow(len(str) - escapedQuotes) + for _, r := range str { + if r == quote { + if !skipped { + skipped = true + continue + } + skipped = false + } + b.WriteRune(r) + } + l.emitValue(String, b.String()) return } diff --git a/parser/lexer/lexer_test.go b/parser/lexer/lexer_test.go index 5171f4255..baa5aabb1 100644 --- a/parser/lexer/lexer_test.go +++ b/parser/lexer/lexer_test.go @@ -68,6 +68,22 @@ func TestLex(t *testing.T) { {Kind: EOF}, }, }, + { + "`escaped backticks` `` `a``b` ```` `a``` ```b` ```a````b``` ```````` ```a````` `````b```", + []Token{ + {Kind: String, Value: "escaped backticks"}, + {Kind: String, Value: ""}, + {Kind: String, Value: "a`b"}, + {Kind: String, Value: "`"}, + {Kind: String, Value: "a`"}, + {Kind: String, Value: "`b"}, + {Kind: String, Value: "`a``b`"}, + {Kind: String, Value: "```"}, + {Kind: String, Value: "`a``"}, + {Kind: String, Value: "``b`"}, + {Kind: EOF}, + }, + }, { "a and orb().val #.", []Token{ @@ -332,6 +348,26 @@ literal not terminated (1:10) | id "hello | .........^ +id ` + "`" + `hello +literal not terminated (1:10) + | id ` + "`" + `hello + | .........^ + +id ` + "`" + `hello` + "``" + ` +literal not terminated (1:12) + | id ` + "`" + `hello` + "``" + ` + | ...........^ + +id ` + "```" + `hello +literal not terminated (1:12) + | id ` + "```" + `hello + | ...........^ + +id ` + "`" + `hello` + "``" + ` world +literal not terminated (1:18) + | id ` + "`" + `hello` + "``" + ` world + | .................^ + früh ♥︎ unrecognized character: U+2665 '♥' (1:6) | früh ♥︎ From 1c09e5e9ec3d7f1237fb11c47c6cb1545c0c9bf8 Mon Sep 17 00:00:00 2001 From: Andreev Fedor Date: Mon, 8 Sep 2025 12:40:52 +0400 Subject: [PATCH 108/113] Fix error position reporting in multiline script (#827) --- expr_test.go | 11 +++++++++++ file/error.go | 5 +++-- 2 files changed, 14 insertions(+), 2 deletions(-) diff --git a/expr_test.go b/expr_test.go index 14f6a15e7..bed6d7468 100644 --- a/expr_test.go +++ b/expr_test.go @@ -1757,6 +1757,17 @@ func TestEval_exposed_error(t *testing.T) { require.Equal(t, 1, fileError.Line) } +func TestCompile_exposed_error_with_multiline_script(t *testing.T) { + _, err := expr.Compile("{\n\ta: 1,\n\tb: #,\n\tc: 3,\n}") + require.Error(t, err) + + fileError, ok := err.(*file.Error) + require.True(t, ok, "error should be of type *file.Error") + require.Equal(t, "unexpected token Operator(\"#\") (3:5)\n | b: #,\n | ....^", fileError.Error()) + require.Equal(t, 4, fileError.Column) + require.Equal(t, 3, fileError.Line) +} + func TestIssue105(t *testing.T) { type A struct { Field string diff --git a/file/error.go b/file/error.go index 04253b6f6..c398ed59c 100644 --- a/file/error.go +++ b/file/error.go @@ -31,12 +31,13 @@ func (e *Error) Bind(source Source) *Error { break } if r == '\n' { - lineStart = i + lineStart = i + 1 e.Line++ e.Column = 0 + } else { + e.Column++ } runeCount++ - e.Column++ } lineEnd := lineStart + strings.IndexByte(src[lineStart:], '\n') From bcb2d51045da5fd5290d302d9132044a2993f280 Mon Sep 17 00:00:00 2001 From: Diego Augusto Molina Date: Thu, 18 Sep 2025 09:38:27 -0300 Subject: [PATCH 109/113] Improve Performance of the Type System (#824) * export the checker and ensure no methods or fields are exported * make Checker reusable * add PatchAndCheck method to Checker, and reuse it in visitors * avoid unnecessary map and consolidate structs * make all Nature methods use pointer-receiver * added cache for type and nature information * optimize type and nature checks * more aggressively cache some partial results and add cheap checks * cache reused values * reduce copying in Nature by breaking down optional fields * enforce use of cache * improve ergonomics of FromType and NatureOf * improve struct method fetching * make cache private to Nature * first iteration improving struct reflect caching * cleaned up struct fields data * improve caching of functions data * simplify checker code * simplify and remove dead code * add checker benchmarks * address PR comments and minor improvements * rename from SetCache to Bind * make the benchmarks more fair * fix benchmark option not being applied * move Cache to be argument instead of field * merge FuncData into Optional * rename Optional to TypeData * simplify struct logic * cache builtin numeric types --------- Co-authored-by: Anton Medvedev --- ast/node.go | 2 +- checker/checker.go | 962 ++++++++++++++++++---------------- checker/checker_bench_test.go | 114 ++++ checker/checker_test.go | 23 +- checker/info.go | 25 +- checker/nature/nature.go | 586 ++++++++++++++++----- checker/nature/utils.go | 247 +++++++-- checker/types.go | 190 ------- compiler/compiler.go | 29 +- conf/config.go | 5 +- conf/env.go | 44 +- docgen/docgen.go | 7 +- expr.go | 1 + internal/deref/deref.go | 9 + parser/lexer/lexer.go | 7 - parser/parser.go | 5 +- patcher/operator_override.go | 5 +- types/types.go | 25 +- 18 files changed, 1360 insertions(+), 926 deletions(-) create mode 100644 checker/checker_bench_test.go delete mode 100644 checker/types.go diff --git a/ast/node.go b/ast/node.go index 02923ac52..40c507aa6 100644 --- a/ast/node.go +++ b/ast/node.go @@ -66,7 +66,7 @@ func (n *base) Type() reflect.Type { // SetType sets the type of the node. func (n *base) SetType(t reflect.Type) { - n.nature.Type = t + n.nature = nature.FromType(t) } // NilNode represents nil. diff --git a/checker/checker.go b/checker/checker.go index f49234137..531dadac3 100644 --- a/checker/checker.go +++ b/checker/checker.go @@ -4,6 +4,7 @@ import ( "fmt" "reflect" "regexp" + "time" "github.com/expr-lang/expr/ast" "github.com/expr-lang/expr/builtin" @@ -13,17 +14,90 @@ import ( "github.com/expr-lang/expr/parser" ) +var ( + anyType = reflect.TypeOf(new(any)).Elem() + boolType = reflect.TypeOf(true) + intType = reflect.TypeOf(0) + floatType = reflect.TypeOf(float64(0)) + stringType = reflect.TypeOf("") + arrayType = reflect.TypeOf([]any{}) + mapType = reflect.TypeOf(map[string]any{}) + timeType = reflect.TypeOf(time.Time{}) + durationType = reflect.TypeOf(time.Duration(0)) + + anyTypeSlice = []reflect.Type{anyType} +) + +// ParseCheck parses input expression and checks its types. Also, it applies +// all provided patchers. In case of error, it returns error with a tree. +func ParseCheck(input string, config *conf.Config) (*parser.Tree, error) { + tree, err := parser.ParseWithConfig(input, config) + if err != nil { + return tree, err + } + + _, err = new(Checker).PatchAndCheck(tree, config) + if err != nil { + return tree, err + } + + return tree, nil +} + +// Check calls Check on a disposable Checker. +func Check(tree *parser.Tree, config *conf.Config) (reflect.Type, error) { + return new(Checker).Check(tree, config) +} + +type Checker struct { + config *conf.Config + predicateScopes []predicateScope + varScopes []varScope + err *file.Error + needsReset bool +} + +type predicateScope struct { + collection Nature + vars []varScope +} + +type varScope struct { + name string + nature Nature +} + +// PatchAndCheck applies all patchers and checks the tree. +func (v *Checker) PatchAndCheck(tree *parser.Tree, config *conf.Config) (reflect.Type, error) { + v.reset(config) + if len(config.Visitors) > 0 { + // Run all patchers that dont support being run repeatedly first + v.runVisitors(tree, false) + + // Run patchers that require multiple passes next (currently only Operator patching) + v.runVisitors(tree, true) + } + return v.Check(tree, config) +} + +// Check checks types of the expression tree. It returns type of the expression +// and error if any. If config is nil, then default configuration will be used. +func (v *Checker) Check(tree *parser.Tree, config *conf.Config) (reflect.Type, error) { + v.reset(config) + return v.check(tree) +} + // Run visitors in a given config over the given tree // runRepeatable controls whether to filter for only vistors that require multiple passes or not -func runVisitors(tree *parser.Tree, config *conf.Config, runRepeatable bool) { +func (v *Checker) runVisitors(tree *parser.Tree, runRepeatable bool) { for { more := false - for _, v := range config.Visitors { + for _, visitor := range v.config.Visitors { // We need to perform types check, because some visitors may rely on // types information available in the tree. - _, _ = Check(tree, config) + _, _ = v.Check(tree, v.config) - r, repeatable := v.(interface { + r, repeatable := visitor.(interface { Reset() ShouldRepeat() bool }) @@ -31,12 +105,12 @@ func runVisitors(tree *parser.Tree, config *conf.Config, runRepeatable bool) { if repeatable { if runRepeatable { r.Reset() - ast.Walk(&tree.Node, v) + ast.Walk(&tree.Node, visitor) more = more || r.ShouldRepeat() } } else { if !runRepeatable { - ast.Walk(&tree.Node, v) + ast.Walk(&tree.Node, visitor) } } } @@ -47,38 +121,7 @@ func runVisitors(tree *parser.Tree, config *conf.Config, runRepeatable bool) { } } -// ParseCheck parses input expression and checks its types. Also, it applies -// all provided patchers. In case of error, it returns error with a tree. -func ParseCheck(input string, config *conf.Config) (*parser.Tree, error) { - tree, err := parser.ParseWithConfig(input, config) - if err != nil { - return tree, err - } - - if len(config.Visitors) > 0 { - // Run all patchers that dont support being run repeatedly first - runVisitors(tree, config, false) - - // Run patchers that require multiple passes next (currently only Operator patching) - runVisitors(tree, config, true) - } - _, err = Check(tree, config) - if err != nil { - return tree, err - } - - return tree, nil -} - -// Check checks types of the expression tree. It returns type of the expression -// and error if any. If config is nil, then default configuration will be used. -func Check(tree *parser.Tree, config *conf.Config) (reflect.Type, error) { - if config == nil { - config = conf.New(nil) - } - - v := &checker{config: config} - +func (v *Checker) check(tree *parser.Tree) (reflect.Type, error) { nt := v.visit(tree.Node) // To keep compatibility with previous versions, we should return any, if nature is unknown. @@ -93,19 +136,19 @@ func Check(tree *parser.Tree, config *conf.Config) (reflect.Type, error) { if v.config.Expect != reflect.Invalid { if v.config.ExpectAny { - if isUnknown(nt) { + if nt.IsUnknown(&v.config.NtCache) { return t, nil } } switch v.config.Expect { case reflect.Int, reflect.Int64, reflect.Float64: - if !isNumber(nt) { - return nil, fmt.Errorf("expected %v, but got %v", v.config.Expect, nt) + if !nt.IsNumber() { + return nil, fmt.Errorf("expected %v, but got %s", v.config.Expect, nt.String()) } default: - if nt.Kind() != v.config.Expect { - return nil, fmt.Errorf("expected %v, but got %s", v.config.Expect, nt) + if nt.Kind != v.config.Expect { + return nil, fmt.Errorf("expected %v, but got %s", v.config.Expect, nt.String()) } } } @@ -113,81 +156,76 @@ func Check(tree *parser.Tree, config *conf.Config) (reflect.Type, error) { return t, nil } -type checker struct { - config *conf.Config - predicateScopes []predicateScope - varScopes []varScope - err *file.Error -} - -type predicateScope struct { - collection Nature - vars map[string]Nature -} +func (v *Checker) reset(config *conf.Config) { + if v.needsReset { + clearSlice(v.predicateScopes) + clearSlice(v.varScopes) + v.predicateScopes = v.predicateScopes[:0] + v.varScopes = v.varScopes[:0] + v.err = nil + } + v.needsReset = true -type varScope struct { - name string - nature Nature + if config == nil { + config = conf.New(nil) + } + v.config = config } -type info struct { - method bool - fn *builtin.Function - - // elem is element type of array or map. - // Arrays created with type []any, but - // we would like to detect expressions - // like `42 in ["a"]` as invalid. - elem reflect.Type +func clearSlice[S ~[]E, E any](s S) { + var zero E + for i := range s { + s[i] = zero + } } -func (v *checker) visit(node ast.Node) Nature { +func (v *Checker) visit(node ast.Node) Nature { var nt Nature switch n := node.(type) { case *ast.NilNode: - nt = v.NilNode(n) + nt = v.config.NtCache.NatureOf(nil) case *ast.IdentifierNode: - nt = v.IdentifierNode(n) + nt = v.identifierNode(n) case *ast.IntegerNode: - nt = v.IntegerNode(n) + nt = v.config.NtCache.FromType(intType) case *ast.FloatNode: - nt = v.FloatNode(n) + nt = v.config.NtCache.FromType(floatType) case *ast.BoolNode: - nt = v.BoolNode(n) + nt = v.config.NtCache.FromType(boolType) case *ast.StringNode: - nt = v.StringNode(n) + nt = v.config.NtCache.FromType(stringType) case *ast.ConstantNode: - nt = v.ConstantNode(n) + nt = v.config.NtCache.FromType(reflect.TypeOf(n.Value)) case *ast.UnaryNode: - nt = v.UnaryNode(n) + nt = v.unaryNode(n) case *ast.BinaryNode: - nt = v.BinaryNode(n) + nt = v.binaryNode(n) case *ast.ChainNode: - nt = v.ChainNode(n) + nt = v.chainNode(n) case *ast.MemberNode: - nt = v.MemberNode(n) + nt = v.memberNode(n) case *ast.SliceNode: - nt = v.SliceNode(n) + nt = v.sliceNode(n) case *ast.CallNode: - nt = v.CallNode(n) + nt = v.callNode(n) case *ast.BuiltinNode: - nt = v.BuiltinNode(n) + nt = v.builtinNode(n) case *ast.PredicateNode: - nt = v.PredicateNode(n) + nt = v.predicateNode(n) case *ast.PointerNode: - nt = v.PointerNode(n) + nt = v.pointerNode(n) case *ast.VariableDeclaratorNode: - nt = v.VariableDeclaratorNode(n) + nt = v.variableDeclaratorNode(n) case *ast.SequenceNode: - nt = v.SequenceNode(n) + nt = v.sequenceNode(n) case *ast.ConditionalNode: - nt = v.ConditionalNode(n) + nt = v.conditionalNode(n) case *ast.ArrayNode: - nt = v.ArrayNode(n) + nt = v.arrayNode(n) case *ast.MapNode: - nt = v.MapNode(n) + nt = v.mapNode(n) case *ast.PairNode: - nt = v.PairNode(n) + nt = v.pairNode(n) default: panic(fmt.Sprintf("undefined node type (%T)", node)) } @@ -195,236 +233,226 @@ func (v *checker) visit(node ast.Node) Nature { return nt } -func (v *checker) error(node ast.Node, format string, args ...any) Nature { +func (v *Checker) error(node ast.Node, format string, args ...any) Nature { if v.err == nil { // show first error v.err = &file.Error{ Location: node.Location(), Message: fmt.Sprintf(format, args...), } } - return unknown + return Nature{} } -func (v *checker) NilNode(*ast.NilNode) Nature { - return nilNature -} - -func (v *checker) IdentifierNode(node *ast.IdentifierNode) Nature { - if variable, ok := v.lookupVariable(node.Value); ok { - return variable.nature +func (v *Checker) identifierNode(node *ast.IdentifierNode) Nature { + for i := len(v.varScopes) - 1; i >= 0; i-- { + if v.varScopes[i].name == node.Value { + return v.varScopes[i].nature + } } if node.Value == "$env" { - return unknown + return Nature{} } return v.ident(node, node.Value, v.config.Strict, true) } // ident method returns type of environment variable, builtin or function. -func (v *checker) ident(node ast.Node, name string, strict, builtins bool) Nature { - if nt, ok := v.config.Env.Get(name); ok { +func (v *Checker) ident(node ast.Node, name string, strict, builtins bool) Nature { + if nt, ok := v.config.Env.Get(&v.config.NtCache, name); ok { return nt } if builtins { if fn, ok := v.config.Functions[name]; ok { - return Nature{Type: fn.Type(), Func: fn} + nt := v.config.NtCache.FromType(fn.Type()) + if nt.TypeData == nil { + nt.TypeData = new(TypeData) + } + nt.TypeData.Func = fn + return nt } if fn, ok := v.config.Builtins[name]; ok { - return Nature{Type: fn.Type(), Func: fn} + nt := v.config.NtCache.FromType(fn.Type()) + if nt.TypeData == nil { + nt.TypeData = new(TypeData) + } + nt.TypeData.Func = fn + return nt } } if v.config.Strict && strict { - return v.error(node, "unknown name %v", name) + return v.error(node, "unknown name %s", name) } - return unknown + return Nature{} } -func (v *checker) IntegerNode(*ast.IntegerNode) Nature { - return integerNature -} - -func (v *checker) FloatNode(*ast.FloatNode) Nature { - return floatNature -} - -func (v *checker) BoolNode(*ast.BoolNode) Nature { - return boolNature -} - -func (v *checker) StringNode(*ast.StringNode) Nature { - return stringNature -} - -func (v *checker) ConstantNode(node *ast.ConstantNode) Nature { - return Nature{Type: reflect.TypeOf(node.Value)} -} - -func (v *checker) UnaryNode(node *ast.UnaryNode) Nature { +func (v *Checker) unaryNode(node *ast.UnaryNode) Nature { nt := v.visit(node.Node) - nt = nt.Deref() + nt = nt.Deref(&v.config.NtCache) switch node.Operator { case "!", "not": - if isBool(nt) { - return boolNature + if nt.IsBool() { + return v.config.NtCache.FromType(boolType) } - if isUnknown(nt) { - return boolNature + if nt.IsUnknown(&v.config.NtCache) { + return v.config.NtCache.FromType(boolType) } case "+", "-": - if isNumber(nt) { + if nt.IsNumber() { return nt } - if isUnknown(nt) { - return unknown + if nt.IsUnknown(&v.config.NtCache) { + return Nature{} } default: - return v.error(node, "unknown operator (%v)", node.Operator) + return v.error(node, "unknown operator (%s)", node.Operator) } - return v.error(node, `invalid operation: %v (mismatched type %s)`, node.Operator, nt) + return v.error(node, `invalid operation: %s (mismatched type %s)`, node.Operator, nt.String()) } -func (v *checker) BinaryNode(node *ast.BinaryNode) Nature { +func (v *Checker) binaryNode(node *ast.BinaryNode) Nature { l := v.visit(node.Left) r := v.visit(node.Right) - l = l.Deref() - r = r.Deref() + l = l.Deref(&v.config.NtCache) + r = r.Deref(&v.config.NtCache) switch node.Operator { case "==", "!=": - if isComparable(l, r) { - return boolNature + if l.ComparableTo(&v.config.NtCache, r) { + return v.config.NtCache.FromType(boolType) } case "or", "||", "and", "&&": - if isBool(l) && isBool(r) { - return boolNature + if l.IsBool() && r.IsBool() { + return v.config.NtCache.FromType(boolType) } - if or(l, r, isBool) { - return boolNature + if l.MaybeCompatible(&v.config.NtCache, r, BoolCheck) { + return v.config.NtCache.FromType(boolType) } case "<", ">", ">=", "<=": - if isNumber(l) && isNumber(r) { - return boolNature + if l.IsNumber() && r.IsNumber() { + return v.config.NtCache.FromType(boolType) } - if isString(l) && isString(r) { - return boolNature + if l.IsString() && r.IsString() { + return v.config.NtCache.FromType(boolType) } - if isTime(l) && isTime(r) { - return boolNature + if l.IsTime() && r.IsTime() { + return v.config.NtCache.FromType(boolType) } - if isDuration(l) && isDuration(r) { - return boolNature + if l.IsDuration() && r.IsDuration() { + return v.config.NtCache.FromType(boolType) } - if or(l, r, isNumber, isString, isTime, isDuration) { - return boolNature + if l.MaybeCompatible(&v.config.NtCache, r, NumberCheck, StringCheck, TimeCheck, DurationCheck) { + return v.config.NtCache.FromType(boolType) } case "-": - if isNumber(l) && isNumber(r) { - return combined(l, r) + if l.IsNumber() && r.IsNumber() { + return l.PromoteNumericNature(&v.config.NtCache, r) } - if isTime(l) && isTime(r) { - return durationNature + if l.IsTime() && r.IsTime() { + return v.config.NtCache.FromType(durationType) } - if isTime(l) && isDuration(r) { - return timeNature + if l.IsTime() && r.IsDuration() { + return v.config.NtCache.FromType(timeType) } - if isDuration(l) && isDuration(r) { - return durationNature + if l.IsDuration() && r.IsDuration() { + return v.config.NtCache.FromType(durationType) } - if or(l, r, isNumber, isTime, isDuration) { - return unknown + if l.MaybeCompatible(&v.config.NtCache, r, NumberCheck, TimeCheck, DurationCheck) { + return Nature{} } case "*": - if isNumber(l) && isNumber(r) { - return combined(l, r) + if l.IsNumber() && r.IsNumber() { + return l.PromoteNumericNature(&v.config.NtCache, r) } - if isNumber(l) && isDuration(r) { - return durationNature + if l.IsNumber() && r.IsDuration() { + return v.config.NtCache.FromType(durationType) } - if isDuration(l) && isNumber(r) { - return durationNature + if l.IsDuration() && r.IsNumber() { + return v.config.NtCache.FromType(durationType) } - if isDuration(l) && isDuration(r) { - return durationNature + if l.IsDuration() && r.IsDuration() { + return v.config.NtCache.FromType(durationType) } - if or(l, r, isNumber, isDuration) { - return unknown + if l.MaybeCompatible(&v.config.NtCache, r, NumberCheck, DurationCheck) { + return Nature{} } case "/": - if isNumber(l) && isNumber(r) { - return floatNature + if l.IsNumber() && r.IsNumber() { + return v.config.NtCache.FromType(floatType) } - if or(l, r, isNumber) { - return floatNature + if l.MaybeCompatible(&v.config.NtCache, r, NumberCheck) { + return v.config.NtCache.FromType(floatType) } case "**", "^": - if isNumber(l) && isNumber(r) { - return floatNature + if l.IsNumber() && r.IsNumber() { + return v.config.NtCache.FromType(floatType) } - if or(l, r, isNumber) { - return floatNature + if l.MaybeCompatible(&v.config.NtCache, r, NumberCheck) { + return v.config.NtCache.FromType(floatType) } case "%": - if isInteger(l) && isInteger(r) { - return integerNature + if l.IsInteger && r.IsInteger { + return v.config.NtCache.FromType(intType) } - if or(l, r, isInteger) { - return integerNature + if l.MaybeCompatible(&v.config.NtCache, r, IntegerCheck) { + return v.config.NtCache.FromType(intType) } case "+": - if isNumber(l) && isNumber(r) { - return combined(l, r) + if l.IsNumber() && r.IsNumber() { + return l.PromoteNumericNature(&v.config.NtCache, r) } - if isString(l) && isString(r) { - return stringNature + if l.IsString() && r.IsString() { + return v.config.NtCache.FromType(stringType) } - if isTime(l) && isDuration(r) { - return timeNature + if l.IsTime() && r.IsDuration() { + return v.config.NtCache.FromType(timeType) } - if isDuration(l) && isTime(r) { - return timeNature + if l.IsDuration() && r.IsTime() { + return v.config.NtCache.FromType(timeType) } - if isDuration(l) && isDuration(r) { - return durationNature + if l.IsDuration() && r.IsDuration() { + return v.config.NtCache.FromType(durationType) } - if or(l, r, isNumber, isString, isTime, isDuration) { - return unknown + if l.MaybeCompatible(&v.config.NtCache, r, NumberCheck, StringCheck, TimeCheck, DurationCheck) { + return Nature{} } case "in": - if (isString(l) || isUnknown(l)) && isStruct(r) { - return boolNature + if (l.IsString() || l.IsUnknown(&v.config.NtCache)) && r.IsStruct() { + return v.config.NtCache.FromType(boolType) } - if isMap(r) { - if !isUnknown(l) && !l.AssignableTo(r.Key()) { - return v.error(node, "cannot use %v as type %v in map key", l, r.Key()) + if r.IsMap() { + rKey := r.Key(&v.config.NtCache) + if !l.IsUnknown(&v.config.NtCache) && !l.AssignableTo(rKey) { + return v.error(node, "cannot use %s as type %s in map key", l.String(), rKey.String()) } - return boolNature + return v.config.NtCache.FromType(boolType) } - if isArray(r) { - if !isComparable(l, r.Elem()) { - return v.error(node, "cannot use %v as type %v in array", l, r.Elem()) + if r.IsArray() { + rElem := r.Elem(&v.config.NtCache) + if !l.ComparableTo(&v.config.NtCache, rElem) { + return v.error(node, "cannot use %s as type %s in array", l.String(), rElem.String()) } - return boolNature + return v.config.NtCache.FromType(boolType) } - if isUnknown(l) && anyOf(r, isString, isArray, isMap) { - return boolNature + if l.IsUnknown(&v.config.NtCache) && r.IsAnyOf(StringCheck, ArrayCheck, MapCheck) { + return v.config.NtCache.FromType(boolType) } - if isUnknown(r) { - return boolNature + if r.IsUnknown(&v.config.NtCache) { + return v.config.NtCache.FromType(boolType) } case "matches": @@ -434,57 +462,54 @@ func (v *checker) BinaryNode(node *ast.BinaryNode) Nature { return v.error(node, err.Error()) } } - if isString(l) && isString(r) { - return boolNature + if l.IsString() && r.IsString() { + return v.config.NtCache.FromType(boolType) } - if or(l, r, isString) { - return boolNature + if l.MaybeCompatible(&v.config.NtCache, r, StringCheck) { + return v.config.NtCache.FromType(boolType) } case "contains", "startsWith", "endsWith": - if isString(l) && isString(r) { - return boolNature + if l.IsString() && r.IsString() { + return v.config.NtCache.FromType(boolType) } - if or(l, r, isString) { - return boolNature + if l.MaybeCompatible(&v.config.NtCache, r, StringCheck) { + return v.config.NtCache.FromType(boolType) } case "..": - if isInteger(l) && isInteger(r) { - return arrayOf(integerNature) - } - if or(l, r, isInteger) { - return arrayOf(integerNature) + if l.IsInteger && r.IsInteger || l.MaybeCompatible(&v.config.NtCache, r, IntegerCheck) { + return ArrayFromType(&v.config.NtCache, intType) } case "??": - if isNil(l) && !isNil(r) { + if l.Nil && !r.Nil { return r } - if !isNil(l) && isNil(r) { + if !l.Nil && r.Nil { return l } - if isNil(l) && isNil(r) { - return nilNature + if l.Nil && r.Nil { + return v.config.NtCache.NatureOf(nil) } if r.AssignableTo(l) { return l } - return unknown + return Nature{} default: - return v.error(node, "unknown operator (%v)", node.Operator) + return v.error(node, "unknown operator (%s)", node.Operator) } - return v.error(node, `invalid operation: %v (mismatched types %v and %v)`, node.Operator, l, r) + return v.error(node, `invalid operation: %s (mismatched types %s and %s)`, node.Operator, l.String(), r.String()) } -func (v *checker) ChainNode(node *ast.ChainNode) Nature { +func (v *Checker) chainNode(node *ast.ChainNode) Nature { return v.visit(node.Node) } -func (v *checker) MemberNode(node *ast.MemberNode) Nature { +func (v *Checker) memberNode(node *ast.MemberNode) Nature { // $env variable if an, ok := node.Node.(*ast.IdentifierNode); ok && an.Value == "$env" { if name, ok := node.Property.(*ast.StringNode); ok { @@ -498,60 +523,60 @@ func (v *checker) MemberNode(node *ast.MemberNode) Nature { } return v.ident(node, name.Value, strict, false /* no builtins and no functions */) } - return unknown + return Nature{} } base := v.visit(node.Node) prop := v.visit(node.Property) - if isUnknown(base) { - return unknown + if base.IsUnknown(&v.config.NtCache) { + return Nature{} } if name, ok := node.Property.(*ast.StringNode); ok { - if isNil(base) { - return v.error(node, "type nil has no field %v", name.Value) + if base.Nil { + return v.error(node, "type nil has no field %s", name.Value) } // First, check methods defined on base type itself, // independent of which type it is. Without dereferencing. - if m, ok := base.MethodByName(name.Value); ok { + if m, ok := base.MethodByName(&v.config.NtCache, name.Value); ok { return m } } - base = base.Deref() + base = base.Deref(&v.config.NtCache) - switch base.Kind() { + switch base.Kind { case reflect.Map: - if !prop.AssignableTo(base.Key()) && !isUnknown(prop) { - return v.error(node.Property, "cannot use %v to get an element from %v", prop, base) + if !prop.AssignableTo(base.Key(&v.config.NtCache)) && !prop.IsUnknown(&v.config.NtCache) { + return v.error(node.Property, "cannot use %s to get an element from %s", prop.String(), base.String()) } - if prop, ok := node.Property.(*ast.StringNode); ok { + if prop, ok := node.Property.(*ast.StringNode); ok && base.TypeData != nil { if field, ok := base.Fields[prop.Value]; ok { return field } else if base.Strict { - return v.error(node.Property, "unknown field %v", prop.Value) + return v.error(node.Property, "unknown field %s", prop.Value) } } - return base.Elem() + return base.Elem(&v.config.NtCache) case reflect.Array, reflect.Slice: - if !isInteger(prop) && !isUnknown(prop) { - return v.error(node.Property, "array elements can only be selected using an integer (got %v)", prop) + if !prop.IsInteger && !prop.IsUnknown(&v.config.NtCache) { + return v.error(node.Property, "array elements can only be selected using an integer (got %s)", prop.String()) } - return base.Elem() + return base.Elem(&v.config.NtCache) case reflect.Struct: if name, ok := node.Property.(*ast.StringNode); ok { propertyName := name.Value - if field, ok := base.FieldByName(propertyName); ok { - return Nature{Type: field.Type} + if field, ok := base.FieldByName(&v.config.NtCache, propertyName); ok { + return v.config.NtCache.FromType(field.Type) } if node.Method { - return v.error(node, "type %v has no method %v", base, propertyName) + return v.error(node, "type %v has no method %v", base.String(), propertyName) } - return v.error(node, "type %v has no field %v", base, propertyName) + return v.error(node, "type %v has no field %v", base.String(), propertyName) } } @@ -559,47 +584,45 @@ func (v *checker) MemberNode(node *ast.MemberNode) Nature { if name, ok := node.Property.(*ast.StringNode); ok { if node.Method { - return v.error(node, "type %v has no method %v", base, name.Value) + return v.error(node, "type %v has no method %v", base.String(), name.Value) } - return v.error(node, "type %v has no field %v", base, name.Value) + return v.error(node, "type %v has no field %v", base.String(), name.Value) } - return v.error(node, "type %v[%v] is undefined", base, prop) + return v.error(node, "type %v[%v] is undefined", base.String(), prop.String()) } -func (v *checker) SliceNode(node *ast.SliceNode) Nature { +func (v *Checker) sliceNode(node *ast.SliceNode) Nature { nt := v.visit(node.Node) - if isUnknown(nt) { - return unknown + if nt.IsUnknown(&v.config.NtCache) { + return Nature{} } - switch nt.Kind() { + switch nt.Kind { case reflect.String, reflect.Array, reflect.Slice: // ok default: - return v.error(node, "cannot slice %s", nt) + return v.error(node, "cannot slice %s", nt.String()) } if node.From != nil { from := v.visit(node.From) - if !isInteger(from) && !isUnknown(from) { - return v.error(node.From, "non-integer slice index %v", from) + if !from.IsInteger && !from.IsUnknown(&v.config.NtCache) { + return v.error(node.From, "non-integer slice index %v", from.String()) } } if node.To != nil { to := v.visit(node.To) - if !isInteger(to) && !isUnknown(to) { - return v.error(node.To, "non-integer slice index %v", to) + if !to.IsInteger && !to.IsUnknown(&v.config.NtCache) { + return v.error(node.To, "non-integer slice index %v", to.String()) } } return nt } -func (v *checker) CallNode(node *ast.CallNode) Nature { - nt := v.functionReturnType(node) - +func (v *Checker) callNode(node *ast.CallNode) Nature { // Check if type was set on node (for example, by patcher) // and use node type instead of function return type. // @@ -611,18 +634,18 @@ func (v *checker) CallNode(node *ast.CallNode) Nature { // fix `errCall()` to return proper type, so on second // checker pass we should replace anyType on method node // with new correct function return type. - if node.Type() != nil && node.Type() != anyType { - return node.Nature() + if typ := node.Type(); typ != nil && typ != anyType { + nt := node.Nature() + return nt } - return nt -} - -func (v *checker) functionReturnType(node *ast.CallNode) Nature { nt := v.visit(node.Callee) + if nt.IsUnknown(&v.config.NtCache) { + return Nature{} + } - if nt.Func != nil { - return v.checkFunction(nt.Func, node, node.Arguments) + if nt.TypeData != nil && nt.TypeData.Func != nil { + return v.checkFunction(nt.TypeData.Func, node, node.Arguments) } fnName := "function" @@ -635,122 +658,126 @@ func (v *checker) functionReturnType(node *ast.CallNode) Nature { } } - if isUnknown(nt) { - return unknown - } - - if isNil(nt) { + if nt.Nil { return v.error(node, "%v is nil; cannot call nil as function", fnName) } - switch nt.Kind() { - case reflect.Func: + if nt.Kind == reflect.Func { outType, err := v.checkArguments(fnName, nt, node.Arguments, node) if err != nil { if v.err == nil { v.err = err } - return unknown + return Nature{} } return outType } - return v.error(node, "%s is not callable", nt) + return v.error(node, "%s is not callable", nt.String()) } -func (v *checker) BuiltinNode(node *ast.BuiltinNode) Nature { +func (v *Checker) builtinNode(node *ast.BuiltinNode) Nature { switch node.Name { case "all", "none", "any", "one": - collection := v.visit(node.Arguments[0]).Deref() - if !isArray(collection) && !isUnknown(collection) { - return v.error(node.Arguments[0], "builtin %v takes only array (got %v)", node.Name, collection) + collection := v.visit(node.Arguments[0]) + collection = collection.Deref(&v.config.NtCache) + if !collection.IsArray() && !collection.IsUnknown(&v.config.NtCache) { + return v.error(node.Arguments[0], "builtin %v takes only array (got %v)", node.Name, collection.String()) } v.begin(collection) predicate := v.visit(node.Arguments[1]) v.end() - if isFunc(predicate) && + if predicate.IsFunc() && predicate.NumOut() == 1 && - predicate.NumIn() == 1 && isUnknown(predicate.In(0)) { + predicate.NumIn() == 1 && predicate.IsFirstArgUnknown(&v.config.NtCache) { - if !isBool(predicate.Out(0)) && !isUnknown(predicate.Out(0)) { - return v.error(node.Arguments[1], "predicate should return boolean (got %v)", predicate.Out(0).String()) + predicateOut := predicate.Out(&v.config.NtCache, 0) + if !predicateOut.IsBool() && !predicateOut.IsUnknown(&v.config.NtCache) { + return v.error(node.Arguments[1], "predicate should return boolean (got %s)", predicateOut.String()) } - return boolNature + return v.config.NtCache.FromType(boolType) } return v.error(node.Arguments[1], "predicate should has one input and one output param") case "filter": - collection := v.visit(node.Arguments[0]).Deref() - if !isArray(collection) && !isUnknown(collection) { - return v.error(node.Arguments[0], "builtin %v takes only array (got %v)", node.Name, collection) + collection := v.visit(node.Arguments[0]) + collection = collection.Deref(&v.config.NtCache) + if !collection.IsArray() && !collection.IsUnknown(&v.config.NtCache) { + return v.error(node.Arguments[0], "builtin %v takes only array (got %v)", node.Name, collection.String()) } v.begin(collection) predicate := v.visit(node.Arguments[1]) v.end() - if isFunc(predicate) && + if predicate.IsFunc() && predicate.NumOut() == 1 && - predicate.NumIn() == 1 && isUnknown(predicate.In(0)) { + predicate.NumIn() == 1 && predicate.IsFirstArgUnknown(&v.config.NtCache) { - if !isBool(predicate.Out(0)) && !isUnknown(predicate.Out(0)) { - return v.error(node.Arguments[1], "predicate should return boolean (got %v)", predicate.Out(0).String()) + predicateOut := predicate.Out(&v.config.NtCache, 0) + if !predicateOut.IsBool() && !predicateOut.IsUnknown(&v.config.NtCache) { + return v.error(node.Arguments[1], "predicate should return boolean (got %s)", predicateOut.String()) } - if isUnknown(collection) { - return arrayNature + if collection.IsUnknown(&v.config.NtCache) { + return v.config.NtCache.FromType(arrayType) } - return arrayOf(collection.Elem()) + collection = collection.Elem(&v.config.NtCache) + return collection.MakeArrayOf(&v.config.NtCache) } return v.error(node.Arguments[1], "predicate should has one input and one output param") case "map": - collection := v.visit(node.Arguments[0]).Deref() - if !isArray(collection) && !isUnknown(collection) { - return v.error(node.Arguments[0], "builtin %v takes only array (got %v)", node.Name, collection) + collection := v.visit(node.Arguments[0]) + collection = collection.Deref(&v.config.NtCache) + if !collection.IsArray() && !collection.IsUnknown(&v.config.NtCache) { + return v.error(node.Arguments[0], "builtin %v takes only array (got %v)", node.Name, collection.String()) } - v.begin(collection, scopeVar{"index", integerNature}) + v.begin(collection, varScope{"index", v.config.NtCache.FromType(intType)}) predicate := v.visit(node.Arguments[1]) v.end() - if isFunc(predicate) && + if predicate.IsFunc() && predicate.NumOut() == 1 && - predicate.NumIn() == 1 && isUnknown(predicate.In(0)) { + predicate.NumIn() == 1 && predicate.IsFirstArgUnknown(&v.config.NtCache) { - return arrayOf(*predicate.PredicateOut) + return predicate.Ref.MakeArrayOf(&v.config.NtCache) } return v.error(node.Arguments[1], "predicate should has one input and one output param") case "count": - collection := v.visit(node.Arguments[0]).Deref() - if !isArray(collection) && !isUnknown(collection) { - return v.error(node.Arguments[0], "builtin %v takes only array (got %v)", node.Name, collection) + collection := v.visit(node.Arguments[0]) + collection = collection.Deref(&v.config.NtCache) + if !collection.IsArray() && !collection.IsUnknown(&v.config.NtCache) { + return v.error(node.Arguments[0], "builtin %v takes only array (got %v)", node.Name, collection.String()) } if len(node.Arguments) == 1 { - return integerNature + return v.config.NtCache.FromType(intType) } v.begin(collection) predicate := v.visit(node.Arguments[1]) v.end() - if isFunc(predicate) && + if predicate.IsFunc() && predicate.NumOut() == 1 && - predicate.NumIn() == 1 && isUnknown(predicate.In(0)) { - if !isBool(predicate.Out(0)) && !isUnknown(predicate.Out(0)) { - return v.error(node.Arguments[1], "predicate should return boolean (got %v)", predicate.Out(0).String()) + predicate.NumIn() == 1 && predicate.IsFirstArgUnknown(&v.config.NtCache) { + predicateOut := predicate.Out(&v.config.NtCache, 0) + if !predicateOut.IsBool() && !predicateOut.IsUnknown(&v.config.NtCache) { + return v.error(node.Arguments[1], "predicate should return boolean (got %s)", predicateOut.String()) } - return integerNature + return v.config.NtCache.FromType(intType) } return v.error(node.Arguments[1], "predicate should has one input and one output param") case "sum": - collection := v.visit(node.Arguments[0]).Deref() - if !isArray(collection) && !isUnknown(collection) { - return v.error(node.Arguments[0], "builtin %v takes only array (got %v)", node.Name, collection) + collection := v.visit(node.Arguments[0]) + collection = collection.Deref(&v.config.NtCache) + if !collection.IsArray() && !collection.IsUnknown(&v.config.NtCache) { + return v.error(node.Arguments[0], "builtin %v takes only array (got %v)", node.Name, collection.String()) } if len(node.Arguments) == 2 { @@ -758,86 +785,95 @@ func (v *checker) BuiltinNode(node *ast.BuiltinNode) Nature { predicate := v.visit(node.Arguments[1]) v.end() - if isFunc(predicate) && + if predicate.IsFunc() && predicate.NumOut() == 1 && - predicate.NumIn() == 1 && isUnknown(predicate.In(0)) { - return predicate.Out(0) + predicate.NumIn() == 1 && predicate.IsFirstArgUnknown(&v.config.NtCache) { + return predicate.Out(&v.config.NtCache, 0) } } else { - if isUnknown(collection) { - return unknown + if collection.IsUnknown(&v.config.NtCache) { + return Nature{} } - return collection.Elem() + return collection.Elem(&v.config.NtCache) } case "find", "findLast": - collection := v.visit(node.Arguments[0]).Deref() - if !isArray(collection) && !isUnknown(collection) { - return v.error(node.Arguments[0], "builtin %v takes only array (got %v)", node.Name, collection) + collection := v.visit(node.Arguments[0]) + collection = collection.Deref(&v.config.NtCache) + if !collection.IsArray() && !collection.IsUnknown(&v.config.NtCache) { + return v.error(node.Arguments[0], "builtin %v takes only array (got %v)", node.Name, collection.String()) } v.begin(collection) predicate := v.visit(node.Arguments[1]) v.end() - if isFunc(predicate) && + if predicate.IsFunc() && predicate.NumOut() == 1 && - predicate.NumIn() == 1 && isUnknown(predicate.In(0)) { + predicate.NumIn() == 1 && predicate.IsFirstArgUnknown(&v.config.NtCache) { - if !isBool(predicate.Out(0)) && !isUnknown(predicate.Out(0)) { - return v.error(node.Arguments[1], "predicate should return boolean (got %v)", predicate.Out(0).String()) + predicateOut := predicate.Out(&v.config.NtCache, 0) + if !predicateOut.IsBool() && !predicateOut.IsUnknown(&v.config.NtCache) { + return v.error(node.Arguments[1], "predicate should return boolean (got %s)", predicateOut.String()) } - if isUnknown(collection) { - return unknown + if collection.IsUnknown(&v.config.NtCache) { + return Nature{} } - return collection.Elem() + return collection.Elem(&v.config.NtCache) } return v.error(node.Arguments[1], "predicate should has one input and one output param") case "findIndex", "findLastIndex": - collection := v.visit(node.Arguments[0]).Deref() - if !isArray(collection) && !isUnknown(collection) { - return v.error(node.Arguments[0], "builtin %v takes only array (got %v)", node.Name, collection) + collection := v.visit(node.Arguments[0]) + collection = collection.Deref(&v.config.NtCache) + if !collection.IsArray() && !collection.IsUnknown(&v.config.NtCache) { + return v.error(node.Arguments[0], "builtin %v takes only array (got %v)", node.Name, collection.String()) } v.begin(collection) predicate := v.visit(node.Arguments[1]) v.end() - if isFunc(predicate) && + if predicate.IsFunc() && predicate.NumOut() == 1 && - predicate.NumIn() == 1 && isUnknown(predicate.In(0)) { + predicate.NumIn() == 1 && predicate.IsFirstArgUnknown(&v.config.NtCache) { - if !isBool(predicate.Out(0)) && !isUnknown(predicate.Out(0)) { - return v.error(node.Arguments[1], "predicate should return boolean (got %v)", predicate.Out(0).String()) + predicateOut := predicate.Out(&v.config.NtCache, 0) + if !predicateOut.IsBool() && !predicateOut.IsUnknown(&v.config.NtCache) { + return v.error(node.Arguments[1], "predicate should return boolean (got %s)", predicateOut.String()) } - return integerNature + return v.config.NtCache.FromType(intType) } return v.error(node.Arguments[1], "predicate should has one input and one output param") case "groupBy": - collection := v.visit(node.Arguments[0]).Deref() - if !isArray(collection) && !isUnknown(collection) { - return v.error(node.Arguments[0], "builtin %v takes only array (got %v)", node.Name, collection) + collection := v.visit(node.Arguments[0]) + collection = collection.Deref(&v.config.NtCache) + if !collection.IsArray() && !collection.IsUnknown(&v.config.NtCache) { + return v.error(node.Arguments[0], "builtin %v takes only array (got %v)", node.Name, collection.String()) } v.begin(collection) predicate := v.visit(node.Arguments[1]) v.end() - if isFunc(predicate) && + if predicate.IsFunc() && predicate.NumOut() == 1 && - predicate.NumIn() == 1 && isUnknown(predicate.In(0)) { + predicate.NumIn() == 1 && predicate.IsFirstArgUnknown(&v.config.NtCache) { - groups := arrayOf(collection.Elem()) - return Nature{Type: reflect.TypeOf(map[any][]any{}), ArrayOf: &groups} + collection = collection.Elem(&v.config.NtCache) + collection = collection.MakeArrayOf(&v.config.NtCache) + nt := v.config.NtCache.NatureOf(map[any][]any{}) + nt.Ref = &collection + return nt } return v.error(node.Arguments[1], "predicate should has one input and one output param") case "sortBy": - collection := v.visit(node.Arguments[0]).Deref() - if !isArray(collection) && !isUnknown(collection) { - return v.error(node.Arguments[0], "builtin %v takes only array (got %v)", node.Name, collection) + collection := v.visit(node.Arguments[0]) + collection = collection.Deref(&v.config.NtCache) + if !collection.IsArray() && !collection.IsUnknown(&v.config.NtCache) { + return v.error(node.Arguments[0], "builtin %v takes only array (got %v)", node.Name, collection.String()) } v.begin(collection) @@ -848,21 +884,22 @@ func (v *checker) BuiltinNode(node *ast.BuiltinNode) Nature { _ = v.visit(node.Arguments[2]) } - if isFunc(predicate) && + if predicate.IsFunc() && predicate.NumOut() == 1 && - predicate.NumIn() == 1 && isUnknown(predicate.In(0)) { + predicate.NumIn() == 1 && predicate.IsFirstArgUnknown(&v.config.NtCache) { return collection } return v.error(node.Arguments[1], "predicate should has one input and one output param") case "reduce": - collection := v.visit(node.Arguments[0]).Deref() - if !isArray(collection) && !isUnknown(collection) { - return v.error(node.Arguments[0], "builtin %v takes only array (got %v)", node.Name, collection) + collection := v.visit(node.Arguments[0]) + collection = collection.Deref(&v.config.NtCache) + if !collection.IsArray() && !collection.IsUnknown(&v.config.NtCache) { + return v.error(node.Arguments[0], "builtin %v takes only array (got %v)", node.Name, collection.String()) } - v.begin(collection, scopeVar{"index", integerNature}, scopeVar{"acc", unknown}) + v.begin(collection, varScope{"index", v.config.NtCache.FromType(intType)}, varScope{"acc", Nature{}}) predicate := v.visit(node.Arguments[1]) v.end() @@ -870,8 +907,8 @@ func (v *checker) BuiltinNode(node *ast.BuiltinNode) Nature { _ = v.visit(node.Arguments[2]) } - if isFunc(predicate) && predicate.NumOut() == 1 { - return *predicate.PredicateOut + if predicate.IsFunc() && predicate.NumOut() == 1 { + return *predicate.Ref } return v.error(node.Arguments[1], "predicate should has two input and one output param") @@ -888,24 +925,18 @@ func (v *checker) BuiltinNode(node *ast.BuiltinNode) Nature { return v.error(node, "unknown builtin %v", node.Name) } -type scopeVar struct { - varName string - varNature Nature -} - -func (v *checker) begin(collectionNature Nature, vars ...scopeVar) { - scope := predicateScope{collection: collectionNature, vars: make(map[string]Nature)} - for _, v := range vars { - scope.vars[v.varName] = v.varNature - } - v.predicateScopes = append(v.predicateScopes, scope) +func (v *Checker) begin(collectionNature Nature, vars ...varScope) { + v.predicateScopes = append(v.predicateScopes, predicateScope{ + collection: collectionNature, + vars: vars, + }) } -func (v *checker) end() { +func (v *Checker) end() { v.predicateScopes = v.predicateScopes[:len(v.predicateScopes)-1] } -func (v *checker) checkBuiltinGet(node *ast.BuiltinNode) Nature { +func (v *Checker) checkBuiltinGet(node *ast.BuiltinNode) Nature { if len(node.Arguments) != 2 { return v.error(node, "invalid number of arguments (expected 2, got %d)", len(node.Arguments)) } @@ -915,38 +946,38 @@ func (v *checker) checkBuiltinGet(node *ast.BuiltinNode) Nature { if id, ok := node.Arguments[0].(*ast.IdentifierNode); ok && id.Value == "$env" { if s, ok := node.Arguments[1].(*ast.StringNode); ok { - if nt, ok := v.config.Env.Get(s.Value); ok { + if nt, ok := v.config.Env.Get(&v.config.NtCache, s.Value); ok { return nt } } - return unknown + return Nature{} } - if isUnknown(base) { - return unknown + if base.IsUnknown(&v.config.NtCache) { + return Nature{} } - switch base.Kind() { + switch base.Kind { case reflect.Slice, reflect.Array: - if !isInteger(prop) && !isUnknown(prop) { - return v.error(node.Arguments[1], "non-integer slice index %s", prop) + if !prop.IsInteger && !prop.IsUnknown(&v.config.NtCache) { + return v.error(node.Arguments[1], "non-integer slice index %s", prop.String()) } - return base.Elem() + return base.Elem(&v.config.NtCache) case reflect.Map: - if !prop.AssignableTo(base.Key()) && !isUnknown(prop) { - return v.error(node.Arguments[1], "cannot use %s to get an element from %s", prop, base) + if !prop.AssignableTo(base.Key(&v.config.NtCache)) && !prop.IsUnknown(&v.config.NtCache) { + return v.error(node.Arguments[1], "cannot use %s to get an element from %s", prop.String(), base.String()) } - return base.Elem() + return base.Elem(&v.config.NtCache) } - return v.error(node.Arguments[0], "type %v does not support indexing", base) + return v.error(node.Arguments[0], "type %v does not support indexing", base.String()) } -func (v *checker) checkFunction(f *builtin.Function, node ast.Node, arguments []ast.Node) Nature { +func (v *Checker) checkFunction(f *builtin.Function, node ast.Node, arguments []ast.Node) Nature { if f.Validate != nil { args := make([]reflect.Type, len(arguments)) for i, arg := range arguments { argNature := v.visit(arg) - if isUnknown(argNature) { + if argNature.IsUnknown(&v.config.NtCache) { args[i] = anyType } else { args[i] = argNature.Type @@ -956,21 +987,21 @@ func (v *checker) checkFunction(f *builtin.Function, node ast.Node, arguments [] if err != nil { return v.error(node, "%v", err) } - return Nature{Type: t} + return v.config.NtCache.FromType(t) } else if len(f.Types) == 0 { - nt, err := v.checkArguments(f.Name, Nature{Type: f.Type()}, arguments, node) + nt, err := v.checkArguments(f.Name, v.config.NtCache.FromType(f.Type()), arguments, node) if err != nil { if v.err == nil { v.err = err } - return unknown + return Nature{} } // No type was specified, so we assume the function returns any. return nt } var lastErr *file.Error for _, t := range f.Types { - outNature, err := v.checkArguments(f.Name, Nature{Type: t}, arguments, node) + outNature, err := v.checkArguments(f.Name, v.config.NtCache.FromType(t), arguments, node) if err != nil { lastErr = err continue @@ -989,30 +1020,31 @@ func (v *checker) checkFunction(f *builtin.Function, node ast.Node, arguments [] if v.err == nil { v.err = lastErr } - return unknown + return Nature{} } return v.error(node, "no matching overload for %v", f.Name) } -func (v *checker) checkArguments( +func (v *Checker) checkArguments( name string, fn Nature, arguments []ast.Node, node ast.Node, ) (Nature, *file.Error) { - if isUnknown(fn) { - return unknown, nil + if fn.IsUnknown(&v.config.NtCache) { + return Nature{}, nil } - if fn.NumOut() == 0 { - return unknown, &file.Error{ + numOut := fn.NumOut() + if numOut == 0 { + return Nature{}, &file.Error{ Location: node.Location(), Message: fmt.Sprintf("func %v doesn't return value", name), } } - if numOut := fn.NumOut(); numOut > 2 { - return unknown, &file.Error{ + if numOut > 2 { + return Nature{}, &file.Error{ Location: node.Location(), Message: fmt.Sprintf("func %v returns more then two values", name), } @@ -1031,7 +1063,8 @@ func (v *checker) checkArguments( } var err *file.Error - if fn.IsVariadic() { + isVariadic := fn.IsVariadic() + if isVariadic { if len(arguments) < fnNumIn-1 { err = &file.Error{ Location: node.Location(), @@ -1059,38 +1092,38 @@ func (v *checker) checkArguments( for _, arg := range arguments { _ = v.visit(arg) } - return fn.Out(0), err + return fn.Out(&v.config.NtCache, 0), err } for i, arg := range arguments { argNature := v.visit(arg) var in Nature - if fn.IsVariadic() && i >= fnNumIn-1 { + if isVariadic && i >= fnNumIn-1 { // For variadic arguments fn(xs ...int), go replaces type of xs (int) with ([]int). // As we compare arguments one by one, we need underling type. - in = fn.In(fn.NumIn() - 1).Elem() + in = fn.InElem(&v.config.NtCache, fnNumIn-1) } else { - in = fn.In(i + fnInOffset) + in = fn.In(&v.config.NtCache, i+fnInOffset) } - if isFloat(in) && isInteger(argNature) { + if in.IsFloat && argNature.IsInteger { traverseAndReplaceIntegerNodesWithFloatNodes(&arguments[i], in) continue } - if isInteger(in) && isInteger(argNature) && argNature.Kind() != in.Kind() { + if in.IsInteger && argNature.IsInteger && argNature.Kind != in.Kind { traverseAndReplaceIntegerNodesWithIntegerNodes(&arguments[i], in) continue } - if isNil(argNature) { - if in.Kind() == reflect.Ptr || in.Kind() == reflect.Interface { + if argNature.Nil { + if in.Kind == reflect.Ptr || in.Kind == reflect.Interface { continue } - return unknown, &file.Error{ + return Nature{}, &file.Error{ Location: arg.Location(), - Message: fmt.Sprintf("cannot use nil as argument (type %s) to call %v", in, name), + Message: fmt.Sprintf("cannot use nil as argument (type %s) to call %v", in.String(), name), } } @@ -1102,17 +1135,20 @@ func (v *checker) checkArguments( // We also need to check if dereference arg type is assignable to the function input type. // For example, func(int) and argument *int. In this case we will add OpDeref to the argument, // so we can call the function with *int argument. - assignable = assignable || argNature.Deref().AssignableTo(in) + if !assignable && argNature.IsPointer() { + nt := argNature.Deref(&v.config.NtCache) + assignable = nt.AssignableTo(in) + } - if !assignable && !isUnknown(argNature) { - return unknown, &file.Error{ + if !assignable && !argNature.IsUnknown(&v.config.NtCache) { + return Nature{}, &file.Error{ Location: arg.Location(), - Message: fmt.Sprintf("cannot use %s as argument (type %s) to call %v ", argNature, in, name), + Message: fmt.Sprintf("cannot use %s as argument (type %s) to call %v ", argNature.String(), in.String(), name), } } } - return fn.Out(0), nil + return fn.Out(&v.config.NtCache, 0), nil } func traverseAndReplaceIntegerNodesWithFloatNodes(node *ast.Node, newNature Nature) { @@ -1152,45 +1188,46 @@ func traverseAndReplaceIntegerNodesWithIntegerNodes(node *ast.Node, newNature Na } } -func (v *checker) PredicateNode(node *ast.PredicateNode) Nature { +func (v *Checker) predicateNode(node *ast.PredicateNode) Nature { nt := v.visit(node.Node) var out []reflect.Type - if isUnknown(nt) { + if nt.IsUnknown(&v.config.NtCache) { out = append(out, anyType) - } else if !isNil(nt) { + } else if !nt.Nil { out = append(out, nt.Type) } - return Nature{ - Type: reflect.FuncOf([]reflect.Type{anyType}, out, false), - PredicateOut: &nt, - } + n := v.config.NtCache.FromType(reflect.FuncOf(anyTypeSlice, out, false)) + n.Ref = &nt + return n } -func (v *checker) PointerNode(node *ast.PointerNode) Nature { +func (v *Checker) pointerNode(node *ast.PointerNode) Nature { if len(v.predicateScopes) == 0 { return v.error(node, "cannot use pointer accessor outside predicate") } scope := v.predicateScopes[len(v.predicateScopes)-1] if node.Name == "" { - if isUnknown(scope.collection) { - return unknown + if scope.collection.IsUnknown(&v.config.NtCache) { + return Nature{} } - switch scope.collection.Kind() { + switch scope.collection.Kind { case reflect.Array, reflect.Slice: - return scope.collection.Elem() + return scope.collection.Elem(&v.config.NtCache) } return v.error(node, "cannot use %v as array", scope) } if scope.vars != nil { - if t, ok := scope.vars[node.Name]; ok { - return t + for i := range scope.vars { + if node.Name == scope.vars[i].name { + return scope.vars[i].nature + } } } return v.error(node, "unknown pointer #%v", node.Name) } -func (v *checker) VariableDeclaratorNode(node *ast.VariableDeclaratorNode) Nature { - if _, ok := v.config.Env.Get(node.Name); ok { +func (v *Checker) variableDeclaratorNode(node *ast.VariableDeclaratorNode) Nature { + if _, ok := v.config.Env.Get(&v.config.NtCache, node.Name); ok { return v.error(node, "cannot redeclare %v", node.Name) } if _, ok := v.config.Functions[node.Name]; ok { @@ -1199,8 +1236,10 @@ func (v *checker) VariableDeclaratorNode(node *ast.VariableDeclaratorNode) Natur if _, ok := v.config.Builtins[node.Name]; ok { return v.error(node, "cannot redeclare builtin %v", node.Name) } - if _, ok := v.lookupVariable(node.Name); ok { - return v.error(node, "cannot redeclare variable %v", node.Name) + for i := len(v.varScopes) - 1; i >= 0; i-- { + if v.varScopes[i].name == node.Name { + return v.error(node, "cannot redeclare variable %v", node.Name) + } } varNature := v.visit(node.Value) v.varScopes = append(v.varScopes, varScope{node.Name, varNature}) @@ -1209,7 +1248,7 @@ func (v *checker) VariableDeclaratorNode(node *ast.VariableDeclaratorNode) Natur return exprNature } -func (v *checker) SequenceNode(node *ast.SequenceNode) Nature { +func (v *Checker) sequenceNode(node *ast.SequenceNode) Nature { if len(node.Nodes) == 0 { return v.error(node, "empty sequence expression") } @@ -1220,66 +1259,57 @@ func (v *checker) SequenceNode(node *ast.SequenceNode) Nature { return last } -func (v *checker) lookupVariable(name string) (varScope, bool) { - for i := len(v.varScopes) - 1; i >= 0; i-- { - if v.varScopes[i].name == name { - return v.varScopes[i], true - } - } - return varScope{}, false -} - -func (v *checker) ConditionalNode(node *ast.ConditionalNode) Nature { +func (v *Checker) conditionalNode(node *ast.ConditionalNode) Nature { c := v.visit(node.Cond) - if !isBool(c) && !isUnknown(c) { - return v.error(node.Cond, "non-bool expression (type %v) used as condition", c) + if !c.IsBool() && !c.IsUnknown(&v.config.NtCache) { + return v.error(node.Cond, "non-bool expression (type %v) used as condition", c.String()) } t1 := v.visit(node.Exp1) t2 := v.visit(node.Exp2) - if isNil(t1) && !isNil(t2) { + if t1.Nil && !t2.Nil { return t2 } - if !isNil(t1) && isNil(t2) { + if !t1.Nil && t2.Nil { return t1 } - if isNil(t1) && isNil(t2) { - return nilNature + if t1.Nil && t2.Nil { + return v.config.NtCache.NatureOf(nil) } if t1.AssignableTo(t2) { return t1 } - return unknown + return Nature{} } -func (v *checker) ArrayNode(node *ast.ArrayNode) Nature { +func (v *Checker) arrayNode(node *ast.ArrayNode) Nature { var prev Nature allElementsAreSameType := true for i, node := range node.Nodes { curr := v.visit(node) if i > 0 { - if curr.Kind() != prev.Kind() { + if curr.Kind != prev.Kind { allElementsAreSameType = false } } prev = curr } if allElementsAreSameType { - return arrayOf(prev) + return prev.MakeArrayOf(&v.config.NtCache) } - return arrayNature + return v.config.NtCache.FromType(arrayType) } -func (v *checker) MapNode(node *ast.MapNode) Nature { +func (v *Checker) mapNode(node *ast.MapNode) Nature { for _, pair := range node.Pairs { v.visit(pair) } - return mapNature + return v.config.NtCache.FromType(mapType) } -func (v *checker) PairNode(node *ast.PairNode) Nature { +func (v *Checker) pairNode(node *ast.PairNode) Nature { v.visit(node.Key) v.visit(node.Value) - return nilNature + return v.config.NtCache.NatureOf(nil) } diff --git a/checker/checker_bench_test.go b/checker/checker_bench_test.go new file mode 100644 index 000000000..0583d7351 --- /dev/null +++ b/checker/checker_bench_test.go @@ -0,0 +1,114 @@ +package checker_test + +import ( + "runtime" + "testing" + + "github.com/expr-lang/expr" + "github.com/expr-lang/expr/ast" + "github.com/expr-lang/expr/checker" + "github.com/expr-lang/expr/checker/nature" + "github.com/expr-lang/expr/conf" + "github.com/expr-lang/expr/parser" +) + +func BenchmarkChecker(b *testing.B) { + cases := []struct { + name, input string + }{ + {"function calls", ` +func( + func( + func(func(a, 'a', 1, nil), func(a, 'a', 1, nil), func(a, 'a', 1, nil)), + func(func(a, 'a', 1, nil), func(a, 'a', 1, nil), func(a, 'a', 1, nil)), + func(func(a, 'a', 1, nil), func(a, 'a', 1, nil), func(a, 'a', 1, nil)), + ), + func( + func(func(a, 'a', 1, nil), func(a, 'a', 1, nil), func(a, 'a', 1, nil)), + func(func(a, 'a', 1, nil), func(a, 'a', 1, nil), func(a, 'a', 1, nil)), + func(func(a, 'a', 1, nil), func(a, 'a', 1, nil), func(a, 'a', 1, nil)), + ), + func( + func(func(a, 'a', 1, nil), func(a, 'a', 1, nil), func(a, 'a', 1, nil)), + func(func(a, 'a', 1, nil), func(a, 'a', 1, nil), func(a, 'a', 1, nil)), + func(func(a, 'a', 1, nil), func(a, 'a', 1, nil), func(a, 'a', 1, nil)), + ) +) + `}, + {"unary and binary operations", ` +!b && !b || !b == !b && !b != !b || 1 < 1.0 && 0.1 > 1 || 0 <= 1.0 && 0.1 >= 1 && +!b && !b || !b == !b && !b != !b || 1 < 1.0 && 0.1 > 1 || 0 <= 1.0 && 0.1 >= 1 && +!b && !b || !b == !b && !b != !b || 1 < 1.0 && 0.1 > 1 || 0 <= 1.0 && 0.1 >= 1 && +!b && !b || !b == !b && !b != !b || 1 < 1.0 && 0.1 > 1 || 0 <= 1.0 && 0.1 >= 1 && +!b && !b || !b == !b && !b != !b || 1 < 1.0 && 0.1 > 1 || 0 <= 1.0 && 0.1 >= 1 && +!b && !b || !b == !b && !b != !b || 1 < 1.0 && 0.1 > 1 || 0 <= 1.0 && 0.1 >= 1 + `}, + {"deep struct access", ` +a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a. +a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a. +a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a. +a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a + `}, + } + + f := func(params ...any) (any, error) { return nil, nil } + env := map[string]any{ + "a": new(recursive), + "b": true, + "func": f, + } + config := conf.New(env) + expr.Function("func", f, f)(config) + expr.ConstExpr("func")(config) + + for _, c := range cases { + batchSize := 100_000 + if batchSize > b.N { + batchSize = b.N + } + trees := make([]*parser.Tree, 0, batchSize) + for i := 0; i < batchSize; i++ { + tree, err := parser.ParseWithConfig(c.input, config) + if err != nil { + b.Fatal(err) + } + trees = append(trees, tree) + } + runtime.GC() // try to cleanup the mess from the initialization + + b.Run("name="+c.name, func(b *testing.B) { + var err error + for i := 0; i < b.N; i++ { + j := i + if j < 0 || j >= len(trees) { + b.StopTimer() + invalidateTrees(trees...) + j = 0 + b.StartTimer() + } + + _, err = checker.Check(trees[j], config) + } + b.StopTimer() + if err != nil { + b.Fatal(err) + } + }) + } +} + +type visitorFunc func(*ast.Node) + +func (f visitorFunc) Visit(node *ast.Node) { f(node) } + +func invalidateTrees(trees ...*parser.Tree) { + for _, tree := range trees { + ast.Walk(&tree.Node, visitorFunc(func(node *ast.Node) { + (*node).SetNature(nature.Nature{}) + })) + } +} + +type recursive struct { + Inner *recursive `expr:"a"` +} diff --git a/checker/checker_test.go b/checker/checker_test.go index 2ec7c7cfc..bf2b812db 100644 --- a/checker/checker_test.go +++ b/checker/checker_test.go @@ -136,6 +136,7 @@ func TestCheck(t *testing.T) { {"(Embed).EmbedPointerEmbedInt > 0"}, } + c := new(checker.Checker) for _, tt := range tests { t.Run(tt.input, func(t *testing.T) { var err error @@ -145,7 +146,7 @@ func TestCheck(t *testing.T) { config := conf.New(mock.Env{}) expr.AsBool()(config) - _, err = checker.Check(tree, config) + _, err = c.Check(tree, config) assert.NoError(t, err) }) } @@ -682,12 +683,13 @@ invalid operation: + (mismatched types int and bool) (1:6) }, } + c := new(checker.Checker) for _, tt := range errorTests { t.Run(tt.code, func(t *testing.T) { tree, err := parser.Parse(tt.code) require.NoError(t, err) - _, err = checker.Check(tree, conf.New(mock.Env{})) + _, err = c.Check(tree, conf.New(mock.Env{})) if err == nil { err = fmt.Errorf("") } @@ -839,6 +841,7 @@ func TestCheck_TypeWeights(t *testing.T) { "Float32": float32(11), "Float64": float64(12), } + c := new(checker.Checker) for a := range types { for b := range types { tree, err := parser.Parse(fmt.Sprintf("%s + %s", a, b)) @@ -846,7 +849,7 @@ func TestCheck_TypeWeights(t *testing.T) { config := conf.New(types) - _, err = checker.Check(tree, config) + _, err = c.Check(tree, config) require.NoError(t, err) } } @@ -926,6 +929,7 @@ func TestCheck_Function_types_are_checked(t *testing.T) { config := conf.CreateNew() add(config) + c := new(checker.Checker) tests := []string{ "add(1)", @@ -938,7 +942,7 @@ func TestCheck_Function_types_are_checked(t *testing.T) { tree, err := parser.Parse(test) require.NoError(t, err) - _, err = checker.Check(tree, config) + _, err = c.Check(tree, config) require.NoError(t, err) require.Equal(t, reflect.Int, tree.Node.Type().Kind()) }) @@ -948,7 +952,7 @@ func TestCheck_Function_types_are_checked(t *testing.T) { tree, err := parser.Parse("add(1, '2')") require.NoError(t, err) - _, err = checker.Check(tree, config) + _, err = c.Check(tree, config) require.Error(t, err) require.Equal(t, "cannot use string as argument (type int) to call add (1:8)\n | add(1, '2')\n | .......^", err.Error()) }) @@ -1046,12 +1050,13 @@ func TestCheck_env_keyword(t *testing.T) { {`$env[name]`, reflect.Interface}, } + c := new(checker.Checker) for _, test := range tests { t.Run(test.input, func(t *testing.T) { tree, err := parser.Parse(test.input) require.NoError(t, err) - rtype, err := checker.Check(tree, conf.New(env)) + rtype, err := c.Check(tree, conf.New(env)) require.NoError(t, err) require.True(t, rtype.Kind() == test.want, fmt.Sprintf("expected %s, got %s", test.want, rtype.Kind())) }) @@ -1067,12 +1072,13 @@ func TestCheck_builtin_without_call(t *testing.T) { {`string.A`, "type func(interface {}) string has no field A (1:8)\n | string.A\n | .......^"}, } + c := new(checker.Checker) for _, test := range tests { t.Run(test.input, func(t *testing.T) { tree, err := parser.Parse(test.input) require.NoError(t, err) - _, err = checker.Check(tree, conf.New(nil)) + _, err = c.Check(tree, conf.New(nil)) require.Error(t, err) require.Equal(t, test.err, err.Error()) }) @@ -1134,13 +1140,14 @@ func TestCheck_types(t *testing.T) { {`arr | filter(.value contains "a") | filter(.value == 0)`, `invalid operation: == (mismatched types string and int)`}, } + c := new(checker.Checker) for _, test := range tests { t.Run(test.code, func(t *testing.T) { tree, err := parser.Parse(test.code) require.NoError(t, err) config := conf.New(env) - _, err = checker.Check(tree, config) + _, err = c.Check(tree, config) if test.err == noerr { require.NoError(t, err) } else { diff --git a/checker/info.go b/checker/info.go index f1cc92ebe..1b0e05100 100644 --- a/checker/info.go +++ b/checker/info.go @@ -8,22 +8,19 @@ import ( "github.com/expr-lang/expr/vm" ) -func FieldIndex(env Nature, node ast.Node) (bool, []int, string) { +func FieldIndex(c *Cache, env Nature, node ast.Node) (bool, []int, string) { switch n := node.(type) { case *ast.IdentifierNode: - if env.Kind() == reflect.Struct { - if field, ok := env.Get(n.Value); ok && len(field.FieldIndex) > 0 { - return true, field.FieldIndex, n.Value - } + if idx, ok := env.FieldIndex(c, n.Value); ok { + return true, idx, n.Value } case *ast.MemberNode: base := n.Node.Nature() - base = base.Deref() - if base.Kind() == reflect.Struct { + base = base.Deref(c) + if base.Kind == reflect.Struct { if prop, ok := n.Property.(*ast.StringNode); ok { - name := prop.Value - if field, ok := base.FieldByName(name); ok { - return true, field.FieldIndex, name + if idx, ok := base.FieldIndex(c, prop.Value); ok { + return true, idx, prop.Value } } } @@ -31,11 +28,11 @@ func FieldIndex(env Nature, node ast.Node) (bool, []int, string) { return false, nil, "" } -func MethodIndex(env Nature, node ast.Node) (bool, int, string) { +func MethodIndex(c *Cache, env Nature, node ast.Node) (bool, int, string) { switch n := node.(type) { case *ast.IdentifierNode: - if env.Kind() == reflect.Struct { - if m, ok := env.Get(n.Value); ok { + if env.Kind == reflect.Struct { + if m, ok := env.Get(c, n.Value); ok && m.TypeData != nil { return m.Method, m.MethodIndex, n.Value } } @@ -121,7 +118,7 @@ func IsFastFunc(fn reflect.Type, method bool) bool { fn.NumOut() == 1 && fn.Out(0).Kind() == reflect.Interface { rest := fn.In(fn.NumIn() - 1) // function has only one param for functions and two for methods - if kind(rest) == reflect.Slice && rest.Elem().Kind() == reflect.Interface { + if rest != nil && rest.Kind() == reflect.Slice && rest.Elem().Kind() == reflect.Interface { return true } } diff --git a/checker/nature/nature.go b/checker/nature/nature.go index 993c9fcf8..483030aa1 100644 --- a/checker/nature/nature.go +++ b/checker/nature/nature.go @@ -1,247 +1,450 @@ package nature import ( + "fmt" "reflect" + "time" "github.com/expr-lang/expr/builtin" "github.com/expr-lang/expr/internal/deref" ) var ( - unknown = Nature{} + intType = reflect.TypeOf(0) + floatType = reflect.TypeOf(float64(0)) + arrayType = reflect.TypeOf([]any{}) + timeType = reflect.TypeOf(time.Time{}) + durationType = reflect.TypeOf(time.Duration(0)) + + builtinInt = map[reflect.Type]struct{}{ + reflect.TypeOf(int(0)): {}, + reflect.TypeOf(int8(0)): {}, + reflect.TypeOf(int16(0)): {}, + reflect.TypeOf(int32(0)): {}, + reflect.TypeOf(int64(0)): {}, + reflect.TypeOf(uintptr(0)): {}, + reflect.TypeOf(uint(0)): {}, + reflect.TypeOf(uint8(0)): {}, + reflect.TypeOf(uint16(0)): {}, + reflect.TypeOf(uint32(0)): {}, + reflect.TypeOf(uint64(0)): {}, + } + builtinFloat = map[reflect.Type]struct{}{ + reflect.TypeOf(float32(0)): {}, + reflect.TypeOf(float64(0)): {}, + } +) + +type NatureCheck int + +const ( + _ NatureCheck = iota + BoolCheck + StringCheck + IntegerCheck + NumberCheck + MapCheck + ArrayCheck + TimeCheck + DurationCheck ) type Nature struct { - Type reflect.Type // Type of the value. If nil, then value is unknown. - Func *builtin.Function // Used to pass function type from callee to CallNode. - ArrayOf *Nature // Elem nature of array type (usually Type is []any, but ArrayOf can be any nature). - PredicateOut *Nature // Out nature of predicate. + // The order of the fields matter, check alignment before making changes. + + Type reflect.Type // Type of the value. If nil, then value is unknown. + Kind reflect.Kind // Kind of the value. + + *TypeData + + // Ref is a reference used for multiple, disjoint purposes. When the Nature + // is for a: + // - Predicate: then Ref is the nature of the Out of the predicate. + // - Array-like types: then Ref is the Elem nature of array type (usually Type is []any, but ArrayOf can be any nature). + Ref *Nature + + Nil bool // If value is nil. + Strict bool // If map is types.StrictMap. + Method bool // If value retrieved from method. Usually used to determine amount of in arguments. + IsInteger bool // If it's a builtin integer or unsigned integer type. + IsFloat bool // If it's a builtin float type. +} + +type TypeData struct { + methodset *methodset // optional to avoid the map in *Cache + + *structData + + // map-only data Fields map[string]Nature // Fields of map type. DefaultMapValue *Nature // Default value of map type. - Strict bool // If map is types.StrictMap. - Nil bool // If value is nil. - Method bool // If value retrieved from method. Usually used to determine amount of in arguments. + + // callable-only data + Func *builtin.Function // Used to pass function type from callee to CallNode. MethodIndex int // Index of method in type. - FieldIndex []int // Index of field in type. + inElem, outZero *Nature + numIn, numOut int + + isVariadic bool + isVariadicSet bool + numInSet bool + numOutSet bool } -func (n Nature) IsAny() bool { - return n.Kind() == reflect.Interface && n.NumMethods() == 0 +// Cache is a shared cache of type information. It is only used in the stages +// where type information becomes relevant, so packages like ast, parser, types, +// and lexer do not need to use the cache because they don't need any service +// from the Nature type, they only describe. However, when receiving a Nature +// from one of those packages, the cache must be set immediately. +type Cache struct { + methods map[reflect.Type]*methodset + structs map[reflect.Type]Nature } -func (n Nature) IsUnknown() bool { - switch { - case n.Type == nil && !n.Nil: - return true - case n.IsAny(): - return true +// NatureOf returns a Nature describing "i". If "i" is nil then it returns a +// Nature describing the value "nil". +func (c *Cache) NatureOf(i any) Nature { + // reflect.TypeOf(nil) returns nil, but in FromType we want to differentiate + // what nil means for us + if i == nil { + return Nature{Nil: true} } - return false + return c.FromType(reflect.TypeOf(i)) } -func (n Nature) String() string { - if n.Type != nil { - return n.Type.String() +// FromType returns a Nature describing a value of type "t". If "t" is nil then +// it returns a Nature describing an unknown value. +func (c *Cache) FromType(t reflect.Type) Nature { + if t == nil { + return Nature{} + } + var td *TypeData + var isInteger, isFloat bool + k := t.Kind() + switch k { + case reflect.Struct: + // c can be nil when we call the package function FromType, which uses a + // nil *Cache to call this method. + if c != nil { + return c.getStruct(t) + } + fallthrough + case reflect.Func: + td = new(TypeData) + case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64, + reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr: + _, isInteger = builtinInt[t] + case reflect.Float32, reflect.Float64: + _, isFloat = builtinFloat[t] + } + return Nature{ + Type: t, + Kind: k, + TypeData: td, + IsInteger: isInteger, + IsFloat: isFloat, } - return "unknown" } -func (n Nature) Deref() Nature { - if n.Type != nil { - n.Type = deref.Type(n.Type) +func (c *Cache) getStruct(t reflect.Type) Nature { + if c.structs == nil { + c.structs = map[reflect.Type]Nature{} + } else if nt, ok := c.structs[t]; ok { + return nt + } + nt := Nature{ + Type: t, + Kind: reflect.Struct, + TypeData: &TypeData{ + structData: &structData{ + rType: t, + numField: t.NumField(), + anonIdx: -1, // do not lookup embedded fields yet + }, + }, } - return n + c.structs[t] = nt + return nt } -func (n Nature) Kind() reflect.Kind { +func (c *Cache) getMethodset(t reflect.Type, k reflect.Kind) *methodset { + if t == nil || c == nil { + return nil + } + if c.methods == nil { + c.methods = map[reflect.Type]*methodset{ + t: nil, + } + } else if s, ok := c.methods[t]; ok { + return s + } + numMethod := t.NumMethod() + if numMethod < 1 { + c.methods[t] = nil // negative cache + return nil + } + s := &methodset{ + rType: t, + kind: k, + numMethod: numMethod, + } + c.methods[t] = s + return s +} + +// NatureOf calls NatureOf on a nil *Cache. See the comment on Cache. +func NatureOf(i any) Nature { + var c *Cache + return c.NatureOf(i) +} + +// FromType calls FromType on a nil *Cache. See the comment on Cache. +func FromType(t reflect.Type) Nature { + var c *Cache + return c.FromType(t) +} + +func ArrayFromType(c *Cache, t reflect.Type) Nature { + elem := c.FromType(t) + nt := c.FromType(arrayType) + nt.Ref = &elem + return nt +} + +func (n *Nature) IsAny(c *Cache) bool { + return n.Type != nil && n.Kind == reflect.Interface && n.NumMethods(c) == 0 +} + +func (n *Nature) IsUnknown(c *Cache) bool { + return n.Type == nil && !n.Nil || n.IsAny(c) +} + +func (n *Nature) String() string { if n.Type != nil { - return n.Type.Kind() + return n.Type.String() + } + return "unknown" +} + +func (n *Nature) Deref(c *Cache) Nature { + t, _, changed := deref.TypeKind(n.Type, n.Kind) + if !changed { + return *n } - return reflect.Invalid + return c.FromType(t) } -func (n Nature) Key() Nature { - if n.Kind() == reflect.Map { - return Nature{Type: n.Type.Key()} +func (n *Nature) Key(c *Cache) Nature { + if n.Kind == reflect.Map { + return c.FromType(n.Type.Key()) } - return unknown + return Nature{} } -func (n Nature) Elem() Nature { - switch n.Kind() { +func (n *Nature) Elem(c *Cache) Nature { + switch n.Kind { case reflect.Ptr: - return Nature{Type: n.Type.Elem()} + return c.FromType(n.Type.Elem()) case reflect.Map: - if n.DefaultMapValue != nil { + if n.TypeData != nil && n.DefaultMapValue != nil { return *n.DefaultMapValue } - return Nature{Type: n.Type.Elem()} - case reflect.Array, reflect.Slice: - if n.ArrayOf != nil { - return *n.ArrayOf + return c.FromType(n.Type.Elem()) + case reflect.Slice, reflect.Array: + if n.Ref != nil { + return *n.Ref } - return Nature{Type: n.Type.Elem()} + return c.FromType(n.Type.Elem()) } - return unknown + return Nature{} } -func (n Nature) AssignableTo(nt Nature) bool { +func (n *Nature) AssignableTo(nt Nature) bool { if n.Nil { - // Untyped nil is assignable to any interface, but implements only the empty interface. - if nt.IsAny() { + switch nt.Kind { + case reflect.Pointer, reflect.Interface, reflect.Chan, reflect.Func, + reflect.Map, reflect.Slice: + // nil can be assigned to these kinds return true } } - if n.Type == nil || nt.Type == nil { + if n.Type == nil || nt.Type == nil || + n.Kind != nt.Kind && nt.Kind != reflect.Interface { return false } return n.Type.AssignableTo(nt.Type) } -func (n Nature) NumMethods() int { - if n.Type == nil { - return 0 +func (n *Nature) getMethodset(c *Cache) *methodset { + if n.TypeData != nil && n.TypeData.methodset != nil { + return n.TypeData.methodset + } + s := c.getMethodset(n.Type, n.Kind) + if n.TypeData != nil { + n.TypeData.methodset = s // cache locally if possible } - return n.Type.NumMethod() + return s } -func (n Nature) MethodByName(name string) (Nature, bool) { - if n.Type == nil { - return unknown, false - } - method, ok := n.Type.MethodByName(name) - if !ok { - return unknown, false +func (n *Nature) NumMethods(c *Cache) int { + if s := n.getMethodset(c); s != nil { + return s.numMethod } + return 0 +} - if n.Type.Kind() == reflect.Interface { - // In case of interface type method will not have a receiver, - // and to prevent checker decreasing numbers of in arguments - // return method type as not method (second argument is false). - - // Also, we can not use m.Index here, because it will be - // different indexes for different types which implement - // the same interface. - return Nature{Type: method.Type}, true - } else { - return Nature{ - Type: method.Type, - Method: true, - MethodIndex: method.Index, - }, true +func (n *Nature) MethodByName(c *Cache, name string) (Nature, bool) { + if s := n.getMethodset(c); s != nil { + if m := s.method(c, name); m != nil { + return m.nature, true + } } + return Nature{}, false } -func (n Nature) NumIn() int { - if n.Type == nil { - return 0 +func (n *Nature) NumIn() int { + if n.numInSet { + return n.numIn } - return n.Type.NumIn() + n.numInSet = true + n.numIn = n.Type.NumIn() + return n.numIn } -func (n Nature) In(i int) Nature { - if n.Type == nil { - return unknown +func (n *Nature) InElem(c *Cache, i int) Nature { + if n.inElem == nil { + n2 := c.FromType(n.Type.In(i)) + n2 = n2.Elem(c) + n.inElem = &n2 } - return Nature{Type: n.Type.In(i)} + return *n.inElem } -func (n Nature) NumOut() int { - if n.Type == nil { - return 0 +func (n *Nature) In(c *Cache, i int) Nature { + return c.FromType(n.Type.In(i)) +} + +func (n *Nature) IsFirstArgUnknown(c *Cache) bool { + if n.Type != nil { + n2 := c.FromType(n.Type.In(0)) + return n2.IsUnknown(c) } - return n.Type.NumOut() + return false } -func (n Nature) Out(i int) Nature { - if n.Type == nil { - return unknown +func (n *Nature) NumOut() int { + if n.numOutSet { + return n.numOut } - return Nature{Type: n.Type.Out(i)} + n.numOutSet = true + n.numOut = n.Type.NumOut() + return n.numOut } -func (n Nature) IsVariadic() bool { - if n.Type == nil { - return false +func (n *Nature) Out(c *Cache, i int) Nature { + if i != 0 { + return n.out(c, i) + } + if n.outZero != nil { + return *n.outZero } - return n.Type.IsVariadic() + nt := n.out(c, 0) + n.outZero = &nt + return nt } -func (n Nature) FieldByName(name string) (Nature, bool) { +func (n *Nature) out(c *Cache, i int) Nature { if n.Type == nil { - return unknown, false + return Nature{} } - field, ok := fetchField(n.Type, name) - return Nature{Type: field.Type, FieldIndex: field.Index}, ok + return c.FromType(n.Type.Out(i)) } -func (n Nature) PkgPath() string { - if n.Type == nil { - return "" +func (n *Nature) IsVariadic() bool { + if n.isVariadicSet { + return n.isVariadic } - return n.Type.PkgPath() + n.isVariadicSet = true + n.isVariadic = n.Type.IsVariadic() + return n.isVariadic } -func (n Nature) IsFastMap() bool { - if n.Type == nil { - return false +func (n *Nature) FieldByName(c *Cache, name string) (Nature, bool) { + if n.Kind != reflect.Struct { + return Nature{}, false } - if n.Type.Kind() == reflect.Map && - n.Type.Key().Kind() == reflect.String && - n.Type.Elem().Kind() == reflect.Interface { - return true + var sd *structData + if n.TypeData != nil && n.structData != nil { + sd = n.structData + } else { + sd = c.getStruct(n.Type).structData } - return false + if sf := sd.structField(c, nil, name); sf != nil { + return sf.Nature, true + } + return Nature{}, false } -func (n Nature) Get(name string) (Nature, bool) { - if n.Type == nil { - return unknown, false - } +func (n *Nature) IsFastMap() bool { + return n.Type != nil && + n.Type.Kind() == reflect.Map && + n.Type.Key().Kind() == reflect.String && + n.Type.Elem().Kind() == reflect.Interface +} - if m, ok := n.MethodByName(name); ok { - return m, true +func (n *Nature) Get(c *Cache, name string) (Nature, bool) { + if n.Kind == reflect.Map && n.TypeData != nil { + f, ok := n.Fields[name] + return f, ok } + return n.getSlow(c, name) +} - t := deref.Type(n.Type) - - switch t.Kind() { - case reflect.Struct: - if f, ok := fetchField(t, name); ok { - return Nature{ - Type: f.Type, - FieldIndex: f.Index, - }, true - } - case reflect.Map: - if f, ok := n.Fields[name]; ok { - return f, true +func (n *Nature) getSlow(c *Cache, name string) (Nature, bool) { + if nt, ok := n.MethodByName(c, name); ok { + return nt, true + } + if n.Kind == reflect.Struct { + if sf := n.structField(c, nil, name); sf != nil { + return sf.Nature, true } } - return unknown, false + return Nature{}, false } -func (n Nature) All() map[string]Nature { +func (n *Nature) FieldIndex(c *Cache, name string) ([]int, bool) { + if n.Kind != reflect.Struct { + return nil, false + } + if sf := n.structField(c, nil, name); sf != nil { + return sf.Index, true + } + return nil, false +} + +func (n *Nature) All(c *Cache) map[string]Nature { table := make(map[string]Nature) if n.Type == nil { return table } - for i := 0; i < n.Type.NumMethod(); i++ { + for i := 0; i < n.NumMethods(c); i++ { method := n.Type.Method(i) - table[method.Name] = Nature{ - Type: method.Type, - Method: true, - MethodIndex: method.Index, + nt := c.FromType(method.Type) + if nt.TypeData == nil { + nt.TypeData = new(TypeData) } + nt.Method = true + nt.MethodIndex = method.Index + table[method.Name] = nt } t := deref.Type(n.Type) switch t.Kind() { case reflect.Struct: - for name, nt := range StructFields(t) { + for name, nt := range StructFields(c, t) { if _, ok := table[name]; ok { continue } @@ -249,13 +452,116 @@ func (n Nature) All() map[string]Nature { } case reflect.Map: - for key, nt := range n.Fields { - if _, ok := table[key]; ok { - continue + if n.TypeData != nil { + for key, nt := range n.Fields { + if _, ok := table[key]; ok { + continue + } + table[key] = nt } - table[key] = nt } } return table } + +func (n *Nature) IsNumber() bool { + return n.IsInteger || n.IsFloat +} + +func (n *Nature) PromoteNumericNature(c *Cache, rhs Nature) Nature { + if n.IsUnknown(c) || rhs.IsUnknown(c) { + return Nature{} + } + if n.IsFloat || rhs.IsFloat { + return c.FromType(floatType) + } + return c.FromType(intType) +} + +func (n *Nature) IsTime() bool { + return n.Type == timeType +} + +func (n *Nature) IsDuration() bool { + return n.Type == durationType +} + +func (n *Nature) IsBool() bool { + return n.Kind == reflect.Bool +} + +func (n *Nature) IsString() bool { + return n.Kind == reflect.String +} + +func (n *Nature) IsArray() bool { + return n.Kind == reflect.Slice || n.Kind == reflect.Array +} + +func (n *Nature) IsMap() bool { + return n.Kind == reflect.Map +} + +func (n *Nature) IsStruct() bool { + return n.Kind == reflect.Struct +} + +func (n *Nature) IsFunc() bool { + return n.Kind == reflect.Func +} + +func (n *Nature) IsPointer() bool { + return n.Kind == reflect.Ptr +} + +func (n *Nature) IsAnyOf(cs ...NatureCheck) bool { + var result bool + for i := 0; i < len(cs) && !result; i++ { + switch cs[i] { + case BoolCheck: + result = n.IsBool() + case StringCheck: + result = n.IsString() + case IntegerCheck: + result = n.IsInteger + case NumberCheck: + result = n.IsNumber() + case MapCheck: + result = n.IsMap() + case ArrayCheck: + result = n.IsArray() + case TimeCheck: + result = n.IsTime() + case DurationCheck: + result = n.IsDuration() + default: + panic(fmt.Sprintf("unknown check value %d", cs[i])) + } + } + return result +} + +func (n *Nature) ComparableTo(c *Cache, rhs Nature) bool { + return n.IsUnknown(c) || rhs.IsUnknown(c) || + n.Nil || rhs.Nil || + n.IsNumber() && rhs.IsNumber() || + n.IsDuration() && rhs.IsDuration() || + n.IsTime() && rhs.IsTime() || + n.IsArray() && rhs.IsArray() || + n.AssignableTo(rhs) +} + +func (n *Nature) MaybeCompatible(c *Cache, rhs Nature, cs ...NatureCheck) bool { + nIsUnknown := n.IsUnknown(c) + rshIsUnknown := rhs.IsUnknown(c) + return nIsUnknown && rshIsUnknown || + nIsUnknown && rhs.IsAnyOf(cs...) || + rshIsUnknown && n.IsAnyOf(cs...) +} + +func (n *Nature) MakeArrayOf(c *Cache) Nature { + nt := c.FromType(arrayType) + nt.Ref = n + return nt +} diff --git a/checker/nature/utils.go b/checker/nature/utils.go index c1551546c..755c2e08b 100644 --- a/checker/nature/utils.go +++ b/checker/nature/utils.go @@ -6,84 +6,227 @@ import ( "github.com/expr-lang/expr/internal/deref" ) -func fieldName(field reflect.StructField) (string, bool) { - switch taggedName := field.Tag.Get("expr"); taggedName { +func fieldName(fieldName string, tag reflect.StructTag) (string, bool) { + switch taggedName := tag.Get("expr"); taggedName { case "-": return "", false case "": - return field.Name, true + return fieldName, true default: return taggedName, true } } -func fetchField(t reflect.Type, name string) (reflect.StructField, bool) { - // If t is not a struct, early return. - if t.Kind() != reflect.Struct { - return reflect.StructField{}, false +type structData struct { + rType reflect.Type + fields map[string]*structField + numField, ownIdx, anonIdx int + + curParent, curChild *structData + curChildIndex []int +} + +type structField struct { + Nature + Index []int +} + +func (s *structData) finished() bool { + return s.ownIdx >= s.numField && // no own fields left to visit + s.anonIdx >= s.numField && // no embedded fields to visit + s.curChild == nil // no child in process of visiting +} + +func (s *structData) structField(c *Cache, parentEmbed *structData, name string) *structField { + if s.fields == nil { + if s.numField > 0 { + s.fields = make(map[string]*structField, s.numField) + } + } else if f := s.fields[name]; f != nil { + return f + } + if s.finished() { + return nil } - // First check all structs fields. - for i := 0; i < t.NumField(); i++ { - field := t.Field(i) - // Search all fields, even embedded structs. - if n, ok := fieldName(field); ok && n == name { - return field, true + // Lookup own fields first. + for ; s.ownIdx < s.numField; s.ownIdx++ { + field := s.rType.Field(s.ownIdx) + // BUG: we should skip if !field.IsExported() here + + if field.Anonymous && s.anonIdx < 0 { + // start iterating anon fields on the first instead of zero + s.anonIdx = s.ownIdx + } + fName, ok := fieldName(field.Name, field.Tag) + if !ok || fName == "" { + // name can still be empty for a type created at runtime with + // reflect + continue + } + nt := c.FromType(field.Type) + sf := &structField{ + Nature: nt, + Index: field.Index, + } + s.fields[fName] = sf + if parentEmbed != nil { + parentEmbed.trySet(fName, sf) + } + if fName == name { + return sf + } + } + + if s.curChild != nil { + sf := s.findInEmbedded(c, parentEmbed, s.curChild, s.curChildIndex, name) + if sf != nil { + return sf } } - // Second check fields of embedded structs. - for i := 0; i < t.NumField(); i++ { - anon := t.Field(i) - if anon.Anonymous { - anonType := anon.Type - if anonType.Kind() == reflect.Pointer { - anonType = anonType.Elem() - } - if field, ok := fetchField(anonType, name); ok { - field.Index = append(anon.Index, field.Index...) - return field, true - } + // Lookup embedded fields through anon own fields + for ; s.anonIdx >= 0 && s.anonIdx < s.numField; s.anonIdx++ { + field := s.rType.Field(s.anonIdx) + // we do enter embedded non-exported types because they could contain + // exported fields + if !field.Anonymous { + continue + } + t, k, _ := deref.TypeKind(field.Type, field.Type.Kind()) + if k != reflect.Struct { + continue + } + + childEmbed := c.getStruct(t).structData + sf := s.findInEmbedded(c, parentEmbed, childEmbed, field.Index, name) + if sf != nil { + return sf } } - return reflect.StructField{}, false + return nil } -func StructFields(t reflect.Type) map[string]Nature { - table := make(map[string]Nature) +func (s *structData) findInEmbedded( + c *Cache, + parentEmbed, childEmbed *structData, + childIndex []int, + name string, +) *structField { + // Set current parent/child data. This allows trySet to handle child fields + // and add them to our struct and to the parent as well if needed + s.curParent = parentEmbed + s.curChild = childEmbed + s.curChildIndex = childIndex + defer func() { + // Ensure to cleanup references + s.curParent = nil + if childEmbed.finished() { + // If the child can still have more fields to explore then keep it + // referened to look it up again if we need to + s.curChild = nil + s.curChildIndex = nil + } + }() - t = deref.Type(t) + // See if the child has already cached its fields. This is still important + // to check even if it's the s.unfinishedEmbedded because it may have + // explored new fields since the last time we visited it + for name, sf := range childEmbed.fields { + s.trySet(name, sf) + } + + // Recheck if we have what we needed from the above sync + if sf := s.fields[name]; sf != nil { + return sf + } + + // Try finding in the child again in case it hasn't finished + if !childEmbed.finished() { + if childEmbed.structField(c, s, name) != nil { + return s.fields[name] + } + } + + return nil +} + +func (s *structData) trySet(name string, sf *structField) { + if _, ok := s.fields[name]; ok { + return + } + sf = &structField{ + Nature: sf.Nature, + Index: append(s.curChildIndex, sf.Index...), + } + s.fields[name] = sf + if s.curParent != nil { + s.curParent.trySet(name, sf) + } +} + +func StructFields(c *Cache, t reflect.Type) map[string]Nature { + table := make(map[string]Nature) if t == nil { return table } + t, k, _ := deref.TypeKind(t, t.Kind()) + if k == reflect.Struct { + // lookup for a field with an empty name, which will cause to never find a + // match, meaning everything will have been cached. + sd := c.getStruct(t).structData + sd.structField(c, nil, "") + for name, sf := range sd.fields { + table[name] = sf.Nature + } + } + return table +} - switch t.Kind() { - case reflect.Struct: - for i := 0; i < t.NumField(); i++ { - f := t.Field(i) +type methodset struct { + rType reflect.Type + kind reflect.Kind + methods map[string]*method + numMethod, idx int +} - if f.Anonymous { - for name, typ := range StructFields(f.Type) { - if _, ok := table[name]; ok { - continue - } - typ.FieldIndex = append(f.Index, typ.FieldIndex...) - table[name] = typ - } - } +type method struct { + reflect.Method + nature Nature +} - name, ok := fieldName(f) - if !ok { - continue - } - table[name] = Nature{ - Type: f.Type, - FieldIndex: f.Index, - } +func (s *methodset) method(c *Cache, name string) *method { + if s.methods == nil { + s.methods = make(map[string]*method, s.numMethod) + } else if m := s.methods[name]; m != nil { + return m + } + for ; s.idx < s.numMethod; s.idx++ { + rm := s.rType.Method(s.idx) + if !rm.IsExported() { + continue + } + nt := c.FromType(rm.Type) + if s.rType.Kind() != reflect.Interface { + nt.Method = true + nt.MethodIndex = rm.Index + // In case of interface type method will not have a receiver, + // and to prevent checker decreasing numbers of in arguments + // return method type as not method (second argument is false). + // Also, we can not use m.Index here, because it will be + // different indexes for different types which implement + // the same interface. + } + m := &method{ + Method: rm, + nature: nt, + } + s.methods[rm.Name] = m + if rm.Name == name { + return m } } - - return table + return nil } diff --git a/checker/types.go b/checker/types.go deleted file mode 100644 index 09896de5d..000000000 --- a/checker/types.go +++ /dev/null @@ -1,190 +0,0 @@ -package checker - -import ( - "reflect" - "time" - - . "github.com/expr-lang/expr/checker/nature" -) - -var ( - unknown = Nature{} - nilNature = Nature{Nil: true} - boolNature = Nature{Type: reflect.TypeOf(true)} - integerNature = Nature{Type: reflect.TypeOf(0)} - floatNature = Nature{Type: reflect.TypeOf(float64(0))} - stringNature = Nature{Type: reflect.TypeOf("")} - arrayNature = Nature{Type: reflect.TypeOf([]any{})} - mapNature = Nature{Type: reflect.TypeOf(map[string]any{})} - timeNature = Nature{Type: reflect.TypeOf(time.Time{})} - durationNature = Nature{Type: reflect.TypeOf(time.Duration(0))} -) - -var ( - anyType = reflect.TypeOf(new(any)).Elem() - timeType = reflect.TypeOf(time.Time{}) - durationType = reflect.TypeOf(time.Duration(0)) - arrayType = reflect.TypeOf([]any{}) -) - -func arrayOf(nt Nature) Nature { - return Nature{ - Type: arrayType, - ArrayOf: &nt, - } -} - -func isNil(nt Nature) bool { - return nt.Nil -} - -func combined(l, r Nature) Nature { - if isUnknown(l) || isUnknown(r) { - return unknown - } - if isFloat(l) || isFloat(r) { - return floatNature - } - return integerNature -} - -func anyOf(nt Nature, fns ...func(Nature) bool) bool { - for _, fn := range fns { - if fn(nt) { - return true - } - } - return false -} - -func or(l, r Nature, fns ...func(Nature) bool) bool { - if isUnknown(l) && isUnknown(r) { - return true - } - if isUnknown(l) && anyOf(r, fns...) { - return true - } - if isUnknown(r) && anyOf(l, fns...) { - return true - } - return false -} - -func isUnknown(nt Nature) bool { - return nt.IsUnknown() -} - -func isInteger(nt Nature) bool { - switch nt.Kind() { - case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64: - fallthrough - case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64: - return nt.PkgPath() == "" - } - return false -} - -func isFloat(nt Nature) bool { - switch nt.Kind() { - case reflect.Float32, reflect.Float64: - return nt.PkgPath() == "" - } - return false -} - -func isNumber(nt Nature) bool { - return isInteger(nt) || isFloat(nt) -} - -func isTime(nt Nature) bool { - switch nt.Type { - case timeType: - return true - } - return false -} - -func isDuration(nt Nature) bool { - switch nt.Type { - case durationType: - return true - } - return false -} - -func isBool(nt Nature) bool { - switch nt.Kind() { - case reflect.Bool: - return true - } - return false -} - -func isString(nt Nature) bool { - switch nt.Kind() { - case reflect.String: - return true - } - return false -} - -func isArray(nt Nature) bool { - switch nt.Kind() { - case reflect.Slice, reflect.Array: - return true - } - return false -} - -func isMap(nt Nature) bool { - switch nt.Kind() { - case reflect.Map: - return true - } - return false -} - -func isStruct(nt Nature) bool { - switch nt.Kind() { - case reflect.Struct: - return true - } - return false -} - -func isFunc(nt Nature) bool { - switch nt.Kind() { - case reflect.Func: - return true - } - return false -} - -func kind(t reflect.Type) reflect.Kind { - if t == nil { - return reflect.Invalid - } - return t.Kind() -} - -func isComparable(l, r Nature) bool { - if isUnknown(l) || isUnknown(r) { - return true - } - if isNil(l) || isNil(r) { - return true - } - if isNumber(l) && isNumber(r) { - return true - } - if isDuration(l) && isDuration(r) { - return true - } - if isTime(l) && isTime(r) { - return true - } - if isArray(l) && isArray(r) { - return true - } - return l.AssignableTo(r) -} diff --git a/compiler/compiler.go b/compiler/compiler.go index 595355d28..c7469030c 100644 --- a/compiler/compiler.go +++ b/compiler/compiler.go @@ -5,6 +5,7 @@ import ( "math" "reflect" "regexp" + "runtime/debug" "github.com/expr-lang/expr/ast" "github.com/expr-lang/expr/builtin" @@ -24,7 +25,7 @@ const ( func Compile(tree *parser.Tree, config *conf.Config) (program *Program, err error) { defer func() { if r := recover(); r != nil { - err = fmt.Errorf("%v", r) + err = fmt.Errorf("%v\n%s", r, debug.Stack()) } }() @@ -36,6 +37,12 @@ func Compile(tree *parser.Tree, config *conf.Config) (program *Program, err erro debugInfo: make(map[string]string), } + if config != nil { + c.ntCache = &c.config.NtCache + } else { + c.ntCache = new(Cache) + } + c.compile(tree.Node) if c.config != nil { @@ -74,6 +81,7 @@ func Compile(tree *parser.Tree, config *conf.Config) (program *Program, err erro type compiler struct { config *conf.Config + ntCache *Cache locations []file.Location bytecode []Opcode variables int @@ -302,12 +310,12 @@ func (c *compiler) IdentifierNode(node *ast.IdentifierNode) { if env.IsFastMap() { c.emit(OpLoadFast, c.addConstant(node.Value)) - } else if ok, index, name := checker.FieldIndex(env, node); ok { + } else if ok, index, name := checker.FieldIndex(c.ntCache, env, node); ok { c.emit(OpLoadField, c.addConstant(&runtime.Field{ Index: index, Path: []string{name}, })) - } else if ok, index, name := checker.MethodIndex(env, node); ok { + } else if ok, index, name := checker.MethodIndex(c.ntCache, env, node); ok { c.emit(OpLoadMethod, c.addConstant(&runtime.Method{ Name: name, Index: index, @@ -653,7 +661,7 @@ func (c *compiler) MemberNode(node *ast.MemberNode) { env = c.config.Env } - if ok, index, name := checker.MethodIndex(env, node); ok { + if ok, index, name := checker.MethodIndex(c.ntCache, env, node); ok { c.compile(node.Node) c.emit(OpMethod, c.addConstant(&runtime.Method{ Name: name, @@ -664,14 +672,14 @@ func (c *compiler) MemberNode(node *ast.MemberNode) { op := OpFetch base := node.Node - ok, index, nodeName := checker.FieldIndex(env, node) + ok, index, nodeName := checker.FieldIndex(c.ntCache, env, node) path := []string{nodeName} if ok { op = OpFetchField for !node.Optional { if ident, isIdent := base.(*ast.IdentifierNode); isIdent { - if ok, identIndex, name := checker.FieldIndex(env, ident); ok { + if ok, identIndex, name := checker.FieldIndex(c.ntCache, env, ident); ok { index = append(identIndex, index...) path = append([]string{name}, path...) c.emitLocation(ident.Location(), OpLoadField, c.addConstant( @@ -682,7 +690,7 @@ func (c *compiler) MemberNode(node *ast.MemberNode) { } if member, isMember := base.(*ast.MemberNode); isMember { - if ok, memberIndex, name := checker.FieldIndex(env, member); ok { + if ok, memberIndex, name := checker.FieldIndex(c.ntCache, env, member); ok { index = append(memberIndex, index...) path = append([]string{name}, path...) node = member @@ -743,7 +751,7 @@ func (c *compiler) CallNode(node *ast.CallNode) { } } case *ast.IdentifierNode: - if t, ok := c.config.Env.MethodByName(callee.Value); ok && t.Method { + if t, ok := c.config.Env.MethodByName(c.ntCache, callee.Value); ok && t.Method { fnInOffset = 1 fnNumIn-- } @@ -777,7 +785,7 @@ func (c *compiler) CallNode(node *ast.CallNode) { c.compile(node.Callee) if c.config != nil { - isMethod, _, _ := checker.MethodIndex(c.config.Env, node.Callee) + isMethod, _, _ := checker.MethodIndex(c.ntCache, c.config.Env, node.Callee) if index, ok := checker.TypedFuncIndex(node.Callee.Type(), isMethod); ok { c.emit(OpCallTyped, index) return @@ -1080,7 +1088,8 @@ func (c *compiler) BuiltinNode(node *ast.BuiltinNode) { for i, arg := range node.Arguments { c.compile(arg) argType := arg.Type() - if argType.Kind() == reflect.Ptr || arg.Nature().IsUnknown() { + argNature := arg.Nature() + if argType.Kind() == reflect.Ptr || argNature.IsUnknown(c.ntCache) { if f.Deref == nil { // By default, builtins expect arguments to be dereferenced. c.emit(OpDeref) diff --git a/conf/config.go b/conf/config.go index 2c14d9882..8799d3d04 100644 --- a/conf/config.go +++ b/conf/config.go @@ -34,6 +34,7 @@ type Config struct { Functions FunctionsTable Builtins FunctionsTable Disabled map[string]bool // disabled builtins + NtCache nature.Cache } // CreateNew creates new config with default values. @@ -61,7 +62,7 @@ func New(env any) *Config { func (c *Config) WithEnv(env any) { c.EnvObject = env - c.Env = Env(env) + c.Env = EnvWithCache(&c.NtCache, env) c.Strict = c.Env.Strict } @@ -92,7 +93,7 @@ func (c *Config) IsOverridden(name string) bool { if _, ok := c.Functions[name]; ok { return true } - if _, ok := c.Env.Get(name); ok { + if _, ok := c.Env.Get(&c.NtCache, name); ok { return true } return false diff --git a/conf/env.go b/conf/env.go index 8b13df1e1..0acd44570 100644 --- a/conf/env.go +++ b/conf/env.go @@ -9,35 +9,42 @@ import ( "github.com/expr-lang/expr/types" ) +// Env returns the Nature of the given environment. +// +// Deprecated: use EnvWithCache instead. func Env(env any) Nature { + return EnvWithCache(new(Cache), env) +} + +func EnvWithCache(c *Cache, env any) Nature { if env == nil { - return Nature{ - Type: reflect.TypeOf(map[string]any{}), - Strict: true, - } + n := c.NatureOf(map[string]any{}) + n.Strict = true + return n } switch env := env.(type) { case types.Map: - return env.Nature() + nt := env.Nature() + return nt } v := reflect.ValueOf(env) - d := deref.Value(v) + t := v.Type() - switch d.Kind() { + switch deref.Value(v).Kind() { case reflect.Struct: - return Nature{ - Type: v.Type(), - Strict: true, - } + n := c.FromType(t) + n.Strict = true + return n case reflect.Map: - n := Nature{ - Type: v.Type(), - Fields: make(map[string]Nature, v.Len()), - Strict: true, + n := c.FromType(v.Type()) + if n.TypeData == nil { + n.TypeData = new(TypeData) } + n.Strict = true + n.Fields = make(map[string]Nature, v.Len()) for _, key := range v.MapKeys() { elem := v.MapIndex(key) @@ -49,14 +56,15 @@ func Env(env any) Nature { switch face := face.(type) { case types.Map: - n.Fields[key.String()] = face.Nature() + nt := face.Nature() + n.Fields[key.String()] = nt default: if face == nil { - n.Fields[key.String()] = Nature{Nil: true} + n.Fields[key.String()] = c.NatureOf(nil) continue } - n.Fields[key.String()] = Nature{Type: reflect.TypeOf(face)} + n.Fields[key.String()] = c.NatureOf(face) } } diff --git a/docgen/docgen.go b/docgen/docgen.go index 1844f23b5..17830106e 100644 --- a/docgen/docgen.go +++ b/docgen/docgen.go @@ -85,7 +85,9 @@ func CreateDoc(i any) *Context { PkgPath: deref.Type(reflect.TypeOf(i)).PkgPath(), } - for name, t := range conf.Env(i).All() { + cache := new(nature.Cache) + env := conf.EnvWithCache(cache, i) + for name, t := range env.All(cache) { if _, ok := c.Variables[Identifier(name)]; ok { continue } @@ -221,7 +223,8 @@ appendix: c.Types[name] = a } - for name, field := range nature.StructFields(t) { + ntCache := new(nature.Cache) + for name, field := range nature.StructFields(ntCache, t) { if isPrivate(name) || isProtobuf(name) { continue } diff --git a/expr.go b/expr.go index 48298fe7e..e8f4eb64b 100644 --- a/expr.go +++ b/expr.go @@ -48,6 +48,7 @@ func Operator(operator string, fn ...string) Option { Overloads: fn, Env: &c.Env, Functions: c.Functions, + NtCache: &c.NtCache, } c.Visitors = append(c.Visitors, p) } diff --git a/internal/deref/deref.go b/internal/deref/deref.go index da3e28ce6..4ad7877f8 100644 --- a/internal/deref/deref.go +++ b/internal/deref/deref.go @@ -45,3 +45,12 @@ func Value(v reflect.Value) reflect.Value { } return v } + +func TypeKind(t reflect.Type, k reflect.Kind) (_ reflect.Type, _ reflect.Kind, changed bool) { + for k == reflect.Pointer { + changed = true + t = t.Elem() + k = t.Kind() + } + return t, k, changed +} diff --git a/parser/lexer/lexer.go b/parser/lexer/lexer.go index a8cf6a5be..fe41e824a 100644 --- a/parser/lexer/lexer.go +++ b/parser/lexer/lexer.go @@ -92,13 +92,6 @@ func (l *Lexer) peek() rune { return eof } -func (l *Lexer) peekByte() (byte, bool) { - if l.end.byte >= 0 && l.end.byte < len(l.source.String()) { - return l.source.String()[l.end.byte], true - } - return 0, false -} - func (l *Lexer) backup() { if l.eof { l.eof = false diff --git a/parser/parser.go b/parser/parser.go index e1dd111fc..6034403bf 100644 --- a/parser/parser.go +++ b/parser/parser.go @@ -12,7 +12,6 @@ import ( "github.com/expr-lang/expr/builtin" "github.com/expr-lang/expr/conf" "github.com/expr-lang/expr/file" - "github.com/expr-lang/expr/parser/lexer" . "github.com/expr-lang/expr/parser/lexer" "github.com/expr-lang/expr/parser/operator" "github.com/expr-lang/expr/parser/utils" @@ -49,7 +48,7 @@ var predicates = map[string]struct { // Parser is a reusable parser. The zero value is ready for use. type Parser struct { - lexer *lexer.Lexer + lexer *Lexer current, stashed Token hasStash bool err *file.Error @@ -60,7 +59,7 @@ type Parser struct { func (p *Parser) Parse(input string, config *conf.Config) (*Tree, error) { if p.lexer == nil { - p.lexer = lexer.New() + p.lexer = New() } p.config = config source := file.NewSource(input) diff --git a/patcher/operator_override.go b/patcher/operator_override.go index 308cbdba3..cf4287c24 100644 --- a/patcher/operator_override.go +++ b/patcher/operator_override.go @@ -16,6 +16,7 @@ type OperatorOverloading struct { Env *nature.Nature // Env type. Functions conf.FunctionsTable // Env functions. applied bool // Flag to indicate if any changes were made to the tree. + NtCache *nature.Cache } func (p *OperatorOverloading) Visit(node *ast.Node) { @@ -62,7 +63,7 @@ func (p *OperatorOverloading) FindSuitableOperatorOverload(l, r reflect.Type) (r func (p *OperatorOverloading) findSuitableOperatorOverloadInTypes(l, r reflect.Type) (reflect.Type, string, bool) { for _, fn := range p.Overloads { - fnType, ok := p.Env.Get(fn) + fnType, ok := p.Env.Get(p.NtCache, fn) if !ok { continue } @@ -109,7 +110,7 @@ func checkTypeSuits(t reflect.Type, l reflect.Type, r reflect.Type, firstInIndex func (p *OperatorOverloading) Check() { for _, fn := range p.Overloads { - fnType, foundType := p.Env.Get(fn) + fnType, foundType := p.Env.Get(p.NtCache, fn) fnFunc, foundFunc := p.Functions[fn] if !foundFunc && (!foundType || fnType.Type.Kind() != reflect.Func) { panic(fmt.Errorf("function %s for %s operator does not exist in the environment", fn, p.Operator)) diff --git a/types/types.go b/types/types.go index bb1cbe5fa..33257c500 100644 --- a/types/types.go +++ b/types/types.go @@ -44,7 +44,7 @@ func TypeOf(v any) Type { type anyType struct{} func (anyType) Nature() Nature { - return Nature{Type: nil} + return FromType(nil) } func (anyType) Equal(t Type) bool { @@ -58,7 +58,7 @@ func (anyType) String() string { type nilType struct{} func (nilType) Nature() Nature { - return Nature{Nil: true} + return NatureOf(nil) } func (nilType) Equal(t Type) bool { @@ -77,7 +77,7 @@ type rtype struct { } func (r rtype) Nature() Nature { - return Nature{Type: r.t} + return FromType(r.t) } func (r rtype) Equal(t Type) bool { @@ -100,11 +100,12 @@ type Map map[string]Type const Extra = "[[__extra_keys__]]" func (m Map) Nature() Nature { - nt := Nature{ - Type: reflect.TypeOf(map[string]any{}), - Fields: make(map[string]Nature, len(m)), - Strict: true, + nt := NatureOf(map[string]any{}) + if nt.TypeData == nil { + nt.TypeData = new(TypeData) } + nt.Fields = make(map[string]Nature, len(m)) + nt.Strict = true for k, v := range m { if k == Extra { nt.Strict = false @@ -155,11 +156,13 @@ type array struct { func (a array) Nature() Nature { of := a.of.Nature() - return Nature{ - Type: reflect.TypeOf([]any{}), - Fields: make(map[string]Nature, 1), - ArrayOf: &of, + nt := NatureOf([]any{}) + if nt.TypeData == nil { + nt.TypeData = new(TypeData) } + nt.Fields = make(map[string]Nature, 1) + nt.Ref = &of + return nt } func (a array) Equal(t Type) bool { From 5f4de2012b5ae915bc90db0067201b5f90f24e3f Mon Sep 17 00:00:00 2001 From: Anton Medvedev Date: Thu, 18 Sep 2025 21:39:22 +0200 Subject: [PATCH 110/113] Add more tests --- expr_test.go | 23 ++++++++--------------- test/issues/840/issue_test.go | 30 ++++++++++++++++++++++++++++++ 2 files changed, 38 insertions(+), 15 deletions(-) create mode 100644 test/issues/840/issue_test.go diff --git a/expr_test.go b/expr_test.go index bed6d7468..01ccdeeb9 100644 --- a/expr_test.go +++ b/expr_test.go @@ -2318,23 +2318,16 @@ func TestEval_slices_out_of_bound(t *testing.T) { } } -func TestExpr_custom_tests(t *testing.T) { - f, err := os.Open("custom_tests.json") - if os.IsNotExist(err) { - t.Skip("no custom tests") - return +func TestExpr_timeout(t *testing.T) { + tests := []struct{ code string }{ + {`-999999..999999`}, + {`map(1..999999, 1..999999)`}, + {`map(1..999999, repeat('a', #))`}, } - require.NoError(t, err, "open file error") - defer f.Close() - - var tests []string - err = json.NewDecoder(f).Decode(&tests) - require.NoError(t, err, "decode json error") - - for id, tt := range tests { - t.Run(fmt.Sprintf("line %v", id+2), func(t *testing.T) { - program, err := expr.Compile(tt) + for _, tt := range tests { + t.Run(tt.code, func(t *testing.T) { + program, err := expr.Compile(tt.code) require.NoError(t, err) timeout := make(chan bool, 1) diff --git a/test/issues/840/issue_test.go b/test/issues/840/issue_test.go new file mode 100644 index 000000000..1c0d3c95b --- /dev/null +++ b/test/issues/840/issue_test.go @@ -0,0 +1,30 @@ +package issue_test + +import ( + "testing" + + "github.com/expr-lang/expr" + "github.com/expr-lang/expr/internal/testify/require" +) + +func TestEnvFieldMethods(t *testing.T) { + program, err := expr.Compile(`Func(0)`, expr.Env(&Env{})) + require.NoError(t, err) + + env := &Env{} + env.Func = func() int { + return 42 + } + + out, err := expr.Run(program, Env{}) + require.NoError(t, err) + + require.Equal(t, 42, out) +} + +type Env struct { + EmbeddedEnv + Func func() int +} + +type EmbeddedEnv struct{} From 69b27afae29804c646a7d51f8daaa032becd799d Mon Sep 17 00:00:00 2001 From: Anton Medvedev Date: Thu, 18 Sep 2025 21:45:44 +0200 Subject: [PATCH 111/113] Update README.md --- README.md | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/README.md b/README.md index 5afd743d8..a7ded479c 100644 --- a/README.md +++ b/README.md @@ -149,9 +149,9 @@ func main() { * [GoDaddy](https://godaddy.com) employs Expr for the customization of its GoDaddy Pro product. * [ByteDance](https://bytedance.com) incorporates Expr into its internal business rule engine. * [Aviasales](https://aviasales.ru) utilizes Expr as a business rule engine for its flight search engine. -* [Wish.com](https://www.wish.com) employs Expr in its decision-making rule engine for the Wish Assistant. -* [Naoma.AI](https://www.naoma.ai) uses Expr as a part of its call scoring engine. +* [Alibaba](https://alibaba.com) uses Expr in a web framework for building recommendation services. * [Argo](https://argoproj.github.io) integrates Expr into Argo Rollouts and Argo Workflows for Kubernetes. +* [Wish.com](https://www.wish.com) employs Expr in its decision-making rule engine for the Wish Assistant. * [OpenTelemetry](https://opentelemetry.io) integrates Expr into the OpenTelemetry Collector. * [Philips Labs](https://github.com/philips-labs/tabia) employs Expr in Tabia, a tool designed to collect insights on their code bases. * [CrowdSec](https://crowdsec.net) incorporates Expr into its security automation tool. @@ -172,6 +172,7 @@ func main() { * [FastSchema](https://github.com/fastschema/fastschema) - A BaaS leveraging Expr for its customizable and dynamic Access Control system. * [WunderGraph Cosmo](https://github.com/wundergraph/cosmo) - GraphQL Federeration Router uses Expr to customize Middleware behaviour * [SOLO](https://solo.one) uses Expr interally to allow dynamic code execution with custom defined functions. +* [Naoma.AI](https://www.naoma.ai) uses Expr as a part of its call scoring engine. [Add your company too](https://github.com/expr-lang/expr/edit/master/README.md) From 7dbd40912d18b1513abb25fab73d2f955115e3d2 Mon Sep 17 00:00:00 2001 From: Diego Augusto Molina Date: Sun, 21 Sep 2025 15:42:57 -0300 Subject: [PATCH 112/113] Issue 840: Fix get field pointer struct (#843) * improve issue test * fix #840: pointer to struct env not returning fields --- checker/nature/nature.go | 11 +++++++++-- test/issues/840/issue_test.go | 15 ++++++++++----- 2 files changed, 19 insertions(+), 7 deletions(-) diff --git a/checker/nature/nature.go b/checker/nature/nature.go index 483030aa1..ae406acbf 100644 --- a/checker/nature/nature.go +++ b/checker/nature/nature.go @@ -404,8 +404,15 @@ func (n *Nature) getSlow(c *Cache, name string) (Nature, bool) { if nt, ok := n.MethodByName(c, name); ok { return nt, true } - if n.Kind == reflect.Struct { - if sf := n.structField(c, nil, name); sf != nil { + t, k, changed := deref.TypeKind(n.Type, n.Kind) + if k == reflect.Struct { + var sd *structData + if changed { + sd = c.getStruct(t).structData + } else { + sd = n.structData + } + if sf := sd.structField(c, nil, name); sf != nil { return sf.Nature, true } } diff --git a/test/issues/840/issue_test.go b/test/issues/840/issue_test.go index 1c0d3c95b..abc00c3ad 100644 --- a/test/issues/840/issue_test.go +++ b/test/issues/840/issue_test.go @@ -8,23 +8,28 @@ import ( ) func TestEnvFieldMethods(t *testing.T) { - program, err := expr.Compile(`Func(0)`, expr.Env(&Env{})) + program, err := expr.Compile(`Func() + Int`, expr.Env(&Env{})) require.NoError(t, err) env := &Env{} env.Func = func() int { - return 42 + return 40 + } + env.EmbeddedEnv = &EmbeddedEnv{ + Int: 2, } - out, err := expr.Run(program, Env{}) + out, err := expr.Run(program, env) require.NoError(t, err) require.Equal(t, 42, out) } type Env struct { - EmbeddedEnv + *EmbeddedEnv Func func() int } -type EmbeddedEnv struct{} +type EmbeddedEnv struct { + Int int +} From 3d0aec62ca6cbfb94989fa3857385c8d26c922b9 Mon Sep 17 00:00:00 2001 From: Diego Augusto Molina Date: Sun, 21 Sep 2025 15:58:24 -0300 Subject: [PATCH 113/113] Fix #844 alternative 2: do not allow access to unexported struct fields (#846) * add regression test * fix #844: disallow direct access to unexported struct fields --------- Co-authored-by: Anton Medvedev --- checker/checker_test.go | 4 +- checker/nature/utils.go | 5 +- test/issues/844/issue_test.go | 194 ++++++++++++++++++++++++++++++++++ 3 files changed, 199 insertions(+), 4 deletions(-) create mode 100644 test/issues/844/issue_test.go diff --git a/checker/checker_test.go b/checker/checker_test.go index bf2b812db..ec701534b 100644 --- a/checker/checker_test.go +++ b/checker/checker_test.go @@ -760,8 +760,8 @@ func TestCheck_TaggedFieldName(t *testing.T) { config := conf.CreateNew() expr.Env(struct { - x struct { - y bool `expr:"bar"` + X struct { + Y bool `expr:"bar"` } `expr:"foo"` }{})(config) expr.AsBool()(config) diff --git a/checker/nature/utils.go b/checker/nature/utils.go index 755c2e08b..2af946002 100644 --- a/checker/nature/utils.go +++ b/checker/nature/utils.go @@ -52,12 +52,13 @@ func (s *structData) structField(c *Cache, parentEmbed *structData, name string) // Lookup own fields first. for ; s.ownIdx < s.numField; s.ownIdx++ { field := s.rType.Field(s.ownIdx) - // BUG: we should skip if !field.IsExported() here - if field.Anonymous && s.anonIdx < 0 { // start iterating anon fields on the first instead of zero s.anonIdx = s.ownIdx } + if !field.IsExported() { + continue + } fName, ok := fieldName(field.Name, field.Tag) if !ok || fName == "" { // name can still be empty for a type created at runtime with diff --git a/test/issues/844/issue_test.go b/test/issues/844/issue_test.go new file mode 100644 index 000000000..2993ec82f --- /dev/null +++ b/test/issues/844/issue_test.go @@ -0,0 +1,194 @@ +package main + +import ( + "strings" + "testing" + + "github.com/expr-lang/expr" + "github.com/expr-lang/expr/checker" + "github.com/expr-lang/expr/conf" + "github.com/expr-lang/expr/internal/testify/require" + "github.com/expr-lang/expr/parser" +) + +func TestIssue844(t *testing.T) { + testCases := []struct { + name string + env any + expression string + shouldFail bool + }{ + { + name: "exported env, exported field", + env: ExportedEnv{}, + expression: `ExportedEmbedded`, + shouldFail: false, + }, + { + name: "exported env, unexported field", + env: ExportedEnv{}, + expression: `unexportedEmbedded`, + shouldFail: true, + }, + { + name: "exported env, exported field inherited from exported field", + env: ExportedEnv{}, + expression: `Str`, + shouldFail: false, + }, + { + name: "exported env, unexported field inherited from exported field", + env: ExportedEnv{}, + expression: `str`, + shouldFail: true, + }, + { + name: "exported env, exported field inherited from exported field", + env: ExportedEnv{}, + expression: `Integer`, + shouldFail: false, + }, + { + name: "exported env, unexported field inherited from exported field", + env: ExportedEnv{}, + expression: `integer`, + shouldFail: true, + }, + { + name: "exported env, exported field directly accessed from exported field", + env: ExportedEnv{}, + expression: `ExportedEmbedded.Str`, + shouldFail: false, + }, + { + name: "exported env, unexported field directly accessed from exported field", + env: ExportedEnv{}, + expression: `ExportedEmbedded.str`, + shouldFail: true, + }, + { + name: "exported env, exported field directly accessed from exported field", + env: ExportedEnv{}, + expression: `unexportedEmbedded.Integer`, + shouldFail: true, + }, + { + name: "exported env, unexported field directly accessed from exported field", + env: ExportedEnv{}, + expression: `unexportedEmbedded.integer`, + shouldFail: true, + }, + { + name: "unexported env, exported field", + env: unexportedEnv{}, + expression: `ExportedEmbedded`, + shouldFail: false, + }, + { + name: "unexported env, unexported field", + env: unexportedEnv{}, + expression: `unexportedEmbedded`, + shouldFail: true, + }, + { + name: "unexported env, exported field inherited from exported field", + env: unexportedEnv{}, + expression: `Str`, + shouldFail: false, + }, + { + name: "unexported env, unexported field inherited from exported field", + env: unexportedEnv{}, + expression: `str`, + shouldFail: true, + }, + { + name: "unexported env, exported field inherited from exported field", + env: unexportedEnv{}, + expression: `Integer`, + shouldFail: false, + }, + { + name: "unexported env, unexported field inherited from exported field", + env: unexportedEnv{}, + expression: `integer`, + shouldFail: true, + }, + { + name: "unexported env, exported field directly accessed from exported field", + env: unexportedEnv{}, + expression: `ExportedEmbedded.Str`, + shouldFail: false, + }, + { + name: "unexported env, unexported field directly accessed from exported field", + env: unexportedEnv{}, + expression: `ExportedEmbedded.str`, + shouldFail: true, + }, + { + name: "unexported env, exported field directly accessed from exported field", + env: unexportedEnv{}, + expression: `unexportedEmbedded.Integer`, + shouldFail: true, + }, + { + name: "unexported env, unexported field directly accessed from exported field", + env: unexportedEnv{}, + expression: `unexportedEmbedded.integer`, + shouldFail: true, + }, + } + + for _, tc := range testCases { + t.Run(tc.name, func(t *testing.T) { + config := conf.New(tc.env) + tree, err := parser.ParseWithConfig(tc.expression, config) + require.NoError(t, err) + + _, err = new(checker.Checker).PatchAndCheck(tree, config) + if tc.shouldFail { + require.Error(t, err) + errStr := err.Error() + if !strings.Contains(errStr, "unknown name") && + !strings.Contains(errStr, " has no field ") { + t.Fatalf("expected a different error, got: %v", err) + } + } else { + require.NoError(t, err) + } + + // We add this because the issue was actually not catching something + // that sometimes failed with the error: + // reflect.Value.Interface: cannot return value obtained from unexported field or method + // This way, we test that everything we allow passing is also + // allowed later + _, err = expr.Eval(tc.expression, tc.env) + if tc.shouldFail { + require.Error(t, err) + } else { + require.NoError(t, err) + } + }) + } +} + +type ExportedEnv struct { + ExportedEmbedded + unexportedEmbedded +} + +type unexportedEnv struct { + ExportedEmbedded + unexportedEmbedded +} + +type ExportedEmbedded struct { + Str string + str string +} + +type unexportedEmbedded struct { + Integer int + integer int +}