diff --git a/.gitattributes b/.gitattributes new file mode 100644 index 000000000..efd30300a --- /dev/null +++ b/.gitattributes @@ -0,0 +1 @@ +*\[generated\].go linguist-language=txt diff --git a/.github/scripts/coverage.mjs b/.github/scripts/coverage.mjs index 330d8d873..3bc381313 100755 --- a/.github/scripts/coverage.mjs +++ b/.github/scripts/coverage.mjs @@ -1,11 +1,16 @@ -#!/usr/bin/env zx --experimental +#!/usr/bin/env zx const expected = 90 const exclude = [ - 'expr/test', - 'checker/mock', - 'vm/func_types', - 'vm/runtime/helpers', + '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, '..', '..')) @@ -24,9 +29,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/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/check.yml b/.github/workflows/check.yml index 63037cd61..fb4b102ec 100644 --- a/.github/workflows/check.yml +++ b/.github/workflows/check.yml @@ -16,4 +16,4 @@ jobs: with: go-version: 1.18 - name: Test - run: npx zx --experimental .github/scripts/coverage.mjs + run: npx zx .github/scripts/coverage.mjs 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 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/README.md b/README.md index 5a587162c..a7ded479c 100644 --- a/README.md +++ b/README.md @@ -149,8 +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. +* [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. @@ -162,8 +163,16 @@ 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 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 +* [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) 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 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) +} diff --git a/ast/node.go b/ast/node.go index 03e8cf622..40c507aa6 100644 --- a/ast/node.go +++ b/ast/node.go @@ -3,13 +3,20 @@ 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) Type() reflect.Type SetType(reflect.Type) String() string @@ -25,8 +32,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 +46,27 @@ 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 +} + // 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 = nature.FromType(t) } // NilNode represents nil. @@ -163,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. } @@ -196,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 6a7d698a9..e4e45f0fa 100644 --- a/ast/print.go +++ b/ast/print.go @@ -45,13 +45,21 @@ 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 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 { return fmt.Sprintf("%s(%s)", op, n.Node.String()) } return fmt.Sprintf("%s%s", op, n.Node.String()) @@ -65,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 } @@ -80,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 } @@ -162,7 +186,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() } @@ -174,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/print_test.go b/ast/print_test.go index 51edd63f5..d0859606f 100644 --- a/ast/print_test.go +++ b/ast/print_test.go @@ -77,6 +77,13 @@ 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)`}, + {`(-(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`}, + {`if true { 1 } else { 2 }`, `true ? 1 : 2`}, } for _, tt := range tests { diff --git a/ast/visitor.go b/ast/visitor.go index 90bc9f1d0..72cd6366b 100644 --- a/ast/visitor.go +++ b/ast/visitor.go @@ -45,12 +45,16 @@ 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: 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/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.go b/builtin/builtin.go index cc6f197cd..c23daf468 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", @@ -627,14 +636,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", @@ -650,10 +652,13 @@ var Builtins = []*Function{ 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 { @@ -798,14 +803,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]) 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 +820,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) { @@ -830,6 +835,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(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) { @@ -841,7 +897,7 @@ var Builtins = []*Function{ var arr []any for _, arg := range args { - v := reflect.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()) @@ -863,7 +919,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) @@ -873,6 +929,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(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(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 b99ed42ce..6ca1e8fdd 100644 --- a/builtin/builtin_test.go +++ b/builtin/builtin_test.go @@ -152,6 +152,11 @@ 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}}, + {`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 { @@ -235,13 +240,21 @@ 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)"}, + {`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) { - _, 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) + } }) } } @@ -631,3 +644,81 @@ func Test_int_unwraps_underlying_value(t *testing.T) { require.NoError(t, err) assert.Equal(t, true, out) } + +func TestBuiltin_with_deref(t *testing.T) { + x := 42 + arr := []int{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, + "arrStr": &arrStr, + "m": &m, + "json": &jsonString, + "str": &str, + } + + tests := []struct { + 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)`, []int{1}}, + {`take(arr, x)`, []int{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}}, + {`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"}}, + {`join(arrStr, ",")`, "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) + 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/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/builtin/lib.go b/builtin/lib.go index e3cd61b96..6f6a3b6cd 100644 --- a/builtin/lib.go +++ b/builtin/lib.go @@ -5,15 +5,19 @@ import ( "math" "reflect" "strconv" + "unicode/utf8" "github.com/expr-lang/expr/internal/deref" + "github.com/expr-lang/expr/vm/runtime" ) 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)) } @@ -24,15 +28,6 @@ func Type(arg any) any { 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 - } - } if v.Type().Name() != "" && v.Type().PkgPath() != "" { return fmt.Sprintf("%s.%s", v.Type().PkgPath(), v.Type().Name()) } @@ -261,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 := reflect.ValueOf(deref.Deref(arg)) + rv := reflect.ValueOf(arg) switch rv.Kind() { case reflect.Array, reflect.Slice: size := rv.Len() @@ -304,7 +299,7 @@ func mean(args ...any) (int, float64, error) { var count int for _, arg := range args { - rv := reflect.ValueOf(deref.Deref(arg)) + rv := reflect.ValueOf(arg) switch rv.Kind() { case reflect.Array, reflect.Slice: size := rv.Len() @@ -336,7 +331,7 @@ func median(args ...any) ([]float64, error) { var values []float64 for _, arg := range args { - rv := reflect.ValueOf(deref.Deref(arg)) + rv := reflect.ValueOf(arg) switch rv.Kind() { case reflect.Array, reflect.Slice: size := rv.Len() @@ -359,3 +354,88 @@ 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 +} + +func get(params ...any) (out any, err error) { + from := params[0] + 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)) + } + + // 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 + } + } + } + + 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) + switch field.Tag.Get("expr") { + case "-": + return false + case fieldName: + return true + default: + 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/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/checker/checker.go b/checker/checker.go index a2c86c208..531dadac3 100644 --- a/checker/checker.go +++ b/checker/checker.go @@ -4,15 +4,30 @@ import ( "fmt" "reflect" "regexp" + "time" "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" ) +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) { @@ -21,28 +36,7 @@ func ParseCheck(input string, config *conf.Config) (*parser.Tree, error) { return tree, err } - 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 - } - } - } - _, err = Check(tree, config) + _, err = new(Checker).PatchAndCheck(tree, config) if err != nil { return tree, err } @@ -50,16 +44,91 @@ func ParseCheck(input string, config *conf.Config) (*parser.Tree, error) { 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 Check(tree *parser.Tree, config *conf.Config) (t reflect.Type, err error) { - if config == nil { - config = conf.New(nil) +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 (v *Checker) runVisitors(tree *parser.Tree, runRepeatable bool) { + for { + more := false + for _, visitor := range v.config.Visitors { + // We need to perform types check, because some visitors may rely on + // types information available in the tree. + _, _ = v.Check(tree, v.config) + + r, repeatable := visitor.(interface { + Reset() + ShouldRepeat() bool + }) + + if repeatable { + if runRepeatable { + r.Reset() + ast.Walk(&tree.Node, visitor) + more = more || r.ShouldRepeat() + } + } else { + if !runRepeatable { + ast.Walk(&tree.Node, visitor) + } + } + } + + if !more { + break + } } +} - v := &checker{config: config} +func (v *Checker) check(tree *parser.Tree) (reflect.Type, error) { + nt := v.visit(tree.Node) - t, _ = 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,337 +136,323 @@ 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 nt.IsUnknown(&v.config.NtCache) { 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 !nt.IsNumber() { + return nil, fmt.Errorf("expected %v, but got %s", v.config.Expect, nt.String()) } 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.String()) } - return nil, fmt.Errorf("expected %v, but got %v", v.config.Expect, t) } } return t, nil } -type checker struct { - config *conf.Config - predicateScopes []predicateScope - varScopes []varScope - err *file.Error -} - -type predicateScope struct { - vtype reflect.Type - vars map[string]reflect.Type -} +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 - vtype reflect.Type - info info + 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) (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.config.NtCache.NatureOf(nil) case *ast.IdentifierNode: - t, i = v.IdentifierNode(n) + nt = v.identifierNode(n) case *ast.IntegerNode: - t, i = v.IntegerNode(n) + nt = v.config.NtCache.FromType(intType) case *ast.FloatNode: - t, i = v.FloatNode(n) + nt = v.config.NtCache.FromType(floatType) case *ast.BoolNode: - t, i = v.BoolNode(n) + nt = v.config.NtCache.FromType(boolType) case *ast.StringNode: - t, i = v.StringNode(n) + nt = v.config.NtCache.FromType(stringType) case *ast.ConstantNode: - t, i = v.ConstantNode(n) + nt = v.config.NtCache.FromType(reflect.TypeOf(n.Value)) 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) - case *ast.ClosureNode: - t, i = v.ClosureNode(n) + nt = v.builtinNode(n) + case *ast.PredicateNode: + nt = v.predicateNode(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.SequenceNode: + nt = v.sequenceNode(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 Nature{} } -func (v *checker) NilNode(*ast.NilNode) (reflect.Type, info) { - return nilType, info{} -} - -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 { + 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 mapType, info{} + return Nature{} } - return v.ident(node, node.Value, true, true) + + 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) (reflect.Type, info) { - 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} +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 fn.Type(), info{fn: 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 fn.Type(), info{fn: 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) } - if v.config.DefaultType != nil { - return v.config.DefaultType, info{} - } - return anyType, info{} -} - -func (v *checker) IntegerNode(*ast.IntegerNode) (reflect.Type, info) { - return integerType, info{} + return Nature{} } -func (v *checker) FloatNode(*ast.FloatNode) (reflect.Type, info) { - return floatType, info{} -} - -func (v *checker) BoolNode(*ast.BoolNode) (reflect.Type, info) { - return boolType, info{} -} - -func (v *checker) StringNode(*ast.StringNode) (reflect.Type, info) { - return stringType, info{} -} - -func (v *checker) ConstantNode(node *ast.ConstantNode) (reflect.Type, info) { - return reflect.TypeOf(node.Value), info{} -} - -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(&v.config.NtCache) switch node.Operator { case "!", "not": - if isBool(t) { - return boolType, info{} + if nt.IsBool() { + return v.config.NtCache.FromType(boolType) } - if isAny(t) { - return boolType, info{} + if nt.IsUnknown(&v.config.NtCache) { + return v.config.NtCache.FromType(boolType) } case "+", "-": - if isNumber(t) { - return t, info{} + if nt.IsNumber() { + return nt } - if isAny(t) { - return anyType, info{} + 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 %v)`, node.Operator, t) + return v.error(node, `invalid operation: %s (mismatched type %s)`, node.Operator, nt.String()) } -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(&v.config.NtCache) + r = r.Deref(&v.config.NtCache) switch node.Operator { case "==", "!=": - if isComparable(l, r) { - return boolType, info{} + if l.ComparableTo(&v.config.NtCache, r) { + return v.config.NtCache.FromType(boolType) } case "or", "||", "and", "&&": - if isBool(l) && isBool(r) { - return boolType, info{} + if l.IsBool() && r.IsBool() { + return v.config.NtCache.FromType(boolType) } - if or(l, r, isBool) { - return boolType, info{} + if l.MaybeCompatible(&v.config.NtCache, r, BoolCheck) { + return v.config.NtCache.FromType(boolType) } case "<", ">", ">=", "<=": - if isNumber(l) && isNumber(r) { - return boolType, info{} + if l.IsNumber() && r.IsNumber() { + return v.config.NtCache.FromType(boolType) } - if isString(l) && isString(r) { - return boolType, info{} + if l.IsString() && r.IsString() { + return v.config.NtCache.FromType(boolType) } - if isTime(l) && isTime(r) { - return boolType, info{} + if l.IsTime() && r.IsTime() { + return v.config.NtCache.FromType(boolType) } - if or(l, r, isNumber, isString, isTime) { - return boolType, info{} + if l.IsDuration() && r.IsDuration() { + return v.config.NtCache.FromType(boolType) + } + 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), info{} + if l.IsNumber() && r.IsNumber() { + return l.PromoteNumericNature(&v.config.NtCache, r) + } + if l.IsTime() && r.IsTime() { + return v.config.NtCache.FromType(durationType) } - if isTime(l) && isTime(r) { - return durationType, info{} + if l.IsTime() && r.IsDuration() { + return v.config.NtCache.FromType(timeType) } - if isTime(l) && isDuration(r) { - return timeType, info{} + if l.IsDuration() && r.IsDuration() { + return v.config.NtCache.FromType(durationType) } - if or(l, r, isNumber, isTime) { - return anyType, info{} + if l.MaybeCompatible(&v.config.NtCache, r, NumberCheck, TimeCheck, DurationCheck) { + return Nature{} } case "*": - if isNumber(l) && isNumber(r) { - return combined(l, r), info{} + if l.IsNumber() && r.IsNumber() { + return l.PromoteNumericNature(&v.config.NtCache, r) } - if or(l, r, isNumber) { - return anyType, info{} + if l.IsNumber() && r.IsDuration() { + return v.config.NtCache.FromType(durationType) + } + if l.IsDuration() && r.IsNumber() { + return v.config.NtCache.FromType(durationType) + } + if l.IsDuration() && r.IsDuration() { + return v.config.NtCache.FromType(durationType) + } + if l.MaybeCompatible(&v.config.NtCache, r, NumberCheck, DurationCheck) { + return Nature{} } case "/": - if isNumber(l) && isNumber(r) { - return floatType, info{} + if l.IsNumber() && r.IsNumber() { + return v.config.NtCache.FromType(floatType) } - if or(l, r, isNumber) { - return floatType, info{} + if l.MaybeCompatible(&v.config.NtCache, r, NumberCheck) { + return v.config.NtCache.FromType(floatType) } case "**", "^": - if isNumber(l) && isNumber(r) { - return floatType, info{} + if l.IsNumber() && r.IsNumber() { + return v.config.NtCache.FromType(floatType) } - if or(l, r, isNumber) { - return floatType, info{} + if l.MaybeCompatible(&v.config.NtCache, r, NumberCheck) { + return v.config.NtCache.FromType(floatType) } case "%": - if isInteger(l) && isInteger(r) { - return combined(l, r), info{} + if l.IsInteger && r.IsInteger { + return v.config.NtCache.FromType(intType) } - if or(l, r, isInteger) { - return anyType, info{} + if l.MaybeCompatible(&v.config.NtCache, r, IntegerCheck) { + return v.config.NtCache.FromType(intType) } case "+": - if isNumber(l) && isNumber(r) { - return combined(l, r), info{} + if l.IsNumber() && r.IsNumber() { + return l.PromoteNumericNature(&v.config.NtCache, r) + } + if l.IsString() && r.IsString() { + return v.config.NtCache.FromType(stringType) } - if isString(l) && isString(r) { - return stringType, info{} + if l.IsTime() && r.IsDuration() { + return v.config.NtCache.FromType(timeType) } - if isTime(l) && isDuration(r) { - return timeType, info{} + if l.IsDuration() && r.IsTime() { + return v.config.NtCache.FromType(timeType) } - if isDuration(l) && isTime(r) { - return timeType, info{} + if l.IsDuration() && r.IsDuration() { + return v.config.NtCache.FromType(durationType) } - if or(l, r, isNumber, isString, isTime, isDuration) { - return anyType, info{} + if l.MaybeCompatible(&v.config.NtCache, r, NumberCheck, StringCheck, TimeCheck, DurationCheck) { + return Nature{} } case "in": - if (isString(l) || isAny(l)) && isStruct(r) { - return boolType, info{} + if (l.IsString() || l.IsUnknown(&v.config.NtCache)) && r.IsStruct() { + return v.config.NtCache.FromType(boolType) } - if isMap(r) { - if l == nil { // It is possible to compare with nil. - return boolType, info{} + 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()) } - if !isAny(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 v.config.NtCache.FromType(boolType) } - 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 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()) } - if !isComparable(l, ri.elem) { - return v.error(node, "cannot use %v as type %v in array", l, ri.elem) - } - return boolType, info{} + return v.config.NtCache.FromType(boolType) } - if isAny(l) && anyOf(r, isString, isArray, isMap) { - return boolType, info{} + if l.IsUnknown(&v.config.NtCache) && r.IsAnyOf(StringCheck, ArrayCheck, MapCheck) { + return v.config.NtCache.FromType(boolType) } - if isAny(r) { - return boolType, info{} + if r.IsUnknown(&v.config.NtCache) { + return v.config.NtCache.FromType(boolType) } case "matches": @@ -407,58 +462,54 @@ func (v *checker) BinaryNode(node *ast.BinaryNode) (reflect.Type, info) { return v.error(node, err.Error()) } } - if isString(l) && isString(r) { - return boolType, info{} + if l.IsString() && r.IsString() { + return v.config.NtCache.FromType(boolType) } - if or(l, r, isString) { - return boolType, info{} + if l.MaybeCompatible(&v.config.NtCache, r, StringCheck) { + return v.config.NtCache.FromType(boolType) } case "contains", "startsWith", "endsWith": - if isString(l) && isString(r) { - return boolType, info{} + if l.IsString() && r.IsString() { + return v.config.NtCache.FromType(boolType) } - if or(l, r, isString) { - return boolType, info{} + if l.MaybeCompatible(&v.config.NtCache, r, StringCheck) { + return v.config.NtCache.FromType(boolType) } case "..": - ret := reflect.SliceOf(integerType) - if isInteger(l) && isInteger(r) { - return ret, info{} - } - if or(l, r, isInteger) { - return ret, info{} + if l.IsInteger && r.IsInteger || l.MaybeCompatible(&v.config.NtCache, r, IntegerCheck) { + return ArrayFromType(&v.config.NtCache, intType) } case "??": - if l == nil && r != nil { - return r, info{} + if l.Nil && !r.Nil { + return r } - if l != nil && r == nil { - return l, info{} + if !l.Nil && r.Nil { + return l } - if l == nil && r == nil { - return nilType, info{} + if l.Nil && r.Nil { + return v.config.NtCache.NatureOf(nil) } if r.AssignableTo(l) { - return l, info{} + return l } - return anyType, info{} + 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) (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,100 +523,106 @@ 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 Nature{} } - base, _ := v.visit(node.Node) - prop, _ := v.visit(node.Property) + base := v.visit(node.Node) + prop := v.visit(node.Property) + + if base.IsUnknown(&v.config.NtCache) { + return Nature{} + } 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 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 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} - } + if m, ok := base.MethodByName(&v.config.NtCache, name.Value); ok { + return m } } - if kind(base) == reflect.Ptr { - base = base.Elem() - } - - switch kind(base) { - case reflect.Interface: - return anyType, info{} + base = base.Deref(&v.config.NtCache) + switch base.Kind { case reflect.Map: - if prop != nil && !prop.AssignableTo(base.Key()) && !isAny(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 && base.TypeData != nil { + if field, ok := base.Fields[prop.Value]; ok { + return field + } else if base.Strict { + return v.error(node.Property, "unknown field %s", prop.Value) + } } - return base.Elem(), info{} + return base.Elem(&v.config.NtCache) case reflect.Array, reflect.Slice: - if !isInteger(prop) && !isAny(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(), info{} + return base.Elem(&v.config.NtCache) 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{} + 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) } } - return v.error(node, "type %v[%v] is undefined", base, prop) + // Not found. + + if name, ok := node.Property.(*ast.StringNode); ok { + if node.Method { + 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.String(), name.Value) + } + return v.error(node, "type %v[%v] is undefined", base.String(), prop.String()) } -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 nt.IsUnknown(&v.config.NtCache) { + return Nature{} + } + + 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.String()) } if node.From != nil { - from, _ := v.visit(node.From) - if !isInteger(from) && !isAny(from) { - return v.error(node.From, "non-integer slice index %v", from) + from := v.visit(node.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) && !isAny(to) { - return v.error(node.To, "non-integer slice index %v", to) + to := v.visit(node.To) + if !to.IsInteger && !to.IsUnknown(&v.config.NtCache) { + return v.error(node.To, "non-integer slice index %v", to.String()) } } - return t, info{} -} -func (v *checker) CallNode(node *ast.CallNode) (reflect.Type, info) { - t, i := v.functionReturnType(node) + return nt +} +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. // @@ -577,18 +634,18 @@ func (v *checker) CallNode(node *ast.CallNode) (reflect.Type, info) { // 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.Type(), i + if typ := node.Type(); typ != nil && typ != anyType { + nt := node.Nature() + return nt } - return t, i -} - -func (v *checker) functionReturnType(node *ast.CallNode) (reflect.Type, info) { - fn, fnInfo := v.visit(node.Callee) + nt := v.visit(node.Callee) + if nt.IsUnknown(&v.config.NtCache) { + return Nature{} + } - if fnInfo.fn != nil { - return v.checkFunction(fnInfo.fn, node, node.Arguments) + if nt.TypeData != nil && nt.TypeData.Func != nil { + return v.checkFunction(nt.TypeData.Func, node, node.Arguments) } fnName := "function" @@ -601,240 +658,257 @@ func (v *checker) functionReturnType(node *ast.CallNode) (reflect.Type, info) { } } - if fn == nil { + if nt.Nil { return v.error(node, "%v is nil; cannot call nil as function", fnName) } - switch fn.Kind() { - case reflect.Interface: - return anyType, info{} - case reflect.Func: - outType, err := v.checkArguments(fnName, fn, fnInfo.method, node.Arguments, node) + 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 anyType, info{} + return Nature{} } - return outType, info{} + return outType } - return v.error(node, "%v is not callable", fn) + return v.error(node, "%s is not callable", nt.String()) } -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) { - 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) - closure, _ := v.visit(node.Arguments[1]) + predicate := v.visit(node.Arguments[1]) v.end() - if isFunc(closure) && - closure.NumOut() == 1 && - closure.NumIn() == 1 && isAny(closure.In(0)) { + if predicate.IsFunc() && + predicate.NumOut() == 1 && + predicate.NumIn() == 1 && predicate.IsFirstArgUnknown(&v.config.NtCache) { - if !isBool(closure.Out(0)) && !isAny(closure.Out(0)) { - return v.error(node.Arguments[1], "predicate should return boolean (got %v)", closure.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 boolType, info{} + 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]) - if !isArray(collection) && !isAny(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) - closure, _ := v.visit(node.Arguments[1]) + predicate := v.visit(node.Arguments[1]) v.end() - if isFunc(closure) && - closure.NumOut() == 1 && - closure.NumIn() == 1 && isAny(closure.In(0)) { + if predicate.IsFunc() && + predicate.NumOut() == 1 && + predicate.NumIn() == 1 && predicate.IsFirstArgUnknown(&v.config.NtCache) { - if !isBool(closure.Out(0)) && !isAny(closure.Out(0)) { - return v.error(node.Arguments[1], "predicate should return boolean (got %v)", closure.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 isAny(collection) { - return arrayType, info{} + if collection.IsUnknown(&v.config.NtCache) { + return v.config.NtCache.FromType(arrayType) } - return arrayType, info{} + 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]) - if !isArray(collection) && !isAny(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", integerType}) - closure, _ := v.visit(node.Arguments[1]) + v.begin(collection, varScope{"index", v.config.NtCache.FromType(intType)}) + predicate := v.visit(node.Arguments[1]) v.end() - if isFunc(closure) && - closure.NumOut() == 1 && - closure.NumIn() == 1 && isAny(closure.In(0)) { + if predicate.IsFunc() && + predicate.NumOut() == 1 && + predicate.NumIn() == 1 && predicate.IsFirstArgUnknown(&v.config.NtCache) { - return arrayType, info{} + 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]) - if !isArray(collection) && !isAny(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 integerType, info{} + return v.config.NtCache.FromType(intType) } 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 && isAny(closure.In(0)) { - if !isBool(closure.Out(0)) && !isAny(closure.Out(0)) { - return v.error(node.Arguments[1], "predicate should return boolean (got %v)", closure.Out(0).String()) + if predicate.IsFunc() && + predicate.NumOut() == 1 && + 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 integerType, info{} + 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]) - if !isArray(collection) && !isAny(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 { 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 && isAny(closure.In(0)) { - return closure.Out(0), info{} + if predicate.IsFunc() && + predicate.NumOut() == 1 && + predicate.NumIn() == 1 && predicate.IsFirstArgUnknown(&v.config.NtCache) { + return predicate.Out(&v.config.NtCache, 0) } } else { - if isAny(collection) { - return anyType, info{} + if collection.IsUnknown(&v.config.NtCache) { + return Nature{} } - return collection.Elem(), info{} + return collection.Elem(&v.config.NtCache) } case "find", "findLast": - collection, _ := v.visit(node.Arguments[0]) - if !isArray(collection) && !isAny(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) - closure, _ := v.visit(node.Arguments[1]) + predicate := v.visit(node.Arguments[1]) v.end() - if isFunc(closure) && - closure.NumOut() == 1 && - closure.NumIn() == 1 && isAny(closure.In(0)) { + if predicate.IsFunc() && + predicate.NumOut() == 1 && + predicate.NumIn() == 1 && predicate.IsFirstArgUnknown(&v.config.NtCache) { - if !isBool(closure.Out(0)) && !isAny(closure.Out(0)) { - return v.error(node.Arguments[1], "predicate should return boolean (got %v)", closure.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 isAny(collection) { - return anyType, info{} + if collection.IsUnknown(&v.config.NtCache) { + return Nature{} } - return collection.Elem(), info{} + 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]) - if !isArray(collection) && !isAny(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) - closure, _ := v.visit(node.Arguments[1]) + predicate := v.visit(node.Arguments[1]) v.end() - if isFunc(closure) && - closure.NumOut() == 1 && - closure.NumIn() == 1 && isAny(closure.In(0)) { + if predicate.IsFunc() && + predicate.NumOut() == 1 && + predicate.NumIn() == 1 && predicate.IsFirstArgUnknown(&v.config.NtCache) { - if !isBool(closure.Out(0)) && !isAny(closure.Out(0)) { - return v.error(node.Arguments[1], "predicate should return boolean (got %v)", closure.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 integerType, info{} + 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]) - if !isArray(collection) && !isAny(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) - closure, _ := v.visit(node.Arguments[1]) + predicate := v.visit(node.Arguments[1]) v.end() - if isFunc(closure) && - closure.NumOut() == 1 && - closure.NumIn() == 1 && isAny(closure.In(0)) { + if predicate.IsFunc() && + predicate.NumOut() == 1 && + predicate.NumIn() == 1 && predicate.IsFirstArgUnknown(&v.config.NtCache) { - return reflect.TypeOf(map[any][]any{}), info{} + 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]) - if !isArray(collection) && !isAny(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) - closure, _ := v.visit(node.Arguments[1]) + predicate := 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)) { + if predicate.IsFunc() && + predicate.NumOut() == 1 && + predicate.NumIn() == 1 && predicate.IsFirstArgUnknown(&v.config.NtCache) { - return reflect.TypeOf([]any{}), info{} + 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]) - if !isArray(collection) && !isAny(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", integerType}, scopeVar{"acc", anyType}) - closure, _ := v.visit(node.Arguments[1]) + v.begin(collection, varScope{"index", v.config.NtCache.FromType(intType)}, varScope{"acc", Nature{}}) + predicate := 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{} + if predicate.IsFunc() && predicate.NumOut() == 1 { + return *predicate.Ref } return v.error(node.Arguments[1], "predicate should has two input and one output param") @@ -851,124 +925,126 @@ func (v *checker) BuiltinNode(node *ast.BuiltinNode) (reflect.Type, info) { return v.error(node, "unknown builtin %v", node.Name) } -type scopeVar struct { - name string - vtype reflect.Type +func (v *Checker) begin(collectionNature Nature, vars ...varScope) { + v.predicateScopes = append(v.predicateScopes, predicateScope{ + collection: collectionNature, + vars: vars, + }) } -func (v *checker) begin(vtype reflect.Type, vars ...scopeVar) { - scope := predicateScope{vtype: vtype, vars: make(map[string]reflect.Type)} - for _, v := range vars { - scope.vars[v.name] = v.vtype - } - v.predicateScopes = append(v.predicateScopes, scope) -} - -func (v *checker) end() { +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 { + if nt, ok := v.config.Env.Get(&v.config.NtCache, s.Value); ok { + return nt + } } - return anyType, info{} + return Nature{} } - t, _ := v.visit(val) + if base.IsUnknown(&v.config.NtCache) { + return Nature{} + } - 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(p) && !isAny(p) { - return v.error(prop, "non-integer slice index %v", p) + if !prop.IsInteger && !prop.IsUnknown(&v.config.NtCache) { + return v.error(node.Arguments[1], "non-integer slice index %s", prop.String()) } - return t.Elem(), info{} + return base.Elem(&v.config.NtCache) case reflect.Map: - p, _ := v.visit(prop) - if p == nil { - return v.error(prop, "cannot use nil as map index") + 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()) } - if !p.AssignableTo(t.Key()) && !isAny(p) { - return v.error(prop, "cannot use %v to get an element from %v", p, t) - } - return t.Elem(), info{} + return base.Elem(&v.config.NtCache) } - return v.error(val, "type %v does not support indexing", t) + 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) (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 argNature.IsUnknown(&v.config.NtCache) { + 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 v.config.NtCache.FromType(t) } else if len(f.Types) == 0 { - t, err := v.checkArguments(f.Name, f.Type(), false, 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 anyType, info{} + return Nature{} } // 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, v.config.NtCache.FromType(t), arguments, node) if err != nil { lastErr = err continue } - return outType, info{} + + // 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 { if v.err == nil { v.err = lastErr } - return anyType, info{} + return Nature{} } return v.error(node, "no matching overload for %v", f.Name) } -func (v *checker) checkArguments( +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 fn.IsUnknown(&v.config.NtCache) { + return Nature{}, nil } - if fn.NumOut() == 0 { - return anyType, &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 anyType, &file.Error{ + if numOut > 2 { + return Nature{}, &file.Error{ Location: node.Location(), Message: fmt.Sprintf("func %v returns more then two values", name), } @@ -977,17 +1053,18 @@ 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 } var err *file.Error - if fn.IsVariadic() { + isVariadic := fn.IsVariadic() + if isVariadic { if len(arguments) < fnNumIn-1 { err = &file.Error{ Location: node.Location(), @@ -1013,117 +1090,144 @@ 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 + return fn.Out(&v.config.NtCache, 0), err } for i, arg := range arguments { - t, _ := v.visit(arg) + argNature := v.visit(arg) - var in reflect.Type - if fn.IsVariadic() && i >= fnNumIn-1 { + var in Nature + 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(t) { + if in.IsFloat && argNature.IsInteger { traverseAndReplaceIntegerNodesWithFloatNodes(&arguments[i], in) continue } - if isInteger(in) && isInteger(t) && kind(t) != kind(in) { + if in.IsInteger && argNature.IsInteger && argNature.Kind != in.Kind { traverseAndReplaceIntegerNodesWithIntegerNodes(&arguments[i], in) continue } - if t == nil { - continue + if argNature.Nil { + if in.Kind == reflect.Ptr || in.Kind == reflect.Interface { + continue + } + return Nature{}, &file.Error{ + Location: arg.Location(), + Message: fmt.Sprintf("cannot use nil as argument (type %s) to call %v", in.String(), name), + } } - if !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. + if !assignable && argNature.IsPointer() { + nt := argNature.Deref(&v.config.NtCache) + assignable = nt.AssignableTo(in) + } + + if !assignable && !argNature.IsUnknown(&v.config.NtCache) { + return Nature{}, &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.String(), in.String(), name), } } } - return fn.Out(0), nil + return fn.Out(&v.config.NtCache, 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") - } - return reflect.FuncOf([]reflect.Type{anyType}, []reflect.Type{t}, false), info{} +func (v *Checker) predicateNode(node *ast.PredicateNode) Nature { + nt := v.visit(node.Node) + var out []reflect.Type + if nt.IsUnknown(&v.config.NtCache) { + out = append(out, anyType) + } else if !nt.Nil { + out = append(out, nt.Type) + } + n := v.config.NtCache.FromType(reflect.FuncOf(anyTypeSlice, out, false)) + n.Ref = &nt + return n } -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") + return v.error(node, "cannot use pointer accessor outside predicate") } scope := v.predicateScopes[len(v.predicateScopes)-1] if node.Name == "" { - switch scope.vtype.Kind() { - case reflect.Interface: - return anyType, info{} + if scope.collection.IsUnknown(&v.config.NtCache) { + return Nature{} + } + switch scope.collection.Kind { case reflect.Array, reflect.Slice: - return scope.vtype.Elem(), info{} + 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, info{} + 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) (reflect.Type, info) { - if _, ok := v.config.Types[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 { @@ -1132,78 +1236,80 @@ func (v *checker) VariableDeclaratorNode(node *ast.VariableDeclaratorNode) (refl 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) + } } - 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) { - for i := len(v.varScopes) - 1; i >= 0; i-- { - if v.varScopes[i].name == name { - return v.varScopes[i], true - } +func (v *Checker) sequenceNode(node *ast.SequenceNode) Nature { + if len(node.Nodes) == 0 { + return v.error(node, "empty sequence expression") } - return varScope{}, false + var last Nature + for _, node := range node.Nodes { + last = v.visit(node) + } + return last } -func (v *checker) ConditionalNode(node *ast.ConditionalNode) (reflect.Type, info) { - c, _ := v.visit(node.Cond) - if !isBool(c) && !isAny(c) { - return v.error(node.Cond, "non-bool expression (type %v) used as condition", c) +func (v *Checker) conditionalNode(node *ast.ConditionalNode) Nature { + c := v.visit(node.Cond) + 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) + t1 := v.visit(node.Exp1) + t2 := v.visit(node.Exp2) - if t1 == nil && t2 != nil { - return t2, info{} + if t1.Nil && !t2.Nil { + return t2 } - if t1 != nil && t2 == nil { - return t1, info{} + if !t1.Nil && t2.Nil { + return t1 } - if t1 == nil && t2 == nil { - return nilType, info{} + if t1.Nil && t2.Nil { + return v.config.NtCache.NatureOf(nil) } if t1.AssignableTo(t2) { - return t1, info{} + return t1 } - return anyType, info{} + return Nature{} } -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 prev.MakeArrayOf(&v.config.NtCache) } - return arrayType, info{} + return v.config.NtCache.FromType(arrayType) } -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 v.config.NtCache.FromType(mapType) } -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 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 1509045e3..ec701534b 100644 --- a/checker/checker_test.go +++ b/checker/checker_test.go @@ -1,6 +1,7 @@ package checker_test import ( + "context" "fmt" "reflect" "regexp" @@ -9,6 +10,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" @@ -134,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 @@ -143,433 +146,556 @@ 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) }) } } -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) + | .............................^ +`, + }, + { + `1; 2 + true; 3`, + ` +invalid operation: + (mismatched types int and bool) (1:6) + | 1; 2 + true; 3 + | .....^ +`, + }, + } - tree, err := parser.Parse(input[0]) - assert.NoError(t, err) + 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{})) - if err == nil { - err = fmt.Errorf("") - } + _, err = c.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()) + }) } } @@ -634,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) @@ -644,26 +770,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) @@ -717,7 +823,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) { @@ -735,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)) @@ -742,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) } } @@ -822,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)", @@ -834,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()) }) @@ -844,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()) }) @@ -942,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())) }) @@ -960,17 +1069,91 @@ 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 | .......^"}, } + 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()) }) } } + +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{ + "bar": types.Map{ + "baz": types.String, + types.Extra: types.String, + }, + }, + "arr": types.Array(types.Map{ + "value": types.String, + }), + types.Extra: types.Any, + } + + noerr := "no error" + tests := []struct { + code string + 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)`}, + {`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 = c.Check(tree, config) + 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 112bfab31..1b0e05100 100644 --- a/checker/info.go +++ b/checker/info.go @@ -4,26 +4,23 @@ 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(c *Cache, 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 idx, ok := env.FieldIndex(c, n.Value); ok { + return true, idx, 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(c) + 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 idx, ok := base.FieldIndex(c, prop.Value); ok { + return true, idx, prop.Value } } } @@ -31,11 +28,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(c *Cache, 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(c, n.Value); ok && m.TypeData != nil { + return m.Method, m.MethodIndex, n.Value + } } case *ast.MemberNode: if name, ok := n.Property.(*ast.StringNode); ok { @@ -114,13 +113,12 @@ 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 { 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 new file mode 100644 index 000000000..ae406acbf --- /dev/null +++ b/checker/nature/nature.go @@ -0,0 +1,574 @@ +package nature + +import ( + "fmt" + "reflect" + "time" + + "github.com/expr-lang/expr/builtin" + "github.com/expr-lang/expr/internal/deref" +) + +var ( + 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 { + // 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. + + // callable-only data + Func *builtin.Function // Used to pass function type from callee to CallNode. + MethodIndex int // Index of method in type. + inElem, outZero *Nature + numIn, numOut int + + isVariadic bool + isVariadicSet bool + numInSet bool + numOutSet bool +} + +// 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 +} + +// 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 c.FromType(reflect.TypeOf(i)) +} + +// 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, + } +} + +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 + }, + }, + } + c.structs[t] = nt + return nt +} + +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.String() + } + return "unknown" +} + +func (n *Nature) Deref(c *Cache) Nature { + t, _, changed := deref.TypeKind(n.Type, n.Kind) + if !changed { + return *n + } + return c.FromType(t) +} + +func (n *Nature) Key(c *Cache) Nature { + if n.Kind == reflect.Map { + return c.FromType(n.Type.Key()) + } + return Nature{} +} + +func (n *Nature) Elem(c *Cache) Nature { + switch n.Kind { + case reflect.Ptr: + return c.FromType(n.Type.Elem()) + case reflect.Map: + if n.TypeData != nil && n.DefaultMapValue != nil { + return *n.DefaultMapValue + } + return c.FromType(n.Type.Elem()) + case reflect.Slice, reflect.Array: + if n.Ref != nil { + return *n.Ref + } + return c.FromType(n.Type.Elem()) + } + return Nature{} +} + +func (n *Nature) AssignableTo(nt Nature) bool { + if n.Nil { + 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 || + n.Kind != nt.Kind && nt.Kind != reflect.Interface { + return false + } + return n.Type.AssignableTo(nt.Type) +} + +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 s +} + +func (n *Nature) NumMethods(c *Cache) int { + if s := n.getMethodset(c); s != nil { + return s.numMethod + } + return 0 +} + +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.numInSet { + return n.numIn + } + n.numInSet = true + n.numIn = n.Type.NumIn() + return n.numIn +} + +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 *n.inElem +} + +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 false +} + +func (n *Nature) NumOut() int { + if n.numOutSet { + return n.numOut + } + n.numOutSet = true + n.numOut = n.Type.NumOut() + return n.numOut +} + +func (n *Nature) Out(c *Cache, i int) Nature { + if i != 0 { + return n.out(c, i) + } + if n.outZero != nil { + return *n.outZero + } + nt := n.out(c, 0) + n.outZero = &nt + return nt +} + +func (n *Nature) out(c *Cache, i int) Nature { + if n.Type == nil { + return Nature{} + } + return c.FromType(n.Type.Out(i)) +} + +func (n *Nature) IsVariadic() bool { + if n.isVariadicSet { + return n.isVariadic + } + n.isVariadicSet = true + n.isVariadic = n.Type.IsVariadic() + return n.isVariadic +} + +func (n *Nature) FieldByName(c *Cache, name string) (Nature, bool) { + if n.Kind != reflect.Struct { + return Nature{}, false + } + var sd *structData + if n.TypeData != nil && n.structData != nil { + sd = n.structData + } else { + sd = c.getStruct(n.Type).structData + } + if sf := sd.structField(c, nil, name); sf != nil { + return sf.Nature, true + } + return Nature{}, 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 +} + +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) +} + +func (n *Nature) getSlow(c *Cache, name string) (Nature, bool) { + if nt, ok := n.MethodByName(c, name); ok { + return nt, true + } + 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 + } + } + return Nature{}, false +} + +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.NumMethods(c); i++ { + method := n.Type.Method(i) + 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(c, t) { + if _, ok := table[name]; ok { + continue + } + table[name] = nt + } + + case reflect.Map: + if n.TypeData != nil { + for key, nt := range n.Fields { + if _, ok := table[key]; ok { + continue + } + 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 new file mode 100644 index 000000000..2af946002 --- /dev/null +++ b/checker/nature/utils.go @@ -0,0 +1,233 @@ +package nature + +import ( + "reflect" + + "github.com/expr-lang/expr/internal/deref" +) + +func fieldName(fieldName string, tag reflect.StructTag) (string, bool) { + switch taggedName := tag.Get("expr"); taggedName { + case "-": + return "", false + case "": + return fieldName, true + default: + return taggedName, true + } +} + +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 + } + + // Lookup own fields first. + for ; s.ownIdx < s.numField; s.ownIdx++ { + field := s.rType.Field(s.ownIdx) + 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 + // 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 + } + } + + // 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 nil +} + +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 + } + }() + + // 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 +} + +type methodset struct { + rType reflect.Type + kind reflect.Kind + methods map[string]*method + numMethod, idx int +} + +type method struct { + reflect.Method + nature Nature +} + +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 nil +} diff --git a/checker/types.go b/checker/types.go deleted file mode 100644 index d10736a77..000000000 --- a/checker/types.go +++ /dev/null @@ -1,228 +0,0 @@ -package checker - -import ( - "reflect" - "time" - - "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{}) - anyType = reflect.TypeOf(new(any)).Elem() - timeType = reflect.TypeOf(time.Time{}) - durationType = reflect.TypeOf(time.Duration(0)) -) - -func combined(a, b reflect.Type) reflect.Type { - if a.Kind() == b.Kind() { - return a - } - if isFloat(a) || isFloat(b) { - return floatType - } - return integerType -} - -func anyOf(t reflect.Type, fns ...func(reflect.Type) bool) bool { - for _, fn := range fns { - if fn(t) { - return true - } - } - return false -} - -func or(l, r reflect.Type, fns ...func(reflect.Type) bool) bool { - if isAny(l) && isAny(r) { - return true - } - if isAny(l) && anyOf(r, fns...) { - return true - } - if isAny(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 - } - } - 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 - } - } - return false -} - -func isFloat(t reflect.Type) bool { - if t != nil { - switch t.Kind() { - case reflect.Float32, reflect.Float64: - return true - } - } - return false -} - -func isNumber(t reflect.Type) bool { - return isInteger(t) || isFloat(t) -} - -func isTime(t reflect.Type) bool { - if t != nil { - switch t { - case timeType: - return true - } - } - return false -} - -func isDuration(t reflect.Type) bool { - if t != nil { - switch t { - case durationType: - return true - } - } - return false -} - -func isBool(t reflect.Type) bool { - if t != nil { - switch t.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 - } - } - 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 - } - } - 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 - } - } - 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 - } - } - 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 - } - } - 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 - } - } - - // 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 kind(t reflect.Type) reflect.Kind { - if t == nil { - return reflect.Invalid - } - return t.Kind() -} - -func isComparable(l, r reflect.Type) bool { - if l == nil || r == nil { - return true - } - switch { - case l.Kind() == r.Kind(): - return true - case isNumber(l) && isNumber(r): - return true - case isAny(l) || isAny(r): - return true - } - return false -} diff --git a/compiler/compiler.go b/compiler/compiler.go index 457088d3f..c7469030c 100644 --- a/compiler/compiler.go +++ b/compiler/compiler.go @@ -5,10 +5,12 @@ import ( "math" "reflect" "regexp" + "runtime/debug" "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" @@ -23,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()) } }() @@ -35,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 { @@ -73,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 @@ -259,12 +268,14 @@ 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: c.VariableDeclaratorNode(n) + case *ast.SequenceNode: + c.SequenceNode(n) case *ast.ConditionalNode: c.ConditionalNode(n) case *ast.ArrayNode: @@ -292,21 +303,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(c.ntCache, 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(c.ntCache, env, node); ok { c.emit(OpLoadMethod, c.addConstant(&runtime.Method{ Name: name, Index: index, @@ -345,7 +354,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 { @@ -378,16 +386,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.Type().Kind() { case reflect.Float32: c.emitPush(float32(node.Value)) case reflect.Float64: c.emitPush(node.Value) + default: + c.emitPush(node.Value) } } @@ -404,6 +409,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) } @@ -592,8 +601,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) @@ -647,12 +656,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(c.ntCache, env, node); ok { c.compile(node.Node) c.emit(OpMethod, c.addConstant(&runtime.Method{ Name: name, @@ -663,14 +672,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(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(types, 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( @@ -681,7 +690,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(c.ntCache, env, member); ok { index = append(memberIndex, index...) path = append([]string{name}, path...) node = member @@ -696,7 +705,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) } @@ -727,9 +738,42 @@ 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 fn.Kind() == 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.Env.MethodByName(c.ntCache, callee.Value); ok && t.Method { + fnInOffset = 1 + fnNumIn-- + } + } + for i, arg := range node.Arguments { + c.compile(arg) + + 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 { + c.compile(arg) + } } + if ident, ok := node.Callee.(*ast.IdentifierNode); ok { if c.config != nil { if fn, ok := c.config.Functions[ident.Value]; ok { @@ -740,12 +784,16 @@ func (c *compiler) CallNode(node *ast.CallNode) { } c.compile(node.Callee) - isMethod, _, _ := checker.MethodIndex(c.config.Types, 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.ntCache, 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)) } @@ -755,6 +803,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() { @@ -769,6 +818,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() { @@ -784,6 +834,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() { @@ -798,6 +849,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]) @@ -813,6 +865,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]) @@ -832,6 +885,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]) @@ -843,6 +897,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 { @@ -860,6 +915,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) @@ -879,6 +935,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() { @@ -906,6 +963,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() { @@ -924,6 +982,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() { @@ -951,6 +1010,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() { @@ -969,6 +1029,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) @@ -982,6 +1043,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]) @@ -1000,9 +1062,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) @@ -1021,8 +1085,20 @@ 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() + 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) + } else { + if f.Deref(i, argType) { + c.emit(OpDeref) + } + } + } } if f.Fast != nil { @@ -1080,7 +1156,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) } @@ -1106,6 +1182,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}) } @@ -1162,12 +1247,27 @@ func (c *compiler) PairNode(node *ast.PairNode) { } func (c *compiler) derefInNeeded(node ast.Node) { - switch kind(node) { + if node.Nature().Nil { + return + } + switch node.Type().Kind() { case reflect.Ptr, reflect.Interface: c.emit(OpDeref) } } +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 { @@ -1181,8 +1281,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/compiler/compiler_test.go b/compiler/compiler_test.go index eb7f3d323..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 { @@ -442,10 +460,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 +516,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 `, }, { @@ -628,3 +644,34 @@ 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) + }) + } +} + +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/conf/config.go b/conf/config.go index 01a407a10..8799d3d04 100644 --- a/conf/config.go +++ b/conf/config.go @@ -6,33 +6,42 @@ 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/vm/runtime" ) +var ( + // DefaultMemoryBudget represents default maximum allowed memory usage by the vm.VM. + DefaultMemoryBudget uint = 1e6 + + // DefaultMaxNodes represents default maximum allowed AST nodes by the compiler. + DefaultMaxNodes uint = 1e4 +) + 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 + MaxNodes uint + ConstFns map[string]reflect.Value + Visitors []ast.Visitor + Functions FunctionsTable + Builtins FunctionsTable + Disabled map[string]bool // disabled builtins + NtCache nature.Cache } // CreateNew creates new config with default values. func CreateNew() *Config { c := &Config{ Optimize: true, - Types: make(TypesTable), + MaxNodes: DefaultMaxNodes, ConstFns: make(map[string]reflect.Value), Functions: make(map[string]*builtin.Function), Builtins: make(map[string]*builtin.Function), @@ -52,31 +61,16 @@ 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 = EnvWithCache(&c.NtCache, env) + c.Strict = c.Env.Strict } 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 +93,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(&c.NtCache, name); ok { return true } return false diff --git a/conf/env.go b/conf/env.go new file mode 100644 index 000000000..0acd44570 --- /dev/null +++ b/conf/env.go @@ -0,0 +1,76 @@ +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" +) + +// 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 { + n := c.NatureOf(map[string]any{}) + n.Strict = true + return n + } + + switch env := env.(type) { + case types.Map: + nt := env.Nature() + return nt + } + + v := reflect.ValueOf(env) + t := v.Type() + + switch deref.Value(v).Kind() { + case reflect.Struct: + n := c.FromType(t) + n.Strict = true + return n + + case reflect.Map: + 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) + if !elem.IsValid() || !elem.CanInterface() { + panic(fmt.Sprintf("invalid map value: %s", key)) + } + + face := elem.Interface() + + switch face := face.(type) { + case types.Map: + nt := face.Nature() + n.Fields[key.String()] = nt + + default: + if face == nil { + n.Fields[key.String()] = c.NatureOf(nil) + continue + } + n.Fields[key.String()] = c.NatureOf(face) + } + + } + + return n + } + + panic(fmt.Sprintf("unknown type %T", env)) +} 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..17830106e 100644 --- a/docgen/docgen.go +++ b/docgen/docgen.go @@ -5,6 +5,7 @@ import ( "regexp" "strings" + "github.com/expr-lang/expr/checker/nature" "github.com/expr-lang/expr/conf" "github.com/expr-lang/expr/internal/deref" ) @@ -84,8 +85,10 @@ func CreateDoc(i any) *Context { PkgPath: deref.Type(reflect.TypeOf(i)).PkgPath(), } - for name, t := range conf.CreateTypesTable(i) { - if t.Ambiguous { + cache := new(nature.Cache) + env := conf.EnvWithCache(cache, i) + for name, t := range env.All(cache) { + if _, ok := c.Variables[Identifier(name)]; ok { continue } c.Variables[Identifier(name)] = c.use(t.Type, fromMethod(t.Method)) @@ -220,8 +223,12 @@ appendix: c.Types[name] = a } - for name, field := range conf.FieldsFromStruct(t) { - if isPrivate(name) || isProtobuf(name) || field.Ambiguous { + ntCache := new(nature.Cache) + for name, field := range nature.StructFields(ntCache, 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/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/language-definition.md b/docs/language-definition.md index c8709aa04..5e530a57d 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) @@ -689,6 +689,22 @@ Concatenates two or more arrays. concat([1, 2], [3, 4]) == [1, 2, 3, 4] ``` +### flatten(array) {#flatten} + +Flattens given array into one-dimensional array. + +```expr +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. 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{} diff --git a/expr.go b/expr.go index 8c619e1c4..e8f4eb64b 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" ) @@ -45,8 +46,9 @@ func Operator(operator string, fn ...string) Option { p := &patcher.OperatorOverloading{ Operator: operator, Overloads: fn, - Types: c.Types, + Env: &c.Env, Functions: c.Functions, + NtCache: &c.NtCache, } c.Visitors = append(c.Visitors, p) } @@ -194,6 +196,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() @@ -240,7 +251,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 8b7856a43..01ccdeeb9 100644 --- a/expr_test.go +++ b/expr_test.go @@ -6,12 +6,16 @@ import ( "fmt" "os" "reflect" + "strings" "sync" "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" @@ -136,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() { @@ -311,7 +394,7 @@ func ExampleOperator() { // Output: true } -func ExampleOperator_Decimal() { +func ExampleOperator_with_decimal() { type Decimal struct{ N float64 } code := `A + B - C` @@ -503,20 +586,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{}), @@ -540,7 +609,7 @@ func ExamplePatch() { } fmt.Printf("%v", output) - // Output : Hello, you, world! + // Output: Hello, you, world! } func ExampleWithContext() { @@ -584,7 +653,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) @@ -870,6 +939,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, @@ -1106,6 +1187,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, @@ -1290,6 +1375,29 @@ 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", + }, + { + `1; 2; 3`, + 3, + }, + { + `let a = 1; Add(2, 2); let b = 2; a + b`, + 3, + }, } for _, tt := range tests { @@ -1644,11 +1752,22 @@ 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) } +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 @@ -1673,10 +1792,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) { @@ -2203,43 +2318,16 @@ 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)`}, +func TestExpr_timeout(t *testing.T) { + tests := []struct{ code string }{ + {`-999999..999999`}, + {`map(1..999999, 1..999999)`}, + {`map(1..999999, repeat('a', #))`}, } 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) { - t.Skip("no custom tests") - return - } - - 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) require.NoError(t, err) timeout := make(chan bool, 1) @@ -2296,94 +2384,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 { - 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) { @@ -2712,3 +2712,174 @@ func TestExpr_nil_op_str(t *testing.T) { }) } } + +func TestExpr_env_types_map(t *testing.T) { + envTypes := types.Map{ + "foo": types.Map{ + "bar": types.String, + }, + } + + 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.Map{ + "bar": types.String, + }, + } + + program, err := expr.Compile(`foo.bar`, expr.Env(envTypes)) + require.NoError(t, err) + + _, err = expr.Run(program, envTypes) + require.Error(t, err) +} + +func TestIssue758_filter_map_index(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) +} + +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") +} + +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) + }) + } +} + +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") + }) + } +} + +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 + } + 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/file/error.go b/file/error.go index 8ff85dfa5..c398ed59c 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,48 @@ 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 + 1 e.Line++ e.Column = 0 } else { e.Column++ } + runeCount++ + } + + 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/deref/deref.go b/internal/deref/deref.go index acdc89811..4ad7877f8 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,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/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/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 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/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 2b547c41c..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. */ @@ -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/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/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..17659a914 100644 --- a/optimizer/filter_map.go +++ b/optimizer/filter_map.go @@ -9,17 +9,25 @@ type filterMap struct{} 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 { + 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" && filter.Map == nil /* not already optimized */ { - Patch(node, &BuiltinNode{ + patchCopyType(node, &BuiltinNode{ Name: "filter", Arguments: filter.Arguments, - Map: closure.Node, + Map: predicate.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..b45fbdead --- /dev/null +++ b/optimizer/filter_map_test.go @@ -0,0 +1,114 @@ +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)) +} + +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)) +} diff --git a/optimizer/fold.go b/optimizer/fold.go index 910c92402..bb40eab93 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].(*PredicateNode).Node, + Right: n.Arguments[1].(*PredicateNode).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..03458689f 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}) @@ -225,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{ @@ -252,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{ @@ -280,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{ @@ -308,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{ @@ -336,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{ @@ -353,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.ClosureNode{ - 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) @@ -395,7 +323,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{ @@ -443,7 +371,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{ @@ -493,7 +421,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{ @@ -501,7 +429,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 6e8a7f7cf..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) - Patch(node, &BuiltinNode{ + v.Visit(&predicate.Node) + patchCopyType(node, &BuiltinNode{ Name: left.Name, Arguments: []Node{ left.Arguments[0], - closure, + predicate, }, }) } 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/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/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..fe41e824a 100644 --- a/parser/lexer/lexer.go +++ b/parser/lexer/lexer.go @@ -2,152 +2,171 @@ 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) 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) { +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 +186,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 +197,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 +217,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,16 +234,48 @@ func (l *lexer) scanString(quote rune) (n int) { return } -func (l *lexer) scanRawString(quote rune) (n int) { - ch := l.next() // read character after back tick - for ch != quote { - if ch == eof { +func (l *Lexer) scanRawString(quote rune) (n int) { + 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, string(l.source[l.start+1:l.end-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 5edcbe5c4..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{ @@ -239,6 +255,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 { @@ -275,13 +327,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) } @@ -296,9 +348,30 @@ 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 ♥︎ + | .....^ ` func TestLex_error(t *testing.T) { diff --git a/parser/lexer/state.go b/parser/lexer/state.go index d351e2f5c..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(); { @@ -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) @@ -142,7 +140,7 @@ loop: return root } -func not(l *lexer) stateFn { +func not(l *Lexer) stateFn { l.emit(Operator) l.skipSpaces() @@ -169,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 } @@ -186,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' { @@ -197,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 { @@ -211,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 77b2a700a..6034403bf 100644 --- a/parser/parser.go +++ b/parser/parser.go @@ -1,7 +1,9 @@ package parser import ( + "errors" "fmt" + "io" "math" "strconv" "strings" @@ -19,7 +21,7 @@ type arg byte const ( expr arg = 1 << iota - closure + predicate ) const optional arg = 1 << 7 @@ -27,58 +29,43 @@ 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 { - tokens []Token - current Token - pos int - err *file.Error - depth int // closure call depth - config *conf.Config +// Parser is a reusable parser. The zero value is ready for use. +type Parser struct { + 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 } -type Tree struct { - Node Node - Source file.Source -} - -func Parse(input string) (*Tree, error) { - return ParseWithConfig(input, &conf.Config{ - Disabled: map[string]bool{}, - }) -} - -func ParseWithConfig(input string, config *conf.Config) (*Tree, error) { - source := file.NewSource(input) - - tokens, err := Lex(source) - if err != nil { - return nil, err +func (p *Parser) Parse(input string, config *conf.Config) (*Tree, error) { + if p.lexer == nil { + p.lexer = New() } - - p := &parser{ - tokens: tokens, - current: tokens[0], - config: config, - } - - node := p.parseExpression(0) + 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) @@ -88,19 +75,76 @@ func ParseWithConfig(input string, config *conf.Config) (*Tree, error) { Node: node, Source: source, } + err := p.err - if p.err != nil { - return tree, p.err.Bind(source) + // 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) error(format string, args ...any) { +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 + } + return nil +} + +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 +} + +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 { + Node Node + Source file.Source +} + +func Parse(input string) (*Tree, error) { + return ParseWithConfig(input, nil) +} + +func ParseWithConfig(input string, config *conf.Config) (*Tree, error) { + return new(Parser).Parse(input, config) +} + +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, @@ -109,16 +153,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 @@ -128,11 +188,40 @@ func (p *parser) expect(kind Kind, values ...string) { // parse functions -func (p *parser) parseExpression(precedence int) Node { +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 + } + if precedence == 0 && p.current.Is(Operator, "let") { return p.parseVariableDeclaration() } + if precedence == 0 && p.current.Is(Operator, "if") { + return p.parseConditionalIf() + } + nodeLeft := p.parsePrimary() prevOperator := "" @@ -143,15 +232,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 { @@ -187,19 +277,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 @@ -218,24 +312,41 @@ 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) p.expect(Operator, "=") value := p.parseExpression(0) p.expect(Operator, ";") - node := p.parseExpression(0) - let := &VariableDeclaratorNode{ + node := p.parseSequenceExpression() + return p.createNode(&VariableDeclaratorNode{ Name: variableName.Value, Value: value, Expr: node, + }, variableName.Location) +} + +func (p *Parser) parseConditionalIf() Node { + p.next() + nodeCondition := p.parseExpression(0) + p.expect(Bracket, "{") + expr1 := p.parseSequenceExpression() + p.expect(Bracket, "}") + p.expect(Operator, "else") + p.expect(Bracket, "{") + expr2 := p.parseSequenceExpression() + p.expect(Bracket, "}") + + return &ConditionalNode{ + Cond: nodeCondition, + Exp1: expr1, + Exp2: expr2, } - let.SetLocation(variableName.Location) - return let + } -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() @@ -250,34 +361,39 @@ 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 } -func (p *parser) parsePrimary() Node { +func (p *Parser) parsePrimary() Node { token := p.current if token.Is(Operator) { 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) } } 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) } @@ -292,14 +408,12 @@ 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 { - if token.Is(Operator, "#") || token.Is(Operator, ".") { - p.error("cannot use pointer accessor outside closure") - } } if token.Is(Operator, "::") { @@ -312,7 +426,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 @@ -322,23 +436,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 + } } } @@ -385,8 +507,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, "[") { @@ -401,26 +525,29 @@ 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 } - return &IntegerNode{Value: int(number)} + 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 } - return &FloatNode{Value: number} + 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 := 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 { @@ -448,38 +575,51 @@ 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) } + // skip last comma + if p.current.Is(Operator, ",") { + p.next() + } 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{ + } 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), + }, 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 } -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) @@ -489,6 +629,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) } @@ -497,29 +640,39 @@ func (p *parser) parseArguments(arguments []Node) []Node { return arguments } -func (p *parser) parseClosure() 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) + if p.current.Is(Operator, ";") { + p.error("wrap predicate with brackets { and }") + } + } p.depth-- - if expectClosingBracket { + if withBrackets { p.expect(Bracket, "}") } - closure := &ClosureNode{ + predicateNode := p.createNode(&PredicateNode{ Node: node, + }, startToken.Location) + if predicateNode == nil { + return nil } - closure.SetLocation(startToken.Location) - return closure + return predicateNode } -func (p *parser) parseArrayExpression(token Token) Node { +func (p *Parser) parseArrayExpression(token Token) Node { nodes := make([]Node, 0) p.expect(Bracket, "[") @@ -536,12 +689,14 @@ 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 } -func (p *parser) parseMapExpression(token Token) Node { +func (p *Parser) parseMapExpression(token Token) Node { p.expect(Bracket, "{") nodes := make([]Node, 0) @@ -563,8 +718,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) @@ -575,20 +732,24 @@ 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 } -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 == "?." @@ -609,8 +770,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 == "?." @@ -619,26 +782,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 == "[" { @@ -652,11 +822,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 { @@ -670,25 +842,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, "]") } @@ -700,26 +879,29 @@ 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) - 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 3c6ee5b2b..16dac6b79 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" @@ -427,7 +428,7 @@ world`}, Name: "all", Arguments: []Node{ &IdentifierNode{Value: "Tickets"}, - &ClosureNode{ + &PredicateNode{ Node: &PointerNode{}, }}}, }, @@ -437,7 +438,7 @@ world`}, Name: "all", Arguments: []Node{ &IdentifierNode{Value: "Tickets"}, - &ClosureNode{ + &PredicateNode{ Node: &BinaryNode{ Operator: ">", Left: &MemberNode{Node: &PointerNode{}, @@ -450,7 +451,7 @@ world`}, Name: "one", Arguments: []Node{ &IdentifierNode{Value: "Tickets"}, - &ClosureNode{ + &PredicateNode{ Node: &BinaryNode{ Operator: ">", Left: &MemberNode{ @@ -463,7 +464,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 +551,7 @@ world`}, Name: "map", Arguments: []Node{ &ArrayNode{}, - &ClosureNode{ + &PredicateNode{ Node: &PointerNode{Name: "index"}, }, }, @@ -647,6 +648,279 @@ 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"}}, + }, + { + "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", + &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 )", + &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", + &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 }", + &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}}}}, + }, + { + `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"}, + }, + }, + { + `all( + [ + true, + false, + ], + #, + )`, + &BuiltinNode{ + Name: "all", + Arguments: []Node{ + &ArrayNode{ + Nodes: []Node{ + &BoolNode{Value: true}, + &BoolNode{Value: false}, + }, + }, + &PredicateNode{ + Node: &PointerNode{}, + }, + }, + }, + }, + { + `list | all(#,)`, + &BuiltinNode{ + Name: "all", + Arguments: []Node{ + &IdentifierNode{Value: "list"}, + &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) { @@ -657,131 +931,111 @@ 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 closure (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] - | ......^ -` + | ......^`}, + {`foo(1; 2; 3)`, `unexpected token Operator(";") (1:6) + | foo(1; 2; 3) + | .....^`}, + { + `map(ls, 1; 2; 3)`, + `wrap predicate with brackets { and } (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 } + | ....^`, + }, + { + `list | all(#,,)`, + `unexpected token Operator(",") (1:14) + | list | all(#,,) + | .............^`, + }, + } -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) + }) } } @@ -904,7 +1158,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"}, @@ -914,3 +1168,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/patcher/operator_override.go b/patcher/operator_override.go index 551fe09bb..cf4287c24 100644 --- a/patcher/operator_override.go +++ b/patcher/operator_override.go @@ -6,15 +6,17 @@ 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. + NtCache *nature.Cache } func (p *OperatorOverloading) Visit(node *ast.Node) { @@ -42,6 +44,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 } @@ -56,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.Types[fn] + fnType, ok := p.Env.Get(p.NtCache, fn) if !ok { continue } @@ -103,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.Types[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)) @@ -119,7 +126,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/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/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)) +} diff --git a/test/deref/deref_test.go b/test/deref/deref_test.go index 0b228ca16..8df682faf 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" @@ -203,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" @@ -253,3 +254,86 @@ 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) +} + +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/examples/examples_test.go b/test/examples/examples_test.go new file mode 100644 index 000000000..86de35d3f --- /dev/null +++ b/test/examples/examples_test.go @@ -0,0 +1,32 @@ +package main + +import ( + "os" + "testing" + + "github.com/expr-lang/expr" + "github.com/expr-lang/expr/internal/testify/require" +) + +var examples []CodeBlock + +func init() { + b, err := os.ReadFile("../../testdata/examples.md") + if err != nil { + panic(err) + } + examples = extractCodeBlocksWithTitle(string(b)) +} + +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) + require.NoError(t, err) + }) + } +} 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 +} diff --git a/test/fuzz/fuzz_corpus.txt b/test/fuzz/fuzz_corpus.txt index 7b0174923..72afdf6ce 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,353 +6540,594 @@ 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 ? 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) -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"), 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, -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 @@ -6289,11 +7136,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 @@ -6301,129 +7149,98 @@ 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, reduce(list, i64)) get(list, score(1)) -get(list[i32:i], i64) +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, #), 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 : 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) -get(ok ? list : "foo", f32) -get(ok ? ok : half, array) -get(ok ? true : i32, f32) +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(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) -get({"bar": i32}.i32, ok) +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)) 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()) @@ -6431,14 +7248,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)) @@ -6446,20 +7269,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)) @@ -6475,27 +7296,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)) @@ -6511,46 +7331,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) @@ -6566,9 +8883,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) @@ -6583,7 +8902,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) @@ -6592,38 +8910,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) @@ -6665,22 +8994,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) @@ -6693,84 +9077,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)) @@ -6778,37 +9163,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) @@ -6817,2451 +9208,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 != nil ? list : half(nil) -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 @@ -9270,181 +11878,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)) @@ -9454,46 +12036,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 @@ -9502,35 +12086,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 @@ -9539,17 +12123,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) @@ -9557,107 +12146,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([nil], #?.div(#)) -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) @@ -9665,1222 +12234,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)) @@ -10890,220 +13383,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 @@ -11111,28 +13572,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, # <= #) @@ -11141,155 +13604,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") @@ -11306,6 +13778,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") @@ -11313,6 +13786,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") @@ -11327,7 +13802,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") @@ -11339,13 +13816,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) @@ -11369,6 +13846,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) @@ -11387,6 +13865,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) @@ -11395,7 +13875,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) @@ -11415,6 +13894,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) @@ -11431,40 +13911,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) @@ -11475,7 +13940,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) @@ -11483,7 +13947,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) @@ -11492,6 +13955,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) @@ -11499,15 +13963,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) @@ -11519,28 +13987,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) @@ -11549,16 +14018,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) @@ -11566,35 +14037,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) @@ -11614,27 +14071,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) @@ -11643,10 +14104,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) @@ -11658,6 +14122,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) @@ -11681,6 +14146,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) @@ -11696,12 +14162,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) @@ -11713,6 +14179,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) @@ -11723,8 +14190,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) @@ -11743,7 +14209,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) @@ -11778,7 +14243,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) @@ -11797,24 +14261,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) @@ -11823,707 +14280,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) @@ -12531,7 +16010,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) @@ -12542,73 +16020,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)) @@ -12617,76 +16103,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)) @@ -12694,72 +16199,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) @@ -12768,292 +16275,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) @@ -13064,367 +16524,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)) @@ -13432,116 +16855,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) @@ -13549,133 +16987,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)) @@ -13683,143 +17092,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)) @@ -13827,297 +17185,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)) @@ -14126,11 +17459,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)) @@ -14142,50 +17475,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) @@ -14193,84 +17534,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)) @@ -14278,50 +17593,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)) @@ -14330,142 +17630,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) @@ -14473,288 +17756,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()) @@ -14764,182 +17990,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) @@ -14947,1423 +18133,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_expr_seed_corpus.zip b/test/fuzz/fuzz_expr_seed_corpus.zip index 0fd46ab3a..d812de92e 100644 Binary files a/test/fuzz/fuzz_expr_seed_corpus.zip and b/test/fuzz/fuzz_expr_seed_corpus.zip differ 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() diff --git a/test/gen/env.go b/test/gen/env.go new file mode 100644 index 000000000..077575280 --- /dev/null +++ b/test/gen/env.go @@ -0,0 +1,21 @@ +package main + +var Env = map[string]any{ + "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 }, +} + +type Foo struct { + Bar string +} + +func (f Foo) String() string { + return "foo" +} diff --git a/test/gen/gen.go b/test/gen/gen.go index 1eb36c9bf..b43b677c0 100644 --- a/test/gen/gen.go +++ b/test/gen/gen.go @@ -2,50 +2,16 @@ package main import ( "fmt" - "math/rand" "reflect" + "runtime" "runtime/debug" + "strings" + "sync" "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 +49,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 { @@ -110,49 +76,71 @@ 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(weightedRandomInt([]intWeight{ - {3, 100}, - {4, 40}, - {5, 50}, - {6, 30}, - {7, 20}, - {8, 10}, - {9, 5}, - {10, 5}, - })).String() - - 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() } -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}, + {envNode, 1}, {floatNode, 1}, {integerNode, 1}, {stringNode, 1}, @@ -161,14 +149,17 @@ func node(depth int) ast.Node { {pointerNode, 10}, })(depth - 1) } - return weightedRandom([]fnWeight{ - {arrayNode, 1}, - {mapNode, 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}, {predicateNode, 1000}, {pointerNode, 500}, @@ -177,183 +168,205 @@ 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 envNode(_ int) string { + return "$env" } -func integerNode(_ int) ast.Node { - return &ast.IntegerNode{ - Value: 1, - } +func floatNode(_ int) string { + return "1.0" } -func stringNode(_ int) ast.Node { - words := []string{ - "foo", - "bar", - } - return &ast.StringNode{ - Value: words[rand.Intn(len(words))], - } +func integerNode(_ int) string { + return oneOf(list[string]{ + {"1", 1}, + {"0", 1}, + }) } -func booleanNode(_ int) ast.Node { - return &ast.BoolNode{ - Value: maybe(), - } +func stringNode(_ int) string { + return "foo" } -func identifierNode(_ int) ast.Node { - return &ast.IdentifierNode{ - Value: dict[rand.Intn(len(dict))], - } +func booleanNode(_ int) string { + return random([]string{"true", "false"}) } -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 identifierNode(_ int) string { + if maybe() { + return "foobar" } + return random(dict) } -func unaryNode(depth int) ast.Node { - cases := []string{"-", "!", "not"} - return &ast.UnaryNode{ - Operator: cases[rand.Intn(len(cases))], - Node: node(depth - 1), +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 binaryNode(depth int) ast.Node { - return &ast.BinaryNode{ - Operator: operators[rand.Intn(len(operators))], - Left: node(depth - 1), - Right: node(depth - 1), - } +func unaryNode(depth int) string { + return random([]string{"-", "!", "not"}) } -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 binaryNode(depth int) string { + return fmt.Sprintf("%v %v %v", node(depth-1), random(operators), node(depth-1)) } -func funcNode(_ int) ast.Node { - return &ast.IdentifierNode{ - Value: dict[rand.Intn(len(dict))], +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 callNode(depth int) ast.Node { - var args []ast.Node - max := weightedRandomInt([]intWeight{ +func funcNode(_ int) string { + return random(dict) +} + +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(predicates), 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) 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 sliceNode(depth int) ast.Node { - return &ast.SliceNode{ - Node: node(depth - 1), - From: node(depth - 1), - To: 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}, + }) +} + +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 conditionalNode(depth int) ast.Node { - return &ast.ConditionalNode{ - Cond: node(depth - 1), - Exp1: node(depth - 1), - Exp2: node(depth - 1), +func variableNode(depth int) string { + e := node(depth - 1) + if !strings.Contains(e, "foobar") { + return "~!@" } + return fmt.Sprintf("let foobar = %v; %v", node(depth-1), e) } diff --git a/test/gen/gen_test.go b/test/gen/gen_test.go index 6ac07c4f8..4050fc6e9 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) { - b, err := os.ReadFile("../../testdata/examples.txt") + flag.Parse() + + b, err := os.ReadFile("../../testdata/generated.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) + program, err := expr.Compile(line, expr.Env(Env)) + if err != nil { + if !*updateFlag { + t.Errorf("Compilation failed: %v", err) + } + return + } + + _, err = expr.Run(program, Env) + if err != nil { + if !*updateFlag { + t.Errorf("Execution failed: %v", err) + } + return + } - _, err = expr.Run(program, env) - require.NoError(t, err) + 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/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))] } 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") +} 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/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/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/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)) +} 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") +} 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) +} 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) + } +} diff --git a/test/issues/840/issue_test.go b/test/issues/840/issue_test.go new file mode 100644 index 000000000..abc00c3ad --- /dev/null +++ b/test/issues/840/issue_test.go @@ -0,0 +1,35 @@ +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() + Int`, expr.Env(&Env{})) + require.NoError(t, err) + + env := &Env{} + env.Func = func() int { + return 40 + } + env.EmbeddedEnv = &EmbeddedEnv{ + Int: 2, + } + + 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 { + Int int +} 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 +} 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 } 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), 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") +} 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/examples.txt deleted file mode 100644 index 9c18442e4..000000000 --- a/testdata/examples.txt +++ /dev/null @@ -1,19950 +0,0 @@ -!!!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 != 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) -!(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 == score) -!(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 != 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) -!(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 != 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) -!(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 != half : map(list, i32) -!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 != score) -!not (greet == div) -!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 <= 0.5 ? half : trimPrefix(nil) -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 -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 half == div -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 > 1 || add != greet -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] -[[f32]] -[add != nil] -[add, add] -[add, f32] -[add, i] -[add] -[all(list, false)] -[any(list, ok)] -[array, add] -[array, array] -[array, f32] -[array, greet] -[array, i64] -[array, i] -[array, list] -[array, ok, add] -[array, string(nil)] -[array] -[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] -[f64 / f64] -[f64 < 0.5] -[f64 < f32] -[f64 < i64] -[f64 <= 1] -[f64 in array] -[f64, add] -[f64, f64] -[f64, half] -[f64, i64] -[f64] -[f64] == array -[find(array, true)] -[findIndex(list, false)] -[findLast(list, ok)] -[float(0.5)] -[float(1)] -[foo, add] -[foo, array] -[foo, half] -[foo, i] -[foo, ok] -[foo, reduce(array, #)] -[foo.Bar] -[foo.Qux] -[foo?.Bar, f32, f64] -[foo?.Bar, i32] -[foo?.Bar] -[foo?.Qux] -[foo?.String()] -[foo] -[greet != nil] -[greet, array] -[greet, div] -[greet, foo] -[greet, greet] -[greet, half] -[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, f64] -[half, i64 < f64] -[half, list] -[half] -[i != i64] -[i .. 1] -[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, -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] -[list != nil] -[list, div] -[list, f32] -[list, greet] -[list, half] -[list, i] -[list, ok] -[list] -[map(array, #)] -[map(array, add)] -[map(array, f64)] -[map(array, foo)] -[max(1)] -[nil != 0.5] -[not false] -[ok ? 1 : greet] -[ok, f32] -[ok, half] -[ok, i64] -[ok, i] -[ok, list, 0.5] == list -[ok, ok] -[ok] -[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)] -[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(div)] -[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) -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) -abs(1 - i64) -abs(1 / 0.5) -abs(1 / 1) -abs(1 / i) -abs(1 / i32) -abs(1 ^ f32) -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) >= i -abs(1) ^ f64 -abs(abs(0.5)) -abs(abs(1)) -abs(abs(f64)) -abs(abs(i32)) -abs(abs(i64)) -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 ** 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(f64 * f64) -abs(f64 ** 1) -abs(f64 + 0.5) -abs(f64 + 1) -abs(f64 + f64) -abs(f64 - 1) -abs(f64 - f32) -abs(f64 / 0.5) -abs(f64 / 1) -abs(f64 / f64) -abs(f64 / i) -abs(f64 ^ 0.5) -abs(f64 ^ f32) -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(first(array)) -abs(float(0.5)) -abs(float(1)) -abs(float(f32)) -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(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) -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(int(1)) -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(max(f64)) -abs(max(i32)) -abs(max(i64)) -abs(mean(array)) -abs(median(array)) -abs(min(0.5)) -abs(min(1)) -abs(min(f32)) -abs(min(f64)) -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, 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(sum(array)) -abs(true ? 1 : ok) -add -add != add -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 -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) -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, # > #) -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, 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(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, greet == half) -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, 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) -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([foo], # != i64) -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, # != 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, # <= #) -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, add == greet) -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, 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, 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) -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(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, add == score) -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, 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 == #) -array -array != array -array != array ? 1 : false -array != array ? score : i32 -array != list -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 ? half : false -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 -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, !true) -count(array, "bar" <= "bar") -count(array, "bar" not endsWith "bar") -count(array, "foo" matches "foo") -count(array, # != #) -count(array, # != 0.5) -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, 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, 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, add != half) -count(list, div == score) -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, greet != score) -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(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 != 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 -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 -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 != f64 -f64 != f64 * f32 -f64 != f64 ? f64 : true -f64 != first(array) -f64 != floor(1) -f64 != half(0.5) -f64 != half(1) -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 * 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 * 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 ** f64 -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 * 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 + 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 + 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 - f64 -f64 - f64 + -1 -f64 - f64 < f64 -f64 - float(f32) -f64 - floor(1) -f64 - half(1) -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 / 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 / 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 / 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 < 1 % 1 -f64 < 1 * 0.5 -f64 < 1 ** i32 -f64 < 1 / f32 -f64 < 1 == false -f64 < 1 ? i : "foo" -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 < f64 -f64 < f64 == ok -f64 < floor(i64) -f64 < get(array, i) -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 <= 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 <= 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 == 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 == f64 -f64 == f64 ** i -f64 == f64 - f64 -f64 == float(0.5) -f64 == floor(0.5) -f64 == half(0.5) -f64 == half(f64) -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 > 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 > 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 >= 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 * 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 ^ 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 ^ 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 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 ? f32 : half != score -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) -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, 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 <= #) -filter(array, f32 == #) -filter(array, f32 == i64) -filter(array, f32 > #) -filter(array, f32 >= #) -filter(array, f64 < #) -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, 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(list, ok) -filter(list, ok)[i] -filter(list, score == half) -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) -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, div == half) -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, half == score) -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, 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, false)?.Bar -find(list, foo != #) -find(list, foo == #) -find(list, greet != div) -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, ok) -find(list, ok).String -find(list, ok).String() -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, 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) -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, 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, ok) -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 -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(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, 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, 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([1, f64], half == add) -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) -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 != #) -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, 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, #) -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(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, 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, 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, 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([false], 0.5 == #) -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) -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, half == 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, 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(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, half != div) -findLastIndex(list, half == greet) -findLastIndex(list, half == score) -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, 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]) -first([foo]) -first([ok]) -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(list) -first(list) not in list -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(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(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) -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) - f64 -float(1) <= i64 -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(add(1, 1)) -float(array[i32]) -float(array[i64]) -float(array[i]) -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 ** 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(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) -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(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(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 + i64) -float(i - 1) -float(i - f64) -float(i / 0.5) -float(i / 1) -float(i ^ 0.5) -float(i ^ i32) -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(int(1)) -float(int(f32)) -float(int(i)) -float(int(i32)) -float(last(array)) -float(len("bar")) -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(max(i)) -float(max(i32)) -float(max(i64)) -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(round(1)) -float(round(i32)) -float(round(i64)) -float(score(1)) -float(score(1, 1)) -float(score(i)) -float(string(0.5)) -float(string(1)) -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(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) -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 != foo -foo != nil != nil -foo != reduce(list, #) -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 in 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 <= 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()) -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.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 -foo.String() not in foo -foo?.Bar -foo?.Bar != foo?.Bar -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 != 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)) -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(ok)) -fromBase64(type(score)) -fromBase64(type(true)) -fromJSON(string(1)) -fromJSON(string(f32)) -fromJSON(string(f64)) -fromJSON(string(i)) -fromJSON(string(i32)) -fromJSON(string(i64)) -fromJSON(string(ok)) -fromJSON(string(true)) -fromJSON(toJSON("bar")) -fromJSON(toJSON(0.5)) -fromJSON(toJSON(array)) -fromJSON(toJSON(f64)) -fromJSON(toJSON(false)) -fromJSON(toJSON(foo)) -fromJSON(toJSON(i)) -fromJSON(toJSON(i32)) -fromJSON(toJSON(list)) -fromJSON(toJSON(nil)) -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) -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 : foo, Bar) -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, -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(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, 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) -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 ? "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) -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 -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") -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()) -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(string(1)) -greet(string(add)) -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(i)) -greet(string(i32)) -greet(string(i64)) -greet(string(list)) -greet(string(nil)) -greet(string(ok)) -greet(string(score)) -greet(string(true)) -greet(toBase64("bar")) -greet(toBase64(trimPrefix("bar"))) -greet(toJSON("bar")) -greet(toJSON("foo")) -greet(toJSON(0.5)) -greet(toJSON(1)) -greet(toJSON(array)) -greet(toJSON(f32)) -greet(toJSON(f64)) -greet(toJSON(false)) -greet(toJSON(foo)) -greet(toJSON(i)) -greet(toJSON(i32)) -greet(toJSON(i64)) -greet(toJSON(list)) -greet(toJSON(nil)) -greet(toJSON(ok)) -greet(toJSON(true)) -greet(trim("bar")) -greet(trim("foo")) -greet(trimPrefix("bar")) -greet(trimPrefix("foo")) -greet(trimSuffix("bar")) -greet(trimSuffix("foo")) -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(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(nil)) -greet(type(ok)) -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 != score) -groupBy(array, div == half) -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 != add) -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 == div) -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 == add) -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 ? 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 -half != nil == false -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)) -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) -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 != 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 != 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 * 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 != 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 % 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 * 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 % 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 * 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 ** 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 ** 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 ** 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 + 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 + 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 - 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 - 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 .. 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 / 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 / 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 < f64 -i < f64 - 1 -i < float(f64) -i < floor(f32) -i < half(0.5) -i < half(1) -i < half(f64) -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 <= f64 -i <= float(0.5) -i <= float(f32) -i <= half(1) -i <= half(f64) -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 == 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 == 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 > 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 ** 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 >= f64 -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 * 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 ^ 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 * 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 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 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) -int(1 ** i) -int(1 + 1) -int(1 + f32) -int(1 + f64) -int(1 + i32) -int(1 - 0.5) -int(1 - f32) -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) ^ f64 -int(abs(0.5)) -int(abs(1)) -int(abs(f64)) -int(abs(i)) -int(abs(i32)) -int(abs(i64)) -int(add(1, 1)) -int(array[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 ** 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(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) -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(float(1)) -int(float(f32)) -int(float(f64)) -int(float(i32 ** i)) -int(float(i32)) -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) -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(int(1)) -int(int(f64)) -int(len("bar")) -int(len(array)) -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(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(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(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")) -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([f32, list]) -last([list, list]) -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(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(list) -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(map(array, #)) -last(map(array, 1)) -last(map(array, array)) -last(map(array, foo)) -last(map(array, i)) -last(map(list, "foo")) -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(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]) -len([foo]) -len([half]) -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(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(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) % i32 -len(list) % i64 -len(list) .. i64 -len(list) / i32 -len(list) <= i -len(list) > i -len(list) ^ f64 -len(list[1:i]) -len(lower("bar")) -len(lower("foo")) -len(map(array, "bar")) -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(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(string(1)) -len(string(add)) -len(string(f64)) -len(string(foo)) -len(string(half)) -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(toJSON(1)) -len(toJSON(array)) -len(toJSON(f32)) -len(toJSON(false)) -len(toJSON(i)) -len(toJSON(i32)) -len(toJSON(list)) -len(toJSON(nil)) -len(toJSON(ok)) -len(toJSON(true)) -len(trim("foo")) -len(trimPrefix("foo")) -len(trimSuffix("bar")) -len(type("foo")) -len(type(0.5)) -len(type(1)) -len(type(add)) -len(type(array)) -len(type(div)) -len(type(half)) -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}) -list -list != 1 .. 1 -list != ["foo"] -list != [i, 0.5] -list != [i] -list != array -list != filter(array, ok) -list != filter(array, true) -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 == array -list == array == nil -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[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") -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(string(add)) -lower(string(f32)) -lower(string(f64)) -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(toJSON(f64)) -lower(toJSON(foo)) -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(type("bar")) -lower(type("foo")) -lower(type(0.5)) -lower(type(1)) -lower(type(add)) -lower(type(div)) -lower(type(f32)) -lower(type(half)) -lower(type(i)) -lower(type(i32)) -lower(type(i64)) -lower(type(list)) -lower(type(ok)) -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([1], get(#, 1)) -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], #?.f32(ok, #, false)) -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(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, # == #) -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, # >= #) -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, #) -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, 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 == greet) -map(array, add == nil) -map(array, add(#, #)) -map(array, add(#, i)) -map(array, add) -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, 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) -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, 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?.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, 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, 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, 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(list, # != #) -map(list, # != nil) -map(list, # == #) -map(list, # in list) -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, #?.String) -map(list, -0.5) -map(list, -f32) -map(list, -i) -map(list, -i32) -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, add == score) -map(list, add) -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, 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, foo) -map(list, foo.Qux) -map(list, foo.String()) -map(list, foo?.String) -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) -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, 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, 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, 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] -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, 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(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 -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(abs(1)) -max(abs(f32)) -max(abs(f64)) -max(abs(i)) -max(abs(i32)) -max(add(1, i)) -max(array[1]) -max(array[i64]) -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 * 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(f64 * f64) -max(f64 ** 0.5) -max(f64 ** f64) -max(f64 ** i) -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) -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, 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(float(1)) -max(float(1), i) -max(float(i32)) -max(float(i64)) -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(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 ** f64) -max(i ** score(1)) -max(i + 1) -max(i - 1) -max(i - i) -max(i - i64) -max(i ^ 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) >= i -max(i, f32) -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(len(list)) -max(max(0.5)) -max(max(0.5, f64)) -max(max(1)) -max(max(i)) -max(max(i32)) -max(max(i64)) -max(mean(array)) -max(median(array)) -max(min(0.5, 0.5)) -max(min(1)) -max(min(1, f64)) -max(min(f32, i64, i32)) -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(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(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(-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) -min(1 * 1) -min(1 * f32) -min(1 * i) -min(1 * i32) -min(1 ** i) -min(1 + 0.5) -min(1 + 1) -min(1 + f32) -min(1 + i64) -min(1 - 1) -min(1 - f64) -min(1 - i) -min(1 - i32) -min(1 - i64) -min(1 / 0.5) -min(1 / f32) -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(abs(1)) -min(abs(f32)) -min(abs(f64)) -min(abs(i)) -min(abs(i32)) -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(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(f64 * f64) -min(f64 ** f32) -min(f64 ** f64) -min(f64 + 0.5) -min(f64 + f32) -min(f64 + i64) -min(f64 - 1) -min(f64 - i) -min(f64 - i32) -min(f64 / 0.5) -min(f64 / f32) -min(f64 / i) -min(f64 / i64) -min(f64 ^ 1) -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, 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(first(array)) -min(float(0.5)) -min(float(1)) -min(float(f32)) -min(float(f64)) -min(float(i)) -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(1)) -min(half(1), -1) -min(half(f64 - 0.5)) -min(half(f64)) -min(i % 1) -min(i % i64) -min(i * i) -min(i ** 0.5) -min(i ** i) -min(i + 1) -min(i - 0.5) -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) * 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, 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(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(array)) -min(len(list)) -min(max(0.5)) -min(max(1, 0.5)) -min(max(f32)) -min(max(f64)) -min(max(i)) -min(max(i64, 1)) -min(mean(array)) -min(min(1)) -min(min(1, 1, 1)) -min(min(1, i, f32)) -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(round(1)) -min(round(f32)) -min(round(i32)) -min(round(i64)) -min(score(1)) -min(score(i)) -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 != 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 -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 == 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") -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, # <= #) -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, # >= #) -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, 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) -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, 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(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, div == #?.Qux) -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 == 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) -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 != 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) -not (array == array) -not (array == list) -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) -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 != 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) -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 != 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 && 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 -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 != 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 && add != greet -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 && 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 -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 ? 1 : score != greet -ok ? abs(i64) : i64 -ok ? add : abs(f32) -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 ? 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 -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 : "foo" endsWith lower(nil) -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 ? 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 ? false : foo.Bar -ok ? foo : div -ok ? foo : f32 -ok ? foo : foo -ok ? foo : greet -ok ? foo : half -ok ? foo : i32 -ok ? foo : i32 > i32 -ok ? foo : i64 -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 ? 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 ? 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 ? 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 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 -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 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 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 -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 -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 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 || greet == half -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 || 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, # / 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, # <= 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, div != score) -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, 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 -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(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, 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, 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([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 -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, greet) != score != nil -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, 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) -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 (half != score)) -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 != half) -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 == 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 -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) -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([add]) -sort([greet]) -sort([half]) -sort([i64]) -sort([list]) -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(map(array, #)) -sort(map(array, 1)) -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" != 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) -string(1 != nil) -string(1 % 1) -string(1 % i) -string(1 % i32) -string(1 * 0.5) -string(1 * f32) -string(1 * f64) -string(1 ** 0.5) -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) -string(1 .. i32) -string(1 .. i64) -string(1 / 0.5) -string(1 / f64) -string(1 / i) -string(1 / i32) -string(1 / i64) -string(1 < 0.5) -string(1 <= 1) -string(1 <= f32) -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 >= 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([f64]) -string([list]) -string([score]) -string([true]) -string(abs(0.5)) -string(abs(1)) -string(abs(f32)) -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 -string(all(array, ok)) -string(all(array, true)) -string(any(array, ok)) -string(any(list, false)) -string(any(list, ok)) -string(array != array) -string(array != nil) -string(array) -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 != 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) -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(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 + f32) -string(f64 - 0.5) -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) -string(f64 >= f32) -string(f64 >= i) -string(f64 ^ 0.5) -string(f64 ^ f32) -string(f64 ^ i) -string(f64 in array) -string(f64 not in array) -string(f64) -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(findLast(array, false)) -string(findLast(array, ok)) -string(findLast(array, true)) -string(findLastIndex(array, ok)) -string(first(array)) -string(first(list)) -string(float(0.5)) -string(float(1)) -string(float(f64)) -string(float(i)) -string(float(i64)) -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) -string(foo.Qux) -string(foo.String()) -string(foo.String) -string(foo?.Bar) -string(foo?.Qux) -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 != add) -string(greet != nil) -string(greet == greet) -string(greet == nil) -string(greet == score) -string(greet("bar")) -string(greet("foo")) -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 != score) -string(half == nil) -string(half(0.5)) -string(half(1)) -string(half(f64)) -string(half) -string(i != 1) -string(i != i64) -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) -string(i .. i) -string(i .. i32) -string(i / 1) -string(i / f32) -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 ^ 1) -string(i ^ f32) -string(i ^ i) -string(i ^ i64) -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(int(1)) -string(int(i32)) -string(int(i64)) -string(last(array)) -string(last(list).String()) -string(len("bar")) -string(len(array)) -string(len(list)) -string(list != nil) -string(list == array) -string(list == list) -string(list == nil) -string(list) -string(list[1]) -string(list[i32]) -string(list[i64]) -string(list[i]) -string(map(array, #)) -string(map(array, 0.5)) -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(max(1)) -string(max(f32)) -string(max(f64)) -string(max(i)) -string(max(i64)) -string(mean(array)) -string(min(0.5)) -string(min(f32)) -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 != ok) -string(nil == "bar") -string(nil == 0.5) -string(nil == 1) -string(nil == div) -string(nil == foo) -string(nil == list) -string(nil == nil) -string(nil == ok) -string(nil == score) -string(nil in list) -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(ok || false) -string(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 != div) -string(score != greet) -string(score != half) -string(score != nil) -string(score == greet) -string(score == nil) -string(score(1 % 1)) -string(score(1)) -string(score(i)) -string(score) -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(string(false)) -string(string(greet)) -string(string(half)) -string(string(i)) -string(string(i64)) -string(string(nil)) -string(string(ok)) -string(string(score)) -string(sum(array)) -string(toBase64("foo")) -string(toJSON("bar")) -string(toJSON(0.5)) -string(toJSON(1)) -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(nil)) -string(toJSON(ok)) -string(toJSON(true)) -string(trim("bar")) -string(trim(type(nil))) -string(trimPrefix("foo")) -string(trimSuffix("foo")) -string(true != false) -string(true && ok) -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 or ok) -string(true || true) -string(type("bar")) -string(type("foo")) -string(type(-i64)) -string(type(0.5)) -string(type(1)) -string(type(array)) -string(type(f32)) -string(type(f64)) -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}) -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(lower("bar")) -toBase64(lower("foo")) -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)) -toBase64(string(f64)) -toBase64(string(foo)) -toBase64(string(greet)) -toBase64(string(half)) -toBase64(string(i)) -toBase64(string(list)) -toBase64(string(ok)) -toBase64(toBase64("bar")) -toBase64(toJSON("bar")) -toBase64(toJSON(0.5)) -toBase64(toJSON(1)) -toBase64(toJSON(f32)) -toBase64(toJSON(f64)) -toBase64(toJSON(foo)) -toBase64(toJSON(i64)) -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(type(1)) -toBase64(type(add)) -toBase64(type(div)) -toBase64(type(f32)) -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) -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) -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 / 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 == nil) -toJSON(1 > f32) -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([false]) -toJSON([foo]) -toJSON([nil]) -toJSON([true]) -toJSON(abs(0.5)) -toJSON(abs(1)) -toJSON(abs(f32)) -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) -toJSON(array == nil) -toJSON(array) -toJSON(array[1:i64]) -toJSON(array[1]) -toJSON(array[i]) -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 != score) -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(f64 != nil) -toJSON(f64 * 1) -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) -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(first(list)) -toJSON(float(0.5)) -toJSON(float(1)) -toJSON(float(f32)) -toJSON(float(f64)) -toJSON(float(i)) -toJSON(float(i64)) -toJSON(floor(0.5)) -toJSON(floor(f64)) -toJSON(floor(i)) -toJSON(floor(i32)) -toJSON(foo != nil) -toJSON(foo in list) -toJSON(foo) -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 != 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) -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(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) -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 == 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 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(int(1)) -toJSON(int(i)) -toJSON(int(i32)) -toJSON(int(i64)) -toJSON(len("bar")) -toJSON(len(array)) -toJSON(len(greet("foo"))) -toJSON(len(list)) -toJSON(list != array) -toJSON(list != nil) -toJSON(list == array) -toJSON(list == list) -toJSON(list) -toJSON(list[1]) -toJSON(lower("bar")) -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(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(max(1)) -toJSON(max(f32)) -toJSON(max(f64)) -toJSON(max(i32)) -toJSON(mean(array)) -toJSON(median(array)) -toJSON(min(0.5)) -toJSON(min(1)) -toJSON(min(f32)) -toJSON(min(f64)) -toJSON(min(f64, f64)) -toJSON(min(i)) -toJSON(min(i32)) -toJSON(min(i64)) -toJSON(nil != 0.5) -toJSON(nil != 1) -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 == 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(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 && 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) -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 != add) -toJSON(score != div) -toJSON(score != score) -toJSON(score == half) -toJSON(score(1)) -toJSON(score(1, 1)) -toJSON(score(i)) -toJSON(sort(array)) -toJSON(string("bar")) -toJSON(string(0.5)) -toJSON(string(1)) -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(true)) -toJSON(sum(array)) -toJSON(take(array, i32)) -toJSON(toBase64("bar")) -toJSON(toJSON("bar")) -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(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("foo")) -toJSON(type(add)) -toJSON(type(array)) -toJSON(type(f32)) -toJSON(type(f64)) -toJSON(type(false)) -toJSON(type(foo)) -toJSON(type(i)) -toJSON(type(i32)) -toJSON(type(i64)) -toJSON(type(list)) -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)) -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) -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(string(array)) -trim(string(f32)) -trim(string(foo)) -trim(string(i64)) -trim(string(list)) -trim(string(nil)) -trim(toJSON("bar")) -trim(toJSON(1)) -trim(toJSON(f32)) -trim(toJSON(false)) -trim(toJSON(foo)) -trim(toJSON(i32)) -trim(toJSON(i64)) -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(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") -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(string(1)) -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(nil)) -trimPrefix(string(score)) -trimPrefix(string(true)) -trimPrefix(string({"bar": greet})) -trimPrefix(toBase64("bar")) -trimPrefix(toJSON("foo")) -trimPrefix(toJSON(1)) -trimPrefix(toJSON(array)) -trimPrefix(toJSON(f32)) -trimPrefix(toJSON(foo)) -trimPrefix(toJSON(i32)) -trimPrefix(toJSON(i64)) -trimPrefix(toJSON(list)) -trimPrefix(toJSON(nil)) -trimPrefix(toJSON(true)) -trimPrefix(trimPrefix("foo")) -trimPrefix(type("bar")) -trimPrefix(type(0.5)) -trimPrefix(type(1)) -trimPrefix(type(array)) -trimPrefix(type(f32)) -trimPrefix(type(f64)) -trimPrefix(type(greet)) -trimPrefix(type(half)) -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") -trimSuffix(foo.Bar) -trimSuffix(foo.String()) -trimSuffix(foo?.Bar) -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(string(add)) -trimSuffix(string(array)) -trimSuffix(string(div)) -trimSuffix(string(f64)) -trimSuffix(string(false)) -trimSuffix(string(foo)) -trimSuffix(string(half)) -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(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(true)) -trimSuffix(trim("bar")) -trimSuffix(trim("foo")) -trimSuffix(trimPrefix("bar")) -trimSuffix(trimPrefix("foo")) -trimSuffix(trimSuffix("bar")) -trimSuffix(type(1)) -trimSuffix(type(add)) -trimSuffix(type(array)) -trimSuffix(type(div)) -trimSuffix(type(f32)) -trimSuffix(type(foo)) -trimSuffix(type(greet)) -trimSuffix(type(half)) -trimSuffix(type(i32)) -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 -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 ? 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 -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) -type(1 != nil) -type(1 % 1) -type(1 % i) -type(1 * 0.5) -type(1 * f32) -type(1 * i) -type(1 * i32) -type(1 ** 0.5) -type(1 ** f64) -type(1 ** i) -type(1 ** i64) -type(1 + 0.5) -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 / i) -type(1 < i32) -type(1 < i64) -type(1 <= 0.5) -type(1 <= 1) -type(1 <= f64) -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 >= i) -type(1 >= i64) -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(abs(i)) -type(abs(i32)) -type(abs(i64)) -type(add != greet) -type(add != half) -type(add) -type(all(array, ok)) -type(all(list, ok)) -type(all(list, true)) -type(any(array, false)) -type(any(array, ok)) -type(any(list, false)) -type(array != list) -type(array != nil) -type(array == array) -type(array) -type(array) >= trimPrefix("foo") -type(array[1]) -type(array[i32]) -type(array[i]) -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 == 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(f64 == nil) -type(f64 > i) -type(f64 > i32) -type(f64 >= 0.5) -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 ? "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(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(first(list)) -type(float(f32)) -type(float(i32)) -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.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 != div) -type(greet == div) -type(greet("bar")) -type(greet("foo")) -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(list, #)) -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)) -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(i - 1) -type(i - i) -type(i - i64) -type(i .. i) -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 ^ i) -type(i ^ i32) -type(i ^ i64) -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(int(f64)) -type(int(i)) -type(int(i32)) -type(int(i64)) -type(last(array)) -type(last(list)) -type(len(array)) -type(len(list)) -type(list != nil) -type(list == array) -type(list == nil) -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(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(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(max(1)) -type(max(1, i32)) -type(max(f64)) -type(max(i64)) -type(median(array)) -type(min(1)) -type(min(f32)) -type(min(i)) -type(min(i32)) -type(min(i64)) -type(nil != "foo") -type(nil != 0.5) -type(nil != 1) -type(nil != greet) -type(nil != half) -type(nil != i32) -type(nil != i64) -type(nil != nil) -type(nil != score) -type(nil == "foo") -type(nil == array) -type(nil == f32) -type(nil == false) -type(nil == foo) -type(nil == greet) -type(nil == nil) -type(nil == score) -type(nil in array) -type(nil in list) -type(nil not in array) -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 != 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 or false) -type(ok || false) -type(ok) -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 == div) -type(score == greet) -type(score == nil) -type(score(1)) -type(score(1, 1)) -type(score(i)) -type(score) -type(sort(array)) -type(string(0.5)) -type(string(1)) -type(string(add)) -type(string(div)) -type(string(f32)) -type(string(f64)) -type(string(false)) -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(toJSON(1)) -type(toJSON(array)) -type(toJSON(false)) -type(toJSON(i)) -type(toJSON(i32)) -type(toJSON(i64)) -type(toJSON(list)) -type(toJSON(nil)) -type(trim("foo")) -type(trimPrefix("bar")) -type(true != nil) -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 || true) -type(true) in foo -type(true) matches string(list) -type(type(0.5)) -type(type(1)) -type(type(add)) -type(type(div)) -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(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") -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(string(1)) -upper(string(add)) -upper(string(array)) -upper(string(f32)) -upper(string(i32)) -upper(string(i64)) -upper(string(list)) -upper(string(nil)) -upper(string(score)) -upper(string(true)) -upper(toBase64("bar")) -upper(toBase64("foo")) -upper(toJSON("foo")) -upper(toJSON(1)) -upper(toJSON(f32)) -upper(toJSON(false)) -upper(toJSON(foo)) -upper(toJSON(i)) -upper(toJSON(i32)) -upper(toJSON(list)) -upper(toJSON(nil)) -upper(toJSON(true)) -upper(trim("bar")) -upper(trim("foo")) -upper(trimSuffix("bar")) -upper(trimSuffix("foo")) -upper(type("bar")) -upper(type("foo")) -upper(type(array)) -upper(type(div)) -upper(type(f32)) -upper(type(foo.Bar)) -upper(type(greet)) -upper(type(i)) -upper(type(i32)) -upper(type(list)) -upper(type(nil)) -upper(type(ok)) -upper(type(score)) -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)) -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 != add} -{"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} diff --git a/testdata/generated.txt b/testdata/generated.txt new file mode 100644 index 000000000..557fa9511 --- /dev/null +++ b/testdata/generated.txt @@ -0,0 +1,22359 @@ +$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 ^ 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] +[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, 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] +[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, f64] +[array, f64] | findIndex(ok) +[array, f64] | reduce(str) +[array, f64]?.[i] +[array, false, ok] | findLastIndex(#) +[array, foo] +[array, greet] +[array, i] +[array, i]?.[i] +[array, list] +[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)] +[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] +[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, 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] | 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)] +[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, 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, str] +[foo, true]?.[i] +[foo, values($env)] +[foo.Bar, ok] +[foo.Bar] +[foo.String()] +[foo.String, f64] +[foo.String] +[foo?.Bar] +[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, f64] +[greet, foo == $env] +[greet, foo] +[greet, foo] | none(true) +[greet, foo]?.[i] +[greet, greet] +[greet, i] +[greet, list] +[greet, nil]?.[i] +[greet, ok] +[greet, str] +[greet, true]?.[i] +[greet] +[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(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 | max(array, i)] +[i, $env?.String] +[i, $env?.foobar] +[i, 1.0]?.[i] +[i, add] +[i, array] +[i, f64 > i] +[i, f64] +[i, f64] != array +[i, foo?.String] +[i, foo] +[i, greet] +[i, i] +[i, list] +[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 | 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, 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, $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 ? 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, 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(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(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)] +[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(array)] +[type(f64)] +[type(false)] +[type(foo)] +[type(greet)] +[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 ** 1) +abs(1 ** 1.0) +abs(1 ** f64) +abs(1 + 0) +abs(1 - 1) +abs(1 - 1.0) +abs(1 - f64) +abs(1 / i) +abs(1 ^ 0) +abs(1 ^ 1) +abs(1 ^ i) +abs(1 | max(array)) +abs(1) + f64 +abs(1) < f64 +abs(1) < i +abs(1) >= i +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(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(bitor(0, 0)) +abs(ceil(0)) +abs(ceil(1)) +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 ** 1.0) +abs(f64 + 0) +abs(f64 + 1.0) +abs(f64 + f64) +abs(f64 - 1) +abs(f64 - i) +abs(f64 / f64) +abs(f64 ^ 0) +abs(f64 ^ 1.0) +abs(f64 ^ i) +abs(f64) +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)) +abs(float(1.0)) +abs(float(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 ^ 1.0) +abs(i | bitshl(0)) +abs(i) +abs(i) + f64 +abs(i) ^ i +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(last(array)) +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(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(median(f64)) +abs(median(f64, array)) +abs(median(i)) +abs(min(0)) +abs(min(1.0)) +abs(min(array)) +abs(min(i)) +abs(reduce(array, #)) +abs(reduce(array, #, nil)) +abs(reduce(array, i)) +abs(reduce(list, 0)) +abs(reduce(list, 1)) +abs(round(0)) +abs(round(1)) +abs(round(1.0)) +abs(sum($env, 1.0)) +abs(sum(array)) +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 != 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 == 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, 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, # <= #) +all(array, # == #) +all(array, # == $env) +all(array, # == 0) +all(array, # > #) +all(array, # >= #) +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(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, # in list) +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, 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, # != $env) +any(array, # < 0) +any(array, # <= #) +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 <= i) +any(array, ok != ok) +any(array, ok or $env) +any(array, ok) +any(array, str >= str) +any(keys($env), ok) +any(list, # != #) +any(list, # == #) +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, ok) +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 && true +array != array or ok +array != flatten(array) +array != list +array != list != false +array != list && 1.0 > 0 +array != list || ok +array != map($env, 1.0) +array != map(list, #) +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 != ok +array == keys($env) +array == list +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, sum(array)) +bitnand($env.i, i) +bitnand(i, i) +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 | 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(count(array, false)) +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(i % i) +bitnot(i * 0) +bitnot(i * 1) +bitnot(i + 0) +bitnot(i | add(i)) +bitnot(i | min(1.0)) +bitnot(i) +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(last(array)) +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, 0)) +bitnot(max(array, 0)) +bitnot(max(i)) +bitnot(min(0)) +bitnot(min(array)) +bitnot(min(i)) +bitnot(min(i, 0)) +bitnot(reduce(array, #)) +bitnot(reduce(array, 0)) +bitnot(reduce(list, i)) +bitnot(sum(array)) +bitnot(sum(array, #)) +bitnot(sum(list, 0)) +bitor($env.i, i) +bitor(i, array?.[i]) +bitor(i, i) +bitor(i, len(list)) +bitshl(i, $env?.i) +bitshl(i, i) +bitshr(i, $env?.i) +bitshr(i, i) +bitshr(i, sum(array)) +bitushr(i, i) +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 - 1.0) +ceil(1 ^ 1.0) +ceil(1 | bitor(0)) +ceil(1) != i +ceil(1) > f64 +ceil(1) ^ i +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(i)) +ceil(array?.[i]) +ceil(bitnot(0)) +ceil(bitnot(1)) +ceil(ceil(0)) +ceil(ceil(1)) +ceil(ceil(1.0)) +ceil(ceil(f64)) +ceil(count($env, false)) +ceil(f64 * 0) +ceil(f64 ** 0) +ceil(f64 ** 1) +ceil(f64 ** 1.0) +ceil(f64 ** i) +ceil(f64 + 1.0) +ceil(f64 + f64) +ceil(f64 - 1) +ceil(f64 / 1) +ceil(f64 / 1.0) +ceil(f64 / f64) +ceil(f64 / i) +ceil(f64 ^ 1.0) +ceil(f64 ^ i) +ceil(f64 | min(1.0)) +ceil(f64) +ceil(f64) != i +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(1.0)) +ceil(float(f64)) +ceil(float(i)) +ceil(floor(0)) +ceil(floor(1)) +ceil(floor(1.0)) +ceil(floor(f64)) +ceil(floor(i)) +ceil(i % i) +ceil(i * 1) +ceil(i * 1.0) +ceil(i ** 0) +ceil(i ** 1) +ceil(i ** 1.0) +ceil(i + 1) +ceil(i + i) +ceil(i - 0) +ceil(i - 1.0) +ceil(i - i) +ceil(i / 1) +ceil(i / 1.0) +ceil(i / f64) +ceil(i / i) +ceil(i ^ 0) +ceil(i ^ f64) +ceil(i ^ i) +ceil(i | min(0)) +ceil(i | min(1.0)) +ceil(i) +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(last(array)) +ceil(len($env)) +ceil(len(array)) +ceil(len(list)) +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(median(f64)) +ceil(median(i)) +ceil(median(i, 1.0)) +ceil(min(0)) +ceil(min(1)) +ceil(min(1.0)) +ceil(min(1.0, f64)) +ceil(min(1.0, i)) +ceil(min(array)) +ceil(min(f64)) +ceil(reduce(array, #)) +ceil(reduce(array, #acc)) +ceil(reduce(array, 1.0)) +ceil(reduce(list, 0)) +ceil(round(0)) +ceil(round(1.0)) +ceil(round(i)) +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, # > #) +count(array, # >= i) +count(array, # not in array) +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, i >= #) +count(array, nil == $env) +count(array, ok) +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) .. 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 != $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 && $env +f64 != f64 and true +f64 != float(i) +f64 != floor(f64) +f64 != floor(i) +f64 != 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 * i +f64 * f64 / i +f64 * f64 > 1 +f64 * float(0) +f64 * float(f64) +f64 * float(i) +f64 * i +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 * 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 >= 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 ** 1.0 +f64 + f64 ^ i +f64 + i +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 < i +f64 - f64 <= f64 +f64 - floor(0) +f64 - i +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 <= 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 ** i +f64 / f64 / 1.0 +f64 / f64 <= f64 +f64 / first(array) +f64 / float(1.0) +f64 / i +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 +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 < array?.[i] +f64 < ceil(1.0) +f64 < count(list, true) +f64 < f64 +f64 < f64 > 0 +f64 < f64 ?: ok +f64 < f64 in $env?.String +f64 < float(1) +f64 < floor(1) +f64 < floor(f64) +f64 < i +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 && $env +f64 <= f64 - 0 +f64 <= f64 and $env +f64 <= floor(1.0) +f64 <= i +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 * 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 == findLastIndex($env, true) +f64 == i +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 != true +f64 > f64 * f64 +f64 > f64 - 1 +f64 > f64 >= 1.0 +f64 > float(1.0) +f64 > i +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 == ok +f64 >= f64 ^ f64 +f64 >= float(0) +f64 >= float(1) +f64 >= float(1.0) +f64 >= i +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 != $env +f64 ^ f64 ** i +f64 ^ f64 + 1.0 +f64 ^ find(array, ok) +f64 ^ float(i) +f64 ^ i +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 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 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, # <= #) +filter(array, $env != $env) +filter(array, $env and false) +filter(array, 1 >= #) +filter(array, 1.0 <= f64) +filter(array, 1.0 == $env) +filter(array, 1.0 > 1.0) +filter(array, f64 <= #) +filter(array, false) | all($env[1.0:]) +filter(array, false) | sortBy($env) +filter(array, false) | sortBy(add) +filter(array, ok) +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) | 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, $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(list, # != #) +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 != nil) +find(list, nil == str) +find(list, ok) +find(list, ok).Bar +find(list, ok)?.Bar +find(list, ok)?.String +find(list, str == $env) +find(list, true).Bar +find(list, true).String +find(list, true)?.String +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, # != nil) +findIndex(array, # > #) +findIndex(array, # >= #) +findIndex(array, $env != true) +findIndex(array, $env.ok) +findIndex(array, $env?.ok) +findIndex(array, 0 == #) +findIndex(array, 1 <= #) +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, true) | min(array) +findIndex(filter($env, false), #.list(foobar)) +findIndex(flatten(list), .String != ok) +findIndex(list, # == #) +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, nil != $env) +findIndex(list, ok) +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, # <= #) +findLast(array, # > 1.0) +findLast(array, $env?.ok) +findLast(array, 1 != #) +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) >= 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, #.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, i > 0) +findLast(list, nil == #) +findLast(list, nil == greet) +findLast(list, ok) +findLast(list, ok).Bar +findLast(list, ok).String() +findLast(list, true && false) +findLast(list, true).String +findLast(list, true)?.Bar +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, # < i) +findLastIndex(array, # <= #) +findLastIndex(array, # > #) +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, 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, #.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, ok) +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) == 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) == $env?.String +first(list).Bar +first(list).String +first(list).String() +first(list)?.Bar +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)) +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)) +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 + 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) < 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(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(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(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 - 1.0) +float(f64 / 1.0) +float(f64 / i) +float(f64 ^ 0) +float(f64 ^ 1.0) +float(f64) +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(f64)) +float(floor(1)) +float(floor(1.0)) +float(floor(f64)) +float(i % 1) +float(i * 1.0) +float(i ** 1.0) +float(i + 1) +float(i - 0) +float(i - 1) +float(i - f64) +float(i - i) +float(i / 1) +float(i / 1.0) +float(i) +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(1.0)) +float(int(f64)) +float(int(i)) +float(lastIndexOf(str, str)) +float(len($env)) +float(len(array)) +float(len(list)) +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(mean(0)) +float(mean(1)) +float(mean(1.0 - 1.0)) +float(mean(1.0)) +float(mean(array)) +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(1.0)) +float(round(f64)) +float(round(i)) +float(string(0)) +float(string(1)) +float(string(1.0)) +float(string(f64)) +float(sum($env, 0)) +float(sum($env, 1)) +float(sum($env?.array)) +float(sum(array)) +float(sum(array, #)) +float(sum(array, 1)) +float(sum(array, i)) +float(sum(list, 1)) +float(toJSON(1)) +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 ** i) +floor(1 + 1.0) +floor(1 + i) +floor(1 - i) +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) != 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(1.0)) +floor(abs(f64)) +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(ceil(1)) +floor(ceil(1.0)) +floor(ceil(i)) +floor(count($env, true)) +floor(count(list, ok)) +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 ^ 1.0) +floor(f64 ^ i) +floor(f64) +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(floor(0)) +floor(floor(1)) +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 ^ 0) +floor(i ^ 1.0) +floor(i ^ i) +floor(i | min(0)) +floor(i) +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(1.0)) +floor(int(f64)) +floor(int(i)) +floor(last(array)) +floor(len($env)) +floor(len(array)) +floor(len(list)) +floor(len(str)) +floor(let foobar = 1.0; foobar) +floor(list | sum(1)) +floor(max(0)) +floor(max(1)) +floor(max(1.0)) +floor(max(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, 1)) +floor(round(1)) +floor(round(1.0)) +floor(round(f64)) +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 != 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 != 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 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 != false +foo not in list && ok +foo.Bar +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() != 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 != 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 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() != 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(str)) +fromBase64(toJSON(nil)) +fromBase64(toJSON(ok)) +fromBase64(toJSON(true)) +fromBase64(type(add)) +fromBase64(type(greet)) +fromBase64(type(ok)) +fromJSON(string(0)) +fromJSON(string(1)) +fromJSON(string(1.0)) +fromJSON(string(f64)) +fromJSON(string(false)) +fromJSON(string(i)) +fromJSON(string(ok)) +fromJSON(string(true)) +fromJSON(toJSON(0)) +fromJSON(toJSON(1)) +fromJSON(toJSON(1.0)) +fromJSON(toJSON(array)) +fromJSON(toJSON(f64)) +fromJSON(toJSON(false)) +fromJSON(toJSON(foo)) +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)) +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(if ok { i } else { array }, list) +get(list, i) +get(list, i).String +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 != 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 == 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.String()) +greet(foo?.Bar) +greet(foo?.Bar) not endsWith str +greet(foo?.String()) +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(f64)) +greet(string(false)) +greet(string(foo)) +greet(string(greet)) +greet(string(groupBy(list, ok))) +greet(string(i)) +greet(string(last(array))) +greet(string(list)) +greet(string(nil)) +greet(string(ok)) +greet(string(str)) +greet(string(true)) +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(f64)) +greet(toJSON(false)) +greet(toJSON(foo) | greet()) +greet(toJSON(foo)) +greet(toJSON(foo?.Bar)) +greet(toJSON(i)) +greet(toJSON(list)) +greet(toJSON(nil)) +greet(toJSON(ok)) +greet(toJSON(str)) +greet(toJSON(true)) +greet(trim(str)) +greet(trimPrefix(str)) +greet(trimSuffix(foo.String())) +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(f64)) +greet(type(false)) +greet(type(foo)) +greet(type(greet)) +greet(type(i)) +greet(type(list)) +greet(type(map(array, ok))) +greet(type(nil == f64)) +greet(type(nil)) +greet(type(ok)) +greet(type(str)) +greet(type(true)) +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, # * i) +groupBy(array, # + #) +groupBy(array, # / #) +groupBy(array, # == #) +groupBy(array, # > #) +groupBy(array, # >= #).String +groupBy(array, # >= 0) +groupBy(array, # ^ #) +groupBy(array, #) +groupBy(array, #).Bar +groupBy(array, #).String +groupBy(array, #).add +groupBy(array, #).array +groupBy(array, #).f64 +groupBy(array, #).foo +groupBy(array, #).greet +groupBy(array, #).i +groupBy(array, #).list +groupBy(array, #).ok +groupBy(array, #).str +groupBy(array, #)?.Bar +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, #)?.f64 +groupBy(array, #)?.foo +groupBy(array, #)?.foobar +groupBy(array, #)?.greet +groupBy(array, #)?.i +groupBy(array, #)?.list +groupBy(array, #)?.ok +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).f64 +groupBy(array, 1).foo +groupBy(array, 1).greet +groupBy(array, 1).i +groupBy(array, 1).list +groupBy(array, 1)?.Bar +groupBy(array, 1)?.[i] +groupBy(array, 1)?.[ok] +groupBy(array, 1)?.[str] +groupBy(array, 1)?.add +groupBy(array, 1)?.f64 +groupBy(array, 1)?.list +groupBy(array, 1)?.ok +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, bitshr(#, 0)) +groupBy(array, f64 - 1) +groupBy(array, f64 / #) +groupBy(array, f64 < #) +groupBy(array, f64) +groupBy(array, f64).Bar +groupBy(array, f64).String +groupBy(array, f64).add +groupBy(array, f64).array +groupBy(array, f64).f64 +groupBy(array, f64).i +groupBy(array, f64).ok +groupBy(array, f64).str +groupBy(array, f64)?.Bar +groupBy(array, f64)?.[i] +groupBy(array, f64)?.[ok] +groupBy(array, f64)?.[str] +groupBy(array, f64)?.add +groupBy(array, f64)?.foo +groupBy(array, f64)?.list +groupBy(array, f64)?.ok +groupBy(array, f64)?.str +groupBy(array, false and $env) +groupBy(array, false or true) +groupBy(array, false).Bar +groupBy(array, false).String +groupBy(array, false).add +groupBy(array, false).f64 +groupBy(array, false).foo +groupBy(array, false).greet +groupBy(array, false).list +groupBy(array, false).str +groupBy(array, false)?.Bar +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)?.f64 +groupBy(array, false)?.foo +groupBy(array, false)?.greet +groupBy(array, false)?.ok +groupBy(array, false)?.str +groupBy(array, foo not in list) +groupBy(array, foo) +groupBy(array, foo).Bar +groupBy(array, foo).String +groupBy(array, foo).add +groupBy(array, foo).array +groupBy(array, foo).foo +groupBy(array, foo).greet +groupBy(array, foo).i +groupBy(array, foo).list +groupBy(array, foo).ok +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)?.f64 +groupBy(array, foo)?.greet +groupBy(array, foo)?.i +groupBy(array, foo)?.list +groupBy(array, foo)?.ok +groupBy(array, foo)?.str +groupBy(array, foo.Bar) +groupBy(array, greet == $env) +groupBy(array, greet(str)) +groupBy(array, i | bitand(#))?.list +groupBy(array, i) +groupBy(array, i).add +groupBy(array, i).array +groupBy(array, i).f64 +groupBy(array, i).foo +groupBy(array, i).greet +groupBy(array, i).i +groupBy(array, i).ok +groupBy(array, i).str +groupBy(array, i)?.Bar +groupBy(array, i)?.[f64] +groupBy(array, i)?.[ok] +groupBy(array, i)?.[str] +groupBy(array, i)?.add +groupBy(array, i)?.array +groupBy(array, i)?.f64 +groupBy(array, i)?.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).String +groupBy(array, ok).add +groupBy(array, ok).f64 +groupBy(array, ok).foo +groupBy(array, ok).greet +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)?.foo +groupBy(array, ok)?.list +groupBy(array, ok)?.ok +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).add +groupBy(array, true).array +groupBy(array, true).f64 +groupBy(array, true).foo +groupBy(array, true).i +groupBy(array, true).list +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)?.f64 +groupBy(array, true)?.i +groupBy(array, true)?.list +groupBy(array, true)?.ok +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, #) +groupBy(list, #).Bar +groupBy(list, #).String +groupBy(list, #).add +groupBy(list, #).array +groupBy(list, #).f64 +groupBy(list, #).foo +groupBy(list, #).greet +groupBy(list, #).i +groupBy(list, #).list +groupBy(list, #).ok +groupBy(list, #).str +groupBy(list, #)?.Bar +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, #)?.f64 +groupBy(list, #)?.foo +groupBy(list, #)?.greet +groupBy(list, #)?.i +groupBy(list, #)?.list +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, $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).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).String +groupBy(list, 1).f64 +groupBy(list, 1).foo +groupBy(list, 1).foobar +groupBy(list, 1).greet +groupBy(list, 1).str +groupBy(list, 1)?.Bar +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)?.f64 +groupBy(list, 1)?.greet +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).String +groupBy(list, f64).array +groupBy(list, f64).f64 +groupBy(list, f64).foo +groupBy(list, f64).greet +groupBy(list, f64).i +groupBy(list, f64).ok +groupBy(list, f64)?.Bar +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)?.f64 +groupBy(list, f64)?.foo +groupBy(list, f64)?.ok +groupBy(list, f64)?.str +groupBy(list, false).Bar +groupBy(list, false).String +groupBy(list, false).add +groupBy(list, false).f64 +groupBy(list, false).foo +groupBy(list, false).foobar +groupBy(list, false).i +groupBy(list, false).list +groupBy(list, false).str +groupBy(list, false)?.String +groupBy(list, false)?.[i] +groupBy(list, false)?.[ok] +groupBy(list, false)?.add +groupBy(list, false)?.array +groupBy(list, false)?.f64 +groupBy(list, false)?.greet +groupBy(list, false)?.ok +groupBy(list, false)?.str +groupBy(list, foo != nil) +groupBy(list, foo == #) +groupBy(list, foo) +groupBy(list, foo).Bar +groupBy(list, foo).String +groupBy(list, foo).add +groupBy(list, foo).array +groupBy(list, foo).f64 +groupBy(list, foo).foo +groupBy(list, foo).greet +groupBy(list, foo).i +groupBy(list, foo).list +groupBy(list, foo).ok +groupBy(list, foo).str +groupBy(list, foo)?.Bar +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)?.f64 +groupBy(list, foo)?.foo +groupBy(list, foo)?.greet +groupBy(list, foo)?.i +groupBy(list, foo)?.list +groupBy(list, foo)?.ok +groupBy(list, foo)?.str +groupBy(list, foo.Bar) +groupBy(list, foo?.Bar) +groupBy(list, greet(.Bar)) +groupBy(list, i + i) +groupBy(list, i) +groupBy(list, i).add +groupBy(list, i).array +groupBy(list, i).f64 +groupBy(list, i).foo +groupBy(list, i).i +groupBy(list, i).list +groupBy(list, i).ok +groupBy(list, i).str +groupBy(list, i)?.[ok] +groupBy(list, i)?.add +groupBy(list, i)?.array +groupBy(list, i)?.f64 +groupBy(list, i)?.foo +groupBy(list, i)?.greet +groupBy(list, i)?.ok +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).String +groupBy(list, ok).add +groupBy(list, ok).f64 +groupBy(list, ok).foo +groupBy(list, ok).i +groupBy(list, ok).list +groupBy(list, ok).ok +groupBy(list, ok)?.Bar +groupBy(list, ok)?.[f64] +groupBy(list, ok)?.[foo] +groupBy(list, ok)?.[i] +groupBy(list, ok)?.[ok] +groupBy(list, ok)?.add +groupBy(list, ok)?.foo +groupBy(list, ok)?.list +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)).str +groupBy(list, string(false)) +groupBy(list, true).Bar +groupBy(list, true).add +groupBy(list, true).array +groupBy(list, true).f64 +groupBy(list, true).foo +groupBy(list, true).greet +groupBy(list, true).i +groupBy(list, true).list +groupBy(list, true).ok +groupBy(list, true)?.Bar +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)?.f64 +groupBy(list, true)?.greet +groupBy(list, true)?.list +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 != $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 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 && false +i != f64 + 1.0 +i != float(1.0) +i != floor(0) +i != floor(1) +i != i +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 != sum(array) +i % $env.i +i % $env?.i +i % 1 != 1.0 +i % 1 == i +i % array?.[i] +i % i +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 * floor(0) +i * i +i * i != i +i * i % 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 ** $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 * 1.0 +i ** f64 == nil +i ** i +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(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 ** i +i + f64 <= i +i + float(1.0) +i + i +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 != 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 != 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 .. 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 / f64 +i / f64 < 1.0 +i / floor(1.0) +i / i +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 != 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 + 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 <= f64 < 1.0 +i <= f64 > $env +i <= f64 in $env?.String +i <= floor(1) +i <= i +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 != $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 == $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 && $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 ** 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 +i >= f64 ** f64 +i >= f64 ** i +i >= f64 + 1 +i >= f64 < i +i >= f64 > 1.0 +i >= f64 || $env +i >= float(1) +i >= floor(i) +i >= i +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 +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 / 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 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 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 + f64) +int(1 - 1.0) +int(1 - f64) +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(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(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(i)) +int(bitshr(0, i)) +int(ceil($env?.i)) +int(ceil(0)) +int(ceil(1)) +int(ceil(f64)) +int(ceil(i)) +int(count($env, true)) +int(count(list, false)) +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 + i) +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) <= 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(1.0)) +int(float(f64)) +int(float(i)) +int(floor(1.0)) +int(floor(f64)) +int(floor(i)) +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) != 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(1.0)) +int(int(i)) +int(last(array)) +int(len($env)) +int(len(0 .. i)) +int(len(array)) +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(mean(0)) +int(mean(1)) +int(mean(1.0)) +int(mean(1.0, f64)) +int(mean(array)) +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.0)) +int(min(array)) +int(min(i)) +int(ok ? 1.0 : greet) +int(ok ? f64 : list) +int(reduce(list, 1.0)) +int(round(1)) +int(round(1.0)) +int(round(f64)) +int(round(i)) +int(string(0)) +int(string(1.0)) +int(sum($env, i)) +int(sum(array)) +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, 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([$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) != 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(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).String +last(list).String() +last(list)?.Bar +last(list)?.String +last(list)?.String() +last(list[1:]) +last(map($env, $env)) +last(map($env, f64)) +last(map($env, foo)) +last(map(array, #)) +last(map(array, false)) +last(map(list, #)) +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(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([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) * 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?.String()) +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, 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) % i +len(list) ** i +len(list) == f64 +len(list) > i +len(list) ^ f64 +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, $env)) +len(map(array, 1)) +len(map(array, foo)) +len(map(list, #)) +len(map(list, f64)) +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(1.0)) +len(string(array)) +len(string(false)) +len(string(foo)) +len(string(greet)) +len(string(i)) +len(string(list)) +len(string(nil)) +len(string(ok)) +len(toBase64(str)) +len(toJSON(0)) +len(toJSON(1)) +len(toJSON(false)) +len(toJSON(foo)) +len(toJSON(list)) +len(toJSON(nil)) +len(toJSON(ok)) +len(toJSON(str)) +len(toJSON(true)) +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(foo)) +len(type(greet)) +len(type(i)) +len(type(list)) +len(type(nil)) +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 != $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 != array and ok +list != array or false +list != array || $env +list != flatten(list) +list != i .. i +list != keys($env) +list != list +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 : foo +list == array ?: list +list == array or ok +list == array[:i] +list == flatten(array) +list == keys($env) +list == list +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[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(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(array)) +lower(string(f64)) +lower(string(false)) +lower(string(foo)) +lower(string(list)) +lower(string(nil)) +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(trimPrefix(str)) +lower(trimSuffix(str)) +lower(type($env)) +lower(type(1)) +lower(type(1.0)) +lower(type(add)) +lower(type(false)) +lower(type(foo)) +lower(type(i)) +lower(type(list)) +lower(type(nil)) +lower(type(ok)) +lower(type(str)) +lower(type(true)) +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, # .. #) +map(array, # <= #) +map(array, # <= 1.0) +map(array, # == #) +map(array, # > 0) +map(array, # >= #) +map(array, # ^ #) +map(array, # ^ 1.0) +map(array, #) +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) | 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)?.[i] +map(array, bitnot(#)) +map(array, f64 - 1.0) +map(array, f64) +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, foo != $env) +map(array, foo == foo) +map(array, foo) +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?.String) +map(array, greet) +map(array, greet)?.[i] +map(array, i < 0) +map(array, i == #index) +map(array, i) +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, 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) | 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, # == #) +map(list, # == foo) +map(list, #) +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, #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, .String) +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, 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) | 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) | 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, greet) | findIndex(true) +map(list, i >= 0) +map(list, i) +map(list, i) | groupBy(# < #) +map(list, i) | sortBy(#) +map(list, i)?.[i] +map(list, list) +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, 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, sum(array)) +map(list, trim(str)) +map(list, true ? array : f64) +map(list, true)?.[i] +map(list, type(#)) +map(list, type($env)) +map(list, upper(#.Bar)) +map(map(array, #), #) +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, 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(1.0)) +max(abs(f64)) +max(abs(i)) +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(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 * i) +max(f64 ** 1) +max(f64 + 0) +max(f64 + 1) +max(f64 ^ 1.0) +max(f64) +max(f64) != 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(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.0)) +max(float(f64)) +max(float(i)) +max(floor(1)) +max(floor(i)) +max(i % 1) +max(i % i) +max(i * 1.0) +max(i * i, i) +max(i ** 1.0) +max(i ** f64) +max(i + 0) +max(i + f64) +max(i - 1) +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) < f64 +max(i) <= f64 +max(i) not in array +max(i) | bitxor(0) +max(i, array) +max(i, f64) +max(i, i) +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(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(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(median(array, 1)) +max(median(f64)) +max(median(i)) +max(min(0)) +max(min(1)) +max(min(1.0)) +max(min(array)) +max(min(f64)) +max(min(i)) +max(ok ? 1.0 : nil) +max(ok ? f64 : $env) +max(reduce($env, i, foo)) +max(reduce(array, #)) +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(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) != 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, 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) != 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 / 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)) +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 ** 0) +min(1 ** 1.0) +min(1 ** i) +min(1 + 1.0) +min(1 - f64) +min(1 / 0) +min(1 / 1) +min(1 / 1.0) +min(1 / i) +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(1.0)) +min(abs(f64)) +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(ceil(1)) +min(ceil(1.0)) +min(ceil(f64)) +min(ceil(i)) +min(count($env, false)) +min(count($env, ok)) +min(f64 * f64) +min(f64 ** 1) +min(f64 ** 1.0) +min(f64 ** f64) +min(f64 + 0) +min(f64 + 1.0) +min(f64 + f64) +min(f64 - 0) +min(f64 - 1.0) +min(f64 - i) +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) <= $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, 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(flatten(array)) +min(float(1)) +min(float(1.0)) +min(float(f64)) +min(float(i)) +min(floor(1.0 + i)) +min(floor(1.0)) +min(floor(f64)) +min(floor(i)) +min(groupBy(array, #)?.array) +min(i % i) +min(i * f64) +min(i * i) +min(i + 1.0) +min(i + i) +min(i - 0) +min(i - f64) +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) != $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, 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(1.0)) +min(int(i)) +min(last($env)) +min(last(array)) +min(len($env)) +min(len(array)) +min(len(list)) +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(mean(0)) +min(mean(1)) +min(mean(1.0)) +min(mean(array)) +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(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(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(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.String +nil != foo.String() +nil != foo?.Bar +nil != foo?.String +nil != foo?.String() +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.String +nil == foo.String() +nil == foo?.Bar +nil == foo?.String +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 == 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) +none(array, # != nil) +none(array, # < 1) +none(array, # <= #) +none(array, # == 0) +none(array, # >= #) +none(array, $env == foo) +none(array, $env.ok) +none(array, 0 <= 0) +none(array, 1 == #) +none(array, add == add) +none(array, f64 == #) +none(array, i != #) +none(array, i < #) +none(array, nil == i) +none(array, ok && false) +none(array, ok) +none(concat(array), f64 >= #) +none(flatten(array), ok) +none(list | map($env), #.ok) +none(list | map(str), ok) +none(list, # != foo) +none(list, # == #) +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, ok == $env) +none(list, 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 != $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 != 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 && $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 ? 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 : f64 +ok ? add : list | reduce(#) +ok ? add : str +ok ? array : $env | sum(#) +ok ? array : add +ok ? array : foo +ok ? array : list | min(i) +ok ? array : ok +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 : uniq($env) +ok ? false : $env.foo +ok ? false : $env?.[add] +ok ? false : $env?.list +ok ? false : foo.Bar +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 : foo?.Bar +ok ? foo : foo?.String +ok ? foo : list +ok ? foo not in list : array +ok ? greet : array +ok ? greet : f64 +ok ? greet : foo +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 : list +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 | 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 ok +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 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 != str +ok or nil == add +ok or nil == array +ok or none($env, #) +ok or ok +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 || ok +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) +one(array, # <= 1) +one(array, # == 1) +one(array, # >= #) +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, str > str) +one(array, true) == ok +one(if ok { $env } else { add }, ok) +one(list, # != foo) +one(list, # == #) +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, greet == nil) +one(list, i == 0) +one(list, list != $env) +one(list, nil == list) +one(list, nil not in $env) +one(list, ok) +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([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, # % i) +reduce(array, # * #) +reduce(array, # + 0) +reduce(array, # / #) +reduce(array, # <= #) +reduce(array, # == #) +reduce(array, # > i) +reduce(array, # >= #) +reduce(array, # ^ #) +reduce(array, # in array) +reduce(array, #) +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, add, f64) +reduce(array, array) +reduce(array, array) | mean(1, i) +reduce(array, array)?.[i] +reduce(array, array[1:]) +reduce(array, bitnand(1, #acc)) +reduce(array, bitnot(#)) +reduce(array, bitnot(#)) % i +reduce(array, bitor(i, #)) +reduce(array, ceil(#)) +reduce(array, concat(list)) +reduce(array, f64) +reduce(array, false) == $env?.String +reduce(array, float(i)) +reduce(array, foo == $env) +reduce(array, foo) +reduce(array, foo).Bar +reduce(array, foo).String +reduce(array, foo)?.Bar +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?.Bar) +reduce(array, foo?.String) +reduce(array, greet(str)) +reduce(array, greet) +reduce(array, greet, foo) +reduce(array, i .. #, greet) +reduce(array, i <= #) +reduce(array, i ^ #acc) +reduce(array, i) +reduce(array, i, array) % i +reduce(array, i, f64) not in $env?.array +reduce(array, keys($env)) +reduce(array, list) +reduce(array, list[:#]) +reduce(array, mean(#)) +reduce(array, median(#)) +reduce(array, ok ? ok : #index) +reduce(array, 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, 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, #) +reduce(list, #).Bar +reduce(list, #).String +reduce(list, #).String() +reduce(list, #)?.Bar +reduce(list, #)?.String +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, #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, .String) +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, array) +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, f64) +reduce(list, false ?: foo) +reduce(list, false) ? f64 : [false] +reduce(list, first(#acc)) +reduce(list, foo) +reduce(list, foo).Bar +reduce(list, foo).String +reduce(list, foo)?.Bar +reduce(list, foo)?.String +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?.String()) +reduce(list, foo?.String) +reduce(list, greet(#.Bar)) +reduce(list, greet) +reduce(list, greet, greet) +reduce(list, i ^ 0) +reduce(list, i) +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, list)?.[i] +reduce(list, list, i) +reduce(list, nil != $env) +reduce(list, ok) +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(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 ** i) +round(1 + 0) +round(1 + 1.0) +round(1 + i) +round(1 - 0) +round(1 - 1.0) +round(1 - i) +round(1 / 1) +round(1 / i) +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(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(array | reduce(#)) +round(array | sum(#)) +round(array | sum(1)) +round(array?.[0]) +round(array?.[i]) +round(bitnot(i)) +round(ceil(1.0)) +round(ceil(f64)) +round(f64 * 0) +round(f64 * 1) +round(f64 * 1.0) +round(f64 * i) +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 ^ 1) +round(f64 ^ 1.0) +round(f64 ^ f64) +round(f64) +round(f64) + f64 +round(f64) + f64 < 0 +round(f64) <= i +round(f64) >= i +round(false ? 0 : 1.0) +round(false ?: 1) +round(findLast(array, ok)) +round(findLastIndex($env, true)) +round(first(array)) +round(float(0)) +round(float(1)) +round(float(1.0)) +round(float(f64)) +round(float(i)) +round(floor(0)) +round(floor(1)) +round(floor(1.0)) +round(floor(f64)) +round(floor(i)) +round(i % 1) +round(i * 1.0) +round(i * i) +round(i ** 0) +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 ^ 0) +round(i ^ 1.0) +round(i) +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(f64)) +round(int(string(1.0))) +round(last(array)) +round(len(list)) +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(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(median(f64)) +round(median(f64, i)) +round(median(i)) +round(min(1)) +round(min(1.0)) +round(min(array)) +round(min(f64)) +round(min(i)) +round(ok ? i : 0) +round(reduce(array, #)) +round(reduce(array, #, nil)) +round(reduce(list, #index, nil)) +round(round(1)) +round(round(1.0)) +round(sum($env, 0)) +round(sum($env, 1)) +round(sum($env, f64)) +round(sum(array)) +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([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) == 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, 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)) +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 * 0) +string(1 * 1.0) +string(1 * f64) +string(1 * i) +string(1 ** 0) +string(1 ** 1) +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 / 0) +string(1 / 1.0) +string(1 / f64) +string(1 < 0) +string(1 < 1.0) +string(1 <= 1.0) +string(1 <= f64) +string(1 <= i) +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 ^ 1) +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([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)) +string(abs(1)) +string(abs(1.0)) +string(abs(f64)) +string(add == nil) +string(add(1, 0)) +string(add(1, 1)) +string(add) +string(add) in foo +string(add) matches str +string(add) | greet() +string(any(array, 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) > 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(i)) +string(ceil(0)) +string(ceil(1)) +string(ceil(1.0)) +string(ceil(f64)) +string(concat(array)) +string(count($env, false)) +string(f64 != $env) +string(f64 != f64) +string(f64 != nil) +string(f64 * 1) +string(f64 * f64) +string(f64 ** 0) +string(f64 ** 1.0) +string(f64 + 1) +string(f64 + 1.0) +string(f64 + f64) +string(f64 - 1) +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 > 1.0) +string(f64 > f64) +string(f64 >= 0) +string(f64 >= 1.0) +string(f64 >= i) +string(f64 ^ 1.0) +string(f64 ^ i) +string(f64) +string(f64) + str +string(f64) < str +string(false != $env) +string(false != false) +string(false != true) +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(flatten(list)) +string(float(0)) +string(float(1.0)) +string(float(f64)) +string(float(i)) +string(floor(0)) +string(floor(1)) +string(floor(1.0)) +string(floor(f64)) +string(floor(i)) +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.String()) +string(foo.String) +string(foo?.Bar) +string(foo?.Bar) not in foo +string(foo?.String()) +string(foo?.String) +string(greet(str)) +string(greet) +string(greet) not matches str +string(groupBy(list, ok)?.greet) +string(groupBy(list, str)) +string(i != 0) +string(i != 1) +string(i != 1.0) +string(i != nil) +string(i % 1) +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 / 0) +string(i / f64) +string(i <= f64) +string(i == $env) +string(i == f64) +string(i > 0) +string(i >= 1.0) +string(i ^ 1) +string(i ^ f64) +string(i ^ i) +string(i not in array) +string(i | bitshr(i)) +string(i | min(1.0, 1.0)) +string(i) +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(1.0)) +string(int(f64)) +string(int(i)) +string(keys($env)) +string(last($env)) +string(last(array)) +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 | 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) 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, 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(1.0)) +string(max(array)) +string(max(i)) +string(mean(0)) +string(mean(1.0)) +string(mean(array)) +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(nil != $env) +string(nil != 0) +string(nil != 1.0) +string(nil != foo) +string(nil != ok) +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 == 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) != $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(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, foo)) +string(reduce(array, list)) +string(reduce(list, foo)) +string(reduce(list, greet)) +string(reduce(list, ok, 1.0)) +string(round(0)) +string(round(1)) +string(round(1.0)) +string(round(f64)) +string(round(i)) +string(sort($env)) +string(sort(array)) +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(i)) +string(string(list)) +string(string(ok)) +string(string(str)) +string(string(true)) +string(sum($env, 0)) +string(sum($env, 1.0)) +string(sum(array)) +string(sum(list, 0)) +string(toBase64(str)) +string(toJSON(0)) +string(toJSON(1)) +string(toJSON(1.0)) +string(toJSON(array)) +string(toJSON(f64)) +string(toJSON(false)) +string(toJSON(foo)) +string(toJSON(nil)) +string(toJSON(ok)) +string(toJSON(str)) +string(toJSON(true)) +string(toPairs($env)) +string(trim(str)) +string(trimPrefix(str)) +string(true != false) +string(true != nil) +string(true != ok) +string(true != true) +string(true && $env) +string(true && false) +string(true == false) +string(true == nil) +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(true) + str +string(type($env)) +string(type(0)) +string(type(1)) +string(type(1.0)) +string(type(add)) +string(type(array)) +string(type(false)) +string(type(foo)) +string(type(greet)) +string(type(list)) +string(type(nil)) +string(type(ok)) +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..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) != f64 +sum(array) != i +sum(array) != i ** 1.0 +sum(array) % i +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) <= 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(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, #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(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(list, i) +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(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(1.0)) +toBase64(string(array)) +toBase64(string(f64)) +toBase64(string(false)) +toBase64(string(foo)) +toBase64(string(greet)) +toBase64(string(i)) +toBase64(string(list)) +toBase64(string(nil)) +toBase64(string(ok)) +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(i / 1)) +toBase64(toJSON(i)) +toBase64(toJSON(list)) +toBase64(toJSON(nil)) +toBase64(toJSON(ok)) +toBase64(toJSON(true)) +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(array)) +toBase64(type(f64)) +toBase64(type(false)) +toBase64(type(foo)) +toBase64(type(greet)) +toBase64(type(i)) +toBase64(type(list)) +toBase64(type(nil)) +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.0) +toJSON(1 * i) +toJSON(1 ** i) +toJSON(1 + 1) +toJSON(1 + 1.0) +toJSON(1 + f64) +toJSON(1 - f64) +toJSON(1 .. 0) +toJSON(1 .. 1) +toJSON(1 .. i) +toJSON(1 / f64) +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 > 0) +toJSON(1 > 1) +toJSON(1 > i) +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)) +toJSON(abs(1)) +toJSON(abs(1.0)) +toJSON(abs(f64)) +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 | 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) + 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(ceil(0)) +toJSON(ceil(1)) +toJSON(ceil(1.0)) +toJSON(ceil(f64)) +toJSON(ceil(i)) +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 * 0) +toJSON(f64 * f64) +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 && $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(flatten(array)) +toJSON(flatten(list)) +toJSON(float(0)) +toJSON(float(1)) +toJSON(float(1.0)) +toJSON(float(f64)) +toJSON(float(i)) +toJSON(floor(0)) +toJSON(floor(1.0)) +toJSON(floor(f64)) +toJSON(floor(i)) +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(greet != $env) +toJSON(greet != greet) +toJSON(greet != nil) +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 * 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 == 0) +toJSON(i == 1.0) +toJSON(i == nil) +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) + 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(1.0)) +toJSON(int(f64)) +toJSON(keys($env)) +toJSON(last($env)) +toJSON(last(list)) +toJSON(len($env)) +toJSON(len(list)) +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) == 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, 0)) +toJSON(map(list, #)) +toJSON(map(list, .Bar)) +toJSON(map(list, f64)) +toJSON(max(0)) +toJSON(max(1)) +toJSON(max(1.0)) +toJSON(max(1.0, 0)) +toJSON(max(1.0, 1)) +toJSON(max(f64)) +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(median(array, array)) +toJSON(median(f64)) +toJSON(median(i)) +toJSON(min(0)) +toJSON(min(1)) +toJSON(min(1.0)) +toJSON(min(array)) +toJSON(min(f64)) +toJSON(nil != $env) +toJSON(nil != 0) +toJSON(nil != 1) +toJSON(nil != 1.0) +toJSON(nil != add) +toJSON(nil != array) +toJSON(nil != false) +toJSON(nil != greet) +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 == list) +toJSON(nil == nil) +toJSON(nil == ok) +toJSON(nil in array) +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(ok != nil) +toJSON(ok != ok) +toJSON(ok && ok) +toJSON(ok && true) +toJSON(ok == false) +toJSON(ok ? foo : ok) +toJSON(ok ?: foo) +toJSON(ok or false) +toJSON(ok) +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, #.Bar)) +toJSON(reduce(list, 1.0)) +toJSON(reduce(list, foo)) +toJSON(reduce(list, ok)) +toJSON(reverse(array)) +toJSON(reverse(list)) +toJSON(round(0)) +toJSON(round(1)) +toJSON(round(1.0)) +toJSON(round(f64)) +toJSON(round(i)) +toJSON(sort($env)) +toJSON(sort(array)) +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(f64)) +toJSON(string(false)) +toJSON(string(foo)) +toJSON(string(list)) +toJSON(string(nil)) +toJSON(string(str)) +toJSON(string(true)) +toJSON(string(values($env))) +toJSON(sum($env, 1.0)) +toJSON(sum(array)) +toJSON(sum(array, #)) +toJSON(toBase64(str)) +toJSON(toJSON(1)) +toJSON(toJSON(1.0)) +toJSON(toJSON(array)) +toJSON(toJSON(f64)) +toJSON(toJSON(false)) +toJSON(toJSON(foo)) +toJSON(toJSON(i)) +toJSON(toJSON(list)) +toJSON(toJSON(nil)) +toJSON(toJSON(ok)) +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 ? foo : 1.0) +toJSON(true ? foo : f64) +toJSON(true ? nil : false) +toJSON(true ?: nil) +toJSON(true and true) +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(f64)) +toJSON(type(false)) +toJSON(type(foo)) +toJSON(type(greet)) +toJSON(type(i)) +toJSON(type(list)) +toJSON(type(nil)) +toJSON(type(ok)) +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(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(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(f64)) +trim(string(false)) +trim(string(foo)) +trim(string(list)) +trim(string(nil)) +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(1.0)) +trim(toJSON(array)) +trim(toJSON(f64)) +trim(toJSON(foo)) +trim(toJSON(list)) +trim(toJSON(nil)) +trim(toJSON(ok)) +trim(toJSON(true)) +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(nil)) +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(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(1.0)) +trimPrefix(string(array)) +trimPrefix(string(false)) +trimPrefix(string(foo)) +trimPrefix(string(greet)) +trimPrefix(string(i)) +trimPrefix(string(list)) +trimPrefix(string(nil)) +trimPrefix(string(ok)) +trimPrefix(string(str)) +trimPrefix(string(true)) +trimPrefix(toBase64(str)) +trimPrefix(toJSON(0)) +trimPrefix(toJSON(1.0)) +trimPrefix(toJSON(array)) +trimPrefix(toJSON(f64)) +trimPrefix(toJSON(false)) +trimPrefix(toJSON(foo)) +trimPrefix(toJSON(i)) +trimPrefix(toJSON(nil)) +trimPrefix(toJSON(ok)) +trimPrefix(toJSON(str)) +trimPrefix(toJSON(true)) +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(f64)) +trimPrefix(type(false)) +trimPrefix(type(foo)) +trimPrefix(type(i)) +trimPrefix(type(nil)) +trimPrefix(type(true)) +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(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(f64)) +trimSuffix(string(false)) +trimSuffix(string(foo)) +trimSuffix(string(foo.Bar)) +trimSuffix(string(greet)) +trimSuffix(string(i)) +trimSuffix(string(list)) +trimSuffix(string(nil)) +trimSuffix(string(ok)) +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(list)) +trimSuffix(toJSON(nil)) +trimSuffix(toJSON(ok)) +trimSuffix(toJSON(str)) +trimSuffix(toJSON(true)) +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(false)) +trimSuffix(type(foo)) +trimSuffix(type(greet)) +trimSuffix(type(i)) +trimSuffix(type(list)) +trimSuffix(type(nil)) +trimSuffix(type(ok)) +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 ? 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 * 0) +type(1 * 1.0) +type(1 * f64) +type(1 * i) +type(1 ** 1.0) +type(1 ** f64) +type(1 + 0) +type(1 + 1) +type(1 + 1.0) +type(1 .. 0) +type(1 / 1) +type(1 / i) +type(1 <= 0) +type(1 <= 1) +type(1 <= 1.0) +type(1 <= i) +type(1 == i) +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 ^ 0) +type(1 ^ 1) +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(add != $env) +type(add != add) +type(add == nil) +type(add(i, 0)) +type(add) +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, 1 > #)) +type(any(array, ok)) +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) < 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(bitshr(i, 1)) +type(bitxor(i, i)) +type(ceil(0)) +type(ceil(1)) +type(ceil(1.0)) +type(ceil(f64)) +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 >= 1.0) +type(f64 ^ 1) +type(f64 ^ 1.0) +type(f64 ^ i) +type(f64 not in array) +type(f64) +type(f64) > str +type(f64) not startsWith str +type(false != false) +type(false != ok) +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(findIndex($env, ok)) +type(findLast($env, false)) +type(findLast(list, ok)) +type(first($env)) +type(first(array)) +type(first(list)) +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(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.String()) +type(foo.String) +type(foo?.Bar) +type(foo?.String()) +type(foo?.String) +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, 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.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 .. 0) +type(i .. i) +type(i / 1.0) +type(i < i) +type(i <= 0) +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 | bitushr(i)) +type(i) +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(keys($env)) +type(last($env)) +type(last($env)?.String) +type(last($env?.Bar)) +type(last(array)) +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 == $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) == 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, false)) +type(map(list, #)) +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.0)) +type(max(array)) +type(max(f64)) +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(1.0)) +type(min(array)) +type(min(f64)) +type(min(i)) +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 != i) +type(nil != list) +type(nil != nil) +type(nil != str) +type(nil == $env) +type(nil == 0) +type(nil == 1) +type(nil == 1.0) +type(nil == add) +type(nil == array) +type(nil == f64) +type(nil == false) +type(nil == foo) +type(nil == list) +type(nil == nil) +type(nil == ok) +type(nil in $env) +type(nil in array) +type(nil 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(ok != nil) +type(ok == $env) +type(ok == nil) +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(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, $env)) +type(reduce(array, add)) +type(reduce(array, f64)) +type(reduce(array, foo)) +type(reduce(array, ok)) +type(reduce(list, #)) +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(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(array)) +type(string(f64)) +type(string(false != nil)) +type(string(false)) +type(string(foo)) +type(string(greet)) +type(string(list)) +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(list)) +type(toJSON(median(i))) +type(toJSON(nil)) +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 == ok) +type(true ? $env : add) +type(true or false) +type(true or ok) +type(true || false) +type(true || true) +type(true) <= str +type(true) | greet() +type(type($env)) +type(type(0)) +type(type(1)) +type(type(1.0)) +type(type(add)) +type(type(array)) +type(type(f64)) +type(type(false)) +type(type(foo)) +type(type(greet)) +type(type(i)) +type(type(list)) +type(type(str)) +type(type(true)) +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(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(f64)) +upper(string(foo)) +upper(string(foo.Bar)) +upper(string(i)) +upper(string(list)) +upper(string(nil)) +upper(string(ok)) +upper(string(str)) +upper(string(true)) +upper(toBase64(str)) +upper(toJSON(1.0)) +upper(toJSON(array)) +upper(toJSON(f64)) +upper(toJSON(false)) +upper(toJSON(foo)) +upper(toJSON(i)) +upper(toJSON(list)) +upper(toJSON(nil)) +upper(toJSON(ok)) +upper(toJSON(str)) +upper(toJSON(true)) +upper(trim(str)) +upper(trimPrefix(str)) +upper(type(0)) +upper(type(1)) +upper(type(1.0)) +upper(type(add)) +upper(type(array)) +upper(type(f64)) +upper(type(false)) +upper(type(foo)) +upper(type(greet)) +upper(type(list)) +upper(type(nil)) +upper(type(ok)) +upper(type(str)) +upper(type(true)) +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(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}} diff --git a/types/types.go b/types/types.go new file mode 100644 index 000000000..33257c500 --- /dev/null +++ b/types/types.go @@ -0,0 +1,184 @@ +package types + +import ( + "fmt" + "reflect" + "strings" + + . "github.com/expr-lang/expr/checker/nature" +) + +// Type is a type that can be used to represent a value. +type Type interface { + Nature() Nature + Equal(Type) bool + String() string +} + +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{} + Any = anyType{} +) + +func TypeOf(v any) Type { + if v == nil { + return Nil + } + return rtype{t: reflect.TypeOf(v)} +} + +type anyType struct{} + +func (anyType) Nature() Nature { + return FromType(nil) +} + +func (anyType) Equal(t Type) bool { + return true +} + +func (anyType) String() string { + return "any" +} + +type nilType struct{} + +func (nilType) Nature() Nature { + return NatureOf(nil) +} + +func (nilType) Equal(t Type) bool { + if t == Any { + return true + } + return t == Nil +} + +func (nilType) String() string { + return "nil" +} + +type rtype struct { + t reflect.Type +} + +func (r rtype) Nature() Nature { + return FromType(r.t) +} + +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() + } + return false +} + +func (r rtype) String() string { + return r.t.String() +} + +// 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 := 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 + natureOfDefaultValue := v.Nature() + nt.DefaultMapValue = &natureOfDefaultValue + continue + } + nt.Fields[k] = v.Nature() + } + return nt +} + +func (m Map) Equal(t Type) bool { + if t == Any { + return true + } + 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, ", ")) +} + +// 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() + 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 { + if t == Any { + return true + } + 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..15a6ca77a --- /dev/null +++ b/types/types_test.go @@ -0,0 +1,50 @@ +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 // Index added for IDEA to show green test marker per test. + 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}, + {"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}, + {"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}, + {"28", Any, Array(Int), true}, + {"29", Array(Int), Any, true}, + } + + 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()) + } + }) + } +} 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 diff --git a/vm/runtime/runtime.go b/vm/runtime/runtime.go index cd48a280d..56759c531 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() @@ -162,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() @@ -213,7 +222,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 } 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..ed61d2f90 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,7 +21,6 @@ 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) } @@ -38,9 +38,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 @@ -67,16 +67,19 @@ 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 { vm.Variables = make([]any, program.variables) } - - vm.memoryBudget = MemoryBudget + if vm.MemoryBudget == 0 { + vm.MemoryBudget = conf.DefaultMemoryBudget + } vm.memory = 0 vm.ip = 0 @@ -332,10 +335,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) } @@ -457,7 +458,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++ @@ -599,7 +600,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") } } @@ -615,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 + } +} diff --git a/vm/vm_test.go b/vm/vm_test.go index 3ed57d75b..817fc6cc2 100644 --- a/vm/vm_test.go +++ b/vm/vm_test.go @@ -4,8 +4,11 @@ import ( "errors" "fmt" "reflect" + "strings" "testing" + "time" + "github.com/expr-lang/expr/file" "github.com/expr-lang/expr/internal/testify/require" "github.com/expr-lang/expr" @@ -259,3 +262,1072 @@ 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.OpCall, + vm.OpProfileEnd, + }, + Arguments: []int{0, 1, 0, 0}, + Constants: []any{ + &vm.Span{}, + func() (any, error) { + time.Sleep(time.Millisecond * 10) + return nil, nil + }, + }, + } + + testVM := &vm.VM{} + _, err := testVM.Run(program, nil) + require.NoError(t, err) + + span := program.Constants[0].(*vm.Span) + require.Greater(t, span.Duration, time.Millisecond) +} + +// 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( + file.Source{}, // 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( + file.Source{}, // 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( + file.Source{}, // 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) + } + }) + } +} + +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) + } + }) + } +}