mirror of
https://github.com/hanzoai/expr.git
synced 2026-09-24 16:58:58 +00:00
22360 lines
466 KiB
Plaintext
22360 lines
466 KiB
Plaintext
$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}}
|