$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}}