!!!ok
!!$env?.ok
!!false
!!not false
!!ok
!!ok ?? 1
!!true
!$env && false
!$env and !true
!$env and false
!$env or true
!$env || true
!$env.ok
!$env.ok ?? foo
!$env?.ok
!all($env, false)
!all($env, true)
!all(array, false)
!all(array, true)
!all(list, true)
!any($env, false)
!any($env, ok)
!any($env, true)
!any(array, false)
!any(array, ok ?? #)
!any(array, ok)
!any(array, true)
!any(list, ok)
!false != $env
!false != 0 ?? false
!false != false
!false != nil
!false != ok
!false != true
!false && $env
!false && false
!false && ok
!false && true
!false == $env
!false == false
!false == nil
!false == ok
!false == ok == ok
!false == true
!false ? 0 : f64
!false ? 0 : nil
!false ? 1 : ok
!false ? 1.0 : 0
!false ? add : array
!false ? add : foo
!false ? array : $env
!false ? array : nil
!false ? f64 : true
!false ? false : foo
!false ? false : greet
!false ? false : true
!false ? foo : $env
!false ? foo : foo
!false ? foo : greet
!false ? str : $env
!false ?: $env
!false ?: 1.0
!false ?: bitnand(i, 1)
!false ?: foo
!false ?: list
!false ?: nil
!false ?: true
!false ?? $env
!false ?? $env?.String
!false ?? 0
!false ?? 1
!false ?? 1.0
!false ?? add
!false ?? array
!false ?? f64
!false ?? false
!false ?? foo
!false ?? greet
!false ?? i
!false ?? list
!false ?? nil
!false ?? ok
!false ?? sortBy($env, $env)
!false ?? str
!false ?? true
!false and $env
!false and 1.0 != f64
!false and 1.0 ?? list
!false and false
!false and false == $env
!false and ok
!false and true
!false or $env
!false or 1.0 != f64
!false or false
!false or ok
!false or true
!false || $env
!false || $env?.[$env]
!false || $env?.[greet()]
!false || $env?.[greet]
!false || false
!false || ok
!false || true
!false; foo
!nil ?? false
!nil ?? false || true
!nil ?? ok
!nil ?? true
!none($env, false)
!none($env, ok)
!none($env, true)
!none(array, ok)
!none(array, true)
!none(list, ok)
!not !false
!not !ok
!not $env.ok
!not false
!not not false
!not ok
!not true
!ok
!ok != $env
!ok != false
!ok != nil
!ok != ok
!ok != true
!ok && $env
!ok && $env?.Bar
!ok && $env?.[i]
!ok && false
!ok && list not in $env
!ok && ok
!ok && true
!ok == $env
!ok == false
!ok == nil
!ok == nil == nil
!ok == ok
!ok == true
!ok ? $env : $env
!ok ? $env : 0
!ok ? $env : str
!ok ? 1 : str
!ok ? 1.0 : 1.0
!ok ? 1.0 : str
!ok ? add : ok
!ok ? array : false
!ok ? foo : 1
!ok ? foo : foo
!ok ? list : foo
!ok ? nil : 1.0
!ok ? nil : true
!ok ?: $env
!ok ?: $env?.f64
!ok ?: i
!ok ?: ok
!ok ?: str
!ok ?? $env
!ok ?? $env?.add
!ok ?? 0
!ok ?? 1
!ok ?? 1.0
!ok ?? add
!ok ?? array
!ok ?? f64
!ok ?? false
!ok ?? foo
!ok ?? foo?.String
!ok ?? greet
!ok ?? i
!ok ?? list
!ok ?? nil
!ok ?? ok
!ok ?? str
!ok ?? true
!ok and $env
!ok and $env ?? ok
!ok and false
!ok and ok
!ok and true
!ok not in $env?.[Bar]
!ok or $env
!ok or $env?.Bar
!ok or false
!ok or ok
!ok or true
!ok || $env
!ok || $env ?? f64
!ok || false
!ok || foo ?? i
!ok || greet == $env
!ok || ok
!ok || true
!one($env, false)
!one($env, ok)
!one($env, true)
!one(array, false)
!one(array, true)
!one(list, ok)
!reduce($env, false, foo)
!reduce([true], $env != nil)
!reduce(array, false, list)
!reduce(array, ok)
!reduce(array, ok, $env)
!reduce(array, true)
!reduce(list, false)
!reduce(list, ok)
!reduce(list, true)
!true != $env
!true != $env?.[foobar]
!true != false
!true != nil
!true != ok
!true != true
!true && $env
!true && $env?.[Bar]
!true && 1 ?? foo
!true && 1.0 != nil
!true && false
!true && not $env
!true && ok
!true && true
!true == $env
!true == $env?.String
!true == false
!true == nil
!true == ok
!true == true
!true ? 1 : false
!true ? 1.0 : 1.0
!true ? 1.0 : str
!true ? add : 1.0
!true ? array : 0
!true ? f64 : f64
!true ? nil : false
!true ? str : 1.0
!true ? str : add
!true ? str : nil
!true ? str : str
!true ?: array
!true ?: false
!true ?: foo
!true ?: i
!true ?: nil
!true ?: ok
!true ?: str
!true ?? $env
!true ?? $env?.array
!true ?? 0
!true ?? 1
!true ?? 1.0
!true ?? add
!true ?? array
!true ?? date($env, foo)
!true ?? f64
!true ?? false
!true ?? foo
!true ?? greet
!true ?? i
!true ?? list
!true ?? nil
!true ?? ok
!true ?? str
!true ?? true
!true and $env
!true and false
!true and nil ?? $env
!true and ok
!true and true
!true not in [$env]
!true or $env
!true or $env == foo
!true or false
!true or ok
!true or true
!true || $env
!true || false
!true || ok
!true || true
$env != $env == ok
$env != $env ?: greet
$env != $env or f64 ?? foo
$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?.String?.String
$env != $env?.[Bar]
$env != $env?.[Bar]?.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?.foobar?.ok
$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 != 0 ?? add
$env != 0 ?? ok
$env != 1 != $env?.[str]
$env != 1 / f64
$env != 1.0 != $env.ok
$env != 1.0 * $env.i
$env != 1.0 * f64
$env != 1.0 * i
$env != 1.0 ** i && false
$env != 1.0 + f64
$env != 1.0 - f64
$env != 1.0 / i
$env != 1.0 == $env?.false
$env != 1.0 ?? foo
$env != 1.0 ?? ok
$env != 1.0 or ok
$env != 1.0 || abs($env)
$env != add ? add : ok ?: array
$env != add || $env + $env
$env != add || 1.0 not in $env
$env != array or ok
$env != array?.[i]
$env != f64 && ok
$env != f64 + i
$env != f64 / f64
$env != f64 ? $env?.ok : foo
$env != f64 and ok
$env != false != ok
$env != foo != greet ?? 1
$env != foo && add ?? foo
$env != foo == $env?.[String]
$env != foo == ok
$env != foo ?? add
$env != foo ?? ok
$env != foo ?? str
$env != foo and ok
$env != foo.Bar
$env != foo.String
$env != foo.String()
$env != foo?.Bar
$env != foo?.String
$env != foo?.String()
$env != greet ?? add
$env != greet ?? f64
$env != i ?? f64 ?? foo
$env != i ?? i
$env != i ?? list
$env != i not in toPairs($env)
$env != i or one($env, true)
$env != i || ok
$env != list ?? flatten($env)
$env != list ?? list
$env != list and ok
$env != list or ok
$env != list?.[i]
$env != nil != ok
$env != nil ?? array
$env != nil ?? i
$env != nil ?? ok
$env != ok ?? add
$env != str && ok
$env != str + str
$env != str in $env?.[String]
$env != str || 1 in $env
$env != true ?? list
$env != true ?? ok
$env != true and nil != nil
$env && false && 1.0 == 1.0
$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 && ok
$env == $env ?: i != $env
$env == $env ?? $env?.[ok]
$env == $env ?? f64
$env == $env and ok
$env == $env or $env?.Bar()
$env == $env or ok
$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?.$env?.[list]
$env == $env?.Bar
$env == $env?.String
$env == $env?.String?.foo
$env == $env?.String?.foobar?.[array]
$env == $env?.String?.list
$env == $env?.[Bar]
$env == $env?.[Bar]?.[i]
$env == $env?.[Bar]?.[ok]?.[array]
$env == $env?.[Bar]?.foo
$env == $env?.[Bar]?.i
$env == $env?.[String]
$env == $env?.[foobar?.Bar]
$env == $env?.[foobar]
$env == $env?.[str]
$env == $env?.add
$env == $env?.array
$env == $env?.f64
$env == $env?.f64 / i
$env == $env?.foo
$env == $env?.foo.Bar
$env == $env?.foobar
$env == $env?.greet
$env == $env?.i
$env == $env?.list
$env == $env?.ok
$env == $env?.str
$env == 0 ?? list
$env == 0 ?? ok == ok
$env == 0 ^ f64
$env == 0 and take($env, 0)
$env == 1 && ok
$env == 1 * f64
$env == 1 .. i
$env == 1 ?: array
$env == 1.0 && $env != greet
$env == 1.0 && map($env, false)?.[i]
$env == 1.0 ** 1 ?: 1
$env == 1.0 ** f64
$env == 1.0 - f64
$env == 1.0 / $env?.i
$env == 1.0 == $env?.Bar
$env == 1.0 == none(array, true)
$env == 1.0 ?: $env?.greet
$env == 1.0 ?? i
$env == 1.0 ?? ok
$env == 1.0 ^ $env?.f64
$env == 1.0 ^ f64
$env == 1.0 and add != add
$env == 1.0 or foo ?? str
$env == add ?? array
$env == add and $env[foo:]
$env == add or nil != foo
$env == array ?? -1.0
$env == array ?? add
$env == array and ok
$env == array?.[i]
$env == f64 * f64
$env == f64 - f64
$env == f64 - i
$env == f64 == ok
$env == false == ok
$env == false not in $env?.[Bar]
$env == false not in $env?.[String]
$env == foo != !ok
$env == foo && ok
$env == foo == $env ?? 1.0
$env == foo ?? add
$env == foo ?? list
$env == foo ?? ok
$env == foo || ok
$env == foo.Bar
$env == foo.String
$env == foo.String()
$env == foo?.Bar
$env == foo?.String
$env == foo?.String()
$env == greet ?? $env?.[str]
$env == i ** f64
$env == i || ok
$env == list && $env not in list
$env == list && findLast($env, .array)
$env == list or ok
$env == list?.[i]
$env == list[i:]
$env == nil != ok
$env == nil && 1.0 > i
$env == nil ?? type(foo)
$env == nil or all($env, false)
$env == ok ?? ok
$env == ok and $env in foo
$env == ok and not $env?.String
$env == str && ok or $env
$env == str ?? 1 and ok
$env == str ?? add
$env == str ?? lastIndexOf($env, str)
$env == str || ok
$env == true && f64 ?? 1
$env == true ?? !true
$env == true ?? list
$env == true || ok
$env >= 1.0 == $env or true
$env ?? $env ?? timezone($env)
$env ?? $env | map($env)
$env ?? $env | map(i)
$env ?? $env | map(str)
$env ?? $env | reduce(true, true)
$env ?? $env.add
$env ?? $env.array
$env ?? $env.f64
$env ?? $env.foo
$env ?? $env.foo?.String
$env ?? $env.greet
$env ?? $env.i
$env ?? $env.list
$env ?? $env.ok
$env ?? $env.str
$env ?? $env?.$env?.[add]
$env ?? $env?.$env?.array
$env ?? $env?.Bar
$env ?? $env?.Bar()
$env ?? $env?.Bar()?.add
$env ?? $env?.Bar(String(foobar) | float(String))
$env ?? $env?.Bar?.add
$env ?? $env?.Bar?.f64
$env ?? $env?.String
$env ?? $env?.String()
$env ?? $env?.String(String ?? not foobar)
$env ?? $env?.String.f64
$env ?? $env?.String.greet
$env ?? $env?.String?.i(foo)
$env ?? $env?.[Bar]
$env ?? $env?.[String]
$env ?? $env?.[add]
$env ?? $env?.[array]
$env ?? $env?.[f64]
$env ?? $env?.[foo?.add]
$env ?? $env?.[foo]
$env ?? $env?.[foobar | sortBy(1)]
$env ?? $env?.[foobar.foobar]
$env ?? $env?.[foobar?.[f64]]
$env ?? $env?.[foobar]
$env ?? $env?.[greet || false]
$env ?? $env?.[greet?.f64]
$env ?? $env?.[greet]
$env ?? $env?.[greet] | any(ok)
$env ?? $env?.[greet]?.f64
$env ?? $env?.[i]
$env ?? $env?.[i].foo()
$env ?? $env?.[list]
$env ?? $env?.[ok()]
$env ?? $env?.[ok?.[str]]
$env ?? $env?.[ok]
$env ?? $env?.[str]
$env ?? $env?.[str].i
$env ?? $env?.add
$env ?? $env?.array
$env ?? $env?.f64
$env ?? $env?.findLast(ok)
$env ?? $env?.foo
$env ?? $env?.foobar
$env ?? $env?.greet
$env ?? $env?.i
$env ?? $env?.list
$env ?? $env?.ok
$env ?? $env?.str
$env ?? $env[:1 not endsWith foobar]
$env ?? $env[:Bar()]
$env ?? $env[:f64()]
$env ?? $env[:f64(foobar)]
$env ?? $env[:filter(foobar, #)]
$env ?? $env[:foo.foo]
$env ?? $env[:foobar not startsWith greet].f64
$env ?? $env[:foobar]
$env ?? $env[:nil | any(array)]?.[i]
$env ?? $env[:str | foo(0)]
$env ?? $env[String(String):]
$env ?? $env[String(i):$env?.array(foo, false)]
$env ?? $env[array():]
$env ?? $env[filter(foobar, #):]
$env ?? $env[foo:String]
$env ?? $env[foobar | groupBy(1.0):]
$env ?? $env[foobar || Bar:]
$env ?? $env[foobar:]
$env ?? $env[foobar[foobar:0]:foobar]
$env ?? $env[list():true <= 1.0]
$env ?? $env[list:foobar]
$env ?? $env[str | groupBy(#.list):]
$env ?? 0 | filter(false)
$env ?? 0 | find(false)
$env ?? 0 | map(array)
$env ?? 0 | map(false)
$env ?? 0 | map(str)
$env ?? 0 | none(true)
$env ?? 1 | map(#index)
$env ?? 1 | sum(f64)
$env ?? 1.0 ?? array
$env ?? 1.0 ?? greet
$env ?? 1.0 | findIndex(ok)
$env ?? 1.0 | map($env)
$env ?? 1.0 | map(ok)
$env ?? 1.0 | sum(0)
$env ?? 1.0 | sum(i)
$env ?? add | any(false)
$env ?? add | reduce(foo, nil)
$env ?? array | map($env)
$env ?? array | map(foo)
$env ?? array | map(true)
$env ?? array | reduce(i, 1.0)
$env ?? array | sum(1.0)
$env ?? array?.[i]
$env ?? f64 ?? f64
$env ?? f64 | find(false)
$env ?? f64 | findLastIndex(ok)
$env ?? f64 | map(add)
$env ?? f64 | map(str)
$env ?? false | all(false)
$env ?? false | none(true)
$env ?? false | sum(1.0)
$env ?? foo ?? $env?.[str]
$env ?? foo ?? array
$env ?? foo ?? f64
$env ?? foo ?? i
$env ?? foo | any(false)
$env ?? foo | count(true)
$env ?? foo | map(1.0)
$env ?? foo | none(ok)
$env ?? foo | one(ok)
$env ?? foo | reduce(f64, $env)
$env ?? foo | sum(1.0)
$env ?? foo | sum(i)
$env ?? foo.Bar
$env ?? foo.String
$env ?? foo.String()
$env ?? foo?.Bar
$env ?? foo?.String
$env ?? foo?.String()
$env ?? greet ?? i
$env ?? greet | map($env)
$env ?? greet | none(true)
$env ?? greet | sum(1.0)
$env ?? i ?? array
$env ?? i | map(0)
$env ?? i | sum(0)
$env ?? list | any(false)
$env ?? list?.[i]
$env ?? nil ?? false | map(foo)
$env ?? nil ?? i
$env ?? nil ?? str
$env ?? nil | all(ok)
$env ?? nil | any(true)
$env ?? nil | filter(0 >= 1)
$env ?? nil | findLastIndex(true)
$env ?? nil | none(false)
$env ?? nil | none(true)
$env ?? nil | reduce(str, true)
$env ?? nil | sum(1)
$env ?? ok ?? ok
$env ?? ok | map(true)
$env ?? ok | none(ok)
$env ?? str ?? $env?.add
$env ?? str | map(foo)
$env ?? str | map(ok)
$env ?? str | none(true)
$env ?? str | sum(0)
$env ?? true | all(true)
$env ?? true | findLastIndex(true)
$env ?? true | none(ok)
$env and false or 1.0 != f64
$env contains $env?.Bar
$env contains $env?.Bar?.str
$env contains $env?.String
$env contains $env?.String?.foo
$env contains $env?.String?.list
$env contains $env?.[Bar]
$env contains $env?.[Bar]?.Bar
$env contains $env?.[Bar]?.[f64]
$env contains $env?.[String]
$env contains $env?.[String]?.[foo]
$env contains $env?.[foobar]
$env contains $env?.[str[:1.0]]
$env contains $env?.foobar
$env contains $env?.nil?.[list]
$env endsWith $env?.Bar
$env endsWith $env?.Bar?.[foo]
$env endsWith $env?.String
$env endsWith $env?.String?.[array]
$env endsWith $env?.[Bar]
$env endsWith $env?.[Bar]?.[f64]
$env endsWith $env?.[Bar]?.[foo].i
$env endsWith $env?.[Bar]?.str
$env endsWith $env?.[String?.array]
$env endsWith $env?.[String]
$env endsWith $env?.[foobar?.[add]]
$env endsWith $env?.[foobar]
$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?.ok()]
$env in $env?.[Bar]
$env in $env?.[Bar]?.add?.[i]
$env in $env?.[String?.[str]]
$env in $env?.[String]
$env in $env?.[String]?.foo(foo)
$env in $env?.[foobar]
$env in $env?.array
$env in $env?.foo || true
$env in $env?.foobar
$env in $env?.foobar?.foo
$env in $env?.foobar?.list(foo)
$env in $env?.list
$env in $env?.true?.f64(foobar)
$env in 0 .. i
$env in 1 .. i
$env in 1..i
$env in array ?: ok
$env in array ?? greet
$env in array or ok
$env in array[:]
$env in array[:i]
$env in i .. $env.i
$env in list && $env and $env
$env in list and $env?.[f64]
$env in list and max($env)
$env in nil ?? list
$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?.[foobar]]
$env matches $env?.[String]
$env matches $env?.[String]?.ok()
$env matches $env?.[foobar]
$env matches $env?.[last(foo)]
$env matches $env?.foobar
$env matches $env?.foobar?.Bar(foobar, foobar)
$env matches $env?.foobar?.greet()
$env matches $env?.foobar?.greet(foobar, 1)
$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?.str]
$env not contains $env?.[String]
$env not contains $env?.[first(foobar, greet)]
$env not contains $env?.[foobar?.array()]
$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 contains $env?.foobar?.i
$env not contains $env?.nil?.f64
$env not endsWith $env?.Bar
$env not endsWith $env?.Bar?.[list]
$env not endsWith $env?.String
$env not endsWith $env?.String?.[greet]
$env not endsWith $env?.[Bar]
$env not endsWith $env?.[String]
$env not endsWith $env?.[foobar]
$env not endsWith $env?.foobar
$env not endsWith $env?.nil?.add()
$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?.list]
$env not in $env?.[foobar]
$env not in $env?.array
$env not in $env?.foobar
$env not in $env?.foobar?.[foo]
$env not in $env?.foobar?.foobar
$env not in $env?.list
$env not in 1 .. 1 ?? add
$env not in 1..i
$env not in array && ok
$env not in array == $env || false
$env not in array == $env?.[String]
$env not in array || i ?? false
$env not in array[:i]
$env not in list and 1 <= f64
$env not in list and greet == greet
$env not in list or ok
$env not in nil ?? list
$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?.String?.array
$env not matches $env?.[Bar]
$env not matches $env?.[Bar]?.[str]
$env not matches $env?.[String?.[Bar]]
$env not matches $env?.[String]
$env not matches $env?.[String]?.[add]
$env not matches $env?.[foobar?.[0]]
$env not matches $env?.[foobar]
$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]?.Bar
$env not startsWith $env?.[Bar]?.f64
$env not startsWith $env?.[String]
$env not startsWith $env?.[String]?.[f64]
$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?.Bar?.Bar
$env startsWith $env?.Bar?.add
$env startsWith $env?.String
$env startsWith $env?.[Bar]
$env startsWith $env?.[String]
$env startsWith $env?.[String]?.greet
$env startsWith $env?.[foobar]
$env startsWith $env?.[foobar]?.[i]
$env startsWith $env?.foobar
$env startsWith $env?.foobar?.Bar()
$env | all(false) && $env?.[f64]
$env | all(ok) && ok
$env | all(ok) or -$env
$env | any(false) != ok
$env | any(false) ?? str
$env | any(ok) != ok
$env | any(ok) == ok
$env | count(ok) | min(0)
$env | count(true) .. -i
$env | filter(#) | filter(false)
$env | filter(#.f64) | filter(false)
$env | filter(false) | all(#.str())
$env | filter(false) | all($env)
$env | filter(false) | all(true)
$env | filter(false) | any(#)
$env | filter(false) | any(.list)
$env | filter(false) | count($env)
$env | filter(false) | count(.i.greet)
$env | filter(false) | filter(.str)
$env | filter(false) | find($env)
$env | filter(false) | findIndex(#.ok)
$env | filter(false) | findIndex(.String)
$env | filter(false) | findIndex(.foo)
$env | filter(false) | findLast(.greet)
$env | filter(false) | findLast(.ok)
$env | filter(false) | findLastIndex(.i)
$env | filter(false) | groupBy(#.f64)
$env | filter(false) | groupBy(str)
$env | filter(false) | map(#)
$env | filter(false) | one(#)
$env | filter(false) | one(.foo)
$env | filter(false) | sum(#)
$env | filter(false) | sum(.greet)
$env | filter(true) | map($env)
$env | filter(true) | map(1.0)
$env | find(.add) startsWith str || true
$env | find(false) ?? $env?.String
$env | findIndex(false) not in array
$env | findIndex(ok) <= i
$env | findIndex(true) ?? f64
$env | findLast(false) == str or true
$env | findLast(false) | get(nil)
$env | findLastIndex(false) in sort($env)
$env | findLastIndex(true) + f64
$env | findLastIndex(true) - i
$env | findLastIndex(true) > i
$env | get(str) | groupBy(foo)
$env | map(#index) != array
$env | map(#index) | findIndex(true)
$env | map(#index) | groupBy(f64)
$env | map(#index) | map(i)
$env | map(#index) | reduce(f64, nil)
$env | map(#index) | sortBy(f64)
$env | map($env) | count(ok)
$env | map($env) | find(#.ok)
$env | map($env) | findIndex(false)
$env | map($env) | map(#.ok)
$env | map($env) | map(.array)
$env | map($env) | map(list)
$env | map($env) | map(true)
$env | map($env) | reduce(add)
$env | map($env) | reduce(true)
$env | map($env) | sortBy(#.i)
$env | map($env) | sortBy(.i)
$env | map($env) | sortBy(i)
$env | map(0) == list
$env | map(0) | all(ok)
$env | map(0) | groupBy(1)
$env | map(0) | map(ok)
$env | map(0) | sortBy(#)
$env | map(0) | sortBy(1.0)
$env | map(0) | sum(#)
$env | map(0) | sum(1.0)
$env | map(1) | groupBy(#)
$env | map(1) | map($env)
$env | map(1) | sum(#)
$env | map(1) | sum(f64)
$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(ok)
$env | map(1.0) | none(true)
$env | map(1.0) | reduce(#)
$env | map(1.0) | reduce(1.0)
$env | map(1.0) | reduce(false, list)
$env | map(1.0) | sortBy(#)
$env | map(add) | count(true)
$env | map(add) | reduce(#, 1.0)
$env | map(array) ?? i
$env | map(array) | findIndex(ok)
$env | map(array) | map(add)
$env | map(array) | one(false)
$env | map(f64) | map(#)
$env | map(false) | groupBy(1)
$env | map(false) | map(f64)
$env | map(false) | reduce(foo, i)
$env | map(false) | reduce(str)
$env | map(foo) ?? array
$env | map(foo) | any(false)
$env | map(foo) | findIndex(true)
$env | map(foo) | groupBy(#)
$env | map(foo) | groupBy(1)
$env | map(foo) | map(#)
$env | map(foo) | map(list)
$env | map(foo) | none(ok)
$env | map(foo) | reduce(#acc)
$env | map(foo) | reduce($env, $env)
$env | map(foo) | sum(1)
$env | map(greet) | map(array)
$env | map(greet) | map(greet)
$env | map(greet) | reduce(foo)
$env | map(i) ?? greet
$env | map(i) | count(false)
$env | map(i) | groupBy(1.0)
$env | map(list) ?? list
$env | map(list) | any(false)
$env | map(list) | any(ok)
$env | map(list) | reduce(ok)
$env | map(list) | reduce(true)
$env | map(ok) ?? 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) != list
$env | map(str) | findIndex(ok)
$env | map(str) | groupBy(foo)
$env | map(str) | map(1)
$env | map(str) | map(foo)
$env | map(str) | reduce(#)
$env | map(str) | sortBy(str)
$env | map(true) ?? array
$env | map(true) ?? str
$env | map(true) | all(#)
$env | map(true) | count(#)
$env | map(true) | filter(#)
$env | map(true) | find(false)
$env | map(true) | findLastIndex(#)
$env | map(true) | groupBy(foo)
$env | map(true) | map(#)
$env | map(true) | map($env)
$env | median(1.0) or true || true
$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(0, false) | max(1.0, f64)
$env | reduce(1.0, 1) <= f64
$env | reduce(false, $env); list
$env | reduce(greet, array) ?? foo
$env | reduce(ok, 1) ?: greet
$env | reduce(str, foo) not startsWith str
$env | sum(#) not endsWith $env or true
$env | sum(1.0) <= i
$env | sum(1.0) in array
$env | sum(f64) > f64
$env | sum(f64) ?? ok
$env | sum(i) / bitnot(i)
$env || false and $env?.Bar()
$env || true || $env < 1
$env.add != $env?.add
$env.add == $env.add
$env.add == $env?.add
$env.add == add
$env.add ?? !false
$env.add ?? $env?.foo
$env.add ?? [i]
$env.add ?? add
$env.add ?? array
$env.add ?? count(array)
$env.add ?? foo
$env.add ?? greet
$env.add ?? groupBy(array, $env)
$env.add ?? i
$env.add ?? list
$env.add ?? list ?? nil
$env.add ?? ok
$env.add ?? str
$env.add ?? sum($env)
$env.add not in [nil, false]
$env.add(1, 1) < f64 && ok
$env.array != array
$env.array != list
$env.array == $env?.array
$env.array == array
$env.array == list
$env.array ?? !true
$env.array ?? $env | groupBy(#)
$env.array ?? $env?.Bar
$env.array ?? $env?.[String]
$env.array ?? $env?.add
$env.array ?? [nil]
$env.array ?? add
$env.array ?? array
$env.array ?? f64
$env.array ?? foo | findLastIndex(false)
$env.array ?? greet
$env.array ?? list
$env.array ?? ok
$env.array | all(false)
$env.array | all(ok)
$env.array | all(true)
$env.array | any($env?.ok)
$env.array | any(false)
$env.array | any(nil == #)
$env.array | any(ok)
$env.array | concat(array)
$env.array | concat(list)
$env.array | count(false)
$env.array | count(true)
$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(false)
$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(false)
$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($env?.[String])
$env.array | map(1)
$env.array | map(1.0)
$env.array | map(array)
$env.array | map(f64)
$env.array | map(false)
$env.array | map(float(1.0))
$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 | median(1.0)
$env.array | median(i)
$env.array | min(0)
$env.array | min(1)
$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.array | reduce(#, $env)
$env.array | reduce(#, 0)
$env.array | reduce(#, 1)
$env.array | reduce(#, false)
$env.array | reduce(#, foo)
$env.array | reduce(#, greet)
$env.array | reduce(#index)
$env.array | reduce($env)
$env.array | reduce($env, 1.0)
$env.array | reduce(0)
$env.array | reduce(1)
$env.array | reduce(1.0)
$env.array | reduce(1.0, f64)
$env.array | reduce(1.0, greet)
$env.array | reduce(add)
$env.array | reduce(add, greet)
$env.array | reduce(add, true)
$env.array | reduce(array)
$env.array | reduce(f64)
$env.array | reduce(f64, 0)
$env.array | reduce(f64, i)
$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(foo, i)
$env.array | reduce(greet)
$env.array | reduce(i)
$env.array | reduce(i, true)
$env.array | reduce(list)
$env.array | reduce(not false)
$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(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(0)
$env.array | sum(1)
$env.array | sum(1.0)
$env.array | sum(i)
$env.array | take(0)
$env.array | take(1)
$env.array | take(i)
$env.array?.[i]
$env.array[:]
$env.array[:i]
$env.f64 != $env.i
$env.f64 != -1.0
$env.f64 != 0 % i
$env.f64 != abs(f64)
$env.f64 != f64
$env.f64 != i
$env.f64 != sum(array)
$env.f64 * 0 >= 1.0
$env.f64 * array?.[i]
$env.f64 * f64
$env.f64 * i
$env.f64 * i ?? str
$env.f64 ** f64
$env.f64 ** i
$env.f64 ** sum(array)
$env.f64 + $env.i
$env.f64 + f64
$env.f64 + f64 == 1
$env.f64 + i
$env.f64 - 1 >= f64
$env.f64 - 1.0 > 0
$env.f64 - f64
$env.f64 - i
$env.f64 - i ^ 0
$env.f64 / 0.0
$env.f64 / f64
$env.f64 / i
$env.f64 < 1.0 ?: list
$env.f64 < 1.0 || ok
$env.f64 < f64
$env.f64 < i
$env.f64 <= $env.i
$env.f64 <= 1.0 != false
$env.f64 <= f64
$env.f64 <= i
$env.f64 <= i ?? foo
$env.f64 == $env.f64
$env.f64 == f64
$env.f64 == i
$env.f64 > $env.f64
$env.f64 > bitushr(0, i)
$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 ?? !true
$env.f64 ?? add
$env.f64 ?? f64
$env.f64 ?? foo
$env.f64 ?? greet
$env.f64 ?? i
$env.f64 ?? list
$env.f64 ?? list?.[i]
$env.f64 ?? ok
$env.f64 ?? sortBy(list, f64)
$env.f64 ?? str
$env.f64 ^ 0 / 0
$env.f64 ^ f64
$env.f64 ^ i
$env.f64 ^ i != $env
$env.f64 in array
$env.f64 in array and ok
$env.f64 not in array ? i : $env
$env.f64 not in first($env)
$env.f64 | max(1.0)
$env.f64 | max(f64)
$env.f64 | max(i, 1.0)
$env.f64 | mean(0)
$env.f64 | mean(1)
$env.f64 | mean(f64)
$env.f64 | median(i)
$env.f64 | min(0)
$env.f64 | min(array)
$env.f64 | min(i)
$env.foo != $env.foo
$env.foo != $env?.foo
$env.foo != foo
$env.foo != {foo: list, foo: true, foo: $env}?.foo
$env.foo == $env?.foo
$env.foo == foo
$env.foo == nil == $env
$env.foo == nil and ok
$env.foo ?? $env.array
$env.foo ?? $env?.[add]
$env.foo ?? add
$env.foo ?? all($env, true)
$env.foo ?? array
$env.foo ?? array?.[i]
$env.foo ?? foo
$env.foo ?? greet
$env.foo ?? greet(str)
$env.foo ?? i
$env.foo ?? last(array)
$env.foo ?? list
$env.foo ?? ok
$env.foo ?? str
$env.foo ?? sum($env, 1.0)
$env.foo in list
$env.foo not in list
$env.foo.Bar
$env.foo.String
$env.foo.String()
$env.foo?.Bar
$env.foo?.Bar > str
$env.foo?.String
$env.foo?.String()
$env.greet != $env && $env
$env.greet != $env.greet
$env.greet != greet
$env.greet == $env?.foobar?.[list]
$env.greet == greet
$env.greet ?? $env?.[list]
$env.greet ?? $env?.list
$env.greet ?? array
$env.greet ?? f64
$env.greet ?? foo
$env.greet ?? greet
$env.greet ?? greet(str)
$env.greet ?? list
$env.greet ?? ok
$env.greet ?? reduce(list, str)
$env.greet ?? str
$env.greet($env.str)
$env.greet($env?.[str])
$env.greet($env?.str)
$env.greet(foo.Bar)
$env.greet(foo.String())
$env.greet(foo?.Bar)
$env.greet(foo?.String())
$env.greet(greet(str))
$env.greet(str)
$env.greet(string($env))
$env.greet(string(1.0))
$env.greet(toJSON(list))
$env.greet(trimPrefix(str))
$env.greet(type(0))
$env.i != $env?.Bar
$env.i != $env?.[Bar]?.foo()
$env.i != 1 / 1
$env.i != 1.0 + 1.0
$env.i != f64
$env.i != i
$env.i % i
$env.i % i != $env
$env.i % i <= 0
$env.i * -i
$env.i * f64
$env.i * i
$env.i * min(0)
$env.i ** f64
$env.i ** i
$env.i ** mean(1.0)
$env.i + f64
$env.i + i
$env.i - -0
$env.i - -1.0
$env.i - 1 == 1.0
$env.i - ceil(1)
$env.i - f64
$env.i - i
$env.i .. i
$env.i / $env.f64
$env.i / f64
$env.i / find(array, true)
$env.i / i
$env.i / i - 0
$env.i < $env.i
$env.i < 1.0 != $env
$env.i < 1.0 or $env
$env.i < f64
$env.i < f64 ^ f64
$env.i < i
$env.i < i / i
$env.i <= 1.0 > 1.0
$env.i <= f64
$env.i <= i
$env.i == $env?.f64
$env.i == f64
$env.i == i
$env.i > $env.i
$env.i > f64
$env.i > i
$env.i >= $env?.i
$env.i >= f64
$env.i >= f64 / f64
$env.i >= i
$env.i ?? $env?.[str]
$env.i ?? add
$env.i ?? array
$env.i ?? f64
$env.i ?? foo?.Bar
$env.i ?? foo?.String
$env.i ?? greet
$env.i ?? i
$env.i ?? ok
$env.i ?? str
$env.i ?? sum(array)
$env.i ?? toJSON(f64)
$env.i ^ f64
$env.i ^ i
$env.i in $env?.[Bar]
$env.i in array
$env.i in array != nil
$env.i in take(array, 0)
$env.i not in $env?.[String]
$env.i not in $env?.array
$env.i not in array
$env.i | add(i)
$env.i | bitnand(i)
$env.i | bitor(0)
$env.i | bitor(1)
$env.i | bitshl(0)
$env.i | bitshl(1)
$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.i | median(1)
$env.list != array
$env.list != list
$env.list == $env?.Bar
$env.list == array
$env.list == list
$env.list == nil || $env
$env.list ?? $env?.[greet]
$env.list ?? $env?.i
$env.list ?? -0
$env.list ?? add
$env.list ?? f64
$env.list ?? false | sortBy(#.Bar)
$env.list ?? foo
$env.list ?? i
$env.list ?? list
$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(ok)
$env.list | count(true)
$env.list | filter(false)
$env.list | filter(ok)
$env.list | filter(true)
$env.list | find(false)
$env.list | find(nil not in list)
$env.list | find(ok)
$env.list | find(true)
$env.list | findIndex(false)
$env.list | findIndex(ok)
$env.list | findIndex(true)
$env.list | findLast(false)
$env.list | findLast(ok)
$env.list | findLast(true)
$env.list | findLastIndex(ok)
$env.list | findLastIndex(true)
$env.list | groupBy(#)
$env.list | groupBy(#.Bar)
$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 | groupBy(ok)
$env.list | groupBy(true)
$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(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(false)
$env.list | none(ok)
$env.list | none(true)
$env.list | one(false)
$env.list | one(foo != $env)
$env.list | one(ok)
$env.list | one(true)
$env.list | reduce(#)
$env.list | reduce(#, $env)
$env.list | reduce(#, 0)
$env.list | reduce(#, 1.0)
$env.list | reduce(#, nil)
$env.list | reduce(#, true)
$env.list | reduce(#.Bar)
$env.list | reduce(#.String)
$env.list | reduce(#acc)
$env.list | reduce(#acc, $env)
$env.list | reduce(#index)
$env.list | reduce($env)
$env.list | reduce(.Bar, 1)
$env.list | reduce(.Bar, 1.0)
$env.list | reduce(.String)
$env.list | reduce(0)
$env.list | reduce(1)
$env.list | reduce(1, $env)
$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(array, 0)
$env.list | reduce(f64)
$env.list | reduce(false)
$env.list | reduce(false, i)
$env.list | reduce(false, str)
$env.list | reduce(foo == #)
$env.list | reduce(foo)
$env.list | reduce(foo, 0)
$env.list | reduce(foo, foo)
$env.list | reduce(foo, i)
$env.list | reduce(foo, nil)
$env.list | reduce(foo, str)
$env.list | reduce(greet)
$env.list | reduce(greet, foo)
$env.list | reduce(i)
$env.list | reduce(i, 1.0)
$env.list | reduce(list)
$env.list | reduce(str)
$env.list | reduce(str, false)
$env.list | reduce(true)
$env.list | reduce(true, 1)
$env.list | sortBy(#.Bar)
$env.list | sortBy(.Bar)
$env.list | sortBy(0)
$env.list | sortBy(1)
$env.list | sortBy(1.0)
$env.list | sortBy(f64)
$env.list | sortBy(i)
$env.list | sortBy(str)
$env.list | sum(0)
$env.list | sum(1)
$env.list | sum(1.0)
$env.list | sum(f64)
$env.list | sum(i)
$env.list?.[$env?.i]
$env.list?.[i]
$env.list?.[i].Bar
$env.list?.[i].String()
$env.list[:]
$env.list[:sum(array, #)]
$env.list[i:]
$env.ok != list ?? foo
$env.ok != ok
$env.ok && $env?.$env
$env.ok && $env?.[nil]
$env.ok && $env?.[str]
$env.ok && array ?? i
$env.ok && f64 == nil
$env.ok && ok
$env.ok == $env ?? ok
$env.ok == nil || true
$env.ok == ok
$env.ok ? list : date(1)
$env.ok ?: array
$env.ok ?: f64
$env.ok ?? add
$env.ok ?? array
$env.ok ?? foo.String
$env.ok ?? i
$env.ok ?? ok
$env.ok ?? str
$env.ok and $env?.[foobar]
$env.ok and $env?.[nil]
$env.ok and f64 < 1.0
$env.ok and ok
$env.ok in $env?.[nil]
$env.ok in keys($env)
$env.ok not in $env?.$env
$env.ok not in [false]
$env.ok or $env?.String.String
$env.ok or $env?.[String]
$env.ok or $env?.ok
$env.ok or not $env
$env.ok or ok
$env.ok || $env?.foobar
$env.ok || array ?? i
$env.ok || ok
$env.str != str
$env.str + $env.str
$env.str + str
$env.str + type($env)
$env.str + type(nil)
$env.str < $env?.[str]
$env.str < foo.Bar
$env.str < str
$env.str <= str
$env.str <= toJSON(ok)
$env.str == $env?.[Bar]
$env.str == str
$env.str > str
$env.str > type(nil)
$env.str >= greet(str)
$env.str >= str
$env.str ?? $env.foo
$env.str ?? add
$env.str ?? array
$env.str ?? f64
$env.str ?? foo
$env.str ?? greet
$env.str ?? greet($env)
$env.str ?? i
$env.str ?? list
$env.str ?? ok
$env.str ?? str
$env.str contains $env?.String
$env.str contains $env?.[Bar]
$env.str contains str
$env.str contains toJSON(foo)
$env.str endsWith str
$env.str endsWith str[:i]
$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 $env?.[str]
$env.str not contains foo.String()
$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 foo?.Bar
$env.str not matches str
$env.str not startsWith foo?.Bar
$env.str not startsWith str
$env.str startsWith str
$env.str | greet()
$env.str | hasPrefix(str)
$env.str | hasSuffix(str)
$env.str | split(str)
$env.str[:]
$env.str[i:]
$env; $env.add
$env; $env.i
$env; $env?.[Bar]
$env; $env?.foo
$env; $env?.i
$env; $env?.ok
$env; $env?.str
$env; false; $env?.foo
$env; list?.[i]
$env?.$env != $env.array
$env?.$env != foo
$env?.$env != i
$env?.$env != str
$env?.$env == add
$env?.$env == foo?.String()
$env?.$env ?? $env ?? greet
$env?.$env ?? array
$env?.$env ?? greet
$env?.$env and $env || true
$env?.$env in foo || true
$env?.$env in list
$env?.$env not contains str
$env?.$env not endsWith str
$env?.$env?.Bar
$env?.$env?.Bar()
$env?.$env?.Bar()?.[foo]
$env?.$env?.Bar?.foo
$env?.$env?.String
$env?.$env?.String()
$env?.$env?.String(foobar)
$env?.$env?.String(greet)
$env?.$env?.[add]
$env?.$env?.[array]
$env?.$env?.[f64]
$env?.$env?.[f64].list.greet
$env?.$env?.[f64]?.str
$env?.$env?.[foo]
$env?.$env?.[foo].ok
$env?.$env?.[greet]
$env?.$env?.[greet].i
$env?.$env?.[i]
$env?.$env?.[i].f64
$env?.$env?.[i].foo
$env?.$env?.[i].str
$env?.$env?.[i]?.[greet]?.greet()
$env?.$env?.[i]?.[ok]
$env?.$env?.[i]?.f64
$env?.$env?.[list]
$env?.$env?.[ok]
$env?.$env?.[str]
$env?.$env?.[str]?.[foo]?.str
$env?.$env?.add
$env?.$env?.add()
$env?.$env?.add().Bar
$env?.$env?.add(foobar?.[str])
$env?.$env?.add(nil == Bar, add)
$env?.$env?.add?.ok
$env?.$env?.array
$env?.$env?.array()
$env?.$env?.array(foobar)
$env?.$env?.array.i
$env?.$env?.array?.[list]
$env?.$env?.array?.[ok]
$env?.$env?.array?.[str]
$env?.$env?.array?.list
$env?.$env?.count(String, foobar)
$env?.$env?.f64
$env?.$env?.f64()
$env?.$env?.f64(foobar)
$env?.$env?.f64.String
$env?.$env?.filter(1.0, foo)
$env?.$env?.findLast(i, i)
$env?.$env?.foo
$env?.$env?.foo.greet
$env?.$env?.foobar.Bar
$env?.$env?.foobar.i(foo)
$env?.$env?.greet
$env?.$env?.greet()
$env?.$env?.greet.foo()
$env?.$env?.greet.i
$env?.$env?.greet?.i()
$env?.$env?.i
$env?.$env?.i()
$env?.$env?.i()?.list
$env?.$env?.i(foobar?.[f64])?.String
$env?.$env?.i(str, foobar?.f64)
$env?.$env?.i?.greet
$env?.$env?.keys(Bar, foobar)
$env?.$env?.list
$env?.$env?.list()
$env?.$env?.list.String
$env?.$env?.list.list
$env?.$env?.list?.foo
$env?.$env?.list?.list
$env?.$env?.ok
$env?.$env?.ok()
$env?.$env?.ok(String)
$env?.$env?.ok.first(0)?.list
$env?.$env?.ok?.String
$env?.$env?.ok?.ok
$env?.$env?.str
$env?.$env?.str()
$env?.$env?.str()?.[add]
$env?.$env?.str(foobar)
$env?.$env?.sum(0, list)
$env?.$env?.uniq(foobar)
$env?.Bar != $env.add
$env?.Bar != add
$env?.Bar != array
$env?.Bar != f64
$env?.Bar != filter(array, true)
$env?.Bar != foo
$env?.Bar != foo && true
$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 == $env?.foobar
$env?.Bar == 1.0 / f64
$env?.Bar == add
$env?.Bar == array
$env?.Bar == f64
$env?.Bar == foo
$env?.Bar == foo.Bar
$env?.Bar == greet
$env?.Bar == greet(str)
$env?.Bar == i
$env?.Bar == list
$env?.Bar == map(array, #)
$env?.Bar == map(list, 1.0)
$env?.Bar == nil ?? 1.0
$env?.Bar == ok
$env?.Bar == ok or true
$env?.Bar == str
$env?.Bar == string(list)
$env?.Bar ?? $env?.str
$env?.Bar ?? -f64
$env?.Bar ?? [foo]
$env?.Bar ?? add
$env?.Bar ?? array
$env?.Bar ?? f64
$env?.Bar ?? foo
$env?.Bar ?? greet
$env?.Bar ?? i
$env?.Bar ?? list
$env?.Bar ?? not ok
$env?.Bar ?? ok
$env?.Bar ?? str
$env?.Bar ?? type(array)
$env?.Bar contains $env?.$env
$env?.Bar contains str
$env?.Bar endsWith $env?.String
$env?.Bar endsWith str
$env?.Bar endsWith str ? foo : 1
$env?.Bar endsWith toJSON(0)
$env?.Bar in array
$env?.Bar matches $env?.[String]
$env?.Bar matches str
$env?.Bar matches string(i)
$env?.Bar not contains mean(array)
$env?.Bar not contains str
$env?.Bar not endsWith $env.str
$env?.Bar not endsWith foo.Bar
$env?.Bar not in $env?.String
$env?.Bar not in $env?.list
$env?.Bar not in [f64, $env]
$env?.Bar not in array
$env?.Bar not in array ?? array
$env?.Bar not in list
$env?.Bar not in list and $env
$env?.Bar not matches greet(str)
$env?.Bar not matches str
$env?.Bar not startsWith $env?.str
$env?.Bar not startsWith 0 ?? array
$env?.Bar not startsWith str
$env?.Bar not startsWith str ?? $env
$env?.Bar startsWith $env ?? foo
$env?.Bar startsWith $env?.[String]
$env?.Bar startsWith 1.0 ?? 0
$env?.Bar startsWith str
$env?.Bar | get(1.0)
$env?.Bar | get(list)
$env?.Bar | get(nil)
$env?.Bar | get(true)
$env?.Bar().foobar or true
$env?.Bar(foobar)?.foobar && false
$env?.Bar; array
$env?.Bar?.$env?.ok()
$env?.Bar?.Bar
$env?.Bar?.Bar()
$env?.Bar?.Bar() != !ok
$env?.Bar?.Bar().Bar
$env?.Bar?.Bar()?.[f64]
$env?.Bar?.Bar(Bar)
$env?.Bar?.Bar(String)
$env?.Bar?.Bar(f64)
$env?.Bar?.Bar(foo != foobar)
$env?.Bar?.Bar(foobar)
$env?.Bar?.Bar(foobar?.String)
$env?.Bar?.Bar(foobar?.[greet])
$env?.Bar?.Bar(foobar?.greet())
$env?.Bar?.Bar(i)
$env?.Bar?.Bar(list)
$env?.Bar?.Bar.String
$env?.Bar?.Bar.add
$env?.Bar?.Bar.i
$env?.Bar?.Bar.list()
$env?.Bar?.Bar.ok
$env?.Bar?.Bar.str()
$env?.Bar?.Bar?.Bar
$env?.Bar?.Bar?.Bar().greet
$env?.Bar?.Bar?.String
$env?.Bar?.Bar?.[f64]
$env?.Bar?.Bar?.[i]
$env?.Bar?.Bar?.[list]
$env?.Bar?.Bar?.i
$env?.Bar?.Bar?.list
$env?.Bar?.Bar?.ok
$env?.Bar?.Bar?.str
$env?.Bar?.String
$env?.Bar?.String()
$env?.Bar?.String()?.[foo]
$env?.Bar?.String(add(foobar, foobar))
$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(foobar?.f64(foobar))
$env?.Bar?.String(greet(Bar))?.foobar
$env?.Bar?.String(greet)
$env?.Bar?.String(i)
$env?.Bar?.String(str | toBase64(foobar), foobar)
$env?.Bar?.String.f64
$env?.Bar?.String.foo
$env?.Bar?.String.i
$env?.Bar?.String.ok
$env?.Bar?.String?.String
$env?.Bar?.String?.[array]
$env?.Bar?.String?.[f64]
$env?.Bar?.String?.[i]
$env?.Bar?.String?.[str]
$env?.Bar?.String?.add()
$env?.Bar?.String?.date(foo)
$env?.Bar?.String?.foo
$env?.Bar?.String?.str()
$env?.Bar?.[$env.i]
$env?.Bar?.[$env?.Bar]
$env?.Bar?.[$env?.[String]]
$env?.Bar?.[$env?.[add]].Bar
$env?.Bar?.[$env?.f64]
$env?.Bar?.[add]
$env?.Bar?.[add].Bar
$env?.Bar?.[add].String
$env?.Bar?.[add].add
$env?.Bar?.[add].foo
$env?.Bar?.[add].i
$env?.Bar?.[add]?.Bar?.str
$env?.Bar?.[add]?.[greet]
$env?.Bar?.[add]?.[i]
$env?.Bar?.[add]?.f64
$env?.Bar?.[add]?.foo
$env?.Bar?.[add]?.greet
$env?.Bar?.[add]?.list
$env?.Bar?.[add]?.ok
$env?.Bar?.[add]?.str
$env?.Bar?.[array]
$env?.Bar?.[array].ok
$env?.Bar?.[array].ok()
$env?.Bar?.[array]?.Bar
$env?.Bar?.[array]?.String
$env?.Bar?.[array]?.[greet]
$env?.Bar?.[array]?.[list]
$env?.Bar?.[array]?.add
$env?.Bar?.[array]?.foo
$env?.Bar?.[array]?.list
$env?.Bar?.[count($env)]
$env?.Bar?.[f64]
$env?.Bar?.[f64].Bar
$env?.Bar?.[f64].f64
$env?.Bar?.[f64].list
$env?.Bar?.[f64].ok
$env?.Bar?.[f64]?.Bar
$env?.Bar?.[f64]?.[greet]
$env?.Bar?.[f64]?.[list]
$env?.Bar?.[f64]?.add()
$env?.Bar?.[f64]?.array()
$env?.Bar?.[f64]?.str(foobar)
$env?.Bar?.[false != $env]
$env?.Bar?.[foo?.String]
$env?.Bar?.[foo]
$env?.Bar?.[foo].add
$env?.Bar?.[foo].array()
$env?.Bar?.[foo].f64
$env?.Bar?.[foo].greet
$env?.Bar?.[foo].str
$env?.Bar?.[foo]?.Bar
$env?.Bar?.[foo]?.String
$env?.Bar?.[foo]?.[array]
$env?.Bar?.[foo]?.[greet]
$env?.Bar?.[foo]?.[i]
$env?.Bar?.[foo]?.[ok]
$env?.Bar?.[foo]?.add
$env?.Bar?.[foo]?.array(i)
$env?.Bar?.[foo]?.f64
$env?.Bar?.[foo]?.list
$env?.Bar?.[foo]?.str
$env?.Bar?.[greet]
$env?.Bar?.[greet].Bar
$env?.Bar?.[greet].Bar(add)?.greet
$env?.Bar?.[greet].add
$env?.Bar?.[greet].f64
$env?.Bar?.[greet].foo
$env?.Bar?.[greet].i
$env?.Bar?.[greet].list
$env?.Bar?.[greet].ok
$env?.Bar?.[greet]?.Bar
$env?.Bar?.[greet]?.[add]
$env?.Bar?.[greet]?.[f64]
$env?.Bar?.[greet]?.[i]
$env?.Bar?.[greet]?.array
$env?.Bar?.[greet]?.f64
$env?.Bar?.[greet]?.foo()
$env?.Bar?.[greet]?.greet
$env?.Bar?.[greet]?.list.String
$env?.Bar?.[groupBy(list, #)]
$env?.Bar?.[i]
$env?.Bar?.[i].Bar(foo, false, greet).array
$env?.Bar?.[i].add
$env?.Bar?.[i].foo
$env?.Bar?.[i].list
$env?.Bar?.[i].ok
$env?.Bar?.[i]?.Bar
$env?.Bar?.[i]?.String
$env?.Bar?.[i]?.[add]
$env?.Bar?.[i]?.[array]
$env?.Bar?.[i]?.[greet]
$env?.Bar?.[i]?.[i]
$env?.Bar?.[i]?.[list]
$env?.Bar?.[i]?.[ok]
$env?.Bar?.[i]?.add
$env?.Bar?.[i]?.f64
$env?.Bar?.[i]?.foo
$env?.Bar?.[i]?.ok
$env?.Bar?.[i]?.str()
$env?.Bar?.[list?.[i]]
$env?.Bar?.[list]
$env?.Bar?.[list].Bar
$env?.Bar?.[list].add
$env?.Bar?.[list].array()
$env?.Bar?.[list].f64
$env?.Bar?.[list].greet
$env?.Bar?.[list].i(foobar)
$env?.Bar?.[list].ok
$env?.Bar?.[list].str
$env?.Bar?.[list].str()
$env?.Bar?.[list]?.String
$env?.Bar?.[list]?.[add]
$env?.Bar?.[list]?.[array]
$env?.Bar?.[list]?.[f64]
$env?.Bar?.[list]?.[foo]
$env?.Bar?.[list]?.[i]
$env?.Bar?.[list]?.[ok]
$env?.Bar?.[list]?.[str]
$env?.Bar?.[list]?.array.list
$env?.Bar?.[list]?.f64
$env?.Bar?.[list]?.list
$env?.Bar?.[list]?.list()
$env?.Bar?.[list]?.str()
$env?.Bar?.[median(0)]
$env?.Bar?.[nil | date(array)]
$env?.Bar?.[none($env, #.i)]
$env?.Bar?.[ok]
$env?.Bar?.[ok] == greet
$env?.Bar?.[ok].Bar
$env?.Bar?.[ok].String
$env?.Bar?.[ok].f64
$env?.Bar?.[ok].i
$env?.Bar?.[ok].ok()
$env?.Bar?.[ok].str
$env?.Bar?.[ok]?.Bar
$env?.Bar?.[ok]?.String
$env?.Bar?.[ok]?.[greet]
$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]?.foo
$env?.Bar?.[ok]?.greet()
$env?.Bar?.[ok]?.greet.array(foobar?.[str])
$env?.Bar?.[ok]?.i()?.[ok]
$env?.Bar?.[ok]?.ok
$env?.Bar?.[ok]?.str
$env?.Bar?.[str]
$env?.Bar?.[str].f64
$env?.Bar?.[str].foo()
$env?.Bar?.[str].i
$env?.Bar?.[str].list
$env?.Bar?.[str].ok(foobar)
$env?.Bar?.[str].str
$env?.Bar?.[str]?.[array]
$env?.Bar?.[str]?.[foo]
$env?.Bar?.[str]?.[greet]
$env?.Bar?.[str]?.[i]
$env?.Bar?.[str]?.[ok]?.greet
$env?.Bar?.[str]?.add
$env?.Bar?.[str]?.array
$env?.Bar?.[str]?.f64
$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()?.[array]
$env?.Bar?.add()?.greet()
$env?.Bar?.add()?.i()
$env?.Bar?.add(Bar)
$env?.Bar?.add(add)
$env?.Bar?.add(f64)
$env?.Bar?.add(foo)
$env?.Bar?.add(foobar != 1)
$env?.Bar?.add(foobar)
$env?.Bar?.add(foobar?.Bar?.[list])
$env?.Bar?.add(list)
$env?.Bar?.add(ok)
$env?.Bar?.add.Bar
$env?.Bar?.add.f64()
$env?.Bar?.add.foo
$env?.Bar?.add.greet
$env?.Bar?.add.i
$env?.Bar?.add.list
$env?.Bar?.add.ok
$env?.Bar?.add.ok()
$env?.Bar?.add?.Bar
$env?.Bar?.add?.String
$env?.Bar?.add?.[add]
$env?.Bar?.add?.[foo]
$env?.Bar?.add?.[greet]
$env?.Bar?.add?.[list]
$env?.Bar?.add?.[str]
$env?.Bar?.add?.array
$env?.Bar?.add?.greet
$env?.Bar?.all(greet)
$env?.Bar?.any(foo)
$env?.Bar?.any(str)
$env?.Bar?.array
$env?.Bar?.array($env)
$env?.Bar?.array()
$env?.Bar?.array().f64
$env?.Bar?.array()?.[str]
$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.i?.foo
$env?.Bar?.array.list
$env?.Bar?.array.list(string(list) endsWith foobar?.String)
$env?.Bar?.array.str
$env?.Bar?.array?.[add]
$env?.Bar?.array?.[array]
$env?.Bar?.array?.[f64]
$env?.Bar?.array?.[foo]
$env?.Bar?.array?.[str]
$env?.Bar?.array?.array
$env?.Bar?.array?.f64
$env?.Bar?.array?.foo
$env?.Bar?.array?.ok
$env?.Bar?.array?.str
$env?.Bar?.array?.str?.[array]
$env?.Bar?.bitand(foobar)
$env?.Bar?.bitnand(i, f64)
$env?.Bar?.bitshl(str, foobar)
$env?.Bar?.bitshr(foobar)
$env?.Bar?.bitushr(Bar, str)
$env?.Bar?.count(nil, nil)
$env?.Bar?.f64
$env?.Bar?.f64()
$env?.Bar?.f64().add()
$env?.Bar?.f64(1)
$env?.Bar?.f64(Bar?.[ok])
$env?.Bar?.f64(f64)
$env?.Bar?.f64(foobar)
$env?.Bar?.f64(foobar, foobar?.str())
$env?.Bar?.f64(i == foobar not in nil)
$env?.Bar?.f64(list)
$env?.Bar?.f64(ok, foobar)
$env?.Bar?.f64(str, foobar)
$env?.Bar?.f64.Bar(0)
$env?.Bar?.f64.array()
$env?.Bar?.f64.list
$env?.Bar?.f64?.Bar()
$env?.Bar?.f64?.[f64]
$env?.Bar?.f64?.[greet]
$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?.filter(Bar)
$env?.Bar?.filter(Bar, foobar)
$env?.Bar?.filter(foo)
$env?.Bar?.find(false)
$env?.Bar?.find(foobar)
$env?.Bar?.findIndex($env, foobar)
$env?.Bar?.findIndex(false)
$env?.Bar?.findLast($env)
$env?.Bar?.findLastIndex(1, foobar)
$env?.Bar?.findLastIndex(foo, foo)
$env?.Bar?.findLastIndex(foobar, ok)
$env?.Bar?.floor(ok, 1.0)
$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().i
$env?.Bar?.foo()?.[add]
$env?.Bar?.foo(Bar not matches foobar)
$env?.Bar?.foo(f64)
$env?.Bar?.foo(foobar)
$env?.Bar?.foo(foobar, foobar)
$env?.Bar?.foo(foobar?.list(foobar, array))
$env?.Bar?.foo(i)
$env?.Bar?.foo(list)
$env?.Bar?.foo(str)
$env?.Bar?.foo.Bar
$env?.Bar?.foo.add
$env?.Bar?.foo.array
$env?.Bar?.foo.f64
$env?.Bar?.foo.greet(greet)
$env?.Bar?.foo.greet.i
$env?.Bar?.foo.i
$env?.Bar?.foo.list
$env?.Bar?.foo?.Bar
$env?.Bar?.foo?.[array]
$env?.Bar?.foo?.[foo]
$env?.Bar?.foo?.[i]
$env?.Bar?.foo?.[ok]
$env?.Bar?.foo?.add
$env?.Bar?.foo?.i
$env?.Bar?.foo?.str
$env?.Bar?.foobar
$env?.Bar?.foobar ?? foo
$env?.Bar?.foobar.String.greet?.ok
$env?.Bar?.foobar.add
$env?.Bar?.foobar.add(foobar)
$env?.Bar?.foobar.array
$env?.Bar?.foobar.f64
$env?.Bar?.foobar.foobar
$env?.Bar?.foobar.i
$env?.Bar?.foobar.i()
$env?.Bar?.foobar.list
$env?.Bar?.foobar.ok
$env?.Bar?.foobar.str()?.ok
$env?.Bar?.foobar?.Bar(Bar)
$env?.Bar?.foobar?.String
$env?.Bar?.foobar?.[f64]
$env?.Bar?.foobar?.[foo]
$env?.Bar?.foobar?.[i].String
$env?.Bar?.foobar?.[list]
$env?.Bar?.foobar?.array
$env?.Bar?.foobar?.array(foobar)
$env?.Bar?.foobar?.foo
$env?.Bar?.foobar?.i
$env?.Bar?.foobar?.list
$env?.Bar?.foobar?.str
$env?.Bar?.fromBase64(ok)
$env?.Bar?.fromPairs(0)
$env?.Bar?.greet
$env?.Bar?.greet()
$env?.Bar?.greet()?.String
$env?.Bar?.greet(String not contains foo, foo)
$env?.Bar?.greet(String)
$env?.Bar?.greet(array)
$env?.Bar?.greet(foo)
$env?.Bar?.greet(foobar ?? String)
$env?.Bar?.greet(foobar startsWith foobar)
$env?.Bar?.greet(foobar | greet())
$env?.Bar?.greet(foobar)
$env?.Bar?.greet(foobar?.ok())
$env?.Bar?.greet(ok)
$env?.Bar?.greet(str)
$env?.Bar?.greet.add()
$env?.Bar?.greet.f64
$env?.Bar?.greet.foo
$env?.Bar?.greet.greet
$env?.Bar?.greet?.[add]
$env?.Bar?.greet?.[array]
$env?.Bar?.greet?.[f64]
$env?.Bar?.greet?.[i]
$env?.Bar?.greet?.[i]?.f64
$env?.Bar?.greet?.[ok]
$env?.Bar?.greet?.add
$env?.Bar?.greet?.array
$env?.Bar?.greet?.foo
$env?.Bar?.greet?.foo(foobar)?.str
$env?.Bar?.greet?.greet()
$env?.Bar?.greet?.i()
$env?.Bar?.greet?.list
$env?.Bar?.groupBy(add)
$env?.Bar?.groupBy(true, foo)
$env?.Bar?.i
$env?.Bar?.i == 1.0
$env?.Bar?.i()
$env?.Bar?.i().foo
$env?.Bar?.i()?.array
$env?.Bar?.i(Bar, ok)
$env?.Bar?.i(String)
$env?.Bar?.i(foo.Bar)
$env?.Bar?.i(foobar)
$env?.Bar?.i(foobar?.[str])
$env?.Bar?.i(foobar?.str().str)
$env?.Bar?.i(list)
$env?.Bar?.i(nil matches foobar)
$env?.Bar?.i(nil, false)
$env?.Bar?.i.Bar(1, nil)
$env?.Bar?.i.array()
$env?.Bar?.i.i
$env?.Bar?.i.ok
$env?.Bar?.i?.String
$env?.Bar?.i?.String(foobar)
$env?.Bar?.i?.[add]
$env?.Bar?.i?.[greet]?.[array]
$env?.Bar?.i?.[ok]
$env?.Bar?.i?.array
$env?.Bar?.i?.foo
$env?.Bar?.i?.foo()
$env?.Bar?.i?.ok
$env?.Bar?.last(foobar)
$env?.Bar?.len(add)
$env?.Bar?.len(greet)
$env?.Bar?.list
$env?.Bar?.list()
$env?.Bar?.list().ok
$env?.Bar?.list()?.ok
$env?.Bar?.list(1.0 startsWith foobar, foobar?.list)
$env?.Bar?.list(Bar | type(nil))
$env?.Bar?.list(f64)
$env?.Bar?.list(foobar)
$env?.Bar?.list(foobar?.i)
$env?.Bar?.list(list)?.str
$env?.Bar?.list(nil)
$env?.Bar?.list(type(foobar))
$env?.Bar?.list.Bar
$env?.Bar?.list.String
$env?.Bar?.list.array
$env?.Bar?.list.f64()
$env?.Bar?.list.foobar
$env?.Bar?.list?.Bar
$env?.Bar?.list?.String
$env?.Bar?.list?.[array]
$env?.Bar?.list?.[foo]?.String()?.list
$env?.Bar?.list?.[greet]
$env?.Bar?.list?.[list]
$env?.Bar?.list?.add
$env?.Bar?.list?.f64
$env?.Bar?.list?.foo
$env?.Bar?.list?.i
$env?.Bar?.list?.str
$env?.Bar?.map(foobar)
$env?.Bar?.map(foobar, greet, String)
$env?.Bar?.median(true, $env)
$env?.Bar?.nil.array()
$env?.Bar?.nil?.ok()
$env?.Bar?.none(false, foobar)
$env?.Bar?.none(foo)
$env?.Bar?.none(foobar)
$env?.Bar?.ok
$env?.Bar?.ok()
$env?.Bar?.ok().array
$env?.Bar?.ok().greet
$env?.Bar?.ok()?.f64
$env?.Bar?.ok()?.list
$env?.Bar?.ok(add)
$env?.Bar?.ok(f64)
$env?.Bar?.ok(foobar)
$env?.Bar?.ok(foobar?.[array])
$env?.Bar?.ok(foobar?.[f64])
$env?.Bar?.ok(foobar?.foo)
$env?.Bar?.ok(greet)
$env?.Bar?.ok(list)
$env?.Bar?.ok(str)
$env?.Bar?.ok.String()
$env?.Bar?.ok.f64
$env?.Bar?.ok.f64(foobar?.[add]?.f64())
$env?.Bar?.ok.greet
$env?.Bar?.ok.i(add)
$env?.Bar?.ok.list
$env?.Bar?.ok.ok
$env?.Bar?.ok.str
$env?.Bar?.ok?.Bar
$env?.Bar?.ok?.String
$env?.Bar?.ok?.[add]
$env?.Bar?.ok?.[array]
$env?.Bar?.ok?.[f64]
$env?.Bar?.ok?.[foo]
$env?.Bar?.ok?.add
$env?.Bar?.ok?.f64
$env?.Bar?.ok?.foo
$env?.Bar?.ok?.greet
$env?.Bar?.ok?.i
$env?.Bar?.ok?.str
$env?.Bar?.one(array)
$env?.Bar?.one(list)
$env?.Bar?.reduce(foobar, foobar)
$env?.Bar?.reduce(str)
$env?.Bar?.reduce(true)
$env?.Bar?.replace(str)
$env?.Bar?.round(array)
$env?.Bar?.round(foobar)
$env?.Bar?.round(foobar, nil)
$env?.Bar?.sort(list)?.Bar
$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() endsWith str
$env?.Bar?.str()?.[str]
$env?.Bar?.str()?.f64
$env?.Bar?.str()?.greet
$env?.Bar?.str(1, foobar)
$env?.Bar?.str(Bar)
$env?.Bar?.str(add)
$env?.Bar?.str(f64 in nil)
$env?.Bar?.str(foobar)
$env?.Bar?.str(foobar?.[foobar])
$env?.Bar?.str(foobar?.array(String))
$env?.Bar?.str(greet)
$env?.Bar?.str(ok)
$env?.Bar?.str.f64
$env?.Bar?.str.foo
$env?.Bar?.str.i
$env?.Bar?.str.list
$env?.Bar?.str?.Bar
$env?.Bar?.str?.Bar()
$env?.Bar?.str?.[foo]
$env?.Bar?.str?.[greet]
$env?.Bar?.str?.[ok]
$env?.Bar?.str?.[str]
$env?.Bar?.str?.[str]?.Bar
$env?.Bar?.str?.[str]?.array
$env?.Bar?.str?.array
$env?.Bar?.str?.greet(foobar)
$env?.Bar?.str?.i()
$env?.Bar?.str?.list
$env?.Bar?.str?.str()
$env?.Bar?.string(foobar)
$env?.Bar?.sum(f64)
$env?.Bar?.sum(false)
$env?.Bar?.toJSON(true)
$env?.Bar?.true?.add
$env?.Bar?.type(i)
$env?.String != $env ? ok : true
$env?.String != add
$env?.String != array
$env?.String != f64
$env?.String != float(i)
$env?.String != foo
$env?.String != foo?.String
$env?.String != greet
$env?.String != i
$env?.String != list
$env?.String != list != true
$env?.String != ok
$env?.String != str
$env?.String == $env?.list
$env?.String == -1.0
$env?.String == add
$env?.String == array
$env?.String == f64
$env?.String == foo
$env?.String == greet
$env?.String == i
$env?.String == list
$env?.String == str
$env?.String ?? add
$env?.String ?? array
$env?.String ?? foo
$env?.String ?? greet
$env?.String ?? list
$env?.String ?? str
$env?.String ?? toJSON(1.0)
$env?.String contains 0 ?? greet
$env?.String contains str
$env?.String endsWith $env && $env
$env?.String endsWith str
$env?.String in $env ? 1 : true
$env?.String in $env ?? greet
$env?.String in array
$env?.String in list
$env?.String matches $env ?: foo
$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 endsWith str
$env?.String not in $env?.Bar?.array
$env?.String not in array
$env?.String not in list
$env?.String not in values($env)
$env?.String not matches $env?.[String]
$env?.String not matches foo.String()
$env?.String not matches str
$env?.String not startsWith str
$env?.String startsWith str
$env?.String startsWith toJSON(foo)
$env?.String | get(1.0)
$env?.String | get(false)
$env?.String() == 1 || true
$env?.String?.$env != true
$env?.String?.$env.foo
$env?.String?.Bar
$env?.String?.Bar()
$env?.String?.Bar(String)
$env?.String?.Bar(add)
$env?.String?.Bar(f64)
$env?.String?.Bar(foo, ok)
$env?.String?.Bar(foobar)
$env?.String?.Bar(greet != 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.ok
$env?.String?.Bar.str
$env?.String?.Bar?.Bar?.[ok]
$env?.String?.Bar?.String
$env?.String?.Bar?.[f64]
$env?.String?.Bar?.[greet]
$env?.String?.Bar?.[list]
$env?.String?.Bar?.[ok]
$env?.String?.Bar?.add
$env?.String?.Bar?.greet
$env?.String?.Bar?.greet()
$env?.String?.Bar?.i
$env?.String?.Bar?.ok
$env?.String?.Bar?.str
$env?.String?.String
$env?.String?.String()
$env?.String?.String().array
$env?.String?.String(foobar not matches Bar)
$env?.String?.String(foobar)
$env?.String?.String(foobar, foobar)
$env?.String?.String(i)
$env?.String?.String(str)
$env?.String?.String.add.f64
$env?.String?.String.f64
$env?.String?.String.i
$env?.String?.String.list
$env?.String?.String.ok
$env?.String?.String?.[foo]
$env?.String?.String?.[greet]
$env?.String?.String?.[i]
$env?.String?.String?.[list].ok
$env?.String?.String?.add
$env?.String?.String?.f64
$env?.String?.String?.foo
$env?.String?.String?.greet
$env?.String?.String?.list
$env?.String?.String?.one(foobar?.list)
$env?.String?.[$env or $env]
$env?.String?.[$env | count(true)]
$env?.String?.[$env.f64]
$env?.String?.[$env?.[f64]]
$env?.String?.[add]
$env?.String?.[add] != greet
$env?.String?.[add].Bar
$env?.String?.[add].array
$env?.String?.[add].greet
$env?.String?.[add].i
$env?.String?.[add].ok
$env?.String?.[add]?.Bar?.array
$env?.String?.[add]?.[f64]
$env?.String?.[add]?.[foo]
$env?.String?.[add]?.[i]
$env?.String?.[add]?.[list]
$env?.String?.[array]
$env?.String?.[array].Bar
$env?.String?.[array].f64
$env?.String?.[array].f64()
$env?.String?.[array].greet
$env?.String?.[array].str
$env?.String?.[array]?.Bar
$env?.String?.[array]?.String
$env?.String?.[array]?.[add]
$env?.String?.[array]?.[array]
$env?.String?.[array]?.[f64]
$env?.String?.[array]?.[list]
$env?.String?.[array]?.add
$env?.String?.[array]?.array
$env?.String?.[array]?.foo
$env?.String?.[array]?.foo()
$env?.String?.[f64]
$env?.String?.[f64].add
$env?.String?.[f64].array
$env?.String?.[f64].foobar
$env?.String?.[f64].greet
$env?.String?.[f64].i()
$env?.String?.[f64]?.Bar
$env?.String?.[f64]?.String
$env?.String?.[f64]?.[f64]
$env?.String?.[f64]?.[list]
$env?.String?.[f64]?.[str]
$env?.String?.[f64]?.array
$env?.String?.[f64]?.greet
$env?.String?.[f64]?.list
$env?.String?.[f64]?.list()
$env?.String?.[f64]?.ok
$env?.String?.[f64]?.str()
$env?.String?.[findLast($env, .list)]
$env?.String?.[foo]
$env?.String?.[foo].array
$env?.String?.[foo].f64
$env?.String?.[foo].f64()
$env?.String?.[foo].i
$env?.String?.[foo]?.String
$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?.[foo]?.ok()
$env?.String?.[foo]?.str
$env?.String?.[greet]
$env?.String?.[greet] not in array
$env?.String?.[greet].add
$env?.String?.[greet].any(foobar).str
$env?.String?.[greet].array
$env?.String?.[greet]?.[add]
$env?.String?.[greet]?.[list]
$env?.String?.[greet]?.f64
$env?.String?.[greet]?.greet()
$env?.String?.[greet]?.list
$env?.String?.[greet]?.ok
$env?.String?.[i]
$env?.String?.[i].Bar
$env?.String?.[i].f64
$env?.String?.[i].f64()
$env?.String?.[i].foo
$env?.String?.[i].list
$env?.String?.[i]?.String
$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]?.list
$env?.String?.[i]?.str
$env?.String?.[i]?.str()
$env?.String?.[list]
$env?.String?.[list].array
$env?.String?.[list].f64
$env?.String?.[list].foo
$env?.String?.[list].list
$env?.String?.[list].ok
$env?.String?.[list].ok()
$env?.String?.[list].str
$env?.String?.[list]?.[list]
$env?.String?.[list]?.[str]
$env?.String?.[list]?.add
$env?.String?.[list]?.list(foobar)
$env?.String?.[list]?.ok
$env?.String?.[ok]
$env?.String?.[ok].Bar
$env?.String?.[ok].add
$env?.String?.[ok].list()
$env?.String?.[ok]?.Bar
$env?.String?.[ok]?.Bar.str
$env?.String?.[ok]?.[array]
$env?.String?.[ok]?.[f64]?.foo
$env?.String?.[ok]?.[i]
$env?.String?.[ok]?.[ok]
$env?.String?.[ok]?.[str]
$env?.String?.[ok]?.add
$env?.String?.[ok]?.add()
$env?.String?.[ok]?.foo()
$env?.String?.[ok]?.greet
$env?.String?.[ok]?.ok
$env?.String?.[str]
$env?.String?.[str] != lower(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]?.foo()
$env?.String?.[str]?.str(str)
$env?.String?.[sum($env)]
$env?.String?.abs(1.0)
$env?.String?.add
$env?.String?.add()
$env?.String?.add()?.[i]
$env?.String?.add(Bar)
$env?.String?.add(f64 not endsWith nil)
$env?.String?.add(f64)
$env?.String?.add(foobar)
$env?.String?.add(foobar).i
$env?.String?.add(foobar, ceil(abs(foobar, 1)))
$env?.String?.add(ok)
$env?.String?.add(str)
$env?.String?.add.f64
$env?.String?.add.ok
$env?.String?.add.ok()
$env?.String?.add?.Bar
$env?.String?.add?.[array]
$env?.String?.add?.[f64]
$env?.String?.add?.[greet]
$env?.String?.add?.[ok]
$env?.String?.add?.[str]
$env?.String?.add?.add
$env?.String?.add?.array
$env?.String?.add?.f64
$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(f64)?.[foo]
$env?.String?.any(foo)
$env?.String?.any(foobar, foobar, foobar)
$env?.String?.array
$env?.String?.array not endsWith str
$env?.String?.array()
$env?.String?.array()?.[f64]
$env?.String?.array(String)
$env?.String?.array(add)
$env?.String?.array(array matches nil)
$env?.String?.array(foo)
$env?.String?.array(foobar and true)
$env?.String?.array(foobar)
$env?.String?.array(i)
$env?.String?.array(str not in String)
$env?.String?.array.Bar
$env?.String?.array.String
$env?.String?.array.add
$env?.String?.array.array
$env?.String?.array.f64
$env?.String?.array.foo
$env?.String?.array.list
$env?.String?.array.ok
$env?.String?.array?.Bar
$env?.String?.array?.Bar?.list
$env?.String?.array?.String
$env?.String?.array?.[array]
$env?.String?.array?.[str]
$env?.String?.array?.array()
$env?.String?.array?.f64
$env?.String?.array?.f64.list()
$env?.String?.array?.i.foo
$env?.String?.array?.ok
$env?.String?.bitshl(String)
$env?.String?.bitshr(nil, f64)
$env?.String?.bitushr(str, foobar)
$env?.String?.bitxor(String)
$env?.String?.date(foobar, foobar)
$env?.String?.duration(foobar)
$env?.String?.f64
$env?.String?.f64 == i
$env?.String?.f64()
$env?.String?.f64().f64
$env?.String?.f64()?.String
$env?.String?.f64()?.[i]
$env?.String?.f64()?.[str]
$env?.String?.f64(1.0 ?? nil)
$env?.String?.f64(String)
$env?.String?.f64(foobar)
$env?.String?.f64(foobar)?.greet
$env?.String?.f64(foobar, foobar)
$env?.String?.f64(foobar?.[0])
$env?.String?.f64(i)
$env?.String?.f64(list)
$env?.String?.f64(nil == f64)
$env?.String?.f64.String?.greet
$env?.String?.f64.f64
$env?.String?.f64.greet
$env?.String?.f64.list
$env?.String?.f64.list()
$env?.String?.f64.ok
$env?.String?.f64.str(foobar, foobar)?.[add]
$env?.String?.f64?.String
$env?.String?.f64?.[array]
$env?.String?.f64?.[greet]
$env?.String?.f64?.[ok]
$env?.String?.f64?.add
$env?.String?.f64?.list?.[str]
$env?.String?.f64?.ok
$env?.String?.false?.add()
$env?.String?.filter(str)
$env?.String?.findIndex($env)
$env?.String?.findIndex(f64, foobar)
$env?.String?.findIndex(foobar)
$env?.String?.findIndex(nil)
$env?.String?.findLast(greet, nil)
$env?.String?.flatten(f64)
$env?.String?.flatten(foobar, foobar)
$env?.String?.float($env)
$env?.String?.foo
$env?.String?.foo($env)
$env?.String?.foo()
$env?.String?.foo()?.[i]
$env?.String?.foo(add)
$env?.String?.foo(f64)
$env?.String?.foo(false ?? add)
$env?.String?.foo(foo)
$env?.String?.foo(foobar)
$env?.String?.foo(foobar?.greet)
$env?.String?.foo(greet)
$env?.String?.foo(list, 1)
$env?.String?.foo(ok)
$env?.String?.foo.array
$env?.String?.foo.i
$env?.String?.foo.ok()
$env?.String?.foo?.Bar
$env?.String?.foo?.[f64]
$env?.String?.foo?.[i]
$env?.String?.foo?.[ok]
$env?.String?.foo?.[ok].f64()
$env?.String?.foo?.[str]
$env?.String?.foo?.add
$env?.String?.foo?.f64
$env?.String?.foo?.greet
$env?.String?.foo?.i
$env?.String?.foobar
$env?.String?.foobar ?? add
$env?.String?.foobar in array
$env?.String?.foobar.String(greet)
$env?.String?.foobar.add
$env?.String?.foobar.f64
$env?.String?.foobar.foo
$env?.String?.foobar.greet
$env?.String?.foobar.str()
$env?.String?.foobar?.[add]
$env?.String?.foobar?.[array]
$env?.String?.foobar?.[list]
$env?.String?.foobar?.add()
$env?.String?.foobar?.foo()
$env?.String?.foobar?.foo(i)
$env?.String?.get(nil)
$env?.String?.greet
$env?.String?.greet($env)
$env?.String?.greet()
$env?.String?.greet().Bar
$env?.String?.greet().foo
$env?.String?.greet()?.String
$env?.String?.greet()?.[i]
$env?.String?.greet(0)
$env?.String?.greet(String)
$env?.String?.greet(foobar == String)
$env?.String?.greet(foobar and true)
$env?.String?.greet(foobar or true)
$env?.String?.greet(foobar)
$env?.String?.greet(foobar?.String)
$env?.String?.greet(i)
$env?.String?.greet(nil)
$env?.String?.greet(ok)
$env?.String?.greet(str)
$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?.greet()
$env?.String?.greet?.i
$env?.String?.greet?.list
$env?.String?.groupBy(nil)
$env?.String?.groupBy(str, foobar)
$env?.String?.i
$env?.String?.i()
$env?.String?.i().add
$env?.String?.i()?.add
$env?.String?.i()?.i
$env?.String?.i(0).f64
$env?.String?.i(1)
$env?.String?.i(Bar)?.[array]
$env?.String?.i(String?.$env)
$env?.String?.i(array)
$env?.String?.i(f64)
$env?.String?.i(foobar)
$env?.String?.i.Bar
$env?.String?.i.add
$env?.String?.i.foo
$env?.String?.i.foobar
$env?.String?.i.str
$env?.String?.i?.Bar
$env?.String?.i?.String
$env?.String?.i?.[f64]
$env?.String?.i?.add
$env?.String?.i?.foo
$env?.String?.i?.ok
$env?.String?.int(add, foobar, greet)
$env?.String?.join(true, f64)
$env?.String?.keys(0, 0)
$env?.String?.last(foo)
$env?.String?.list
$env?.String?.list()
$env?.String?.list()?.[i]
$env?.String?.list(1.0, foobar, greet)
$env?.String?.list(false)
$env?.String?.list(foobar not endsWith greet)
$env?.String?.list(foobar?.f64())
$env?.String?.list(ok)
$env?.String?.list.String()
$env?.String?.list.array()
$env?.String?.list.str
$env?.String?.list?.[add]
$env?.String?.list?.[i]
$env?.String?.list?.[list]
$env?.String?.list?.[str]
$env?.String?.list?.add
$env?.String?.list?.f64
$env?.String?.list?.list
$env?.String?.list?.str
$env?.String?.lower(0)
$env?.String?.map($env)
$env?.String?.map(false)
$env?.String?.map(foo)
$env?.String?.map(nil, String)
$env?.String?.mean(add)
$env?.String?.nil endsWith str
$env?.String?.nil?.foo
$env?.String?.not
$env?.String?.not .array
$env?.String?.ok
$env?.String?.ok()
$env?.String?.ok()?.Bar
$env?.String?.ok(array)
$env?.String?.ok(foo)
$env?.String?.ok(foobar not endsWith add)
$env?.String?.ok(foobar)
$env?.String?.ok(foobar?.[foo])
$env?.String?.ok(nil)
$env?.String?.ok.Bar()
$env?.String?.ok.array
$env?.String?.ok.f64
$env?.String?.ok.foo
$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?.ok?.f64
$env?.String?.ok?.i
$env?.String?.ok?.i(foobar)
$env?.String?.ok?.str
$env?.String?.reverse(greet)
$env?.String?.round(foobar, foobar)
$env?.String?.sortBy(foobar)
$env?.String?.sortBy(true)
$env?.String?.str
$env?.String?.str($env)
$env?.String?.str()
$env?.String?.str().String
$env?.String?.str()?.[f64]
$env?.String?.str()?.add
$env?.String?.str()?.ok
$env?.String?.str(foo?.String)
$env?.String?.str(foobar)
$env?.String?.str(i)
$env?.String?.str.Bar
$env?.String?.str.add()
$env?.String?.str.greet(foobar, foobar)
$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?.f64
$env?.String?.str?.greet
$env?.String?.str?.greet()
$env?.String?.str?.i
$env?.String?.str?.ok
$env?.String?.sum(1.0)
$env?.String?.toPairs(Bar)
$env?.String?.true.array
$env?.String?.true?.[list]
$env?.[1.0]?.foobar and false
$env?.[Bar] != $env.i
$env?.[Bar] != $env?.list
$env?.[Bar] != 1.0 && $env
$env?.[Bar] != 1.0 + 1.0
$env?.[Bar] != add
$env?.[Bar] != array
$env?.[Bar] != f64
$env?.[Bar] != foo
$env?.[Bar] != foo.Bar
$env?.[Bar] != greet
$env?.[Bar] != i
$env?.[Bar] != i - 1.0
$env?.[Bar] != list
$env?.[Bar] != min(f64)
$env?.[Bar] != not true
$env?.[Bar] != ok
$env?.[Bar] != str
$env?.[Bar] != str != true
$env?.[Bar] != string(false)
$env?.[Bar] < i || true
$env?.[Bar] == $env.array
$env?.[Bar] == $env?.[str]
$env?.[Bar] == add
$env?.[Bar] == array
$env?.[Bar] == count(array, ok)
$env?.[Bar] == f64
$env?.[Bar] == foo
$env?.[Bar] == foo?.Bar
$env?.[Bar] == greet ? 0 : true
$env?.[Bar] == greet or ok
$env?.[Bar] == i
$env?.[Bar] == list
$env?.[Bar] == ok
$env?.[Bar] == str
$env?.[Bar] ?? add
$env?.[Bar] ?? array
$env?.[Bar] ?? f64
$env?.[Bar] ?? foo
$env?.[Bar] ?? foo?.Bar
$env?.[Bar] ?? greet ?? str
$env?.[Bar] ?? i
$env?.[Bar] ?? list
$env?.[Bar] ?? ok
$env?.[Bar] ?? str
$env?.[Bar] and true and false
$env?.[Bar] contains $env ?? nil
$env?.[Bar] contains foo.Bar
$env?.[Bar] contains last($env)
$env?.[Bar] contains nil ?? $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 $env?.String
$env?.[Bar] not contains greet(str)
$env?.[Bar] not contains str
$env?.[Bar] not endsWith $env || false
$env?.[Bar] not endsWith greet(str)
$env?.[Bar] not endsWith str
$env?.[Bar] not in $env?.[foobar]
$env?.[Bar] not in array
$env?.[Bar] not in list
$env?.[Bar] not matches foo.Bar
$env?.[Bar] not matches str
$env?.[Bar] not matches string(1.0)
$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] | get($env)
$env?.[Bar] | get(1.0)
$env?.[Bar] | get(list)
$env?.[Bar]?.$env?.[f64]
$env?.[Bar]?.$env?.[foo].Bar
$env?.[Bar]?.$env?.array()
$env?.[Bar]?.$env?.str
$env?.[Bar]?.Bar
$env?.[Bar]?.Bar($env)
$env?.[Bar]?.Bar()
$env?.[Bar]?.Bar().ok
$env?.[Bar]?.Bar()?.[i]
$env?.[Bar]?.Bar()?.greet()
$env?.[Bar]?.Bar(0)?.foo
$env?.[Bar]?.Bar(Bar not contains f64)
$env?.[Bar]?.Bar(Bar?.ok)
$env?.[Bar]?.Bar(String?.ok(foobar))
$env?.[Bar]?.Bar(add)
$env?.[Bar]?.Bar(foo)
$env?.[Bar]?.Bar(foo, foobar)
$env?.[Bar]?.Bar(foobar)
$env?.[Bar]?.Bar(greet)
$env?.[Bar]?.Bar(nil)
$env?.[Bar]?.Bar(ok)
$env?.[Bar]?.Bar.add
$env?.[Bar]?.Bar.greet
$env?.[Bar]?.Bar.str
$env?.[Bar]?.Bar?.[add]
$env?.[Bar]?.Bar?.[array]
$env?.[Bar]?.Bar?.[list]?.array
$env?.[Bar]?.Bar?.f64
$env?.[Bar]?.Bar?.foo
$env?.[Bar]?.Bar?.i
$env?.[Bar]?.Bar?.list
$env?.[Bar]?.Bar?.str
$env?.[Bar]?.String
$env?.[Bar]?.String()
$env?.[Bar]?.String().foo
$env?.[Bar]?.String().ok
$env?.[Bar]?.String(f64)
$env?.[Bar]?.String(foobar not contains foobar?.String)
$env?.[Bar]?.String(foobar)
$env?.[Bar]?.String(str)
$env?.[Bar]?.String(str).i
$env?.[Bar]?.String.foobar
$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]?.String?.str
$env?.[Bar]?.[$env % 1]?.[f64]
$env?.[Bar]?.[$env | none(.array)]
$env?.[Bar]?.[$env?.array]
$env?.[Bar]?.[add ?? 1]
$env?.[Bar]?.[add]
$env?.[Bar]?.[add].Bar
$env?.[Bar]?.[add].Bar()
$env?.[Bar]?.[add].Bar()?.[list]
$env?.[Bar]?.[add].f64
$env?.[Bar]?.[add].foo
$env?.[Bar]?.[add].greet
$env?.[Bar]?.[add].list
$env?.[Bar]?.[add].ok
$env?.[Bar]?.[add].str
$env?.[Bar]?.[add]?.[list]
$env?.[Bar]?.[add]?.[ok]
$env?.[Bar]?.[add]?.array
$env?.[Bar]?.[add]?.i
$env?.[Bar]?.[add]?.list
$env?.[Bar]?.[add]?.ok
$env?.[Bar]?.[array]
$env?.[Bar]?.[array].Bar
$env?.[Bar]?.[array].String
$env?.[Bar]?.[array].String()
$env?.[Bar]?.[array].add()
$env?.[Bar]?.[array].f64
$env?.[Bar]?.[array].f64()
$env?.[Bar]?.[array].foo
$env?.[Bar]?.[array].greet
$env?.[Bar]?.[array].i
$env?.[Bar]?.[array]?.Bar
$env?.[Bar]?.[array]?.[array]
$env?.[Bar]?.[array]?.[i]
$env?.[Bar]?.[array]?.[ok]
$env?.[Bar]?.[array]?.f64
$env?.[Bar]?.[array]?.foo
$env?.[Bar]?.[count($env)]
$env?.[Bar]?.[count(list)]
$env?.[Bar]?.[date(ok, false)]
$env?.[Bar]?.[f64]
$env?.[Bar]?.[f64] != i
$env?.[Bar]?.[f64].Bar
$env?.[Bar]?.[f64].array
$env?.[Bar]?.[f64].array()?.list
$env?.[Bar]?.[f64].f64
$env?.[Bar]?.[f64].greet
$env?.[Bar]?.[f64].str
$env?.[Bar]?.[f64]?.Bar
$env?.[Bar]?.[f64]?.[add]
$env?.[Bar]?.[f64]?.[ok]
$env?.[Bar]?.[f64]?.add(foobar, Bar)
$env?.[Bar]?.[f64]?.array
$env?.[Bar]?.[f64]?.f64()
$env?.[Bar]?.[f64]?.foo()
$env?.[Bar]?.[f64]?.i?.[f64]
$env?.[Bar]?.[f64]?.none(foobar)
$env?.[Bar]?.[f64]?.ok
$env?.[Bar]?.[f64]?.str
$env?.[Bar]?.[foo == foo]
$env?.[Bar]?.[foo]
$env?.[Bar]?.[foo].String
$env?.[Bar]?.[foo].foo()
$env?.[Bar]?.[foo].greet
$env?.[Bar]?.[foo].i
$env?.[Bar]?.[foo].ok
$env?.[Bar]?.[foo]?.Bar(f64)
$env?.[Bar]?.[foo]?.[f64]
$env?.[Bar]?.[foo]?.[foo]
$env?.[Bar]?.[foo]?.[list]
$env?.[Bar]?.[foo]?.[list].greet
$env?.[Bar]?.[foo]?.f64
$env?.[Bar]?.[foo]?.findLast(list, foobar)
$env?.[Bar]?.[foo]?.ok()
$env?.[Bar]?.[foo]?.str
$env?.[Bar]?.[greet]
$env?.[Bar]?.[greet] == str
$env?.[Bar]?.[greet].array
$env?.[Bar]?.[greet].array()
$env?.[Bar]?.[greet].i
$env?.[Bar]?.[greet].i()
$env?.[Bar]?.[greet].list
$env?.[Bar]?.[greet].ok
$env?.[Bar]?.[greet].str
$env?.[Bar]?.[greet]?.String
$env?.[Bar]?.[greet]?.[f64]
$env?.[Bar]?.[greet]?.[str]
$env?.[Bar]?.[greet]?.add()
$env?.[Bar]?.[greet]?.array()
$env?.[Bar]?.[greet]?.foo
$env?.[Bar]?.[greet]?.i
$env?.[Bar]?.[greet]?.str
$env?.[Bar]?.[greet]?.str()
$env?.[Bar]?.[groupBy($env, #)]?.[str]
$env?.[Bar]?.[i]
$env?.[Bar]?.[i].Bar
$env?.[Bar]?.[i].Bar()
$env?.[Bar]?.[i].array
$env?.[Bar]?.[i].greet
$env?.[Bar]?.[i].i()
$env?.[Bar]?.[i].list
$env?.[Bar]?.[i].str
$env?.[Bar]?.[i]?.String
$env?.[Bar]?.[i]?.[i]
$env?.[Bar]?.[i]?.[list]
$env?.[Bar]?.[i]?.[ok]
$env?.[Bar]?.[i]?.array
$env?.[Bar]?.[i]?.f64
$env?.[Bar]?.[i]?.foo
$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].str(foobar)
$env?.[Bar]?.[list]?.String
$env?.[Bar]?.[list]?.[array]
$env?.[Bar]?.[list]?.[greet]?.list
$env?.[Bar]?.[list]?.[i]
$env?.[Bar]?.[list]?.[list]
$env?.[Bar]?.[list]?.[ok]
$env?.[Bar]?.[list]?.add()
$env?.[Bar]?.[list]?.f64
$env?.[Bar]?.[list]?.foo
$env?.[Bar]?.[list]?.i
$env?.[Bar]?.[list]?.str()
$env?.[Bar]?.[nil != 0]
$env?.[Bar]?.[ok]
$env?.[Bar]?.[ok].f64
$env?.[Bar]?.[ok].foo()
$env?.[Bar]?.[ok]?.[greet]
$env?.[Bar]?.[ok]?.[i]
$env?.[Bar]?.[ok]?.foo
$env?.[Bar]?.[ok]?.foo()
$env?.[Bar]?.[ok]?.i
$env?.[Bar]?.[ok]?.ok
$env?.[Bar]?.[ok]?.str
$env?.[Bar]?.[str]
$env?.[Bar]?.[str].Bar
$env?.[Bar]?.[str].String
$env?.[Bar]?.[str].greet()
$env?.[Bar]?.[str].i
$env?.[Bar]?.[str].ok
$env?.[Bar]?.[str]?.[array]
$env?.[Bar]?.[str]?.[f64]
$env?.[Bar]?.[str]?.[foo]?.ok
$env?.[Bar]?.[str]?.i()
$env?.[Bar]?.[str]?.ok()
$env?.[Bar]?.[sum($env, str)]
$env?.[Bar]?.abs(nil, ok)?.[ok]
$env?.[Bar]?.add
$env?.[Bar]?.add()
$env?.[Bar]?.add() == add
$env?.[Bar]?.add().str
$env?.[Bar]?.add()?.[f64]
$env?.[Bar]?.add(1)
$env?.[Bar]?.add(Bar)
$env?.[Bar]?.add(String, foo, 1.0 | int(String, 1.0))
$env?.[Bar]?.add(add)
$env?.[Bar]?.add(array)
$env?.[Bar]?.add(foo)
$env?.[Bar]?.add(foobar)
$env?.[Bar]?.add(foobar?.[add])
$env?.[Bar]?.add(list)
$env?.[Bar]?.add(str == foobar?.greet(foobar))
$env?.[Bar]?.add.Bar
$env?.[Bar]?.add.String()
$env?.[Bar]?.add.add
$env?.[Bar]?.add.get(foobar?.str())
$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?.array
$env?.[Bar]?.add?.join(foobar, str)
$env?.[Bar]?.all($env)
$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(1 != foo)
$env?.[Bar]?.array(Bar, array)
$env?.[Bar]?.array(add) == greet
$env?.[Bar]?.array(add, foobar)
$env?.[Bar]?.array(f64)
$env?.[Bar]?.array(foo)
$env?.[Bar]?.array(foobar endsWith 1.0)
$env?.[Bar]?.array(foobar)
$env?.[Bar]?.array(foobar, f64, i)
$env?.[Bar]?.array(foobar?.ok)
$env?.[Bar]?.array(greet)
$env?.[Bar]?.array(sort(foobar))
$env?.[Bar]?.array.Bar
$env?.[Bar]?.array.String()
$env?.[Bar]?.array.add
$env?.[Bar]?.array.f64
$env?.[Bar]?.array.list()
$env?.[Bar]?.array?.[add]
$env?.[Bar]?.array?.[add]?.foo
$env?.[Bar]?.array?.[array]
$env?.[Bar]?.array?.[greet]
$env?.[Bar]?.array?.[list]
$env?.[Bar]?.array?.list
$env?.[Bar]?.bitxor(ok)
$env?.[Bar]?.concat(i, 0)
$env?.[Bar]?.f64
$env?.[Bar]?.f64()
$env?.[Bar]?.f64().array
$env?.[Bar]?.f64()?.f64?.[greet]
$env?.[Bar]?.f64()?.ok
$env?.[Bar]?.f64(1.0 != foo)
$env?.[Bar]?.f64(Bar?.ok?.greet)
$env?.[Bar]?.f64(add)
$env?.[Bar]?.f64(foo)
$env?.[Bar]?.f64(foobar in foobar)?.[add]
$env?.[Bar]?.f64(foobar, ok)
$env?.[Bar]?.f64(greet)
$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.list
$env?.[Bar]?.f64?.[add]
$env?.[Bar]?.f64?.[greet]
$env?.[Bar]?.f64?.[str]
$env?.[Bar]?.f64?.f64
$env?.[Bar]?.f64?.i
$env?.[Bar]?.f64?.list()
$env?.[Bar]?.false.foo
$env?.[Bar]?.find($env, foo)
$env?.[Bar]?.find(Bar)
$env?.[Bar]?.findIndex(true)
$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()?.[i]
$env?.[Bar]?.foo(foobar)
$env?.[Bar]?.foo(foobar)?.foo
$env?.[Bar]?.foo(foobar, foobar)
$env?.[Bar]?.foo(foobar?.true startsWith foobar contains foobar)
$env?.[Bar]?.foo(let bar = array; let z = ok; let z = 1.0; bar)?.[f64]
$env?.[Bar]?.foo.add
$env?.[Bar]?.foo.array
$env?.[Bar]?.foo.greet
$env?.[Bar]?.foo.greet?.greet(foobar)
$env?.[Bar]?.foo.i
$env?.[Bar]?.foo.ok
$env?.[Bar]?.foo.ok()
$env?.[Bar]?.foo.str
$env?.[Bar]?.foo?.Bar
$env?.[Bar]?.foo?.String
$env?.[Bar]?.foo?.[add]
$env?.[Bar]?.foo?.[array]
$env?.[Bar]?.foo?.[greet].list()
$env?.[Bar]?.foo?.[i]
$env?.[Bar]?.foo?.[list]
$env?.[Bar]?.foo?.array
$env?.[Bar]?.foo?.f64
$env?.[Bar]?.foo?.foo()
$env?.[Bar]?.foo?.greet
$env?.[Bar]?.foo?.list
$env?.[Bar]?.foo?.ok
$env?.[Bar]?.foobar
$env?.[Bar]?.foobar == add
$env?.[Bar]?.foobar endsWith $env
$env?.[Bar]?.foobar not endsWith str
$env?.[Bar]?.foobar || false
$env?.[Bar]?.foobar.String
$env?.[Bar]?.foobar.String?.Bar
$env?.[Bar]?.foobar.array
$env?.[Bar]?.foobar.foo
$env?.[Bar]?.foobar.list(nil)
$env?.[Bar]?.foobar.str
$env?.[Bar]?.foobar?.String
$env?.[Bar]?.foobar?.[f64]
$env?.[Bar]?.foobar?.[foo]
$env?.[Bar]?.foobar?.[i]
$env?.[Bar]?.foobar?.[ok]
$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()?.[foo]
$env?.[Bar]?.greet()?.[i]
$env?.[Bar]?.greet()?.f64
$env?.[Bar]?.greet(0)
$env?.[Bar]?.greet(array)
$env?.[Bar]?.greet(f64, foobar)
$env?.[Bar]?.greet(foo endsWith foobar?.[String]).Bar
$env?.[Bar]?.greet(foo)
$env?.[Bar]?.greet(foobar)
$env?.[Bar]?.greet(foobar)?.String
$env?.[Bar]?.greet(foobar, str)
$env?.[Bar]?.greet(greet)
$env?.[Bar]?.greet(list)
$env?.[Bar]?.greet(str)
$env?.[Bar]?.greet.Bar()
$env?.[Bar]?.greet.add
$env?.[Bar]?.greet.array()
$env?.[Bar]?.greet.f64
$env?.[Bar]?.greet.f64(foobar)
$env?.[Bar]?.greet?.[add]
$env?.[Bar]?.greet?.[f64]
$env?.[Bar]?.greet?.[i]
$env?.[Bar]?.greet?.[list]
$env?.[Bar]?.greet?.array
$env?.[Bar]?.greet?.f64
$env?.[Bar]?.greet?.i
$env?.[Bar]?.greet?.ok
$env?.[Bar]?.groupBy(0, $env, foobar)
$env?.[Bar]?.i
$env?.[Bar]?.i($env not matches foobar, Bar)?.foo
$env?.[Bar]?.i($env)
$env?.[Bar]?.i()
$env?.[Bar]?.i()?.str
$env?.[Bar]?.i(0 < 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.add
$env?.[Bar]?.i.array()
$env?.[Bar]?.i.ok
$env?.[Bar]?.i.str
$env?.[Bar]?.i?.Bar
$env?.[Bar]?.i?.[add]
$env?.[Bar]?.i?.[foo]
$env?.[Bar]?.i?.[greet]
$env?.[Bar]?.i?.add
$env?.[Bar]?.i?.array
$env?.[Bar]?.i?.foo()
$env?.[Bar]?.i?.greet
$env?.[Bar]?.i?.i
$env?.[Bar]?.i?.i()
$env?.[Bar]?.i?.ok()
$env?.[Bar]?.i?.str
$env?.[Bar]?.indexOf(nil, 1.0)
$env?.[Bar]?.keys(Bar, false)
$env?.[Bar]?.len(foo)
$env?.[Bar]?.list
$env?.[Bar]?.list()
$env?.[Bar]?.list()?.[array]
$env?.[Bar]?.list()?.[ok]
$env?.[Bar]?.list()?.ok
$env?.[Bar]?.list()?.str
$env?.[Bar]?.list(array)
$env?.[Bar]?.list(foo.String)
$env?.[Bar]?.list(foobar ?? list)
$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.String
$env?.[Bar]?.list.add
$env?.[Bar]?.list.f64
$env?.[Bar]?.list.foobar
$env?.[Bar]?.list.str
$env?.[Bar]?.list?.Bar(foo, f64)
$env?.[Bar]?.list?.[foo]
$env?.[Bar]?.list?.[greet]
$env?.[Bar]?.list?.[list]
$env?.[Bar]?.list?.foo
$env?.[Bar]?.list?.i
$env?.[Bar]?.list?.str
$env?.[Bar]?.list?.str()
$env?.[Bar]?.lower(nil)
$env?.[Bar]?.map(nil)
$env?.[Bar]?.nil.str(Bar)
$env?.[Bar]?.nil?.[ok]
$env?.[Bar]?.nil?.i?.f64
$env?.[Bar]?.none(list)
$env?.[Bar]?.none(ok)
$env?.[Bar]?.not .str
$env?.[Bar]?.not.ok
$env?.[Bar]?.now(f64, foo)
$env?.[Bar]?.now(foobar, foobar, $env)
$env?.[Bar]?.ok
$env?.[Bar]?.ok()
$env?.[Bar]?.ok().list
$env?.[Bar]?.ok()?.add
$env?.[Bar]?.ok(Bar)
$env?.[Bar]?.ok(add)
$env?.[Bar]?.ok(array)
$env?.[Bar]?.ok(f64)
$env?.[Bar]?.ok(foobar?.[f64])
$env?.[Bar]?.ok(greet)
$env?.[Bar]?.ok.String
$env?.[Bar]?.ok.add
$env?.[Bar]?.ok.f64
$env?.[Bar]?.ok.foo
$env?.[Bar]?.ok.list
$env?.[Bar]?.ok.ok
$env?.[Bar]?.ok?.[array]
$env?.[Bar]?.ok?.[greet]
$env?.[Bar]?.ok?.foo
$env?.[Bar]?.ok?.list
$env?.[Bar]?.one(foobar, foobar)?.[str]
$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(0)
$env?.[Bar]?.str(Bar)
$env?.[Bar]?.str(f64)
$env?.[Bar]?.str(f64, array)
$env?.[Bar]?.str(foobar)
$env?.[Bar]?.str(greet)
$env?.[Bar]?.str(list | first(true, foobar))
$env?.[Bar]?.str(list)
$env?.[Bar]?.str(nil)
$env?.[Bar]?.str.Bar
$env?.[Bar]?.str.String
$env?.[Bar]?.str.array
$env?.[Bar]?.str.foo
$env?.[Bar]?.str.greet
$env?.[Bar]?.str.ok
$env?.[Bar]?.str?.Bar
$env?.[Bar]?.str?.[add]
$env?.[Bar]?.str?.[array]
$env?.[Bar]?.str?.[foo]
$env?.[Bar]?.str?.[list]
$env?.[Bar]?.str?.[str]
$env?.[Bar]?.str?.f64
$env?.[Bar]?.str?.i(greet)
$env?.[Bar]?.str?.list
$env?.[Bar]?.sum(foobar)
$env?.[Bar]?.sum(list).ok
$env?.[Bar]?.sum(ok)
$env?.[Bar]?.toBase64(1.0)
$env?.[Bar]?.true not contains $env
$env?.[Bar]?.true?.[ok]
$env?.[Bar]?.uniq(array, $env)
$env?.[Bar]?.uniq(foobar, foo)
$env?.[Bar]?.values(foobar, foobar)
$env?.[String] != $env.ok
$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] != len(list)
$env?.[String] != list
$env?.[String] != nil ? add : foo
$env?.[String] != ok
$env?.[String] != str
$env?.[String] == $env.i
$env?.[String] == 0 != $env
$env?.[String] == 1.0 / 1
$env?.[String] == add
$env?.[String] == array
$env?.[String] == f64
$env?.[String] == foo
$env?.[String] == foo == $env
$env?.[String] == foo?.Bar
$env?.[String] == greet
$env?.[String] == i
$env?.[String] == i && $env
$env?.[String] == list
$env?.[String] == str
$env?.[String] ?? -0
$env?.[String] ?? add
$env?.[String] ?? array
$env?.[String] ?? f64
$env?.[String] ?? foo
$env?.[String] ?? i
$env?.[String] ?? list
$env?.[String] ?? str
$env?.[String] contains $env?.[String]
$env?.[String] contains $env?.[str]
$env?.[String] contains 1.0 ?? greet
$env?.[String] contains add ?? list
$env?.[String] contains str
$env?.[String] endsWith $env?.String
$env?.[String] endsWith $env?.[str]
$env?.[String] endsWith str
$env?.[String] in [1]
$env?.[String] in array
$env?.[String] in list
$env?.[String] matches str
$env?.[String] not contains $env?.Bar
$env?.[String] not contains false ?? greet
$env?.[String] not contains str
$env?.[String] not endsWith 1 ?? greet
$env?.[String] not endsWith str
$env?.[String] not in $env?.array
$env?.[String] not in 0 .. 0
$env?.[String] not in array
$env?.[String] not in list
$env?.[String] not matches str
$env?.[String] not startsWith str
$env?.[String] startsWith $env?.[Bar]
$env?.[String] startsWith foo ?? add
$env?.[String] startsWith min($env)
$env?.[String] startsWith str
$env?.[String] | get(i)
$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()?.str
$env?.[String]?.Bar(1.0).String
$env?.[String]?.Bar(array)
$env?.[String]?.Bar(f64)
$env?.[String]?.Bar(foo contains String)?.[foo]
$env?.[String]?.Bar(foobar)
$env?.[String]?.Bar(greet)
$env?.[String]?.Bar.String
$env?.[String]?.Bar.greet
$env?.[String]?.Bar.i(ok)
$env?.[String]?.Bar.ok()
$env?.[String]?.Bar.ok?.[ok]
$env?.[String]?.Bar.str
$env?.[String]?.Bar?.Bar()
$env?.[String]?.Bar?.[add]
$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]?.Bar?.str.f64
$env?.[String]?.String
$env?.[String]?.String($env)
$env?.[String]?.String()
$env?.[String]?.String().list
$env?.[String]?.String().list(String)
$env?.[String]?.String()?.add
$env?.[String]?.String(String)
$env?.[String]?.String(add)
$env?.[String]?.String(foo)
$env?.[String]?.String(foobar)
$env?.[String]?.String(foobar, $env)
$env?.[String]?.String(foobar?.[list])?.str()
$env?.[String]?.String(greet)
$env?.[String]?.String(last($env, String))
$env?.[String]?.String(ok && foobar)
$env?.[String]?.String.add
$env?.[String]?.String.split(false, add).str.array
$env?.[String]?.String?.Bar
$env?.[String]?.String?.Bar?.greet
$env?.[String]?.String?.String
$env?.[String]?.String?.[$env]
$env?.[String]?.String?.[foo]
$env?.[String]?.String?.[greet]
$env?.[String]?.String?.[i]
$env?.[String]?.String?.[list]
$env?.[String]?.String?.[ok]
$env?.[String]?.String?.array
$env?.[String]?.String?.f64(false)
$env?.[String]?.String?.foo
$env?.[String]?.String?.foo(foobar)
$env?.[String]?.String?.foo?.foo
$env?.[String]?.String?.greet.greet
$env?.[String]?.String?.list
$env?.[String]?.String?.str?.ok
$env?.[String]?.[$env == true]
$env?.[String]?.[$env | none($env)]
$env?.[String]?.[$env.foo]
$env?.[String]?.[$env?.[greet]]
$env?.[String]?.[$env?.array]
$env?.[String]?.[add]
$env?.[String]?.[add].String
$env?.[String]?.[add].foo
$env?.[String]?.[add].greet
$env?.[String]?.[add].str
$env?.[String]?.[add]?.String
$env?.[String]?.[add]?.[add]
$env?.[String]?.[add]?.[list]
$env?.[String]?.[add]?.[ok]
$env?.[String]?.[add]?.add
$env?.[String]?.[add]?.add(foo)
$env?.[String]?.[add]?.greet
$env?.[String]?.[add]?.list?.Bar
$env?.[String]?.[array | reduce(#)]
$env?.[String]?.[array]
$env?.[String]?.[array] == list
$env?.[String]?.[array].Bar
$env?.[String]?.[array].String
$env?.[String]?.[array].String()
$env?.[String]?.[array].array
$env?.[String]?.[array].foo
$env?.[String]?.[array].i
$env?.[String]?.[array].ok
$env?.[String]?.[array]?.Bar()
$env?.[String]?.[array]?.[add]
$env?.[String]?.[array]?.[foo]
$env?.[String]?.[array]?.[list]
$env?.[String]?.[array]?.[ok]
$env?.[String]?.[array]?.[str]
$env?.[String]?.[array]?.add
$env?.[String]?.[array]?.array()
$env?.[String]?.[array]?.f64
$env?.[String]?.[array]?.list?.[add]
$env?.[String]?.[array]?.ok
$env?.[String]?.[array]?.str
$env?.[String]?.[f64]
$env?.[String]?.[f64].add
$env?.[String]?.[f64].foo
$env?.[String]?.[f64].list
$env?.[String]?.[f64].list()
$env?.[String]?.[f64].ok
$env?.[String]?.[f64].str
$env?.[String]?.[f64]?.Bar
$env?.[String]?.[f64]?.Bar()
$env?.[String]?.[f64]?.[f64]
$env?.[String]?.[f64]?.[foo]
$env?.[String]?.[f64]?.[greet]
$env?.[String]?.[f64]?.[i]
$env?.[String]?.[f64]?.[str]
$env?.[String]?.[f64]?.array()
$env?.[String]?.[f64]?.greet
$env?.[String]?.[f64]?.greet().foo
$env?.[String]?.[f64]?.ok
$env?.[String]?.[foo != nil]
$env?.[String]?.[foo]
$env?.[String]?.[foo].String
$env?.[String]?.[foo].f64
$env?.[String]?.[foo].foo
$env?.[String]?.[foo].i
$env?.[String]?.[foo].str.add?.[i]
$env?.[String]?.[foo]?.String
$env?.[String]?.[foo]?.[foo]
$env?.[String]?.[foo]?.[ok]
$env?.[String]?.[foo]?.[ok]?.[f64]
$env?.[String]?.[foo]?.[str]
$env?.[String]?.[foo]?.add
$env?.[String]?.[foo]?.f64()
$env?.[String]?.[foo]?.foo
$env?.[String]?.[greet]
$env?.[String]?.[greet].String
$env?.[String]?.[greet].array
$env?.[String]?.[greet].str
$env?.[String]?.[greet]?.Bar
$env?.[String]?.[greet]?.[greet]
$env?.[String]?.[greet]?.[ok]
$env?.[String]?.[greet]?.foo
$env?.[String]?.[greet]?.i
$env?.[String]?.[greet]?.list(foobar)
$env?.[String]?.[greet]?.ok
$env?.[String]?.[greet]?.str
$env?.[String]?.[i | mean(1.0)]
$env?.[String]?.[i]
$env?.[String]?.[i].Bar
$env?.[String]?.[i].add({foo: str})
$env?.[String]?.[i].f64
$env?.[String]?.[i].foo
$env?.[String]?.[i].i
$env?.[String]?.[i].list
$env?.[String]?.[i].ok
$env?.[String]?.[i]?.[add]
$env?.[String]?.[i]?.[array]
$env?.[String]?.[i]?.[foo]
$env?.[String]?.[i]?.[greet]
$env?.[String]?.[i]?.array
$env?.[String]?.[i]?.greet
$env?.[String]?.[i]?.ok
$env?.[String]?.[list]
$env?.[String]?.[list].array
$env?.[String]?.[list].array()
$env?.[String]?.[list].foobar
$env?.[String]?.[list].greet
$env?.[String]?.[list].i
$env?.[String]?.[list].ok
$env?.[String]?.[list].str
$env?.[String]?.[list]?.String
$env?.[String]?.[list]?.String()
$env?.[String]?.[list]?.[add]
$env?.[String]?.[list]?.[i]
$env?.[String]?.[list]?.array()
$env?.[String]?.[list]?.f64
$env?.[String]?.[list]?.greet
$env?.[String]?.[list]?.ok
$env?.[String]?.[nil ?? array]
$env?.[String]?.[ok and ok]
$env?.[String]?.[ok not in $env]
$env?.[String]?.[ok]
$env?.[String]?.[ok].add
$env?.[String]?.[ok].add?.array
$env?.[String]?.[ok].f64
$env?.[String]?.[ok].ok
$env?.[String]?.[ok]?.Bar
$env?.[String]?.[ok]?.[f64]
$env?.[String]?.[ok]?.[list]
$env?.[String]?.[ok]?.greet
$env?.[String]?.[ok]?.i
$env?.[String]?.[str matches str]
$env?.[String]?.[str not endsWith $env]
$env?.[String]?.[str]
$env?.[String]?.[str] != f64
$env?.[String]?.[str].array
$env?.[String]?.[str].f64
$env?.[String]?.[str].i.add
$env?.[String]?.[str]?.Bar
$env?.[String]?.[str]?.String
$env?.[String]?.[str]?.[f64]
$env?.[String]?.[str]?.[i]
$env?.[String]?.[str]?.[ok]
$env?.[String]?.[str]?.add
$env?.[String]?.[str]?.array
$env?.[String]?.[str]?.foo
$env?.[String]?.add
$env?.[String]?.add($env)
$env?.[String]?.add()
$env?.[String]?.add()?.[foo]
$env?.[String]?.add()?.f64()
$env?.[String]?.add()?.greet
$env?.[String]?.add(1)
$env?.[String]?.add(1.0, foobar)
$env?.[String]?.add(foobar)
$env?.[String]?.add(i == true)
$env?.[String]?.add(str)
$env?.[String]?.add.Bar
$env?.[String]?.add.String
$env?.[String]?.add.array()
$env?.[String]?.add.greet
$env?.[String]?.add.i
$env?.[String]?.add.list()
$env?.[String]?.add?.Bar
$env?.[String]?.add?.String
$env?.[String]?.add?.[add]
$env?.[String]?.add?.[foo]
$env?.[String]?.add?.[greet]
$env?.[String]?.add?.[list]
$env?.[String]?.add?.array
$env?.[String]?.add?.f64
$env?.[String]?.add?.foo
$env?.[String]?.add?.greet
$env?.[String]?.add?.greet()
$env?.[String]?.add?.ok()
$env?.[String]?.all(ok)
$env?.[String]?.any(foobar, ok)
$env?.[String]?.array
$env?.[String]?.array()
$env?.[String]?.array().array
$env?.[String]?.array()?.[foo]
$env?.[String]?.array()?.f64(list)
$env?.[String]?.array(Bar?.foo())
$env?.[String]?.array(String)
$env?.[String]?.array(add)
$env?.[String]?.array(f64)
$env?.[String]?.array(foo)
$env?.[String]?.array(foobar not startsWith foo)
$env?.[String]?.array(foobar)
$env?.[String]?.array(foobar?.[String].add)
$env?.[String]?.array(i)
$env?.[String]?.array(str)
$env?.[String]?.array(toJSON(foobar))
$env?.[String]?.array.String
$env?.[String]?.array.array(String, foo)
$env?.[String]?.array.f64
$env?.[String]?.array.i
$env?.[String]?.array.i()
$env?.[String]?.array.list(foobar)
$env?.[String]?.array.list.array
$env?.[String]?.array.ok
$env?.[String]?.array?.Bar
$env?.[String]?.array?.Bar(list)
$env?.[String]?.array?.[greet]
$env?.[String]?.array?.f64
$env?.[String]?.array?.foo
$env?.[String]?.array?.greet
$env?.[String]?.array?.i
$env?.[String]?.array?.list(i)
$env?.[String]?.bitor(foobar, 0)
$env?.[String]?.bitshl(foobar)
$env?.[String]?.bitshr(nil)
$env?.[String]?.bitushr(foobar)
$env?.[String]?.ceil(nil)
$env?.[String]?.concat(1.0)
$env?.[String]?.duration(foobar)
$env?.[String]?.f64
$env?.[String]?.f64()
$env?.[String]?.f64().Bar
$env?.[String]?.f64().Bar()
$env?.[String]?.f64()?.f64
$env?.[String]?.f64(String?.[array])
$env?.[String]?.f64(foo.Bar)
$env?.[String]?.f64(foobar)
$env?.[String]?.f64(min(foobar))
$env?.[String]?.f64.Bar
$env?.[String]?.f64.Bar()
$env?.[String]?.f64.add()
$env?.[String]?.f64.greet.str
$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]?.f64?.str
$env?.[String]?.false?.str
$env?.[String]?.filter(1)
$env?.[String]?.find(foobar)
$env?.[String]?.findLastIndex(add, f64)
$env?.[String]?.foo
$env?.[String]?.foo()
$env?.[String]?.foo().foo
$env?.[String]?.foo().list
$env?.[String]?.foo()?.foo
$env?.[String]?.foo()?.str
$env?.[String]?.foo(f64, foobar)
$env?.[String]?.foo(foobar)
$env?.[String]?.foo(true)
$env?.[String]?.foo.String
$env?.[String]?.foo.add
$env?.[String]?.foo.add()
$env?.[String]?.foo.add?.greet
$env?.[String]?.foo.array()
$env?.[String]?.foo.f64
$env?.[String]?.foo.foo
$env?.[String]?.foo.greet
$env?.[String]?.foo.i
$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?.add
$env?.[String]?.foo?.array
$env?.[String]?.foo?.greet
$env?.[String]?.foo?.i
$env?.[String]?.foo?.list
$env?.[String]?.foo?.str
$env?.[String]?.foo?.str()
$env?.[String]?.foobar
$env?.[String]?.foobar.Bar
$env?.[String]?.foobar.array
$env?.[String]?.foobar.f64
$env?.[String]?.foobar.foo
$env?.[String]?.foobar.i
$env?.[String]?.foobar.list(foobar, add)
$env?.[String]?.foobar.str
$env?.[String]?.foobar.str()
$env?.[String]?.foobar?.Bar
$env?.[String]?.foobar?.[foo]
$env?.[String]?.foobar?.[i]
$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]?.foobar?.ok()
$env?.[String]?.fromJSON(foobar)
$env?.[String]?.fromPairs(false)
$env?.[String]?.get(String)
$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 != str)
$env?.[String]?.greet(foobar)
$env?.[String]?.greet(greet)
$env?.[String]?.greet.Bar
$env?.[String]?.greet.add
$env?.[String]?.greet.array()
$env?.[String]?.greet.f64
$env?.[String]?.greet.foo
$env?.[String]?.greet.foobar
$env?.[String]?.greet.i
$env?.[String]?.greet.i()
$env?.[String]?.greet.list
$env?.[String]?.greet.ok
$env?.[String]?.greet.ok()
$env?.[String]?.greet?.Bar
$env?.[String]?.greet?.[array]
$env?.[String]?.greet?.[list]
$env?.[String]?.greet?.[str]
$env?.[String]?.greet?.array
$env?.[String]?.greet?.f64
$env?.[String]?.greet?.foo
$env?.[String]?.greet?.greet()
$env?.[String]?.greet?.list.str
$env?.[String]?.groupBy(1.0)
$env?.[String]?.groupBy(f64, foobar, array)?.[ok]
$env?.[String]?.groupBy(foobar)
$env?.[String]?.groupBy(str)
$env?.[String]?.hasPrefix(nil)?.String
$env?.[String]?.i
$env?.[String]?.i in array
$env?.[String]?.i()
$env?.[String]?.i().ok
$env?.[String]?.i()?.[add]
$env?.[String]?.i()?.[array]
$env?.[String]?.i()?.[greet]
$env?.[String]?.i()?.f64
$env?.[String]?.i(add)
$env?.[String]?.i(array)
$env?.[String]?.i(foo)
$env?.[String]?.i(foobar ?? array)
$env?.[String]?.i(foobar)
$env?.[String]?.i(i)
$env?.[String]?.i(ok)
$env?.[String]?.i(str)
$env?.[String]?.i(true)
$env?.[String]?.i.Bar
$env?.[String]?.i.String
$env?.[String]?.i.f64(f64)
$env?.[String]?.i.greet
$env?.[String]?.i.list
$env?.[String]?.i?.[array]
$env?.[String]?.i?.[greet]
$env?.[String]?.i?.[list]
$env?.[String]?.i?.[ok]
$env?.[String]?.i?.[str]
$env?.[String]?.i?.add
$env?.[String]?.i?.array
$env?.[String]?.i?.f64?.String
$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]?.lastIndexOf(true, foobar, foo)
$env?.[String]?.len(false)
$env?.[String]?.list
$env?.[String]?.list($env)
$env?.[String]?.list()
$env?.[String]?.list().i
$env?.[String]?.list(0)
$env?.[String]?.list(1.0)
$env?.[String]?.list(Bar)
$env?.[String]?.list(foo).f64
$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.foo($env)
$env?.[String]?.list.list
$env?.[String]?.list?.String()
$env?.[String]?.list?.[array]
$env?.[String]?.list?.[foo]
$env?.[String]?.list?.[greet]
$env?.[String]?.list?.[list]?.Bar
$env?.[String]?.list?.[ok]
$env?.[String]?.list?.add?.list
$env?.[String]?.list?.array
$env?.[String]?.list?.foo(0)
$env?.[String]?.list?.foobar
$env?.[String]?.list?.i
$env?.[String]?.list?.list
$env?.[String]?.map($env)
$env?.[String]?.map($env, foo).add
$env?.[String]?.map(String, foobar)
$env?.[String]?.nil.String
$env?.[String]?.nil.list
$env?.[String]?.nil?.f64
$env?.[String]?.nil?.ok()
$env?.[String]?.none($env)
$env?.[String]?.none(array)
$env?.[String]?.none(foobar)
$env?.[String]?.not
$env?.[String]?.ok
$env?.[String]?.ok()
$env?.[String]?.ok().add
$env?.[String]?.ok()?.[add]
$env?.[String]?.ok()?.list
$env?.[String]?.ok()?.str() == f64
$env?.[String]?.ok(array)
$env?.[String]?.ok(f64, foobar)
$env?.[String]?.ok(foo contains foobar)
$env?.[String]?.ok(foo)
$env?.[String]?.ok(foobar)
$env?.[String]?.ok(foobar?.[1.0])
$env?.[String]?.ok(foobar?.[list])
$env?.[String]?.ok(nil startsWith ok)
$env?.[String]?.ok(toJSON(foo)).f64
$env?.[String]?.ok.add
$env?.[String]?.ok.f64
$env?.[String]?.ok.foo
$env?.[String]?.ok.i
$env?.[String]?.ok.ok
$env?.[String]?.ok.str
$env?.[String]?.ok?.[array]
$env?.[String]?.ok?.[f64]
$env?.[String]?.ok?.[f64].list
$env?.[String]?.ok?.[foo]
$env?.[String]?.ok?.[list]
$env?.[String]?.ok?.[ok]
$env?.[String]?.ok?.add
$env?.[String]?.ok?.f64
$env?.[String]?.ok?.foo
$env?.[String]?.ok?.ok
$env?.[String]?.one($env)
$env?.[String]?.one(array)
$env?.[String]?.one(foobar)?.[f64]
$env?.[String]?.reduce(1.0)
$env?.[String]?.reduce(foobar)
$env?.[String]?.sortBy(add)
$env?.[String]?.splitAfter(true)
$env?.[String]?.str
$env?.[String]?.str not endsWith $env
$env?.[String]?.str not startsWith str
$env?.[String]?.str()
$env?.[String]?.str().list
$env?.[String]?.str().list?.[list]
$env?.[String]?.str()?.array
$env?.[String]?.str(add)
$env?.[String]?.str(foo)
$env?.[String]?.str(foobar)
$env?.[String]?.str(foobar?.array)
$env?.[String]?.str.String
$env?.[String]?.str.add
$env?.[String]?.str.array
$env?.[String]?.str.foo
$env?.[String]?.str.ok
$env?.[String]?.str?.Bar
$env?.[String]?.str?.String
$env?.[String]?.str?.[add]
$env?.[String]?.str?.[i]
$env?.[String]?.str?.add
$env?.[String]?.str?.f64()
$env?.[String]?.str?.f64(false)?.greet
$env?.[String]?.str?.list()
$env?.[String]?.str?.str
$env?.[String]?.string(foobar, foobar)
$env?.[String]?.sum(String, foobar)
$env?.[String]?.sum(add)
$env?.[String]?.sum(foobar, foobar)
$env?.[String]?.take(String)?.str
$env?.[String]?.trimPrefix(add)
$env?.[String]?.trimPrefix(foobar)
$env?.[String]?.true not in array
$env?.[String]?.true.foo
$env?.[String]?.true?.[1]
$env?.[String]?.true?.foobar
$env?.[add] != 1.0 && false
$env?.[add] * f64 && false
$env?.[add] == nil and false
$env?.[f64] == list || true
$env?.[false] and not true
$env?.[foo] != 1.0 || true
$env?.[foo] endsWith $env && false
$env?.[foobar] != $env.i
$env?.[foobar] != $env.list
$env?.[foobar] != f64
$env?.[foobar] != foo
$env?.[foobar] != greet
$env?.[foobar] != i
$env?.[foobar] != i ? true : $env
$env?.[foobar] != list
$env?.[foobar] != str
$env?.[foobar] == add
$env?.[foobar] == array
$env?.[foobar] == f64
$env?.[foobar] == foo
$env?.[foobar] == greet
$env?.[foobar] == list
$env?.[foobar] == list != $env
$env?.[foobar] == ok
$env?.[foobar] ?? f64
$env?.[foobar] ?? greet
$env?.[foobar] ?? ok
$env?.[foobar] contains str
$env?.[foobar] endsWith $env?.[str]
$env?.[foobar] endsWith str
$env?.[foobar] in $env?.[String]
$env?.[foobar] in list
$env?.[foobar] in reverse(array)
$env?.[foobar] matches str
$env?.[foobar] not contains str
$env?.[foobar] not endsWith str
$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 str
$env?.[foobar] not startsWith trim(str)
$env?.[foobar] startsWith $env or $env
$env?.[foobar] startsWith $env?.[str]
$env?.[foobar] | get($env)
$env?.[foobar] | get(foo)
$env?.[foobar]?.$env == nil
$env?.[foobar]?.$env.greet
$env?.[foobar]?.Bar
$env?.[foobar]?.Bar()
$env?.[foobar]?.Bar().str
$env?.[foobar]?.Bar()?.foobar
$env?.[foobar]?.Bar(add)
$env?.[foobar]?.Bar(foobar)
$env?.[foobar]?.Bar(list)
$env?.[foobar]?.Bar.foo()
$env?.[foobar]?.Bar.foobar
$env?.[foobar]?.Bar.i
$env?.[foobar]?.Bar.str(foobar)
$env?.[foobar]?.Bar?.[f64]
$env?.[foobar]?.Bar?.[i]
$env?.[foobar]?.Bar?.[str]
$env?.[foobar]?.Bar?.[str]?.array
$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(foobar)
$env?.[foobar]?.String(foobar?.f64, Bar?.[foobar])
$env?.[foobar]?.String(nil == foobar)
$env?.[foobar]?.String.Bar
$env?.[foobar]?.String.ok
$env?.[foobar]?.String.str
$env?.[foobar]?.String?.[i]
$env?.[foobar]?.String?.[str]
$env?.[foobar]?.String?.[str]?.[f64]?.ok
$env?.[foobar]?.String?.array
$env?.[foobar]?.String?.i
$env?.[foobar]?.String?.list
$env?.[foobar]?.String?.ok()
$env?.[foobar]?.[!false]
$env?.[foobar]?.[$env | groupBy(i)]
$env?.[foobar]?.[$env[nil:]]
$env?.[foobar]?.[add]
$env?.[foobar]?.[add].f64
$env?.[foobar]?.[add].greet
$env?.[foobar]?.[add].i
$env?.[foobar]?.[add]?.Bar
$env?.[foobar]?.[add]?.[add]
$env?.[foobar]?.[add]?.[foo]
$env?.[foobar]?.[add]?.[greet]
$env?.[foobar]?.[add]?.f64
$env?.[foobar]?.[array]
$env?.[foobar]?.[array].i
$env?.[foobar]?.[array]?.Bar
$env?.[foobar]?.[array]?.Bar()
$env?.[foobar]?.[array]?.[i]
$env?.[foobar]?.[array]?.[ok]
$env?.[foobar]?.[array]?.add
$env?.[foobar]?.[array]?.f64
$env?.[foobar]?.[array]?.f64()
$env?.[foobar]?.[array]?.foo
$env?.[foobar]?.[array]?.list()?.[add]
$env?.[foobar]?.[f64 ^ 1.0]
$env?.[foobar]?.[f64]
$env?.[foobar]?.[f64].array
$env?.[foobar]?.[f64].f64
$env?.[foobar]?.[f64].f64()
$env?.[foobar]?.[f64].greet
$env?.[foobar]?.[f64].ok()
$env?.[foobar]?.[f64]?.[i]
$env?.[foobar]?.[f64]?.[str]
$env?.[foobar]?.[f64]?.greet
$env?.[foobar]?.[foo]
$env?.[foobar]?.[foo].Bar
$env?.[foobar]?.[foo].String
$env?.[foobar]?.[foo].String()
$env?.[foobar]?.[foo].add()
$env?.[foobar]?.[foo]?.[str]
$env?.[foobar]?.[foo]?.i
$env?.[foobar]?.[greet ?? 1.0]
$env?.[foobar]?.[greet]
$env?.[foobar]?.[greet].array.array
$env?.[foobar]?.[greet].f64
$env?.[foobar]?.[greet]?.[add]
$env?.[foobar]?.[greet]?.[i].array
$env?.[foobar]?.[greet]?.[ok]
$env?.[foobar]?.[greet]?.str
$env?.[foobar]?.[i]
$env?.[foobar]?.[i].Bar
$env?.[foobar]?.[i].array
$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].f64()
$env?.[foobar]?.[list].foo
$env?.[foobar]?.[list].ok
$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].list
$env?.[foobar]?.[ok].str
$env?.[foobar]?.[ok]?.[add]
$env?.[foobar]?.[ok]?.[f64]
$env?.[foobar]?.[ok]?.f64
$env?.[foobar]?.[ok]?.ok
$env?.[foobar]?.[sortBy($env, f64)]
$env?.[foobar]?.[str]
$env?.[foobar]?.[str].Bar
$env?.[foobar]?.[str].foo?.[add]
$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(toJSON(foo), Bar)
$env?.[foobar]?.add.add()
$env?.[foobar]?.add.greet(foo)
$env?.[foobar]?.add?.[add]
$env?.[foobar]?.add?.array()
$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 contains str
$env?.[foobar]?.array()
$env?.[foobar]?.array(foobar)
$env?.[foobar]?.array.Bar
$env?.[foobar]?.array.f64
$env?.[foobar]?.array.f64()
$env?.[foobar]?.array?.[add]
$env?.[foobar]?.array?.[f64]
$env?.[foobar]?.array?.[i]
$env?.[foobar]?.array?.add()
$env?.[foobar]?.array?.i
$env?.[foobar]?.bitand(false)
$env?.[foobar]?.count(0)
$env?.[foobar]?.f64
$env?.[foobar]?.f64()
$env?.[foobar]?.f64()?.[ok]
$env?.[foobar]?.f64()?.array
$env?.[foobar]?.f64(String)
$env?.[foobar]?.f64(foobar endsWith String)?.[greet]
$env?.[foobar]?.f64(foobar)
$env?.[foobar]?.f64(i)
$env?.[foobar]?.f64.ok
$env?.[foobar]?.f64?.Bar
$env?.[foobar]?.f64?.[i]
$env?.[foobar]?.f64?.list()
$env?.[foobar]?.f64?.ok
$env?.[foobar]?.false?.[add]
$env?.[foobar]?.filter(foo)
$env?.[foobar]?.find(foobar, 1)
$env?.[foobar]?.findLast(foo).String()
$env?.[foobar]?.foo
$env?.[foobar]?.foo()
$env?.[foobar]?.foo()?.array
$env?.[foobar]?.foo()?.f64
$env?.[foobar]?.foo(Bar)
$env?.[foobar]?.foo(foobar)
$env?.[foobar]?.foo(foobar, foobar)
$env?.[foobar]?.foo.foobar
$env?.[foobar]?.foo?.String
$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 not in $env
$env?.[foobar]?.foobar.str
$env?.[foobar]?.foobar?.[foo]
$env?.[foobar]?.foobar?.greet
$env?.[foobar]?.foobar?.ok(list, foobar)
$env?.[foobar]?.foobar?.str
$env?.[foobar]?.greet
$env?.[foobar]?.greet == foo
$env?.[foobar]?.greet()
$env?.[foobar]?.greet()?.String
$env?.[foobar]?.greet(Bar)
$env?.[foobar]?.greet(String)
$env?.[foobar]?.greet(foobar)
$env?.[foobar]?.greet(foobar, foo)
$env?.[foobar]?.greet(foobar?.list(), array)
$env?.[foobar]?.greet(greet)
$env?.[foobar]?.greet(list, Bar)
$env?.[foobar]?.greet.foo
$env?.[foobar]?.greet.i
$env?.[foobar]?.greet?.add
$env?.[foobar]?.greet?.add(nil)
$env?.[foobar]?.greet?.array
$env?.[foobar]?.greet?.ok
$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.Bar
$env?.[foobar]?.i.String
$env?.[foobar]?.i.array
$env?.[foobar]?.i.foo
$env?.[foobar]?.i?.[array]
$env?.[foobar]?.i?.[foo]
$env?.[foobar]?.i?.[greet]
$env?.[foobar]?.i?.f64
$env?.[foobar]?.i?.ok
$env?.[foobar]?.join(greet, nil)
$env?.[foobar]?.lastIndexOf(nil, foobar)
$env?.[foobar]?.list
$env?.[foobar]?.list()
$env?.[foobar]?.list(1)
$env?.[foobar]?.list(f64)
$env?.[foobar]?.list(foobar)
$env?.[foobar]?.list(str)
$env?.[foobar]?.list.i
$env?.[foobar]?.list.i()
$env?.[foobar]?.list.list
$env?.[foobar]?.list.ok(foobar)
$env?.[foobar]?.list?.[array]
$env?.[foobar]?.list?.[i]
$env?.[foobar]?.list?.[list]
$env?.[foobar]?.list?.f64
$env?.[foobar]?.list?.ok()
$env?.[foobar]?.max(1, ok)
$env?.[foobar]?.max(foo)
$env?.[foobar]?.nil?.[foo]
$env?.[foobar]?.nil?.str(foo, foobar)
$env?.[foobar]?.none(foobar)
$env?.[foobar]?.none(nil, foobar)
$env?.[foobar]?.not .String
$env?.[foobar]?.now(1)
$env?.[foobar]?.ok
$env?.[foobar]?.ok()
$env?.[foobar]?.ok()?.i
$env?.[foobar]?.ok(Bar?.[greet])?.greet
$env?.[foobar]?.ok(foo not startsWith foobar)
$env?.[foobar]?.ok(foo)
$env?.[foobar]?.ok(list)
$env?.[foobar]?.ok.add
$env?.[foobar]?.ok.add()
$env?.[foobar]?.ok.i
$env?.[foobar]?.ok?.[greet]
$env?.[foobar]?.ok?.greet()
$env?.[foobar]?.ok?.i
$env?.[foobar]?.reduce(nil, 1.0)
$env?.[foobar]?.sortBy(foo, 0, foobar)
$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(i)
$env?.[foobar]?.str.ok
$env?.[foobar]?.str?.String
$env?.[foobar]?.str?.[f64]
$env?.[foobar]?.str?.[list]
$env?.[foobar]?.str?.foo
$env?.[foobar]?.str?.i
$env?.[foobar]?.str?.i()
$env?.[foobar]?.str?.list
$env?.[foobar]?.sum($env)
$env?.[foobar]?.trimSuffix(f64, foobar)
$env?.[foobar]?.true?.ok
$env?.[greet]?.foobar or true
$env?.[i] and !true
$env?.[i].i and false
$env?.[list] contains str && false
$env?.[list] || false or true
$env?.[nil] != array
$env?.[nil] != ok
$env?.[nil] == array?.[0]
$env?.[nil] == ok
$env?.[nil] == str
$env?.[nil] ?? add
$env?.[nil] ?? map($env, foo)
$env?.[nil] endsWith str
$env?.[nil] in $env?.[String]
$env?.[nil] not endsWith str
$env?.[nil] not startsWith str
$env?.[nil] | get(nil)
$env?.[nil]?.Bar
$env?.[nil]?.Bar()
$env?.[nil]?.Bar?.[add]
$env?.[nil]?.Bar?.[str]
$env?.[nil]?.String
$env?.[nil]?.String()
$env?.[nil]?.String(Bar?.[str])
$env?.[nil]?.String(f64)
$env?.[nil]?.String(false ?? foobar)
$env?.[nil]?.String.greet
$env?.[nil]?.String?.[add]
$env?.[nil]?.String?.[list]
$env?.[nil]?.[add]
$env?.[nil]?.[add].Bar
$env?.[nil]?.[add]?.[add]
$env?.[nil]?.[add]?.array
$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]?.Bar
$env?.[nil]?.[greet]?.array()
$env?.[nil]?.[i]
$env?.[nil]?.[list]
$env?.[nil]?.[ok]
$env?.[nil]?.[str]
$env?.[nil]?.[str]?.[array]
$env?.[nil]?.[{foo: 1}]
$env?.[nil]?.add
$env?.[nil]?.add()
$env?.[nil]?.array
$env?.[nil]?.array()
$env?.[nil]?.array(add)
$env?.[nil]?.array(list)
$env?.[nil]?.array?.[foo]
$env?.[nil]?.array?.add
$env?.[nil]?.f64
$env?.[nil]?.f64()
$env?.[nil]?.f64.add
$env?.[nil]?.f64.f64
$env?.[nil]?.f64.foo()
$env?.[nil]?.f64.i
$env?.[nil]?.flatten(0)
$env?.[nil]?.foo
$env?.[nil]?.foo()
$env?.[nil]?.foo?.String
$env?.[nil]?.foobar
$env?.[nil]?.foobar.String()
$env?.[nil]?.foobar.str
$env?.[nil]?.foobar?.i
$env?.[nil]?.greet
$env?.[nil]?.greet()
$env?.[nil]?.greet(foobar)
$env?.[nil]?.greet.f64
$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()
$env?.[nil]?.list?.array
$env?.[nil]?.list?.f64
$env?.[nil]?.list?.i
$env?.[nil]?.map(foo)
$env?.[nil]?.ok
$env?.[nil]?.ok()
$env?.[nil]?.ok(f64)
$env?.[nil]?.ok?.[str]
$env?.[nil]?.ok?.f64
$env?.[nil]?.str
$env?.[nil]?.str()
$env?.[nil]?.str(String)
$env?.[nil]?.str(foobar)
$env?.[nil]?.str(str)?.[f64]
$env?.[nil]?.str?.greet()
$env?.[ok] - 1 or true
$env?.[str] != 1 and false
$env?.[str] != add
$env?.[str] != add != $env
$env?.[str] != array
$env?.[str] != f64
$env?.[str] != foo
$env?.[str] != foo.Bar
$env?.[str] != foo?.String()
$env?.[str] != greet
$env?.[str] != i
$env?.[str] != list
$env?.[str] != ok
$env?.[str] != str
$env?.[str] != string(1.0)
$env?.[str] != type(str)
$env?.[str] + str
$env?.[str] < foo?.Bar
$env?.[str] < foo?.String()
$env?.[str] < str
$env?.[str] <= $env.str
$env?.[str] <= str
$env?.[str] == 1.0 == $env
$env?.[str] == add
$env?.[str] == array
$env?.[str] == f64
$env?.[str] == first($env)
$env?.[str] == foo
$env?.[str] == greet
$env?.[str] == i
$env?.[str] == ok
$env?.[str] == str
$env?.[str] > str
$env?.[str] >= str
$env?.[str] ?? $env[:foobar]
$env?.[str] ?? add
$env?.[str] ?? array
$env?.[str] ?? foo
$env?.[str] ?? greet
$env?.[str] ?? i
$env?.[str] ?? list
$env?.[str] ?? ok
$env?.[str] ?? str
$env?.[str] contains foo?.Bar
$env?.[str] contains str
$env?.[str] contains type(greet)
$env?.[str] endsWith $env?.str
$env?.[str] endsWith str
$env?.[str] in $env.foo
$env?.[str] in $env.list
$env?.[str] in array
$env?.[str] in list
$env?.[str] matches foo?.Bar
$env?.[str] matches str
$env?.[str] not contains 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 in list
$env?.[str] not in {foo: 1}
$env?.[str] not matches $env?.[Bar]
$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(false)
$env?.[str] | any(ok)
$env?.[str] | any(true)
$env?.[str] | count(false)
$env?.[str] | count(i != 0)
$env?.[str] | count(ok)
$env?.[str] | count(true)
$env?.[str] | date(str)
$env?.[str] | filter(false)
$env?.[str] | filter(true != false)
$env?.[str] | filter(true)
$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] | findLast(true)
$env?.[str] | findLastIndex(false)
$env?.[str] | findLastIndex(true)
$env?.[str] | greet()
$env?.[str] | groupBy(#)
$env?.[str] | groupBy(0)
$env?.[str] | groupBy(1)
$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($env)
$env?.[str] | map(0)
$env?.[str] | map(1)
$env?.[str] | map(1.0)
$env?.[str] | map(add)
$env?.[str] | map(false)
$env?.[str] | map(foo)
$env?.[str] | map(greet)
$env?.[str] | map(i)
$env?.[str] | map(list)
$env?.[str] | map(ok)
$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(ok)
$env?.[str] | one(true)
$env?.[str] | reduce(#)
$env?.[str] | reduce(#, add)
$env?.[str] | reduce(#, array)
$env?.[str] | reduce(#, false)
$env?.[str] | reduce(#, ok)
$env?.[str] | reduce(#, str)
$env?.[str] | reduce(#acc)
$env?.[str] | reduce($env)
$env?.[str] | reduce($env, ok)
$env?.[str] | reduce($env, true)
$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, add)
$env?.[str] | reduce(greet, foo)
$env?.[str] | reduce(i)
$env?.[str] | reduce(list)
$env?.[str] | reduce(list, true)
$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].Bar or true
$env?.[str]?.[-1.0]
$env?.[str]?.[f64]
$env?.[str]?.[f64] * f64
$env?.[str]?.[i]
$env?.[str][:-1]
$env?.[str][:]
$env?.[str][:f64]
$env?.[str][:i]
$env?.[str][array?.[f64]:]
$env?.[str][f64:]
$env?.add != 1.0 ?? 1
$env?.add != add
$env?.add == $env || ok
$env?.add == add
$env?.add ?? $env.i
$env?.add ?? add
$env?.add ?? array
$env?.add ?? f64
$env?.add ?? foo?.Bar
$env?.add ?? greet
$env?.add ?? i
$env?.add ?? join($env)
$env?.add ?? list
$env?.add ?? ok
$env?.add ?? reverse($env)
$env?.add ?? str
$env?.add ?? sum($env)
$env?.add in $env?.Bar
$env?.add not in $env?.[Bar]
$env?.array != array
$env?.array != array || $env
$env?.array != list
$env?.array == array
$env?.array == list
$env?.array ?? $env?.[add]
$env?.array ?? ceil(1.0)
$env?.array ?? f64
$env?.array ?? false | groupBy(foo)
$env?.array ?? fromBase64(str)
$env?.array ?? i
$env?.array ?? list
$env?.array ?? ok
$env?.array ?? str
$env?.array ?? true | map(add)
$env?.array in $env?.[Bar]
$env?.array in sort($env)
$env?.array | all(false)
$env?.array | all(ok)
$env?.array | all(true)
$env?.array | any(# == 0)
$env?.array | any(false)
$env?.array | any(ok)
$env?.array | any(true)
$env?.array | count(ok)
$env?.array | count(true)
$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(ok)
$env?.array | findIndex(true)
$env?.array | findLast(false ?? nil)
$env?.array | findLast(false)
$env?.array | findLast(ok)
$env?.array | findLast(true)
$env?.array | findLastIndex(false)
$env?.array | findLastIndex(ok)
$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(mean(1))
$env?.array | groupBy(ok)
$env?.array | groupBy(str)
$env?.array | groupBy(true)
$env?.array | map(#)
$env?.array | map(#index)
$env?.array | map($env)
$env?.array | map(0)
$env?.array | map(1)
$env?.array | map(1.0)
$env?.array | map(add)
$env?.array | map(array)
$env?.array | map(f64)
$env?.array | map(false)
$env?.array | map(foo)
$env?.array | map(i)
$env?.array | map(list)
$env?.array | map(ok)
$env?.array | map(str)
$env?.array | map(true)
$env?.array | mean(1)
$env?.array | mean(1.0)
$env?.array | mean(f64)
$env?.array | min(array)
$env?.array | min(i)
$env?.array | none(false)
$env?.array | none(ok)
$env?.array | none(true)
$env?.array | one(f64 != nil)
$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(#, array)
$env?.array | reduce(#, f64)
$env?.array | reduce(#, foo)
$env?.array | reduce(#, true)
$env?.array | reduce(#acc)
$env?.array | reduce(#index)
$env?.array | reduce($env)
$env?.array | reduce($env, $env)
$env?.array | reduce($env, add)
$env?.array | reduce($env, greet)
$env?.array | reduce($env, nil)
$env?.array | reduce(0)
$env?.array | reduce(0, foo)
$env?.array | reduce(1 == #)
$env?.array | reduce(1)
$env?.array | reduce(1, 1)
$env?.array | reduce(1, list)
$env?.array | reduce(1.0)
$env?.array | reduce(1.0, array)
$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(foo, foo)
$env?.array | reduce(greet, str)
$env?.array | reduce(i)
$env?.array | reduce(i, 1.0)
$env?.array | reduce(ok)
$env?.array | reduce(ok, true)
$env?.array | reduce(str)
$env?.array | reduce(true)
$env?.array | reduce(true, 0)
$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(f64)
$env?.array | sum(i)
$env?.array | take(0)
$env?.array; i
$env?.array?.[-0]
$env?.array?.[-1]
$env?.array?.[first(array)]
$env?.array?.[i]
$env?.array[:$env.i]
$env?.array[:]
$env?.array[:i]
$env?.f64 != $env?.String
$env?.f64 != f64
$env?.f64 != i
$env?.f64 != nil ?? 1.0
$env?.f64 * 1.0 == 1.0
$env?.f64 * f64
$env?.f64 * i
$env?.f64 ** $env.f64
$env?.f64 ** 0 / f64
$env?.f64 ** f64
$env?.f64 ** i
$env?.f64 ** int(f64)
$env?.f64 + 0 < 1.0
$env?.f64 + 1 * 0
$env?.f64 + f64
$env?.f64 + i
$env?.f64 - 1 / f64
$env?.f64 - 1.0 == 1.0
$env?.f64 - 1.0 > 0
$env?.f64 - f64
$env?.f64 / f64
$env?.f64 / i
$env?.f64 / len($env)
$env?.f64 < 0 % i
$env?.f64 < 1.0 - 1
$env?.f64 < 1.0 - 1.0
$env?.f64 < f64
$env?.f64 < i
$env?.f64 <= f64
$env?.f64 <= i
$env?.f64 == $env?.[Bar]
$env?.f64 == $env?.[str]
$env?.f64 == f64
$env?.f64 == i
$env?.f64 == max(array, 1.0)
$env?.f64 > f64
$env?.f64 > i
$env?.f64 >= -1
$env?.f64 >= f64
$env?.f64 >= i
$env?.f64 >= i == false
$env?.f64 >= round(f64)
$env?.f64 ?? 1.0 ?? i
$env?.f64 ?? add
$env?.f64 ?? array
$env?.f64 ?? foo
$env?.f64 ?? foo.String
$env?.f64 ?? greet
$env?.f64 ?? list
$env?.f64 ?? list ?? foo
$env?.f64 ?? ok
$env?.f64 ?? str
$env?.f64 ?? upper($env)
$env?.f64 ^ $env?.f64
$env?.f64 ^ f64
$env?.f64 ^ i
$env?.f64 in $env.array
$env?.f64 in array
$env?.f64 not in $env?.String
$env?.f64 not in array
$env?.f64 | max(1.0)
$env?.f64 | mean(0)
$env?.f64 | mean(1.0)
$env?.f64 | median(0)
$env?.f64 | median(1.0, f64)
$env?.f64 | median(f64)
$env?.f64 | min(1.0, 1.0)
$env?.false != add
$env?.false != ok
$env?.false == add
$env?.false ?? array
$env?.false contains $env?.String
$env?.false endsWith str
$env?.false in list
$env?.false?.Bar
$env?.false?.Bar()
$env?.false?.Bar()?.[i]
$env?.false?.Bar.String
$env?.false?.String
$env?.false?.String([foobar contains String])
$env?.false?.String?.list
$env?.false?.[add]
$env?.false?.[add].String()
$env?.false?.[add].i
$env?.false?.[array]
$env?.false?.[array].String()
$env?.false?.[array]?.String
$env?.false?.[f64]
$env?.false?.[foo]
$env?.false?.[foo].String?.list
$env?.false?.[greet]
$env?.false?.[i]
$env?.false?.[list]
$env?.false?.[list]?.array()
$env?.false?.[ok]
$env?.false?.[ok]?.[foo]
$env?.false?.[str]
$env?.false?.add
$env?.false?.add()
$env?.false?.add?.[f64]
$env?.false?.add?.[greet]
$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?.foobar.array
$env?.false?.foobar?.array()
$env?.false?.foobar?.str
$env?.false?.greet
$env?.false?.greet()
$env?.false?.groupBy(str)
$env?.false?.i
$env?.false?.i.str
$env?.false?.list
$env?.false?.list()
$env?.false?.list(String == foobar?.[str])
$env?.false?.list?.Bar
$env?.false?.list?.[foo]
$env?.false?.ok
$env?.false?.ok()
$env?.false?.ok?.[list]
$env?.false?.ok?.foobar.foo
$env?.false?.sortBy($env)
$env?.false?.str
$env?.false?.str()
$env?.false?.str.foo
$env?.false?.str?.add
$env?.foo == foo
$env?.foo ?? $env?.String
$env?.foo ?? $env?.[f64]
$env?.foo ?? array
$env?.foo ?? f64
$env?.foo ?? foo
$env?.foo ?? ok
$env?.foo ?? str
$env?.foo ?? {foo: i}
$env?.foo in $env?.[Bar]
$env?.foo in list
$env?.foo not in $env?.[String]
$env?.foo not in [$env]
$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 != f64
$env?.foobar != greet
$env?.foobar != str
$env?.foobar == $env.i
$env?.foobar == $env.str
$env?.foobar == $env?.add
$env?.foobar == [1.0]
$env?.foobar == add
$env?.foobar == array
$env?.foobar == f64
$env?.foobar == foo
$env?.foobar == greet
$env?.foobar == list
$env?.foobar == ok
$env?.foobar == reduce(list, false)
$env?.foobar == str
$env?.foobar ?? $env?.[String]
$env?.foobar ?? i
$env?.foobar ?? list
$env?.foobar ?? ok
$env?.foobar contains greet(str)
$env?.foobar contains str
$env?.foobar endsWith str
$env?.foobar in array
$env?.foobar in groupBy(array, 1.0)
$env?.foobar in list
$env?.foobar matches str
$env?.foobar not contains str
$env?.foobar not endsWith str
$env?.foobar not in array
$env?.foobar not in array == $env
$env?.foobar not matches str
$env?.foobar startsWith str
$env?.foobar | get(add)
$env?.foobar | get(ok)
$env?.foobar?.$env.array(foo)
$env?.foobar?.$env?.[f64]
$env?.foobar?.Bar
$env?.foobar?.Bar()
$env?.foobar?.Bar().str
$env?.foobar?.Bar()?.[str]
$env?.foobar?.Bar(foobar)
$env?.foobar?.Bar(greet)
$env?.foobar?.Bar(list)
$env?.foobar?.Bar.str
$env?.foobar?.Bar?.[list]
$env?.foobar?.Bar?.list()
$env?.foobar?.String
$env?.foobar?.String()
$env?.foobar?.String()?.Bar
$env?.foobar?.String(array)
$env?.foobar?.String(foo)
$env?.foobar?.String(foobar)
$env?.foobar?.String.i
$env?.foobar?.String.ok
$env?.foobar?.String?.[greet]
$env?.foobar?.String?.add
$env?.foobar?.[add]
$env?.foobar?.[add].list
$env?.foobar?.[add]?.[array]
$env?.foobar?.[add]?.[f64]
$env?.foobar?.[add]?.f64
$env?.foobar?.[add]?.foo
$env?.foobar?.[add]?.greet()
$env?.foobar?.[array]
$env?.foobar?.[array] in list
$env?.foobar?.[array].ok()
$env?.foobar?.[array].str
$env?.foobar?.[array]?.[f64]
$env?.foobar?.[array]?.[f64]?.list?.[i]
$env?.foobar?.[array]?.i?.f64
$env?.foobar?.[count($env)]
$env?.foobar?.[f64]
$env?.foobar?.[f64].add
$env?.foobar?.[f64]?.Bar
$env?.foobar?.[f64]?.[foo]
$env?.foobar?.[f64]?.[i]
$env?.foobar?.[f64]?.[list]
$env?.foobar?.[f64]?.add
$env?.foobar?.[f64]?.f64(foobar)
$env?.foobar?.[f64]?.foo
$env?.foobar?.[f64]?.greet
$env?.foobar?.[f64]?.i
$env?.foobar?.[foo]
$env?.foobar?.[foo].Bar
$env?.foobar?.[foo].str
$env?.foobar?.[foo]?.[i]
$env?.foobar?.[foo]?.[str]
$env?.foobar?.[foo]?.ok
$env?.foobar?.[greet]
$env?.foobar?.[greet].ok().array
$env?.foobar?.[greet].str
$env?.foobar?.[greet]?.[greet]
$env?.foobar?.[greet]?.add
$env?.foobar?.[greet]?.array
$env?.foobar?.[greet]?.ok
$env?.foobar?.[i]
$env?.foobar?.[i].add
$env?.foobar?.[i].str()
$env?.foobar?.[i]?.Bar
$env?.foobar?.[i]?.[list]
$env?.foobar?.[i]?.[ok]
$env?.foobar?.[i]?.foo()
$env?.foobar?.[i]?.i
$env?.foobar?.[i]?.list
$env?.foobar?.[i]?.ok
$env?.foobar?.[list]
$env?.foobar?.[list] != ok
$env?.foobar?.[list].Bar
$env?.foobar?.[list].greet()
$env?.foobar?.[list].list
$env?.foobar?.[list]?.[f64]
$env?.foobar?.[list]?.add
$env?.foobar?.[list]?.i
$env?.foobar?.[nil ?? list]
$env?.foobar?.[ok]
$env?.foobar?.[ok].ok
$env?.foobar?.[ok]?.ok
$env?.foobar?.[ok]?.ok()
$env?.foobar?.[ok]?.str
$env?.foobar?.[str]
$env?.foobar?.[str].String
$env?.foobar?.[str].array
$env?.foobar?.[str].foo
$env?.foobar?.[str].list(foobar?.[i].ok)
$env?.foobar?.[str].ok
$env?.foobar?.[str]?.f64
$env?.foobar?.[str]?.i
$env?.foobar?.[str]?.list
$env?.foobar?.add
$env?.foobar?.add($env)
$env?.foobar?.add()
$env?.foobar?.add().f64()
$env?.foobar?.add(1.0)
$env?.foobar?.add(foobar)
$env?.foobar?.add(foobar?.[add])
$env?.foobar?.add.Bar()
$env?.foobar?.add.add()
$env?.foobar?.add.array
$env?.foobar?.add.foo
$env?.foobar?.add.ok
$env?.foobar?.add.str
$env?.foobar?.add?.[greet]
$env?.foobar?.add?.[greet]?.foo
$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()?.foo
$env?.foobar?.array(Bar)
$env?.foobar?.array(foo)
$env?.foobar?.array(foobar)
$env?.foobar?.array(foobar, ok)
$env?.foobar?.array(i)
$env?.foobar?.array.array()
$env?.foobar?.array.foo
$env?.foobar?.array.list()
$env?.foobar?.array.ok
$env?.foobar?.array.str
$env?.foobar?.array?.String(i)
$env?.foobar?.array?.[add]
$env?.foobar?.array?.array
$env?.foobar?.array?.list
$env?.foobar?.count($env)
$env?.foobar?.count(foo, foo)
$env?.foobar?.f64
$env?.foobar?.f64 not matches $env
$env?.foobar?.f64()
$env?.foobar?.f64()?.greet
$env?.foobar?.f64(add)?.String(list)
$env?.foobar?.f64(false ? foobar : foobar)
$env?.foobar?.f64(foobar)
$env?.foobar?.f64(foobar?.[String])
$env?.foobar?.f64.f64
$env?.foobar?.f64.i
$env?.foobar?.f64?.[array].Bar
$env?.foobar?.f64?.[foo]?.[greet]
$env?.foobar?.f64?.[i]
$env?.foobar?.f64?.[ok]
$env?.foobar?.f64?.array
$env?.foobar?.f64?.array()
$env?.foobar?.f64?.foo
$env?.foobar?.false?.i()
$env?.foobar?.filter(f64)
$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(ceil(Bar, 1), foobar?.Bar())
$env?.foobar?.foo(foobar | string($env))
$env?.foobar?.foo(foobar)?.[i]
$env?.foobar?.foo(i)
$env?.foobar?.foo.f64
$env?.foobar?.foo.ok
$env?.foobar?.foo?.String
$env?.foobar?.foo?.[add]
$env?.foobar?.foo?.[foo]
$env?.foobar?.foo?.[greet]
$env?.foobar?.foo?.ok(str)
$env?.foobar?.foo?.str
$env?.foobar?.foobar
$env?.foobar?.foobar?.[f64]
$env?.foobar?.foobar?.[foo]
$env?.foobar?.foobar?.[greet]
$env?.foobar?.foobar?.[ok]
$env?.foobar?.greet
$env?.foobar?.greet()
$env?.foobar?.greet(array)
$env?.foobar?.greet(foobar)
$env?.foobar?.greet(list)
$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.array
$env?.foobar?.i?.Bar
$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(foobar)
$env?.foobar?.list?.[greet]
$env?.foobar?.list?.[list]
$env?.foobar?.list?.foo
$env?.foobar?.min(foobar, 1.0)
$env?.foobar?.nil.foobar
$env?.foobar?.none(1)
$env?.foobar?.none(array)
$env?.foobar?.not
$env?.foobar?.not?.[ok]
$env?.foobar?.ok
$env?.foobar?.ok()
$env?.foobar?.ok().String()
$env?.foobar?.ok(foobar not contains foobar)
$env?.foobar?.ok(foobar)
$env?.foobar?.ok(ok)
$env?.foobar?.ok(str, $env)
$env?.foobar?.ok.array
$env?.foobar?.ok.f64()
$env?.foobar?.ok?.[array]
$env?.foobar?.ok?.[f64]
$env?.foobar?.ok?.[greet]
$env?.foobar?.ok?.[str]
$env?.foobar?.ok?.i
$env?.foobar?.ok?.ok
$env?.foobar?.one(foobar)
$env?.foobar?.one(i)
$env?.foobar?.reduce(1.0)
$env?.foobar?.repeat(foobar)
$env?.foobar?.replace(str)
$env?.foobar?.reverse($env)
$env?.foobar?.round(foo)
$env?.foobar?.split(1.0)
$env?.foobar?.str
$env?.foobar?.str()
$env?.foobar?.str().String
$env?.foobar?.str()?.[foo]
$env?.foobar?.str(1 ?? foobar)
$env?.foobar?.str(String?.[i])
$env?.foobar?.str(foo)
$env?.foobar?.str(foobar)
$env?.foobar?.str.array
$env?.foobar?.str.i
$env?.foobar?.str.str
$env?.foobar?.str?.[f64]
$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?.trimSuffix(list, i)
$env?.foobar?.true?.$env
$env?.foobar?.true?.str
$env?.foobar?.uniq(foobar).add
$env?.foobar?.upper(list)
$env?.greet != greet
$env?.greet == $env?.[Bar]
$env?.greet == find($env, false)
$env?.greet == greet
$env?.greet == list ?? 1.0
$env?.greet ?? $env?.Bar(true)
$env?.greet ?? $env?.[String]
$env?.greet ?? add
$env?.greet ?? array
$env?.greet ?? f64
$env?.greet ?? foo
$env?.greet ?? greet
$env?.greet ?? i
$env?.greet ?? list
$env?.greet ?? nil ?? foo
$env?.greet ?? ok ?? foo
$env?.greet ?? str
$env?.greet($env?.[str])
$env?.greet($env?.str)
$env?.greet(foo.Bar)
$env?.greet(foo.String())
$env?.greet(foo?.Bar)
$env?.greet(foo?.String())
$env?.greet(greet(str))
$env?.greet(str ?? str)
$env?.greet(str)
$env?.greet(str) startsWith str
$env?.greet(str[:])
$env?.greet(string(0))
$env?.greet(toJSON(1.0))
$env?.greet(toJSON(array))
$env?.greet(toJSON(false))
$env?.greet(toJSON(str))
$env?.greet(trim(str))
$env?.greet(type(greet))
$env?.greet(type(ok))
$env?.greet(type(true))
$env?.greet(upper(str))
$env?.i != $env?.foobar
$env?.i != 1.0 ** i
$env?.i != f64
$env?.i != i
$env?.i % $env.i
$env?.i % 1 ?? foo
$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 ** int(1.0)
$env?.i + $env?.f64
$env?.i + f64
$env?.i + findIndex($env, ok)
$env?.i + i
$env?.i - ceil(i)
$env?.i - i
$env?.i .. 1 | groupBy(f64)
$env?.i .. i
$env?.i / 1.0 <= i
$env?.i / f64
$env?.i / i
$env?.i / len(list)
$env?.i / max(1.0)
$env?.i < 1.0 - 0
$env?.i < f64
$env?.i < i
$env?.i < i + 1
$env?.i <= 0 ^ 1.0
$env?.i <= f64
$env?.i <= i
$env?.i == 1 - 0
$env?.i == f64
$env?.i == first($env)
$env?.i == i
$env?.i == len($env)
$env?.i == len(list)
$env?.i == max($env)
$env?.i > 0 * 1.0
$env?.i > 1 ?? nil
$env?.i > f64
$env?.i > i
$env?.i > i != true
$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 ?? add
$env?.i ?? f64
$env?.i ?? filter($env, #.f64)
$env?.i ?? foo
$env?.i ?? greet
$env?.i ?? i
$env?.i ?? str
$env?.i ?? str ?? str
$env?.i ?? sum($env)
$env?.i ^ 1.0 * 1
$env?.i ^ i
$env?.i ^ i not in array
$env?.i in array
$env?.i not in $env?.String
$env?.i not in $env?.[Bar]
$env?.i not in array
$env?.i | add(0)
$env?.i | add(1)
$env?.i | bitand(i)
$env?.i | bitnand(0)
$env?.i | bitnand(1)
$env?.i | bitor(i)
$env?.i | bitshl(0)
$env?.i | bitushr(i)
$env?.i | max(1.0)
$env?.i | max(array)
$env?.i | mean(i)
$env?.i | median(0)
$env?.i | median(1)
$env?.i | median(1.0)
$env?.i | median(f64)
$env?.i | median(i)
$env?.i | min(1, f64)
$env?.i | min(f64, 1)
$env?.i..i
$env?.list != [1.0]
$env?.list != array
$env?.list != list
$env?.list == [foo, 0]
$env?.list == array
$env?.list == list
$env?.list == nil || $env
$env?.list ?? $env?.add
$env?.list ?? add
$env?.list ?? array
$env?.list ?? f64
$env?.list ?? foo
$env?.list ?? greet
$env?.list ?? i
$env?.list ?? nil ?? ok
$env?.list ?? nil | groupBy(#)
$env?.list ?? ok
$env?.list ?? str
$env?.list ?? toJSON(add)
$env?.list ?? toPairs($env)
$env?.list | all(false)
$env?.list | all(nil == 1)
$env?.list | all(ok)
$env?.list | all(true)
$env?.list | any(f64 >= f64)
$env?.list | any(false)
$env?.list | any(ok)
$env?.list | any(true)
$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 | findIndex(false)
$env?.list | findIndex(ok)
$env?.list | findIndex(true)
$env?.list | findIndex(true) not in array
$env?.list | findLast(false)
$env?.list | findLast(ok)
$env?.list | findLast(true)
$env?.list | findLastIndex(#.Bar in #)
$env?.list | findLastIndex(false)
$env?.list | findLastIndex(ok)
$env?.list | findLastIndex(true)
$env?.list | groupBy(#)
$env?.list | groupBy(#.Bar)
$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(#.String)
$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(false)
$env?.list | none(ok)
$env?.list | none(true)
$env?.list | one(false)
$env?.list | one(ok)
$env?.list | reduce(#)
$env?.list | reduce(#, f64)
$env?.list | reduce(#, false)
$env?.list | reduce(#, foo)
$env?.list | reduce(#, i)
$env?.list | reduce(#.Bar)
$env?.list | reduce(#.Bar, 0)
$env?.list | reduce(#.String, $env)
$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(1.0, list)
$env?.list | reduce(add)
$env?.list | reduce(array)
$env?.list | reduce(array, $env)
$env?.list | reduce(f64 == 1)
$env?.list | reduce(f64, $env)
$env?.list | reduce(false)
$env?.list | reduce(foo)
$env?.list | reduce(foo, nil)
$env?.list | reduce(foo, ok)
$env?.list | reduce(foo, str)
$env?.list | reduce(greet)
$env?.list | reduce(greet, ok)
$env?.list | reduce(list)
$env?.list | reduce(ok)
$env?.list | reduce(str)
$env?.list | reduce(str, nil)
$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(0)
$env?.list | sum(1)
$env?.list | sum(1.0)
$env?.list | sum(f64)
$env?.list | sum(i)
$env?.list | take(1)
$env?.list?.[i]
$env?.list?.[i].Bar
$env?.list?.[i].String
$env?.list[:]
$env?.list[:i]
$env?.list[i:]
$env?.nil != $env?.[String]
$env?.nil != array
$env?.nil != greet
$env?.nil == array
$env?.nil == foo.Bar
$env?.nil ?? foo.String
$env?.nil ?? str
$env?.nil contains $env?.[nil]
$env?.nil in list
$env?.nil matches str
$env?.nil not in array
$env?.nil startsWith str
$env?.nil.Bar || true
$env?.nil?.$env.foo
$env?.nil?.Bar
$env?.nil?.Bar()
$env?.nil?.Bar(list)
$env?.nil?.Bar?.String(Bar)
$env?.nil?.Bar?.[i]
$env?.nil?.Bar?.[list]
$env?.nil?.String
$env?.nil?.String()
$env?.nil?.String(i)
$env?.nil?.String.i
$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?.[f64]?.f64
$env?.nil?.[foo]
$env?.nil?.[foo]?.ok
$env?.nil?.[greet]
$env?.nil?.[greet]?.ok
$env?.nil?.[i]
$env?.nil?.[i]?.Bar
$env?.nil?.[i]?.[foo]
$env?.nil?.[list]
$env?.nil?.[ok]
$env?.nil?.[ok]?.str
$env?.nil?.[str]
$env?.nil?.[str]?.i
$env?.nil?.[str]?.str
$env?.nil?.add
$env?.nil?.add()
$env?.nil?.add(foobar)
$env?.nil?.array
$env?.nil?.array()
$env?.nil?.array(str)
$env?.nil?.array?.foo
$env?.nil?.array?.list
$env?.nil?.f64
$env?.nil?.f64()
$env?.nil?.f64(foobar != i)
$env?.nil?.f64?.true?.greet?.foo
$env?.nil?.filter(0)
$env?.nil?.filter(1.0)
$env?.nil?.findIndex(str)
$env?.nil?.findLast(false)
$env?.nil?.foo
$env?.nil?.foo()
$env?.nil?.foo.foo
$env?.nil?.foo.i
$env?.nil?.foo.str
$env?.nil?.foo?.[add].array
$env?.nil?.foo?.[f64]
$env?.nil?.foo?.f64(Bar)
$env?.nil?.foobar
$env?.nil?.foobar.ok
$env?.nil?.foobar?.Bar(foobar, $env)
$env?.nil?.foobar?.i
$env?.nil?.greet
$env?.nil?.greet()
$env?.nil?.greet?.array
$env?.nil?.i
$env?.nil?.i($env.foo)
$env?.nil?.i()
$env?.nil?.list
$env?.nil?.list()
$env?.nil?.map(foobar)
$env?.nil?.median(foobar)
$env?.nil?.ok
$env?.nil?.ok()
$env?.nil?.ok(add)
$env?.nil?.ok(foobar?.[String].add)
$env?.nil?.ok.add
$env?.nil?.one(foobar, foobar)
$env?.nil?.round(1.0)
$env?.nil?.str
$env?.nil?.str()
$env?.nil?.str(foobar)
$env?.ok && $env?.Bar
$env?.ok && $env?.[str]
$env?.ok && $env?.ok
$env?.ok && nil not in $env
$env?.ok && ok
$env?.ok == ok
$env?.ok ? add : foo
$env?.ok ? foo == nil : i
$env?.ok ?: array
$env?.ok ?: foo
$env?.ok ?? $env?.[Bar]
$env?.ok ?? $env?.[add]
$env?.ok ?? add
$env?.ok ?? array
$env?.ok ?? f64
$env?.ok ?? foo
$env?.ok ?? greet
$env?.ok ?? i
$env?.ok ?? keys($env)
$env?.ok ?? list
$env?.ok ?? str
$env?.ok ?? str ?? $env
$env?.ok and $env?.[String]
$env?.ok and 1.0 == i
$env?.ok and foo != foo
$env?.ok and ok
$env?.ok not in $env && false
$env?.ok or !true
$env?.ok or $env != $env
$env?.ok or $env in str
$env?.ok or i != 1.0
$env?.ok or nil not in $env
$env?.ok or ok
$env?.ok || $env?.Bar()
$env?.ok || ok
$env?.ok || sum($env)
$env?.str != 1.0 ?? foo
$env?.str + str
$env?.str < foo.Bar
$env?.str < str
$env?.str < type(add)
$env?.str <= $env?.str
$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 ?? $env.ok
$env?.str ?? $env?.String()
$env?.str ?? add
$env?.str ?? array
$env?.str ?? f64
$env?.str ?? foo
$env?.str ?? greet
$env?.str ?? list
$env?.str ?? not ok
$env?.str ?? ok
$env?.str ?? str
$env?.str contains $env?.[Bar]
$env?.str contains foo?.Bar
$env?.str contains str
$env?.str endsWith $env and false
$env?.str endsWith str
$env?.str endsWith toJSON(foo)
$env?.str in $env ? 1.0 : nil
$env?.str in $env?.[String]
$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 in {foo: greet, foo: nil}
$env?.str not matches foo.Bar
$env?.str not matches str
$env?.str not startsWith $env.str
$env?.str not startsWith foo?.Bar
$env?.str not startsWith str
$env?.str startsWith $env?.Bar
$env?.str | date(str)
$env?.str | greet()
$env?.str | trim(str)
$env?.str | trimPrefix(str)
$env?.str[:0 ?? false]
$env?.str[:]
$env?.str[:i]
$env?.str[i:]
$env?.true != i
$env?.true != ok
$env?.true == foo
$env?.true == i
$env?.true ?? foo.Bar
$env?.true not endsWith str
$env?.true not matches str
$env?.true | get(array)
$env?.true?.Bar
$env?.true?.Bar()
$env?.true?.Bar(false)
$env?.true?.String
$env?.true?.String()
$env?.true?.String().add
$env?.true?.String.foo(foobar)
$env?.true?.String?.Bar.str
$env?.true?.[add]
$env?.true?.[array]
$env?.true?.[array].Bar
$env?.true?.[array].add()
$env?.true?.[f64]
$env?.true?.[f64]?.String()
$env?.true?.[f64]?.[list]
$env?.true?.[foo]
$env?.true?.[greet]
$env?.true?.[greet].Bar
$env?.true?.[greet]?.ok
$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(foobar matches foo)
$env?.true?.add.foo
$env?.true?.array
$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?.foobar?.str
$env?.true?.greet
$env?.true?.greet()
$env?.true?.greet().i
$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?.reduce(array)
$env?.true?.str
$env?.true?.str()
$env?.true?.true?.array
$env[$env:] - f64 and false
$env[:str] not in foo || true
- + $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)
-$env && false
-$env and false
-$env in str && false
-$env not in foo || true
-$env or true
-$env || true
-$env.f64
-$env.f64 - i
-$env.f64 ?? i
-$env.i
-$env.i / i
-$env.i ?? add
-$env?.[str]?.[f64]
-$env?.array?.[i]
-$env?.f64
-$env?.i
-$env?.i != $env
-$env?.i == f64
--$env.f64
--$env?.f64
--$env?.i
--0
--0 .. i
--0 ?? array
--1
--1 < 1.0
--1.0
--1.0 - 1.0
--bitnot(0)
--f64
--f64 / f64
--i
--sum(array)
-.0 ** 0
-.0 / 1
-0 != $env
-0 != 0
-0 != 1
-0 != 1.0
-0 != f64
-0 != i
-0 != mean(f64)
-0 != min($env)
-0 != nil
-0 % 1
-0 % i
-0 % i + f64
-0 * 0
-0 * 1
-0 * 1.0
-0 * f64
-0 * i
-0 ** 0
-0 ** 1
-0 ** 1.0
-0 ** 1.0 < i
-0 ** 1.0 ?? list
-0 ** i
-0 + -f64
-0 + 0
-0 + 1
-0 + 1.0
-0 + f64
-0 + f64 != 1.0
-0 + i
-0 - 0
-0 - 1
-0 - 1.0
-0 - f64
-0 - floor(f64)
-0 - i
-0 .. 0
-0 .. 1
-0 .. i
-0 / 0
-0 / 1
-0 / 1.0
-0 / f64
-0 / i
-0 < 0
-0 < 1
-0 < 1.0
-0 < f64
-0 < i
-0 <= 0
-0 <= 1
-0 <= 1.0
-0 <= f64
-0 <= i
-0 == $env
-0 == $env?.Bar
-0 == $env?.[Bar]
-0 == 0
-0 == 1
-0 == 1.0
-0 == f64
-0 == i
-0 == mean(1.0)
-0 == nil
-0 > 0
-0 > 1
-0 > 1.0
-0 > f64
-0 > i
-0 >= 0
-0 >= 0 || false
-0 >= 1
-0 >= 1.0
-0 >= f64
-0 >= i
-0 ?? $env
-0 ?? 0
-0 ?? 1
-0 ?? 1.0
-0 ?? add
-0 ?? array
-0 ?? f64
-0 ?? false
-0 ?? foo
-0 ?? foo.Bar
-0 ?? foo?.Bar
-0 ?? greet
-0 ?? i
-0 ?? list
-0 ?? min(0, i)
-0 ?? nil
-0 ?? ok
-0 ?? str
-0 ?? true
-0 ^ 0
-0 ^ 0 | max(1)
-0 ^ 1
-0 ^ 1.0
-0 ^ 1.0 <= 1
-0 ^ f64
-0 ^ i
-0 in $env?.array
-0 in array
-0 not in array
-0 | bitshl(i)
-0 | bitushr(1)
-0 | max(array)
-0 | mean(0)
-0 | mean(1.0)
-0 | median(1.0)
-0 | median(i)
-0.0
-0.1
-1 != $env
-1 != 0
-1 != 1
-1 != 1.0
-1 != 1.0 || true
-1 != f64
-1 != i
-1 != mean(array)
-1 != nil
-1 % 1
-1 % i
-1 * 0
-1 * 1
-1 * 1.0
-1 * 1.0 - i
-1 * f64
-1 * i
-1 ** 0
-1 ** 1
-1 ** 1.0
-1 ** f64
-1 ** i
-1 + 0
-1 + 1
-1 + 1 ^ f64
-1 + 1.0
-1 + f64
-1 + float(i)
-1 + i
-1 - 0
-1 - 1
-1 - 1.0
-1 - f64
-1 - i
-1 .. 0
-1 .. 1
-1 .. i
-1 / 0
-1 / 1
-1 / 1.0
-1 / f64
-1 / i
-1 < 0
-1 < 1
-1 < 1.0
-1 < f64
-1 < i
-1 <= -0
-1 <= 0
-1 <= 1
-1 <= 1.0
-1 <= f64
-1 <= i
-1 == $env
-1 == 0
-1 == 1
-1 == 1.0
-1 == 1.0 * 1
-1 == f64
-1 == i
-1 == nil
-1 == nil != false
-1 > 0
-1 > 1
-1 > 1.0
-1 > f64
-1 > i
-1 >= 0
-1 >= 0 + i
-1 >= 1
-1 >= 1.0
-1 >= f64
-1 >= i
-1 ?? $env
-1 ?? $env.ok
-1 ?? $env?.greet
-1 ?? 0
-1 ?? 1
-1 ?? 1.0
-1 ?? add
-1 ?? array
-1 ?? array ?? $env
-1 ?? f64
-1 ?? false
-1 ?? foo
-1 ?? greet
-1 ?? i
-1 ?? list
-1 ?? nil
-1 ?? ok
-1 ?? str
-1 ?? str && false
-1 ?? sum($env, list)
-1 ?? true
-1 ?? type(i)
-1 ^ $env?.i
-1 ^ 0
-1 ^ 1
-1 ^ 1.0
-1 ^ f64
-1 ^ i
-1 ^ i <= 1
-1 in array
-1 not in $env.array
-1 not in array
-1 | bitnand(0)
-1 | bitnand(1)
-1 | bitor(1)
-1 | bitshr(1)
-1 | bitushr(i)
-1 | bitxor(i)
-1 | max(1.0)
-1 | max(array)
-1 | mean(0)
-1 | mean(1)
-1 | mean(1.0)
-1 | mean(f64)
-1 | median(1, 0)
-1 | min(f64)
-1..i
-1.0
-1.0 != $env
-1.0 != $env?.[Bar]
-1.0 != $env?.i
-1.0 != 0
-1.0 != 1
-1.0 != 1.0
-1.0 != 1.0 == $env?.[String]
-1.0 != f64
-1.0 != i
-1.0 != nil
-1.0 * $env?.i
-1.0 * -1
-1.0 * 0
-1.0 * 1
-1.0 * 1.0
-1.0 * f64
-1.0 * i
-1.0 ** 0
-1.0 ** 1
-1.0 ** 1.0
-1.0 ** f64
-1.0 ** i
-1.0 + 0
-1.0 + 1
-1.0 + 1.0
-1.0 + f64
-1.0 + i
-1.0 + i != 1.0
-1.0 - $env?.i
-1.0 - 0
-1.0 - 1
-1.0 - 1.0
-1.0 - f64
-1.0 - i
-1.0 / $env.i
-1.0 / 0
-1.0 / 1
-1.0 / 1.0
-1.0 / f64
-1.0 / i
-1.0 < 0
-1.0 < 0 ** 1.0
-1.0 < 1
-1.0 < 1.0
-1.0 < f64
-1.0 < i
-1.0 < mean(i, 1.0)
-1.0 <= 0
-1.0 <= 1
-1.0 <= 1.0
-1.0 <= f64
-1.0 <= f64 != $env
-1.0 <= i
-1.0 == $env
-1.0 == $env?.[String]
-1.0 == $env?.[str]
-1.0 == 0
-1.0 == 1
-1.0 == 1 && false
-1.0 == 1.0
-1.0 == f64
-1.0 == f64 ?? add
-1.0 == i
-1.0 == nil
-1.0 > 0
-1.0 > 1
-1.0 > 1.0
-1.0 > f64
-1.0 > i
-1.0 >= -f64
-1.0 >= 0
-1.0 >= 1
-1.0 >= 1.0
-1.0 >= 1.0 >= 1
-1.0 >= f64
-1.0 >= i
-1.0 ?? !true
-1.0 ?? $env
-1.0 ?? $env?.add
-1.0 ?? -f64
-1.0 ?? 0
-1.0 ?? 1
-1.0 ?? 1.0
-1.0 ?? add
-1.0 ?? array
-1.0 ?? f64
-1.0 ?? false
-1.0 ?? foo
-1.0 ?? greet
-1.0 ?? i
-1.0 ?? list
-1.0 ?? nil
-1.0 ?? ok
-1.0 ?? str
-1.0 ?? true
-1.0 ^ 0
-1.0 ^ 1
-1.0 ^ 1.0
-1.0 ^ 1.0 <= 1.0
-1.0 ^ array?.[i]
-1.0 ^ f64
-1.0 ^ i
-1.0 in array
-1.0 not in $env?.Bar
-1.0 not in array
-1.0 | max(f64)
-1.0 | mean(1)
-1.0 | mean(1.0, f64)
-1.0 | median(1.0)
-1.0 | median(i)
-1.0 | min(0)
-1.0 | min(1)
-1.0 | min(1.0)
-1.0 | min(array)
-1.0 | min(array, 1.0)
-1.0; false
-1.1
-abs(0)
-abs(1 * i)
-abs(1)
-abs(1.0)
-abs(f64)
-abs(i)
-abs(reduce(array, 0))
-add(0, 1)
-add(1, 1)
-add(i, 0)
-add(i, 1)
-array?.[0]
-array?.[1]
-array?.[i]
-bitnand(0, 1)
-bitnand(1, i)
-bitnot(0)
-bitnot(1)
-bitnot(i)
-bitnot(min(array))
-bitnot(sum(array))
-bitshl(0, i)
-bitshl(1, i)
-bitshl(i, i)
-bitshr(1, 0)
-bitshr(1, i)
-bitshr(i, 1)
-bitxor(1, 1)
-ceil(0)
-ceil(1)
-ceil(1.0)
-ceil(f64)
-ceil(i)
-count($env, ok)
-count($env, true)
-count(array, false)
-count(array, ok)
-count(list, false)
-count(list, ok)
-count(list, true)
-f64
-f64 != $env
-f64 != 0
-f64 != 1
-f64 != 1.0
-f64 != f64
-f64 != i
-f64 != int(1)
-f64 != nil
-f64 * 0
-f64 * 1
-f64 * 1.0
-f64 * f64
-f64 * i
-f64 ** 0
-f64 ** 1
-f64 ** 1.0
-f64 ** f64
-f64 ** i
-f64 + 0
-f64 + 1
-f64 + 1.0
-f64 + 1.0 / 1
-f64 + f64
-f64 + i
-f64 + sum(array)
-f64 - 0
-f64 - 1
-f64 - 1.0
-f64 - f64
-f64 - i
-f64 / 1
-f64 / 1.0
-f64 / 1.0 ?? false
-f64 / f64
-f64 / i
-f64 / i ** 0
-f64 < 0
-f64 < 1
-f64 < 1.0
-f64 < f64
-f64 < i
-f64 <= 0
-f64 <= 1
-f64 <= 1.0
-f64 <= f64
-f64 <= i
-f64 == $env
-f64 == 0
-f64 == 1
-f64 == 1.0
-f64 == 1.0 || $env
-f64 == f64
-f64 == i
-f64 == max(0)
-f64 == nil
-f64 > 0
-f64 > 1
-f64 > 1.0
-f64 > f64
-f64 > f64 <= f64
-f64 > i
-f64 >= $env?.i
-f64 >= 0
-f64 >= 0 > 0
-f64 >= 1
-f64 >= 1.0
-f64 >= f64
-f64 >= float(1.0)
-f64 >= i
-f64 ?? $env
-f64 ?? 0
-f64 ?? 1
-f64 ?? 1.0
-f64 ?? add
-f64 ?? array
-f64 ?? false
-f64 ?? foo
-f64 ?? greet
-f64 ?? i
-f64 ?? list
-f64 ?? nil
-f64 ?? nil ?? nil
-f64 ?? ok
-f64 ?? str
-f64 ?? string(nil)
-f64 ?? true
-f64 ^ 1
-f64 ^ 1.0
-f64 ^ f64
-f64 ^ i
-f64 in array
-f64 not in array
-f64 | mean(0)
-find(array, ok)
-find(array, true)
-findIndex($env, ok)
-findIndex(list, true)
-findLast(array, ok)
-findLastIndex($env, ok)
-findLastIndex($env, true)
-findLastIndex(array, ok)
-findLastIndex(array, true)
-findLastIndex(list, true)
-first($env | map(#index))
-first(array)
-float(0)
-float(1)
-float(1.0 ?? nil)
-float(1.0)
-float(f64)
-float(i)
-floor($env.i)
-floor(0)
-floor(1)
-floor(1.0)
-floor(f64)
-floor(i)
-i
-i != $env
-i != 0
-i != 1
-i != 1.0
-i != ceil(f64)
-i != f64
-i != i
-i != nil
-i % 1
-i % i
-i * 1
-i * 1.0
-i * f64
-i * i
-i * nil ?? 1.0
-i ** 0
-i ** 1.0
-i ** 1.0 ** f64
-i ** 1.0 == nil
-i ** f64
-i ** i
-i + 0
-i + 1
-i + 1.0
-i + f64
-i + i
-i + median(1.0)
-i - 0
-i - 1
-i - 1.0
-i - array?.[i]
-i - f64
-i - i
-i .. 0
-i .. 1
-i .. i
-i .. min(1)
-i / 0
-i / 1
-i / 1.0
-i / f64
-i / i
-i < 0
-i < 1
-i < 1 and false
-i < 1.0
-i < f64
-i < i
-i < sum(array)
-i <= 0
-i <= 1
-i <= 1.0
-i <= f64
-i <= i
-i == $env
-i == 0
-i == 1.0
-i == 1.0 * i
-i == f64
-i == i
-i == nil
-i > 0
-i > 1
-i > 1.0
-i > f64
-i > i
-i >= 1
-i >= 1.0
-i >= 1.0 ?? foo
-i >= f64
-i >= i
-i >= i || $env
-i ?? $env
-i ?? $env.array
-i ?? $env?.String?.i
-i ?? $env?.[i]
-i ?? $env?.add
-i ?? $env?.i
-i ?? 0
-i ?? 1
-i ?? 1.0
-i ?? add
-i ?? array
-i ?? f64
-i ?? false
-i ?? foo
-i ?? foo?.Bar
-i ?? greet
-i ?? i
-i ?? list
-i ?? nil
-i ?? ok
-i ?? str
-i ?? true
-i ^ 0
-i ^ 0 ?? foo
-i ^ 1
-i ^ 1.0
-i ^ f64
-i ^ i
-i ^ i > 1.0
-i in array
-i not in array
-i | add(i)
-i | bitand(0)
-i | bitor(0)
-i | bitshr(1)
-i | bitxor(1)
-i | bitxor(i)
-i | max(1)
-i | max(f64)
-i | min(1.0)
-i..i
-int($env?.i)
-int(0)
-int(1)
-int(1.0)
-int(array | max(1))
-int(f64)
-int(i)
-last(array)
-len($env)
-len(array)
-len(foo?.Bar)
-len(list)
-len(str)
-max($env).i
-max(0 * 1)
-max(0)
-max(1)
-max(1, 1.0)
-max(1, array)
-max(1.0)
-max(1.0, 0)
-max(1.0, 1.0)
-max(array)
-max(array, 0)
-max(array, i)
-max(f64)
-max(f64, 1.0)
-max(i)
-max(i, 0)
-max(i, 1)
-max(i, array)
-mean(0)
-mean(0, f64)
-mean(1)
-mean(1, 1)
-mean(1, f64)
-mean(1.0)
-mean(1.0, 0, array)
-mean(1.0, 1)
-mean(1.0, 1.0)
-mean(1.0, i)
-mean(array)
-mean(f64)
-mean(f64, 1)
-mean(i)
-mean(i) > f64
-mean(i, f64)
-median(0)
-median(1)
-median(1) < i
-median(1.0)
-median(array)
-median(array, 1.0)
-median(f64)
-median(f64, f64)
-median(i)
-median(i, 1)
-median(min(0))
-min(0)
-min(0, 1)
-min(1)
-min(1.0)
-min(1.0, i)
-min(array)
-min(array, 0, array)
-min(array, i, 1.0)
-min(f64)
-min(f64, 0, 1.0)
-min(i)
-min(i, 1)
-min(i, 1.0)
-min(i, 1.0) + f64
-nil ?? -f64
-nil ?? 0
-nil ?? 1
-nil ?? 1 != nil
-nil ?? 1.0
-nil ?? f64
-nil ?? i
-nil ?? i / 0
-reduce($env, 0, nil)
-reduce($env, i, str)
-reduce(array, #)
-reduce(array, #acc)
-reduce(array, #index, $env)
-reduce(array, 0)
-reduce(array, 1)
-reduce(array, 1, f64)
-reduce(array, 1.0)
-reduce(array, f64)
-reduce(array, i)
-reduce(list, 1)
-reduce(list, 1.0)
-round(0)
-round(1)
-round(1.0)
-round(f64)
-round(i)
-sum($env, 0)
-sum($env, 1)
-sum($env, 1.0)
-sum($env, f64)
-sum($env.array)
-sum(array)
-sum(array); str
-sum(array, #)
-sum(array, 0)
-sum(array, 1)
-sum(array, 1.0)
-sum(array, i)
-sum(list | reduce(array, greet))
-sum(list, 0)
-sum(list, 1)
-sum(list, 1.0)
-sum(list, f64)
-sum(str ?? 0)
0 != $env ?: $env?.[i]?.ok
0 != $env ?: ok
0 != $env ?? add
0 != $env ?? array
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 % sum(array)
0 != 0 && $env == foo
0 != 0 - i
0 != 0 ?: array
0 != 0 ?? f64
0 != 0 ^ 1.0 ^ 1
0 != 0 or 0 != f64
0 != 1.0 && ok ?? greet
0 != 1.0 * $env.f64
0 != 1.0 * i
0 != 1.0 + f64 ** 1.0
0 != 1.0 / i * 1.0
0 != 1.0 ?? ok
0 != 1.0 || $env - i
0 != array?.[i]
0 != f64 - $env?.i
0 != f64 / f64
0 != f64 == $env?.Bar
0 != f64 ^ 1.0 or $env
0 != f64 || $env?.[ok]
0 != f64 || nil == str
0 != f64 || ok
0 != foo ?? list
0 != i ** i
0 != i ^ f64
0 != nil != ok
0 != nil || $env?.[String]
0 != ok ?? $env?.Bar
0 != ok ?? i
0 != true ?? foo?.Bar
0 % $env.i
0 % $env?.i
0 % 1 * i
0 % 1 + i >= 0
0 % 1 < array?.[i]
0 % 1 > -1
0 % 1 > count(array, false)
0 % 1 >= i
0 % 1 in array != $env
0 % 1 | median(f64)
0 % array?.[i]
0 % i * i
0 % i <= f64
0 % i | mean(f64)
0 * $env.f64
0 * $env.i
0 * $env?.f64
0 * $env?.i
0 * 0 != f64
0 * 0 == i
0 * 0 ?? foo
0 * 1 != i
0 * 1 + f64
0 * 1 < f64
0 * 1 | bitshl(0)
0 * 1.0 != i
0 * 1.0 != nil or ok
0 * 1.0 ** i
0 * 1.0 < f64
0 * array?.[i]
0 * f64 + i
0 * f64 <= f64
0 * f64 == f64 || ok
0 * i != i
0 * i ^ f64
0 * i not in groupBy(array, foo)
0 * i | max(0)
0 ** $env.f64
0 ** $env.i
0 ** $env?.f64
0 ** $env?.i
0 ** 0 != $env?.i
0 ** 0 + $env.i
0 ** 0 >= i
0 ** 0 | max(1.0)
0 ** 1 > i
0 ** 1 | max(1)
0 ** 1.0 ** f64
0 ** 1.0 / f64
0 ** 1.0 < i
0 ** 1.0 == i
0 ** 1.0 > i
0 ** 1.0 >= floor(i)
0 ** 1.0 ?? f64
0 ** 1.0 ^ i
0 ** 1.0 | max(f64)
0 ** array?.[i]
0 ** f64 == nil || false
0 ** f64 >= $env?.f64
0 ** i != f64
0 ** i ?? ok
0 ** i ^ $env?.f64
0 + $env.f64
0 + $env.i
0 + $env?.[str]?.[i]
0 + $env?.f64
0 + $env?.i
0 + 0 != f64
0 + 0 - f64
0 + 0 / i
0 + 0 >= f64 <= $env
0 + 0 ^ i
0 + 0 in array
0 + 1 + i
0 + 1 <= $env.i
0 + 1 <= f64
0 + 1 == $env.f64
0 + 1 | min(0)
0 + 1.0 + i
0 + 1.0 <= f64
0 + 1.0 > f64
0 + 1.0 >= i
0 + 1.0 ?? i
0 + 1.0 ^ f64
0 + array?.[i]
0 + f64 > i
0 + i != f64
0 + i * f64
0 + i ** i
0 + i < $env?.f64
0 - $env.f64
0 - $env.i
0 - $env?.f64
0 - $env?.i
0 - 0 != bitand(0, i)
0 - 0 < f64
0 - 0 == i
0 - 1 ** f64
0 - 1 + f64
0 - 1 < $env.i
0 - 1 < sum(array)
0 - 1 >= -f64
0 - 1 ?? array
0 - 1 ?? str
0 - 1.0 + i
0 - array?.[i]
0 - f64 <= f64
0 - f64 > f64
0 - f64 >= f64 * i
0 - f64 >= i
0 - i ?? f64
0 - i ?? foo
0 - nil ?? i
0 .. $env.i
0 .. $env?.i
0 .. 0 ?? toJSON(i)
0 .. 0 | find(ok)
0 .. 0 | map(#)
0 .. 0 | map(#index)
0 .. 0 | map(true)
0 .. 0 | max(1.0)
0 .. 0 | reduce(#)
0 .. 0 | reduce(str)
0 .. 1 | get(1)
0 .. 1 | map(#)
0 .. 1 | map(array)
0 .. 1 | map(foo)
0 .. 1 | reduce(#)
0 .. 1 | reduce($env)
0 .. 1 | reduce(add)
0 .. 1 | sortBy(#)
0 .. 1 | sum(#)
0 .. 1.0 ?? foo
0 .. array?.[i]
0 .. i | any(false)
0 .. i | groupBy(foo)
0 .. i | map(str)
0 .. i | median(f64)
0 .. i | one(false)
0 .. i | reduce(list, add)
0 .. i | sortBy(1)
0 / $env != 1 and false
0 / $env.f64
0 / $env.f64 ** f64
0 / $env.i
0 / $env?.f64
0 / $env?.i
0 / 0 * i
0 / 0 + ceil(1.0)
0 / 0 / i
0 / 0 > f64
0 / 1 / f64
0 / 1 == $env?.String
0 / 1.0 * f64
0 / 1.0 + $env.i
0 / 1.0 > f64
0 / 1.0 ?? $env ?? i
0 / 1.0 ?? date(nil, foo)
0 / 1.0 ?? foo
0 / 1.0 ?? list ?? 1.0
0 / array?.[i]
0 / f64 - f64
0 / f64 <= f64
0 / f64 | median(f64)
0 / i + i
0 / i / 1.0 ?? 0
0 / i <= 0 != nil
0 / i == f64
0 / i > f64
0 / i ?? i
0 / i not in concat(list)
0 < $env.f64
0 < $env.i
0 < $env?.[str]?.[f64]
0 < $env?.f64
0 < $env?.i
0 < 0 != ok
0 < 0 + len(str)
0 < 0 ?? date(1)
0 < 0 ?? ok
0 < 1 % i
0 < 1 - i
0 < 1 >= i
0 < 1 ^ median(1.0)
0 < 1 and foo ?? 1.0
0 < 1.0 * 1 != false
0 < 1.0 - f64
0 < 1.0 / i
0 < 1.0 <= i
0 < 1.0 > i
0 < array?.[i]
0 < f64 + i
0 < f64 - f64
0 < f64 ? array : list
0 < f64 ?? array
0 < f64 ^ 0 / i
0 < f64 || $env?.ok
0 < i + i
0 < i < i
0 < i <= reduce(array, #)
0 <= $env.f64
0 <= $env.i
0 <= $env?.f64
0 <= $env?.i
0 <= 0 ?? ok
0 <= 1 * i
0 <= 1 <= f64
0 <= 1 ^ f64
0 <= 1 or $env != 1
0 <= 1.0 * f64
0 <= array?.[i]
0 <= f64 - f64 or $env
0 <= f64 > f64
0 <= f64 ?? add
0 <= f64 or !$env
0 <= i % i
0 <= i ^ 1.0 <= 1.0
0 <= i || ok
0 <= nil ?? f64
0 == $env == 0 ?? 1.0
0 == $env or $env.ok
0 == $env or ok
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 | get(foo)]
0 == $env?.[Bar]
0 == $env?.[String]
0 == $env?.[first(0, ok)]
0 == $env?.[foobar]
0 == $env?.[foobar]?.add
0 == $env?.[str]
0 == $env?.f64
0 == $env?.i
0 == 0 * f64
0 == 0 * i
0 == 0 not in $env?.foobar
0 == 1.0 && f64 + $env
0 == 1.0 / i
0 == add ?? f64
0 == array?.[i]
0 == f64 - 1 and false
0 == f64 ?: add
0 == f64 ?? ok
0 == false ?? str
0 == foo ?? $env?.add
0 == i and $env?.[foo]
0 == nil and $env matches str
0 == str ?? greet
0 == true ?? list
0 > $env.f64
0 > $env.i
0 > $env?.[str]?.[f64]
0 > $env?.f64
0 > $env?.i
0 > 0 * f64
0 > 0 / i
0 > 0 == ok
0 > 0 > ceil($env)
0 > 0 or foo == nil
0 > 1 - i
0 > 1.0 != str ?? i
0 > 1.0 ** f64
0 > 1.0 / f64
0 > 1.0 >= f64 or ok
0 > 1.0 ^ f64
0 > array?.[i]
0 > f64 > $env?.[Bar]
0 > f64 > f64
0 > f64 ?? f64
0 > f64 and $env?.[greet]
0 > i > i
0 > i and foo == nil
0 >= $env.f64
0 >= $env.i
0 >= $env?.f64
0 >= $env?.i
0 >= 0 ** i
0 >= 0 ?? list
0 >= 0 or str != nil
0 >= 1 >= i
0 >= 1 ?? add
0 >= 1 ?? i
0 >= 1.0 ** i
0 >= 1.0 / 1 ** 1
0 >= 1.0 ?? list
0 >= 1.0 ?? ok
0 >= 1.0 ^ i
0 >= 1.0 and ok
0 >= 1.0 or ok
0 >= array?.[i]
0 >= f64 ** f64
0 >= f64 + f64
0 >= f64 <= $env?.i
0 >= f64 >= $env?.[foo]
0 >= i > i
0 >= i >= 1.0 - $env
0 >= nil ?? f64
0 ?? $env ?? str
0 ?? $env | max(1.0)
0 ?? $env.add
0 ?? $env.array
0 ?? $env.foo
0 ?? $env.greet
0 ?? $env.i
0 ?? $env.list
0 ?? $env.ok
0 ?? $env.str
0 ?? $env?.Bar
0 ?? $env?.String
0 ?? $env?.String()
0 ?? $env?.String(greet())
0 ?? $env?.[Bar]
0 ?? $env?.[String]
0 ?? $env?.[String].String
0 ?? $env?.[add(0)]
0 ?? $env?.[add]
0 ?? $env?.[add]?.[array]
0 ?? $env?.[array]
0 ?? $env?.[date($env)]
0 ?? $env?.[f64]
0 ?? $env?.[foo]
0 ?? $env?.[greet]
0 ?? $env?.[i]
0 ?? $env?.[list]
0 ?? $env?.[nil | date(1, foobar)]
0 ?? $env?.[ok]
0 ?? $env?.[str]
0 ?? $env?.add
0 ?? $env?.array
0 ?? $env?.f64
0 ?? $env?.foo
0 ?? $env?.foobar
0 ?? $env?.greet
0 ?? $env?.i
0 ?? $env?.list
0 ?? $env?.ok
0 ?? $env?.str
0 ?? $env[:String matches $env]
0 ?? $env[:add(greet, str)]
0 ?? $env[:count(foo)]
0 ?? $env[:foo]
0 ?? $env[:foobar and foobar]
0 ?? $env[:foobar | filter(#.i)]
0 ?? $env[:foobar.add]
0 ?? $env[:greet.ok]
0 ?? $env[String():add(list)]
0 ?? $env[i:foobar]
0 ?? 1 ?? i
0 ?? 1 ?? str
0 ?? 1.0 ?? i
0 ?? add ?? i
0 ?? array?.[array?.[i]]
0 ?? array?.[i]
0 ?? f64 | mean(0)
0 ?? foo | get(foo)
0 ?? foo.Bar
0 ?? foo.String
0 ?? foo.String()
0 ?? foo?.Bar
0 ?? foo?.String
0 ?? foo?.String()
0 ?? i ?? foo
0 ?? list ?? greet
0 ?? list?.[i]
0 ?? ok ?? i
0 ?? true ?? foo
0 ^ $env.f64
0 ^ $env.i
0 ^ $env?.f64
0 ^ $env?.i
0 ^ 1 * i
0 ^ 1 ** i
0 ^ 1 / f64
0 ^ 1.0 != $env?.f64
0 ^ 1.0 != i
0 ^ 1.0 + f64
0 ^ 1.0 / f64
0 ^ 1.0 >= f64
0 ^ 1.0 ?? $env.ok
0 ^ 1.0 ?? 1.0 > f64
0 ^ 1.0 in array
0 ^ array?.[i]
0 ^ f64 == i
0 ^ i == 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?.[String]?.array
0 in $env?.array
0 in array != ok
0 in nil ?? array
0 not in $env.array
0 not in $env?.Bar
0 not in $env?.String
0 not in $env?.String?.[array]
0 not in $env?.[Bar]
0 not in $env?.[String]
0 not in $env?.[foobar]
0 not in $env?.array
0 not in $env?.foobar
0 | add(0) ^ f64
0 | bitnand(0) > i
0 | bitor($env) == 1 and false
0 | bitshl(1) / f64
0 | bitshr(0); array; greet
0 | bitxor(0) in array
0 | max(0) in array
0 | max(array, 1.0) - floor(i)
0 | mean(i) ?? f64
0 | min(0) | mean(1)
0 | min(1) ** f64
0..array?.[i]
0..i | count(true)
0..i | groupBy(#)
0..i | groupBy(f64)
0..i | map(1.0)
0..i | map(list)
0.0 != f64
0.0 + 0 == $env
0.1 != floor(1.0)
0.1 | mean(f64)
0.1 | min(1.0)
0; $env.add
0; $env?.add
1 != $env not in [true]
1 != $env.f64
1 != $env.i
1 != $env?.Bar
1 != $env?.Bar?.array
1 != $env?.String
1 != $env?.String?.f64
1 != $env?.[Bar]
1 != $env?.[Bar]?.f64
1 != $env?.[Bar]?.greet
1 != $env?.[String]
1 != $env?.[foobar]
1 != $env?.[str]
1 != $env?.f64
1 != $env?.foobar
1 != $env?.i
1 != 0 * f64
1 != 0 ?? list
1 != 1 - f64
1 != 1 ?? list
1 != 1 ?? ok
1 != 1.0 && 0 == 1.0
1 != 1.0 + i
1 != 1.0 ^ f64
1 != array ?? list
1 != array?.[i]
1 != f64 && $env?.[str]
1 != f64 ** f64
1 != f64 || $env?.[ok]
1 != f64 || ok
1 != false ?? foo
1 != foo ?? f64
1 != i != ok
1 != i + f64
1 != i - f64
1 != i ?? greet
1 != i ^ f64
1 != list ?? array ?: list
1 != nil or ok
1 % $env.i
1 % $env?.i
1 % 1 > f64
1 % 1 ?? list
1 % array?.[i]
1 % i + f64
1 % i < f64
1 % i >= i
1 * $env.f64
1 * $env.i
1 * $env.i + f64
1 * $env?.f64
1 * $env?.i
1 * 0 / f64
1 * 0 < f64
1 * 0 == {foo: 1.0}?.array
1 * 0 not in $env?.[Bar]
1 * 0 | bitushr(0)
1 * 1 == i
1 * 1 | bitnand(0)
1 * 1 | min(f64)
1 * 1.0 * 1.0 * i
1 * 1.0 ** $env.i
1 * 1.0 < f64
1 * 1.0 <= ceil(0)
1 * 1.0 <= f64
1 * 1.0 ?? foo
1 * array?.[i]
1 * f64 * f64
1 * f64 * i
1 * f64 / min(0)
1 * f64 ^ f64 - 1
1 * f64 | mean(1)
1 * i + bitnot(0)
1 * i - f64
1 * i / i
1 * i | bitxor(i)
1 * nil ?? $env?.f64
1 ** $env.f64
1 ** $env.i
1 ** $env?.f64
1 ** $env?.f64 ?? list
1 ** $env?.i
1 ** 0 ** i
1 ** 0 / i
1 ** 0 == ceil(1)
1 ** 0 > f64
1 ** 0 ?? list
1 ** 1 != i
1 ** 1 ** i
1 ** 1.0 != f64
1 ** 1.0 ?? $env == f64
1 ** 1.0 ?? groupBy(list, ok)
1 ** 1.0 in array
1 ** 1.0 | mean(array)
1 ** array?.[i]
1 ** f64 - array?.[i]
1 ** f64 | median(i)
1 ** i + f64
1 ** i < 1.0 + 0
1 ** i <= i
1 ** nil ?? i
1 ** nil ?? mean(0)
1 + $env.f64
1 + $env.i
1 + $env?.f64
1 + $env?.i
1 + 0 ** i
1 + 0 | bitor(i)
1 + 1 % i
1 + 1 >= f64 ^ 0
1 + 1 not in array
1 + 1.0 != i
1 + 1.0 * f64
1 + 1.0 - i
1 + 1.0 < f64
1 + 1.0 ?? foo
1 + 1.0 ?? greet > f64
1 + 1.0 ?? ok
1 + 1.0 ^ i
1 + 1.0 | max(1)
1 + f64 ?? greet
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 - 0 > i
1 - 0 ?? list
1 - 1 == f64
1 - 1 | median(1, 1.0)
1 - 1.0 ** f64
1 - 1.0 + f64
1 - 1.0 / i
1 - 1.0 == 1.0 == $env
1 - 1.0 ?? i
1 - 1.0 ?? not true
1 - 1.0 in array
1 - 1.0 not in array
1 - array?.[i]
1 - f64 / i
1 - f64 > f64
1 - f64 >= 1.0 < 1
1 - f64 ?? add
1 - f64 ^ f64
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 | all($env)
1 .. 0 | filter(true)
1 .. 0 | groupBy(#)
1 .. 0 | groupBy(foo)
1 .. 0 | one($env)
1 .. 0 | sortBy(#)
1 .. 0 | sortBy($env)
1 .. 0 | sortBy(str)
1 .. 0 | sum(greet)
1 .. 1 ?? array
1 .. 1 | filter(ok)
1 .. 1 | findLast(true)
1 .. 1 | map(#)
1 .. 1 | map($env)
1 .. 1 | map(foo)
1 .. 1 | sum(1.0)
1 .. array?.[i]
1 .. i - i
1 .. i ?? i
1 .. i ?? ok
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 / 0 ?? foo
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 <= f64
1 / 1.0 == i || ok
1 / 1.0 > 1.0 != nil
1 / 1.0 ?? f64
1 / array?.[i]
1 / f64 - f64
1 / f64 >= f64
1 / i != i
1 / i + 1.0 / 1
1 / i + i
1 / i ?? i
1 < $env.f64
1 < $env.i
1 < $env?.f64
1 < $env?.f64 && ok
1 < $env?.i
1 < 0 && ok
1 < 0 - f64
1 < 0 - f64 ?? foo
1 < 0 <= $env?.[str]
1 < 0 ?? i
1 < 0 ^ i ** 1.0
1 < 1 * f64
1 < 1 < f64
1 < 1 ?: array
1 < 1 ?? f64
1 < 1 ?? i
1 < 1 ^ sum(array)
1 < 1.0 < i
1 < 1.0 > $env?.[false]
1 < 1.0 ?? add
1 < 1.0 ?? greet
1 < 1.0 ?? str
1 < array?.[i]
1 < f64 / f64
1 < f64 > 0 ** i
1 < f64 >= $env?.i
1 < i > i
1 < i ? ok : ok
1 < i ?? f64
1 < i or min($env)
1 <= $env.f64
1 <= $env.i
1 <= $env?.f64
1 <= $env?.i
1 <= 0 - i
1 <= 0 ?: greet
1 <= 0 and ok
1 <= 1 * i
1 <= 1 / f64
1 <= 1 == true or true
1 <= 1.0 == $env?.[Bar]
1 <= 1.0 >= f64
1 <= 1.0 ?? array
1 <= array?.[i]
1 <= f64 + i
1 <= f64 - f64
1 <= f64 or ok
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 - f64
1 == 1.0 - i
1 == 1.0 ?? 1.0 ?? ok
1 == 1.0 and ok
1 == 1.0 or $env[:foobar]
1 == array?.[i]
1 == f64 && list == $env
1 == f64 * f64 ** 1.0
1 == f64 ?: greet
1 == f64 ?? -$env
1 == f64 ^ f64
1 == foo ?? list
1 == foo ?? str
1 == i != $env?.String
1 == i - f64
1 == i || $env?.[add]
1 == nil != ok
1 == ok ?? foo
1 == str ?? array
1 > $env.f64
1 > $env.i
1 > $env?.f64
1 > $env?.i
1 > 0 != ok
1 > 0 * f64
1 > 0 <= i or $env
1 > 0 ?? foo
1 > 1 or nil != str
1 > 1.0 / i
1 > 1.0 <= -$env
1 > 1.0 <= array?.[i]
1 > 1.0 <= i
1 > 1.0 >= $env.i
1 > 1.0 >= $env[true:1]
1 > 1.0 ^ min(array)
1 > array?.[i]
1 > f64 ** i
1 > i % i
1 > i - i
1 > i / i
1 > i <= f64
1 > i ?? i
1 >= $env.f64
1 >= $env.i
1 >= $env?.f64
1 >= $env?.i
1 >= 0 && $env?.String
1 >= 0 * i
1 >= 0 == ok
1 >= 0 >= f64
1 >= 1 <= f64
1 >= 1 <= i
1 >= 1 ?? greet
1 >= 1.0 ** f64
1 >= 1.0 > float(1)
1 >= 1.0 >= i
1 >= 1.0 ?: list
1 >= 1.0 or $env.ok
1 >= array?.[i]
1 >= f64 > sum($env, 1)
1 >= f64 ?? array
1 >= i ** i
1 >= i >= i
1 ?? $env | get(ok)
1 ?? $env | max(1.0)
1 ?? $env.add
1 ?? $env.array
1 ?? $env.array?.[i]
1 ?? $env.f64
1 ?? $env.foo
1 ?? $env.greet
1 ?? $env.i
1 ?? $env.list
1 ?? $env.ok
1 ?? $env.str
1 ?? $env?.Bar
1 ?? $env?.Bar()
1 ?? $env?.Bar?.[f64]
1 ?? $env?.String
1 ?? $env?.String()
1 ?? $env?.String(nil)
1 ?? $env?.[Bar]
1 ?? $env?.[Bar]?.[add]
1 ?? $env?.[String]
1 ?? $env?.[add]
1 ?? $env?.[array]
1 ?? $env?.[f64()]
1 ?? $env?.[f64]
1 ?? $env?.[f64].f64.greet
1 ?? $env?.[foo(true)]
1 ?? $env?.[foo]
1 ?? $env?.[greet]
1 ?? $env?.[greet]?.[str]
1 ?? $env?.[i]
1 ?? $env?.[i]?.[foo]
1 ?? $env?.[list]
1 ?? $env?.[list]?.Bar
1 ?? $env?.[ok]
1 ?? $env?.[ok].str
1 ?? $env?.[ok]?.[str]
1 ?? $env?.[str]
1 ?? $env?.[str].Bar
1 ?? $env?.add
1 ?? $env?.array
1 ?? $env?.f64
1 ?? $env?.foo
1 ?? $env?.foobar
1 ?? $env?.foobar.greet
1 ?? $env?.foobar?.[f64]?.array()
1 ?? $env?.foobar?.list()
1 ?? $env?.greet
1 ?? $env?.i
1 ?? $env?.list
1 ?? $env?.ok
1 ?? $env?.round(foobar)
1 ?? $env?.str
1 ?? $env[:String | ceil(foobar)]
1 ?? $env[:foobar == foobar].foo
1 ?? $env[:foobar?.array(foobar)]
1 ?? $env[:str]
1 ?? $env[String <= false:foobar < foo]
1 ?? $env[String():]?.list
1 ?? $env[list():]
1 ?? $env[ok(foobar):]
1 ?? $env[reverse(0):]
1 ?? 1 ?? array
1 ?? 1.0 ?? greet
1 ?? 1.0 | bitnand(i)
1 ?? 1.0 | mean(f64)
1 ?? add ?? f64
1 ?? array ?? f64
1 ?? false ?? f64
1 ?? foo ?? array
1 ?? foo ?? str
1 ?? foo | max(1)
1 ?? foo.Bar
1 ?? foo.String
1 ?? foo.String()
1 ?? foo?.Bar
1 ?? foo?.String
1 ?? foo?.String()
1 ?? i ?? array
1 ?? list?.[i]
1 ?? ok | get(true)
1 ^ $env.f64
1 ^ $env.i
1 ^ $env?.f64
1 ^ $env?.i
1 ^ 0 ** i
1 ^ 0 >= i
1 ^ 1 - i
1 ^ 1 > f64
1 ^ 1 ?? foo?.String
1 ^ 1 in $env.array
1 ^ 1 in array
1 ^ 1 not in array
1 ^ 1.0 + f64
1 ^ 1.0 + i - 0
1 ^ 1.0 == f64 ?? 1.0
1 ^ 1.0 == i
1 ^ 1.0 > i
1 ^ 1.0 ?? array
1 ^ 1.0 ?? foo
1 ^ 1.0 ?? list
1 ^ 1.0 ?? {foo: foo}
1 ^ 1.0 ^ f64
1 ^ 1.0 ^ int(1.0)
1 ^ 1.0 ^ round(0)
1 ^ array?.[i]
1 ^ f64 != $env.f64
1 ^ f64 - ceil(1.0)
1 ^ f64 | min(1)
1 ^ i ** i
1 in $env.array
1 in $env?.Bar
1 in $env?.String
1 in $env?.[Bar]
1 in $env?.[Bar]?.[array]
1 in $env?.[Bar]?.f64
1 in $env?.[String]
1 in $env?.array
1 in $env?.foobar
1 in array ?? foo
1 in array || false ? 1 : foo
1 in array || ok
1 not in $env.array
1 not in $env?.$env?.list
1 not in $env?.Bar
1 not in $env?.Bar?.[i]
1 not in $env?.Bar?.add
1 not in $env?.String
1 not in $env?.String?.[foo]
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 not in $env?.foobar?.String(foobar)
1 not in $env?.foobar?.[array]
1 not in list ?? add
1 not in nil ?? array
1 | bitand(i) ?? $env?.[foo]
1 | bitshl(0) != f64
1 | bitshl(1) != f64
1 | bitxor(1) >= i
1 | mean(1) < 0 ?? 1.0
1 | min(1.0) + i
1..array?.[i]
1..i != array
1..i | all(true)
1..i | map(#)
1..i | map(0)
1..i | reduce(array)
1.0 != $env ?? foo
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?.[add]
1.0 != $env?.String?.[i]
1.0 != $env?.String?.[ok]
1.0 != $env?.[Bar]
1.0 != $env?.[String]
1.0 != $env?.[String]?.greet()
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 - f64
1.0 != 0 / abs(1.0)
1.0 != 0 ?? add
1.0 != 0 ?? str
1.0 != 0.-1.0
1.0 != 1 != ok
1.0 != 1 / i
1.0 != 1 ?: foo
1.0 != 1.0 ** i
1.0 != 1.0 / abs(1.0)
1.0 != 1.0 == ok
1.0 != 1.0 ^ $env.f64
1.0 != 1.0 ^ f64
1.0 != 1.0 and $env not endsWith $env
1.0 != add ?? greet
1.0 != add ?? {foo: 1}
1.0 != array?.[i]
1.0 != f64 && ok
1.0 != false ?? $env?.[list]
1.0 != foo ?? array?.[i]
1.0 != foo ?? count($env, false)
1.0 != foo ?? greet
1.0 != i % i
1.0 != i * f64
1.0 != i / i
1.0 != i ^ f64
1.0 != i or ok
1.0 != list ?? array
1.0 != nil ?? 1 ?? foo
1.0 != nil or reduce($env, #.str)?.[str]
1.0 != str ?? array
1.0 != true ?? $env.add
1.0 != true ?? array
1.0 != true ?? f64
1.0 * $env.array?.[i]
1.0 * $env.f64
1.0 * $env.i
1.0 * $env?.f64
1.0 * $env?.i
1.0 * 0 + f64
1.0 * 0 / f64 != nil
1.0 * 0 <= f64
1.0 * 0 == f64
1.0 * 0 >= i
1.0 * 0 ^ f64
1.0 * 1 != i
1.0 * 1 != max($env)
1.0 * 1 ** i
1.0 * 1 ?? add
1.0 * 1 ?? list
1.0 * 1 ?? ok
1.0 * 1 | max(f64)
1.0 * 1.0 != 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 >= 0 == nil
1.0 * 1.0 >= i
1.0 * 1.0 ?? f64
1.0 * 1.0 | mean(array)
1.0 * 1.0 | median(1.0)
1.0 * 1.0 | min(1.0)
1.0 * array?.[i]
1.0 * f64 * i
1.0 * f64 - i
1.0 * f64 - max(1, array)
1.0 * f64 == f64
1.0 * f64 == sum(array)
1.0 * f64 ?? f64
1.0 * f64 ?? greet
1.0 * f64 | max(1.0)
1.0 * i + f64
1.0 * i >= 1.0 ^ 1
1.0 * i ?? ok
1.0 * i not in array
1.0 * i | median(1.0)
1.0 ** $env.f64
1.0 ** $env.i
1.0 ** $env?.f64
1.0 ** $env?.i
1.0 ** 0 - 1.0 in array
1.0 ** 0 - i
1.0 ** 0 / i
1.0 ** 0 < i
1.0 ** 0 <= f64
1.0 ** 0 == f64
1.0 ** 0 == i
1.0 ** 0 > i
1.0 ** 0 ?? str
1.0 ** 0 ^ 0 ** 0
1.0 ** 0 | median(1)
1.0 ** 1 ** $env.i
1.0 ** 1 / 1.0 ?? foo
1.0 ** 1 ^ i
1.0 ** 1.0 != i
1.0 ** 1.0 * i
1.0 ** 1.0 ** -1.0
1.0 ** 1.0 < 0 != false
1.0 ** 1.0 < i
1.0 ** 1.0 ?? array
1.0 ** 1.0 ?? foo
1.0 ** 1.0 ?? greet
1.0 ** 1.0 ?? list
1.0 ** 1.0 ?? nil ?? foo
1.0 ** 1.0 ?? upper($env)
1.0 ** 1.0 | median(1.0)
1.0 ** array?.[i]
1.0 ** f64
1.0 ** f64 != f64
1.0 ** f64 * f64
1.0 ** f64 * i
1.0 ** f64 - f64
1.0 ** f64 / i
1.0 ** f64 >= f64
1.0 ** f64 ?? ok
1.0 ** f64 | median(i)
1.0 ** f64 | min(1)
1.0 ** i - -0
1.0 ** i - float(f64)
1.0 ** i / f64
1.0 ** i <= i * 1.0
1.0 ** nil ?? 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 + 0 / reduce(array, i)
1.0 + 0 < round(1)
1.0 + 0 ?? add
1.0 + 1 ?? f64
1.0 + 1 not in array
1.0 + 1 | median(1.0)
1.0 + 1.0 + i
1.0 + 1.0 - i
1.0 + 1.0 <= i
1.0 + 1.0 ?? add
1.0 + 1.0 ^ f64
1.0 + 1.0 ^ i
1.0 + 1.0 in $env?.Bar
1.0 + 1.0 not in array
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 < i
1.0 + f64 == i
1.0 + f64 >= f64
1.0 + i / f64
1.0 + i < f64
1.0 + i > i
1.0 + i >= i
1.0 + i ?? greet == foo
1.0 - $env.f64
1.0 - $env.i
1.0 - $env?.f64
1.0 - $env?.f64 == 1.0
1.0 - $env?.i
1.0 - 0 != f64
1.0 - 0 * f64
1.0 - 0 >= f64
1.0 - 0 ?? str
1.0 - 1 + 1.0 == nil
1.0 - 1 - i
1.0 - 1 - min(1.0)
1.0 - 1 / i
1.0 - 1 > i and $env
1.0 - 1 not in array
1.0 - 1.0 != f64
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 == i
1.0 - 1.0 > f64
1.0 - 1.0 >= f64
1.0 - 1.0 ?? ok
1.0 - 1.0 in array
1.0 - 1.0 in array ?: i
1.0 - 1.0 | median(0)
1.0 - array?.[i]
1.0 - f64 != f64
1.0 - f64 * i
1.0 - f64 - f64
1.0 - f64 / i
1.0 - f64 in array
1.0 - i * $env.i
1.0 - i ** -i
1.0 - i < i
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 / 0 != i
1.0 / 0 * $env?.f64
1.0 / 0 + f64
1.0 / 0 - i
1.0 / 0 < i
1.0 / 0 <= 1 + f64
1.0 / 0 == f64
1.0 / 0 == i
1.0 / 0 > $env?.f64
1.0 / 0 ?? list
1.0 / 0 | median(f64, i)
1.0 / 0 | min(1.0)
1.0 / 1 != find($env, false)
1.0 / 1 * f64
1.0 / 1 ** i
1.0 / 1 > f64
1.0 / 1 >= f64
1.0 / 1.0 != f64
1.0 / 1.0 + i
1.0 / 1.0 + min(0)
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 > i
1.0 / 1.0 >= f64
1.0 / 1.0 ?? 0 + 1
1.0 / 1.0 ?? i
1.0 / 1.0 ^ f64
1.0 / 1.0 ^ i
1.0 / array?.[i]
1.0 / f64 * i
1.0 / f64 <= f64 || true
1.0 / f64 ?? one($env, #.foo)
1.0 / f64 ^ i
1.0 / f64 in array
1.0 / i ** i
1.0 / i / i != nil
1.0 / i < f64
1.0 / i <= i
1.0 / i == i
1.0 < $env.add(0, i)
1.0 < $env.f64
1.0 < $env.i
1.0 < $env?.f64
1.0 < $env?.i
1.0 < 1 <= f64
1.0 < 1 > $env?.[greet]
1.0 < 1 > f64
1.0 < 1 >= i
1.0 < 1 ?? ok
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 - i
1.0 < 1.0 / round(1.0)
1.0 < 1.0 <= $env?.String
1.0 < 1.0 <= i
1.0 < 1.0 == $env && true
1.0 < 1.0 == ok
1.0 < 1.0 > round($env)
1.0 < 1.0 >= 1.0 == ok
1.0 < 1.0 ? foo != nil : str
1.0 < 1.0 ?? $env?.[greet]
1.0 < 1.0 ?? f64
1.0 < 1.0 ?? foo
1.0 < 1.0 ^ f64
1.0 < 1.0 ^ i
1.0 < 1.0 || ok
1.0 < array?.[i]
1.0 < f64 + $env.i
1.0 < f64 + i
1.0 < f64 - f64
1.0 < f64 - i ?? add
1.0 < f64 < $env?.[ok]
1.0 < f64 ?: i
1.0 < f64 ^ f64
1.0 < i != ok
1.0 < i / f64
1.0 < i > f64
1.0 < i > i
1.0 < i >= -1.0
1.0 < i >= i
1.0 < i ?: 1 == i
1.0 < i ?: list
1.0 < i ^ 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 <= 0 / f64
1.0 <= 0 / i
1.0 <= 0 < f64 <= f64
1.0 <= 0 >= i
1.0 <= 0 ? f64 : greet
1.0 <= 0 ?? array
1.0 <= 0 ?? duration($env)
1.0 <= 0 or ok
1.0 <= 1 ** f64 ^ 1
1.0 <= 1 ** i
1.0 <= 1 / $env?.i
1.0 <= 1 / i
1.0 <= 1 < -i
1.0 <= 1 < f64 < f64
1.0 <= 1 or none($env, $env)
1.0 <= 1.0 != ok
1.0 <= 1.0 && $env?.Bar
1.0 <= 1.0 * f64
1.0 <= 1.0 * i
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 <= i
1.0 <= 1.0 == ok == $env
1.0 <= 1.0 > i
1.0 <= 1.0 >= f64
1.0 <= 1.0 or ok
1.0 <= 1.0 || ok
1.0 <= array?.[i]
1.0 <= f64
1.0 <= f64 != ok
1.0 <= f64 && ok
1.0 <= f64 ** 1 ? 1.0 : ok
1.0 <= f64 < $env.f64
1.0 <= f64 < -0
1.0 <= f64 <= f64
1.0 <= f64 >= f64
1.0 <= f64 ?? add
1.0 <= i * $env.f64
1.0 <= i * i
1.0 <= i / i
1.0 <= i or 1 != f64
1.0 <= i or ok != false
1.0 == $env && ok != false
1.0 == $env ?? array
1.0 == $env ^ $env or true
1.0 == $env or ok
1.0 == $env or true ?? nil
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?.[String]?.[array]
1.0 == $env?.[String]?.[ok].greet
1.0 == $env?.[foobar?.[f64]]
1.0 == $env?.[foobar]
1.0 == $env?.[greet(Bar)]
1.0 == $env?.[str]
1.0 == $env?.f64
1.0 == $env?.foobar
1.0 == $env?.foobar?.[ok]
1.0 == $env?.i
1.0 == $env?.true != $env
1.0 == 0 != $env || false
1.0 == 0 ?? -0
1.0 == 0 ^ f64
1.0 == 0 or $env?.ok
1.0 == 1 != ok
1.0 == 1 % i
1.0 == 1 * f64
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 - i
1.0 == 1.0 / f64
1.0 == 1.0 ?? i
1.0 == 1.0 and ok
1.0 == 1.0 in [nil, 1]
1.0 == 1.0 || any($env, true)
1.0 == 1.0 || ok
1.0 == array?.[i]
1.0 == f64 != ok
1.0 == f64 * 0 ?? 0
1.0 == false ?? uniq(array)
1.0 == foo ?? count(array)
1.0 == foo ?? ok
1.0 == i != ok
1.0 == i != ok; nil
1.0 == i * i
1.0 == i + f64
1.0 == i + sum(list, 1.0)
1.0 == i / i
1.0 == i ?? i
1.0 == nil ?: array
1.0 == nil and $env.ok
1.0 == nil or ok
1.0 == ok ?? f64
1.0 == str ?? foo
1.0 > $env * 1.0 || true
1.0 > $env.f64
1.0 > $env.i
1.0 > $env?.f64
1.0 > $env?.i
1.0 > 0 / i
1.0 > 0 < 1 ^ f64
1.0 > 0 < f64
1.0 > 0 < i
1.0 > 0 >= last(array)
1.0 > 0 || ok
1.0 > 1 > find($env, #)
1.0 > 1 >= $env?.[ok]
1.0 > 1 ?: {foo: add, foo: ok}?.foo
1.0 > 1 ?? $env?.str
1.0 > 1 ?? f64
1.0 > 1 ?? nil && $env
1.0 > 1 ^ i
1.0 > 1.0 * array?.[i]
1.0 > 1.0 <= f64
1.0 > 1.0 == ok
1.0 > 1.0 > i
1.0 > 1.0 >= len(str)
1.0 > 1.0 ?? array
1.0 > 1.0 ?? list
1.0 > array?.[i]
1.0 > f64 * f64
1.0 > f64 ** i
1.0 > f64 + f64
1.0 > f64 / i
1.0 > f64 < f64
1.0 > f64 > round(1.0)
1.0 > f64 ?? greet
1.0 > f64 ?? map(list, true)
1.0 > f64 or none($env, .f64)
1.0 > i != str ?? foo
1.0 > i && median($env, foo)
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?.[str]?.[f64]
1.0 >= $env?.f64
1.0 >= $env?.i
1.0 >= 0 / i
1.0 >= 1 <= f64
1.0 >= 1 > i
1.0 >= 1 > i >= i
1.0 >= 1 ?? array < 0
1.0 >= 1 in $env?.Bar
1.0 >= 1.0 * f64
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 < f64
1.0 >= 1.0 <= f64
1.0 >= 1.0 == {foo: $env, foo: $env}.foo
1.0 >= 1.0 > i
1.0 >= 1.0 ?: list
1.0 >= 1.0 ?? greet
1.0 >= 1.0 ?? list
1.0 >= 1.0 ^ f64
1.0 >= 1.0 and f64 ?? foo
1.0 >= array?.[i]
1.0 >= f64 ** $env?.i
1.0 >= f64 ** 0 > 1.0
1.0 >= f64 + i
1.0 >= f64 - i
1.0 >= f64 / i
1.0 >= f64 > f64
1.0 >= f64 not in $env?.[String]
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 >= i == $env?.[Bar]
1.0 >= i == not false
1.0 >= i ?? array
1.0 >= i and not ok
1.0 ?? $env ?? list
1.0 ?? $env.add
1.0 ?? $env.array
1.0 ?? $env.f64
1.0 ?? $env.foo
1.0 ?? $env.greet
1.0 ?? $env.i
1.0 ?? $env.list
1.0 ?? $env.ok
1.0 ?? $env.str
1.0 ?? $env?.$env?.$env
1.0 ?? $env?.$env?.array
1.0 ?? $env?.Bar
1.0 ?? $env?.Bar()
1.0 ?? $env?.String
1.0 ?? $env?.String()
1.0 ?? $env?.String?.f64
1.0 ?? $env?.String?.ok()
1.0 ?? $env?.[$env?.[foobar]]
1.0 ?? $env?.[1.0 >= list]
1.0 ?? $env?.[1.0 not in array]
1.0 ?? $env?.[Bar]
1.0 ?? $env?.[Bar]?.[list]
1.0 ?? $env?.[String]
1.0 ?? $env?.[String]?.[add]
1.0 ?? $env?.[String]?.ok
1.0 ?? $env?.[add]
1.0 ?? $env?.[add].str
1.0 ?? $env?.[array < array]
1.0 ?? $env?.[array]
1.0 ?? $env?.[array].greet
1.0 ?? $env?.[count(1)]
1.0 ?? $env?.[f64(ok)]
1.0 ?? $env?.[f64]
1.0 ?? $env?.[filter(foobar, foobar)]
1.0 ?? $env?.[findIndex(ok, #acc)]
1.0 ?? $env?.[flatten(add)]
1.0 ?? $env?.[foo | floor(foobar)]
1.0 ?? $env?.[foo?.str]
1.0 ?? $env?.[foo]
1.0 ?? $env?.[foobar | ok()]
1.0 ?? $env?.[foobar?.add(foobar)]
1.0 ?? $env?.[foobar?.add]
1.0 ?? $env?.[foobar]
1.0 ?? $env?.[greet startsWith String]
1.0 ?? $env?.[greet()]
1.0 ?? $env?.[greet?.add]
1.0 ?? $env?.[greet]
1.0 ?? $env?.[i]
1.0 ?? $env?.[list(Bar)]?.[i]
1.0 ?? $env?.[list]
1.0 ?? $env?.[ok]
1.0 ?? $env?.[str]
1.0 ?? $env?.[str].foo
1.0 ?? $env?.[str]?.[f64]
1.0 ?? $env?.add
1.0 ?? $env?.array
1.0 ?? $env?.f64
1.0 ?? $env?.false?.[f64]
1.0 ?? $env?.foo
1.0 ?? $env?.foo?.String
1.0 ?? $env?.foobar.array
1.0 ?? $env?.greet
1.0 ?? $env?.i
1.0 ?? $env?.list
1.0 ?? $env?.ok
1.0 ?? $env?.str
1.0 ?? $env[$env || foobar:foobar ** f64]
1.0 ?? $env[1.0 || true:]
1.0 ?? $env[:$env && add]
1.0 ?? $env[:$env | hasSuffix(false)]
1.0 ?? $env[:findIndex(foobar, foobar)]
1.0 ?? $env[:foobar?.[array]]
1.0 ?? $env[:foobar]
1.0 ?? $env[add not startsWith greet:]
1.0 ?? $env[array():]
1.0 ?? $env[f64 and ok:0 or 1.0]
1.0 ?? $env[foo($env):str(foobar)]
1.0 ?? $env[foo?.foo():]
1.0 ?? $env[foobar | f64():]
1.0 ?? $env[foobar:greet()]
1.0 ?? $env[reduce(true, nil, foobar):foo and foobar]
1.0 ?? 1.0 ?? f64
1.0 ?? 1.0 ?? list
1.0 ?? array ?? ok
1.0 ?? array | mean(0)
1.0 ?? array?.[i]
1.0 ?? array[:$env ?? f64]
1.0 ?? array[:i]
1.0 ?? f64 | max(1.0)
1.0 ?? foo.Bar
1.0 ?? foo.String
1.0 ?? foo.String()
1.0 ?? foo?.Bar
1.0 ?? foo?.String
1.0 ?? foo?.String()
1.0 ?? greet ?? add
1.0 ?? greet ?? ok
1.0 ?? list ?? greet
1.0 ?? list?.[i]
1.0 ?? nil | median(array)
1.0 ?? ok ?? list
1.0 ?? str ?? [true]
1.0 ?? true ?? add
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 < f64
1.0 ^ 0 <= i
1.0 ^ 0 == $env ?? 1.0
1.0 ^ 0 > i ? array : foo
1.0 ^ 0 ?? f64
1.0 ^ 0 ?? foo
1.0 ^ 0 ^ f64
1.0 ^ 1 * i
1.0 ^ 1 ** f64
1.0 ^ 1 - f64
1.0 ^ 1 - sum(array)
1.0 ^ 1 == i
1.0 ^ 1 >= 1 || false
1.0 ^ 1 ?? add
1.0 ^ 1 ?? f64
1.0 ^ 1 ?? foo
1.0 ^ 1.0 * f64
1.0 ^ 1.0 ** f64
1.0 ^ 1.0 ** i
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 ^ 1.0 ?? f64
1.0 ^ 1.0 ?? foo
1.0 ^ 1.0 ?? ok
1.0 ^ 1.0 ^ i
1.0 ^ 1.0 not in array
1.0 ^ 1.0 | min(1.0 ?? $env)
1.0 ^ 1.0 | min(f64)
1.0 ^ array?.[i]
1.0 ^ f64 * i
1.0 ^ f64 <= f64
1.0 ^ f64 <= i and $env
1.0 ^ f64 == f64
1.0 ^ f64 ^ i
1.0 ^ i * i
1.0 ^ i - i
1.0 ^ i < f64 < 1.0
1.0 ^ i <= int(1.0)
1.0 ^ i > i
1.0 ^ i ?? greet
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?.array
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?.[foobar]
1.0 in $env?.array
1.0 in $env?.foobar
1.0 in $env?.foobar?.Bar()
1.0 in 0 .. i
1.0 in array != ok
1.0 in array == ok
1.0 in array ?? i
1.0 in array or ok
1.0 in i..i
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?.[foobar]?.list
1.0 not in $env?.array
1.0 not in $env?.foobar
1.0 not in $env?.nil?.[list].array()
1.0 not in array && ok
1.0 not in array ?? $env?.[list]
1.0 | max(1.0, f64) < f64
1.0 | max(array) <= i
1.0 | max(f64) != i
1.0 | max(i) == f64
1.0 | mean(1.0) * 1 ?? false
1.0 | mean(f64) != i
1.0 | median(0) ^ i
1.0 | median(array) | get(foo)
1.0 | min(1.0) != i
1.0 | min(1.0) ** i
1.0; $env.i
1.0; $env?.Bar
1.0; $env?.i
1.0; $env?.list
1.0; 1.0 < f64
1.0; array | reduce(#)
1.0; foo?.Bar
1.1 * f64
1.1 < i
1.1 >= f64
1; $env.i
1; $env?.foo
1; $env?.foobar
1; $env?.i
1; 1 ?? $env.array
1; add ?? date(i)
1; f64 < i
[!false, -0]
[!false, foo]
[!false]
[!ok, foo]
[!ok, greet]
[!ok]
[!true, array]
[!true]
[$env != $env]
[$env != 0]
[$env != 1, f64]
[$env != 1.0]
[$env != 1]
[$env != add]
[$env != f64]
[$env != false]
[$env != foo]
[$env != greet]
[$env != i]
[$env != list]
[$env != nil]
[$env != ok]
[$env != str]
[$env && false]
[$env && true]
[$env == $env, foo != foo]
[$env == $env.add]
[$env == $env]
[$env == 0]
[$env == 1.0]
[$env == 1]
[$env == add]
[$env == false]
[$env == foo, ok]
[$env == foo]
[$env == greet]
[$env == i, f64]
[$env == i]
[$env == list]
[$env == nil]
[$env == ok]
[$env == str]
[$env == true]
[$env ?? $env]
[$env ?? 0]
[$env ?? 1.0]
[$env ?? 1]
[$env ?? add]
[$env ?? array]
[$env ?? false]
[$env ?? foo]
[$env ?? i]
[$env ?? nil]
[$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 | find(false)]
[$env | findIndex(true)]
[$env | findLast(false)]
[$env | findLastIndex(false)]
[$env | map(#index)]
[$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 | map(true)]
[$env | none(false)]
[$env | one(false)]
[$env | one(ok)]
[$env | reduce(list, 0)]
[$env | reduce(true, foo)]
[$env | sum(0)]
[$env | sum(1)]
[$env | sum(1.0)]
[$env | sum(f64)]
[$env || false]
[$env || true]
[$env, $env]?.[i]
[$env, 0] | any(.ok)
[$env, 1.0] | find(true)
[$env, 1.0] | map(#)
[$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, foo]?.[i]
[$env, greet] | reduce(1)
[$env, i] | reduce(false, $env)
[$env, nil]?.[i]
[$env, ok, $env]?.[i]
[$env, ok] | findLastIndex(#)
[$env, ok] | findLastIndex(false)
[$env, ok] | reduce(f64)
[$env, ok]?.[i]
[$env, true] | groupBy(foo)
[$env, true] | map(foo)
[$env.add, foo]
[$env.add, list]
[$env.add]
[$env.array, i]
[$env.array?.[i]]
[$env.array]
[$env.f64, greet]
[$env.f64, ok]
[$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, $env.i]
[$env.i, greet]
[$env.i, str]
[$env.i]
[$env.list, add]
[$env.list]
[$env.ok, foo]
[$env.ok, i]
[$env.ok, list]
[$env.ok]
[$env.str, max(1.0)]
[$env.str, str]
[$env.str]
[$env?.$env]
[$env?.Bar]
[$env?.String, add]
[$env?.String, f64]
[$env?.String?.f64]
[$env?.String]
[$env?.[Bar], array]
[$env?.[Bar], foo]
[$env?.[Bar]?.f64]
[$env?.[Bar]]
[$env?.[String] == list]
[$env?.[String], foo]
[$env?.[String], list]
[$env?.[String], str]
[$env?.[String]?.[foo]]
[$env?.[String]?.[list]]
[$env?.[String]]
[$env?.[foobar], i]
[$env?.[foobar]?.add?.add]
[$env?.[foobar]?.greet]
[$env?.[foobar]]
[$env?.[nil]?.add()]
[$env?.[nil]]
[$env?.[str] | groupBy(#)]
[$env?.[str], f64]
[$env?.[str]?.[i]]
[$env?.[str]]
[$env?.add, foo]
[$env?.add, ok]
[$env?.add]
[$env?.array | map(str)]
[$env?.array, $env?.list]
[$env?.array, [true]]
[$env?.array, add]
[$env?.array, array != $env]
[$env?.array, str]
[$env?.array]
[$env?.f64]
[$env?.false]
[$env?.foo]
[$env?.foobar, $env.add]
[$env?.foobar?.ok]
[$env?.foobar]
[$env?.greet, add]
[$env?.greet, array]
[$env?.greet]
[$env?.i, i < f64]
[$env?.i, ok]
[$env?.i]
[$env?.list | map(#)]
[$env?.list]
[$env?.nil]
[$env?.ok]
[$env?.str, str]
[$env?.str]
[$env] != list
[$env] == 0 .. 1
[$env] ?? duration($env)
[$env] ?? str
[$env] | all(false)
[$env] | any(#.ok)
[$env] | any(.ok)
[$env] | any(false)
[$env] | any(true)
[$env] | concat(array)
[$env] | count(#.ok)
[$env] | count(ok)
[$env] | filter(.ok)
[$env] | filter(false)
[$env] | filter(ok)
[$env] | find(#.ok != .Bar)
[$env] | find(#.ok)
[$env] | findLast(ok)
[$env] | findLast(true)
[$env] | findLastIndex(#.ok)
[$env] | findLastIndex(false)
[$env] | groupBy(#.f64)
[$env] | groupBy(.add == ok)
[$env] | groupBy(1)
[$env] | groupBy(i)
[$env] | map(#.String)
[$env] | map(#.ok)
[$env] | map($env)
[$env] | map(.greet)
[$env] | map(.list)
[$env] | map(.str)
[$env] | map(1)
[$env] | map(1.0)
[$env] | map(array)
[$env] | map(false)
[$env] | map(foo)
[$env] | map(true)
[$env] | one(.ok)
[$env] | reduce(#)
[$env] | reduce(#.Bar)
[$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(#index)
[$env] | reduce($env)
[$env] | reduce(.Bar)
[$env] | reduce(.Bar, 0)
[$env] | reduce(.String)
[$env] | reduce(0)
[$env] | reduce(1)
[$env] | reduce(1.0)
[$env] | reduce(array)
[$env] | reduce(f64)
[$env] | reduce(false)
[$env] | reduce(false, 1.0)
[$env] | reduce(foo)
[$env] | reduce(greet, true)
[$env] | reduce(i)
[$env] | reduce(list, i)
[$env] | reduce(ok)
[$env] | reduce(str)
[$env] | sortBy(#.list)
[$env] | sortBy(#?.[.String])
[$env] | sortBy(.array)
[$env] | sortBy(.foo)
[$env] | sortBy(1)
[$env] | sortBy(array)
[$env] | sortBy(false)
[$env] | sortBy(foo)
[$env] | sortBy(greet)
[$env] | sortBy(list)
[$env] | sum(#.f64)
[$env] | sum(#.i)
[$env] | sum(.f64)
[$env] | sum(1)
[$env] | sum(1.0)
[$env]; i
[$env][len(list):]
[-$env.f64]
[--1.0]
[-0, list]
[-0, ok]
[-0]
[-1.0, i ?? foo]
[-1.0]
[-1]
[-f64]
[-i, add]
[-i, f64]
[-i]
[0 != $env]
[0 != 0]
[0 != 1.0]
[0 != f64]
[0 != i]
[0 != nil]
[0 % i]
[0 * 0]
[0 * 1.0]
[0 * 1]
[0 * f64]
[0 ** 0]
[0 ** 1.0, f64]
[0 ** 1.0]
[0 ** 1]
[0 + 1.0]
[0 + f64]
[0 + i]
[0 - 0]
[0 - 1.0]
[0 - 1]
[0 - i]
[0 .. 0]
[0 .. i]
[0 / 0]
[0 / f64]
[0 / i]
[0 < 0]
[0 < 1.0]
[0 < 1]
[0 < f64]
[0 < i]
[0 <= 0]
[0 <= f64]
[0 <= i]
[0 == $env]
[0 == 0]
[0 == 1.0]
[0 == 1]
[0 == i]
[0 == nil]
[0 > 0]
[0 > 1]
[0 > f64]
[0 > i]
[0 >= 1.0]
[0 >= 1]
[0 >= f64]
[0 ?? 0]
[0 ?? 1.0]
[0 ?? array]
[0 ?? foo]
[0 ?? greet]
[0 ?? i]
[0 ?? nil]
[0 ?? ok]
[0 ?? true]
[0 ^ 1.0]
[0 ^ 1]
[0 ^ i]
[0 in array]
[0 not in array]
[0 | bitor(1), list]
[0 | median(1.0)]
[0, $env] | count(false || true)
[0, $env] | map(1)
[0, $env] | reduce(str, 1.0)
[0, $env] | sortBy(1.0)
[0, $env]?.[i]
[0, 0] | reduce(1.0, $env)
[0, 1.0] | map(array)
[0, 1.0]?.[i]
[0, 1]?.[i]
[0, add] | findLastIndex(ok)
[0, add]?.[i]
[0, false]?.[i]
[0, foo] | findLast(true)
[0, foo] | reduce(#, 1)
[0, foo]?.[i]
[0, foo][:]
[0, greet]?.[i]
[0, i] | any(false)
[0, i]?.[i]
[0, list, true] | map(#)
[0, list] | sortBy(f64)
[0, list]?.[i]
[0, nil] | map(#)
[0, nil]?.[i]
[0, ok]?.[i]
[0, str] | map(#)
[0, true] ?? str
[0, true]?.[i]
[0.0]
[0.1]
[0] ?? $env?.String
[0] ?? groupBy($env, .Bar)
[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] | map(greet)
[0] | map(true)
[0] | none(false)
[0] | one(ok)
[0] | one(true)
[0] | reduce(#)
[0] | reduce(0, nil)
[0] | reduce(1)
[0] | reduce(false)
[0] | reduce(foo, $env)
[0] | reduce(i)
[0] | sortBy(#)
[0] | sortBy(0)
[0] | sortBy(1.0)
[0] | sortBy(foo)
[0] | sortBy(str)
[0] | sum(#)
[0] | sum(i)
[1 != $env]
[1 != 0]
[1 != 1.0]
[1 != 1]
[1 != f64]
[1 != i]
[1 != nil]
[1 % i]
[1 * 0]
[1 * 1.0]
[1 * 1]
[1 * f64]
[1 ** 1.0]
[1 ** 1]
[1 ** f64]
[1 ** i]
[1 + 0]
[1 + 1.0]
[1 + 1]
[1 + f64]
[1 + i]
[1 - 0]
[1 - 1.0]
[1 - f64]
[1 - i]
[1 .. 1]
[1 / 1.0]
[1 / f64]
[1 / i]
[1 < 0]
[1 < 1.0, foo]
[1 < 1.0]
[1 < 1]
[1 < f64]
[1 <= 1.0]
[1 <= 1]
[1 <= i]
[1 == $env]
[1 == 1.0]
[1 == 1]
[1 == f64]
[1 == i]
[1 == nil]
[1 > 1.0]
[1 > 1]
[1 > i]
[1 >= 1.0]
[1 >= 1]
[1 >= i]
[1 ?? 1, i]
[1 ?? 1.0]
[1 ?? 1]
[1 ?? add]
[1 ?? array]
[1 ?? foo]
[1 ?? list, greet]
[1 ?? list]
[1 ?? nil]
[1 ?? str]
[1 ?? true]
[1 ^ f64]
[1 ^ i]
[1 | max(1.0)]
[1 | median(1.0)]
[1, $env]?.[i]
[1, 1.0] | one(ok)
[1, 1.0]?.[i]
[1, 1] | reduce(true)
[1, 1]?.[i]
[1, false] | all(false)
[1, false] | groupBy(true)
[1, foo] | count(true)
[1, foo]?.[i]
[1, greet] | reduce(#, foo)
[1, greet] | reduce(#acc, 0)
[1, greet]?.[i]
[1, nil] | reduce(add, array)
[1, str, 0] | findLastIndex($env?.ok)
[1, true] | findLastIndex(#)
[1.0 != $env]
[1.0 != $env] | all(ok)
[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 ** 0]
[1.0 ** 1, ok]
[1.0 ** 1.0]
[1.0 ** 1]
[1.0 ** f64]
[1.0 ** i]
[1.0 + 0]
[1.0 + 1.0]
[1.0 + 1]
[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.0]
[1.0 / 1]
[1.0 / f64]
[1.0 / i]
[1.0 < 0]
[1.0 < 1.0]
[1.0 < 1]
[1.0 < f64]
[1.0 < i]
[1.0 <= 0]
[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 > f64]
[1.0 > i]
[1.0 >= 0]
[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 ?? add]
[1.0 ?? array]
[1.0 ?? f64]
[1.0 ?? foo]
[1.0 ?? greet]
[1.0 ?? list]
[1.0 ?? nil]
[1.0 ?? str]
[1.0 ^ 0]
[1.0 ^ 1.0]
[1.0 ^ 1]
[1.0 ^ f64]
[1.0 ^ i]
[1.0 in array, list]
[1.0 not in array]
[1.0 | max(f64)]
[1.0 | mean(array)]
[1.0 | mean(f64)]
[1.0 | min(1)]
[1.0 | min(1.0, i)]
[1.0, $env] | map(add)
[1.0, $env] | map(str)
[1.0, $env] | reduce(array)
[1.0, $env]?.[i]
[1.0, 0] | groupBy(#)
[1.0, 0] | map(#)
[1.0, 1.0] | findLast(true)
[1.0, 1.0] | mean(i)
[1.0, 1.0] | reduce(str)
[1.0, 1.0] | sortBy(#)
[1.0, 1.0]?.[i]
[1.0, 1]?.[i]
[1.0, add] | any(ok)
[1.0, f64] | reduce(#)
[1.0, f64]?.[i]
[1.0, foo]?.[i]
[1.0, greet] | reduce($env, list)
[1.0, greet]?.[i]
[1.0, i]?.[i]
[1.0, list] ?? ok
[1.0, nil] | reduce(true)
[1.0, nil] | sortBy(1)
[1.0, nil] | sum(f64)
[1.0, ok] | findLastIndex(true)
[1.0, ok]?.[i]
[1.0, str] | map(array)
[1.0, str] | reduce(greet)
[1.0, true] | map($env)
[1.0, true]?.[i]
[1.0]
[1.0] != array
[1.0] != nil || ok
[1.0] == list
[1.0] ?? array
[1.0] ?? count($env, $env)
[1.0] ?? f64
[1.0] | all(true)
[1.0] | any(true)
[1.0] | filter(ok)
[1.0] | filter(true)
[1.0] | find(false)
[1.0] | findLastIndex(false)
[1.0] | get(0)
[1.0] | groupBy(#)
[1.0] | groupBy(0)
[1.0] | groupBy(1)
[1.0] | groupBy(1.0)
[1.0] | groupBy(f64)
[1.0] | groupBy(foo)
[1.0] | map(#)
[1.0] | map(#index)
[1.0] | map($env)
[1.0] | map(1)
[1.0] | map(1.0)
[1.0] | map(add)
[1.0] | map(array)
[1.0] | map(foo)
[1.0] | map(greet)
[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(0)
[1.0] | reduce(1, foo)
[1.0] | reduce(1.0)
[1.0] | reduce(add)
[1.0] | reduce(array)
[1.0] | reduce(f64)
[1.0] | reduce(false)
[1.0] | reduce(greet)
[1.0] | sortBy(0)
[1.0] | sortBy(1)
[1.0] | sortBy(false)
[1.0] | sortBy(greet)
[1.0] | sortBy(list)
[1.0] | sum(0)
[1.0] | sum(1.0)
[1.0][:]
[1.1]
[1] != [1]
[1] ?? f64
[1] ?? ok
[1] | all(true)
[1] | filter(false)
[1] | findIndex(ok)
[1] | findIndex(true)
[1] | findLast(ok)
[1] | groupBy(#)
[1] | groupBy(f64)
[1] | groupBy(foo)
[1] | groupBy(str)
[1] | map(#)
[1] | map($env)
[1] | map(1.0)
[1] | map(foo)
[1] | mean(1.0)
[1] | one(ok)
[1] | reduce(#)
[1] | reduce(#, foo)
[1] | reduce(1.0, true)
[1] | reduce(f64, foo)
[1] | reduce(list)
[1] | sortBy(#)
[1] | sortBy($env)
[1] | sortBy(1.0)
[1] | sortBy(array)
[1] | sortBy(true)
[1] | sum(#)
[1] | sum(1.0)
[1] | sum(f64)
[1]?.[f64 ?? $env]
[[$env, greet, i]]
[[$env, i, 1.0]]
[[$env]]
[[0]]
[[1, add]]
[[1, foo], greet]
[[1, ok]]
[[1, true, true]]
[[1.0, foo]]
[[1.0, true]]
[[1.0], 1 / 1.0]
[[1.0], foo]
[[1.0], greet]
[[1.0]]
[[1]]
[[add, ok]]
[[add]]
[[array, $env]]
[[array]]
[[f64, array]]
[[f64, foo]]
[[f64]]
[[false, add]]
[[false]]
[[foo, 1]]
[[foo, array]]
[[foo, f64]]
[[foo, true]]
[[foo], i]
[[foo]]
[[greet], $env?.String]
[[greet], add]
[[greet]]
[[i, foo]]
[[i]]
[[list, nil, foo]]
[[list, nil]]
[[list, ok, foo]]
[[list]]
[[nil, $env]]
[[nil, ok]]
[[nil], f64]
[[nil], i]
[[nil]]
[[ok, 0]]
[[ok, add]]
[[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 ?? $env]
[add ?? 0]
[add ?? 1.0]
[add ?? array]
[add ?? f64]
[add ?? foo]
[add ?? list]
[add ?? nil]
[add ?? str]
[add ?? true]
[add(1, i)]
[add(i, 1)]
[add(i, i)]
[add, $env != 1]
[add, $env.foo]
[add, $env?.[String]]
[add, $env?.[str]]
[add, $env?.greet]
[add, -1.0]
[add, 0] | map(add)
[add, 1.0, i] | count(true)
[add, 1.0]?.[i]
[add, 1] | reduce(true, nil)
[add, [$env]]
[add, add]
[add, array]
[add, f64]
[add, f64]?.[i]
[add, false]?.[i]
[add, foo, list]
[add, foo.Bar]
[add, foo?.String]
[add, foo]
[add, foo] | groupBy(foo)
[add, foo] | reduce(#index)
[add, foo] | reduce(f64)
[add, foo] | reduce(foo)
[add, foo] | sortBy(i)
[add, greet]
[add, greet] | reduce(i, foo)
[add, i]
[add, list]
[add, ok]
[add, ok] | groupBy(foo)
[add, ok] | none(ok)
[add, ok]?.[i]
[add, str]
[add, str] | groupBy(f64)
[add, string(i)]
[add, toJSON(true)]
[add, true]?.[i]
[add]
[add] ?? greet
[add] ?? ok
[add] | all(false)
[add] | all(true)
[add] | any(false)
[add] | any(ok)
[add] | findLast(ok)
[add] | findLastIndex(false)
[add] | groupBy(0)
[add] | groupBy(true)
[add] | map(#)
[add] | map($env)
[add] | map(0)
[add] | map(1.0)
[add] | map(add)
[add] | map(greet)
[add] | map(ok)
[add] | none(ok)
[add] | reduce(#)
[add] | reduce(#, add)
[add] | reduce(#acc)
[add] | reduce(1)
[add] | reduce(foo, foo)
[add] | reduce(ok)
[add] | sortBy($env)
[add] | sortBy(list)
[add] | sum(1)
[add] | sum(1.0)
[add][i:]
[all($env, ok)]
[all($env, true)]
[all(array, false)]
[all(list, ok)]
[any(list, false)]
[array != $env]
[array != array]
[array != list]
[array != nil]
[array == $env]
[array == array]
[array == list]
[array == nil]
[array ?? 1.0]
[array ?? f64]
[array ?? false]
[array ?? foo]
[array ?? greet]
[array ?? true]
[array | all(ok)]
[array | findIndex(ok)]
[array | findLast(false)]
[array | groupBy(#)]
[array | groupBy(foo)]
[array | map(#)]
[array | map($env)]
[array | map(0)]
[array | map(1)]
[array | map(1.0)]
[array | map(add)]
[array | map(foo)]
[array | map(i)]
[array | map(ok)]
[array | mean(1.0)]
[array | one(false)]
[array | one(true)]
[array | reduce(#)]
[array | reduce(#, false)]
[array | reduce(#index)]
[array | reduce($env)]
[array | reduce(0)]
[array | reduce(1.0)]
[array | reduce(add)]
[array | reduce(array)]
[array | reduce(f64)]
[array | reduce(false)]
[array | reduce(foo)]
[array | reduce(foo, true)]
[array | reduce(ok)]
[array | sortBy(#)]
[array | sortBy(1)]
[array | sortBy(1.0)]
[array | sortBy(f64)]
[array | sum(#), foo]
[array | sum(#)]
[array | sum(1)]
[array | sum(1.0)]
[array | sum(i)]
[array, !ok]
[array, !true]
[array, $env.array]
[array, $env?.[Bar]]
[array, 0 == $env]
[array, 1.0 == 1]
[array, 1.0]?.[i]
[array, 1] | findIndex(ok)
[array, add, add]
[array, add]
[array, array]
[array, array]?.[i]
[array, f64]
[array, f64] | findIndex(ok)
[array, f64] | reduce(str)
[array, f64]?.[i]
[array, false, ok] | findLastIndex(#)
[array, false] | sum(f64)
[array, foo]
[array, foo]?.[i]
[array, greet]
[array, greet] | reduce(foo)
[array, i]
[array, i]?.[i]
[array, len($env)]
[array, list]
[array, nil] | map(#)
[array, nil] | sum(0)
[array, ok]
[array, ok] | filter(false)
[array, ok] | reduce(true)
[array, ok]?.[i]
[array, str, ok]
[array, str]
[array, str] | reduce(1.0)
[array, true] ?? $env?.[str]
[array, {foo: list}]
[array?.[1]]
[array?.[i]]
[array[:1]]
[array[i:]]
[array]
[array] ?? add
[array] ?? f64
[array] ?? ok
[array] | all(false)
[array] | any(false)
[array] | count(false)
[array] | count(ok)
[array] | find(true)
[array] | findLastIndex(true)
[array] | groupBy(ok)
[array] | map(#)
[array] | map($env)
[array] | map(1.0)
[array] | map(greet)
[array] | map(ok)
[array] | map(str)
[array] | mean(i)
[array] | reduce(#)
[array] | reduce(#, 1.0)
[array] | reduce($env)
[array] | reduce($env, 1.0)
[array] | reduce(0)
[array] | reduce(1.0)
[array] | reduce(ok)
[array] | sortBy(#)
[array] | sortBy($env)
[array] | sortBy(i)
[array] | sum(0)
[array] | sum(1)
[array] | sum(1.0)
[array][:i]
[bitnot(0)]
[bitnot(1)]
[bitnot(i)]
[ceil(0)]
[ceil(1)]
[ceil(1.0)]
[ceil(f64), add]
[ceil(f64)]
[ceil(i)]
[concat(array), i]
[concat(array)]
[concat(list)]
[count($env, false)]
[count(list, false)]
[f64 != $env]
[f64 != 0]
[f64 != 1.0]
[f64 != i]
[f64 != nil]
[f64 * 1.0]
[f64 * 1]
[f64 * f64]
[f64 * i]
[f64 ** 0]
[f64 ** 1.0]
[f64 ** 1]
[f64 ** i]
[f64 + 1.0]
[f64 - 0]
[f64 - 1]
[f64 - f64]
[f64 / 1.0]
[f64 / 1]
[f64 / f64]
[f64 < 0]
[f64 < 1.0]
[f64 < 1]
[f64 < f64]
[f64 < i]
[f64 <= 1.0]
[f64 <= 1]
[f64 <= f64]
[f64 == $env]
[f64 == 0]
[f64 == 1.0]
[f64 == 1]
[f64 == f64]
[f64 == i]
[f64 == nil]
[f64 > 1.0]
[f64 > f64]
[f64 > i]
[f64 >= 0]
[f64 >= 1.0]
[f64 >= i]
[f64 ?? $env]
[f64 ?? array]
[f64 ?? foo]
[f64 ?? greet]
[f64 ?? nil]
[f64 ^ 0]
[f64 ^ 1]
[f64 ^ f64]
[f64 not in array]
[f64 | median(1.0)]
[f64, $env == 1.0]
[f64, $env.add]
[f64, $env.foo]
[f64, $env.list]
[f64, $env?.String]
[f64, $env] | map(ok)
[f64, 1.0 ^ i]
[f64, 1.0] | map(0)
[f64, abs(f64)]
[f64, add]
[f64, array]
[f64, f64]
[f64, foo]
[f64, foo] | reduce(#)
[f64, foo]?.[i]
[f64, greet]
[f64, i ?? 1]
[f64, i]
[f64, i] | findLast(false)
[f64, i] | groupBy(1)
[f64, i] | take(i)
[f64, list]
[f64, nil != foo]
[f64, nil]?.[i]
[f64, not true]
[f64, ok]
[f64, str]
[f64, str] | findLast(ok)
[f64, {foo: 0}]
[f64]
[f64] | count(ok)
[f64] | findLast(ok)
[f64] | findLast(true)
[f64] | groupBy(#)
[f64] | groupBy(str)
[f64] | map(#)
[f64] | map(#index)
[f64] | map(1)
[f64] | map(1.0)
[f64] | map(add)
[f64] | map(false)
[f64] | map(foo)
[f64] | map(greet)
[f64] | none(false)
[f64] | reduce(#)
[f64] | reduce(1)
[f64] | reduce(1.0)
[f64] | reduce(f64)
[f64] | reduce(false)
[f64] | reduce(greet, true)
[f64] | reduce(true, foo)
[f64] | sortBy($env)
[f64] | sortBy(0)
[f64] | sortBy(add)
[f64] | sum(#)
[f64] | sum(1.0)
[f64] | sum(i)
[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 ? foo : 1.0]
[false ?: 1.0]
[false ?: foo]
[false ?? $env]
[false ?? 0, greet]
[false ?? 0]
[false ?? 1.0]
[false ?? false, greet]
[false ?? false]
[false ?? foo]
[false ?? greet]
[false ?? nil]
[false ?? ok]
[false ?? true]
[false and $env]
[false and ok]
[false and true]
[false or $env]
[false or false]
[false or true]
[false || $env?.[Bar]]
[false || $env]
[false || false, list]
[false || ok]
[false || true]
[false, $env] | findIndex(true)
[false, $env] | groupBy(1.0)
[false, $env]?.[i]
[false, 0] | map(#)
[false, 1.0]?.[i]
[false, 1] != nil ? 1.0 : $env[add(false) == greet():]
[false, 1] | groupBy(#)
[false, 1]?.[i]
[false, add] | all(false)
[false, array] | reduce(0)
[false, f64]?.[i]
[false, foo]?.[i]
[false, greet]?.[i]
[false, i] | map(#)
[false, i]?.[i]
[false, str] | groupBy(foo)
[false, true]?.[i]
[false] == $env?.Bar
[false] ?? f64
[false] ?? foo
[false] | all(#)
[false] | all(true)
[false] | any(#)
[false] | count(false)
[false] | find(#)
[false] | findIndex(#)
[false] | findLast(true)
[false] | findLastIndex(#)
[false] | findLastIndex(false)
[false] | groupBy(#)
[false] | groupBy(1.0)
[false] | groupBy(foo)
[false] | groupBy(i)
[false] | map(#)
[false] | map($env)
[false] | map(foo)
[false] | map(list)
[false] | none(#)
[false] | one(#)
[false] | one(false)
[false] | reduce(false, add)
[false] | reduce(foo)
[false] | reduce(greet)
[false] | reduce(list, foo)
[false] | reduce(true)
[false] | sortBy(#)
[false] | sortBy($env)
[false] | sortBy(1.0)
[false] | sortBy(array)
[false] | sortBy(false)
[false] | sortBy(true)
[false] | sum(1)
[false] | sum(1.0)
[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(array, false)]
[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), string(foo)]
[first(list)]
[flatten(array)]
[flatten(list)]
[float(0)]
[float(1)]
[float(1.0)]
[float(f64), ok]
[float(f64)]
[float(i)]
[floor(0)]
[floor(1), f64]
[floor(1)]
[floor(1.0)]
[floor(f64)]
[floor(i)]
[foo != $env.foo]
[foo != $env]
[foo != foo, add]
[foo != foo]
[foo != nil]
[foo == $env, list]
[foo == $env]
[foo == foo]
[foo == nil]
[foo ?? $env?.String()]
[foo ?? $env]
[foo ?? 0]
[foo ?? 1.0]
[foo ?? 1]
[foo ?? add]
[foo ?? array]
[foo ?? f64]
[foo ?? false]
[foo ?? foo]
[foo ?? i]
[foo ?? list]
[foo ?? str]
[foo ?? true]
[foo in list]
[foo not in list]
[foo, $env?.[str]]
[foo, $env?.f64]
[foo, $env?.false]
[foo, $env?.ok]
[foo, $env] | find(ok)
[foo, $env] | map(1.0)
[foo, $env] | sortBy(f64)
[foo, $env]?.[i]
[foo, -f64]
[foo, 0] | groupBy(1.0)
[foo, 0] | map(#)
[foo, 1.0, $env]?.[i]
[foo, 1.0] | groupBy(1)
[foo, 1.0] | map(foo)
[foo, 1.0] | one(ok)
[foo, 1.0]?.[i]
[foo, 1] | map(list)
[foo, 1]?.[i]
[foo, 1]?.[i] != greet
[foo, abs(1.0)]
[foo, add, $env] | findLastIndex(ok)
[foo, add, f64]
[foo, add]
[foo, add]?.[i]
[foo, array]
[foo, array] | reduce(i)
[foo, array]?.[i]
[foo, f64, greet] | sortBy(1.0)
[foo, f64]
[foo, f64] | count(false)
[foo, f64]?.[i]
[foo, false, add] | none(true)
[foo, false] | map(#)
[foo, false]?.[i]
[foo, foo != $env]
[foo, foo.String]
[foo, foo]
[foo, foo] != list
[foo, foo] | groupBy(1.0)
[foo, foo] | reduce(1.0)
[foo, foo]?.[i]
[foo, greet(str)]
[foo, greet]
[foo, i, greet]
[foo, i]
[foo, i]?.[i]
[foo, int(0)]
[foo, list, foo] | reduce(list)
[foo, list]
[foo, list] != array
[foo, list] | groupBy(f64)
[foo, list]?.[i]
[foo, mean(1)]
[foo, nil != str]
[foo, nil, list] | map(#)
[foo, nil] | map(0)
[foo, nil]?.[i]
[foo, ok]
[foo, ok] | all(true)
[foo, round(1)]
[foo, str]
[foo, str] ?? f64
[foo, str]?.[i]
[foo, true]?.[i]
[foo, values($env)]
[foo.Bar, [foo]]
[foo.Bar, greet]
[foo.Bar, ok]
[foo.Bar]
[foo.String()]
[foo.String, f64]
[foo.String, list]
[foo.String]
[foo?.Bar]
[foo?.String(), ok]
[foo?.String()]
[foo?.String, $env?.String]
[foo?.String]
[foo]
[foo] != array
[foo] == $env?.[Bar]
[foo] ?? add
[foo] ?? array
[foo] ?? greet
[foo] ?? list
[foo] ?? ok
[foo] in [nil]
[foo] | all(ok)
[foo] | all(true)
[foo] | any(ok)
[foo] | any(true)
[foo] | count(false)
[foo] | count(ok)
[foo] | count(true)
[foo] | filter(ok)
[foo] | filter(true)
[foo] | find(false)
[foo] | find(ok)
[foo] | findLast(false)
[foo] | findLastIndex(ok)
[foo] | groupBy(#)
[foo] | groupBy(#.Bar)
[foo] | groupBy(f64)
[foo] | groupBy(false)
[foo] | groupBy(foo)
[foo] | groupBy(ok)
[foo] | map(#)
[foo] | map(.String)
[foo] | map(1)
[foo] | map(add)
[foo] | map(f64)
[foo] | map(foo)
[foo] | map(i)
[foo] | map(list)
[foo] | map(ok)
[foo] | none(!true)
[foo] | none(ok)
[foo] | none(true)
[foo] | one(false)
[foo] | one(ok)
[foo] | reduce(#)
[foo] | reduce(#, ok)
[foo] | reduce(#.String, 0)
[foo] | reduce(#index)
[foo] | reduce(.Bar, 0)
[foo] | reduce(.Bar, nil)
[foo] | reduce(0)
[foo] | reduce(1)
[foo] | reduce(1, 1.0)
[foo] | reduce(1.0)
[foo] | reduce(1.0, foo)
[foo] | reduce(add)
[foo] | reduce(array)
[foo] | reduce(false)
[foo] | reduce(foo)
[foo] | reduce(foo, list)
[foo] | reduce(greet)
[foo] | reduce(i, 0)
[foo] | reduce(list)
[foo] | reduce(ok)
[foo] | reduce(true)
[foo] | sortBy(#)
[foo] | sortBy(#.String)
[foo] | sortBy($env)
[foo] | sortBy(.Bar)
[foo] | sortBy(1)
[foo] | sortBy(add)
[foo] | sortBy(f64)
[foo] | sortBy(false)
[foo] | sortBy(greet)
[foo] | sortBy(i)
[foo] | sortBy(str)
[foo] | sum(i)
[foo][:]
[foo][:i]
[get($env, nil)]
[get($env, str)]
[greet != $env]
[greet != nil]
[greet == $env]
[greet == nil, array]
[greet == nil]
[greet ?? 1.0, list]
[greet ?? 1]
[greet ?? f64]
[greet ?? foo, foo]
[greet ?? foo]
[greet ?? i]
[greet(str), array]
[greet(str), greet]
[greet(str)]
[greet, $env.array]
[greet, $env.greet]
[greet, $env.i]
[greet, $env?.greet]
[greet, $env?.nil]
[greet, $env] | none(false)
[greet, $env] | reduce(true)
[greet, $env]?.[i]
[greet, -i]
[greet, 0]?.[i]
[greet, 1.0]?.[i]
[greet, [array]]
[greet, abs(1.0)]
[greet, add]
[greet, add] | reduce($env)
[greet, array]
[greet, array] | map(i)
[greet, f64]
[greet, f64] | reduce(f64)
[greet, foo == $env]
[greet, foo ?? $env]
[greet, foo]
[greet, foo] | none(true)
[greet, foo]?.[i]
[greet, greet]
[greet, greet] | reduce(#)
[greet, i]
[greet, int(1)]
[greet, list]
[greet, list] | reduce(add)
[greet, nil]?.[i]
[greet, ok]
[greet, str, f64]
[greet, str]
[greet, true]?.[i]
[greet]
[greet] == $env.array
[greet] ?? add
[greet] ?? array
[greet] ?? false ?? i
[greet] ?? i
[greet] ?? list
[greet] ?? median(1.0)
[greet] ?? str
[greet] | all(ok)
[greet] | any(false)
[greet] | count(false)
[greet] | find(false)
[greet] | find(ok)
[greet] | groupBy(1)
[greet] | groupBy(foo)
[greet] | groupBy(true)
[greet] | map($env)
[greet] | map(1)
[greet] | map(add)
[greet] | map(i)
[greet] | map(str)
[greet] | reduce(#, array)
[greet] | reduce(false, nil)
[greet] | reduce(foo, $env)
[greet] | reduce(greet)
[greet] | reduce(ok)
[greet] | sortBy(#)
[greet] | sortBy(array)
[greet] | sortBy(i)
[greet] | sortBy(str)
[greet] | sum(f64)
[greet][:i]
[greet][i:]
[groupBy(array, #)]
[groupBy(array, foo)]
[groupBy(list, #)?.[foo]]
[groupBy(list, #)]
[groupBy(list, 1.0)?.[i]]
[groupBy(list, f64)]
[groupBy(list, false)]
[groupBy(list, foo)]
[i != $env]
[i != 0, str]
[i != 0]
[i != 1.0]
[i != 1]
[i != f64]
[i != i]
[i != nil]
[i % 1]
[i % i]
[i * 0]
[i * 1.0]
[i * 1]
[i * i]
[i ** 0]
[i ** 1.0]
[i ** 1]
[i ** f64]
[i + 1.0]
[i + 1]
[i + f64]
[i - 1.0]
[i - 1]
[i - f64]
[i .. 0]
[i .. i]
[i / 1.0 ?? $env]
[i / 1.0]
[i / 1]
[i < 1.0]
[i < 1]
[i <= 1.0]
[i <= 1]
[i <= f64]
[i == $env]
[i == 0]
[i == 1.0]
[i == 1]
[i == f64]
[i == nil]
[i > 1.0]
[i > f64]
[i >= 1.0]
[i >= 1]
[i >= f64]
[i ?? $env]
[i ?? array]
[i ?? f64]
[i ?? false]
[i ?? foo]
[i ?? true]
[i ^ 1.0]
[i ^ 1]
[i | max(array, i)]
[i | min(0)]
[i, $env in list]
[i, $env?.String]
[i, $env?.[String]]
[i, $env?.foobar]
[i, -1.0]
[i, 1.0 >= 1.0]
[i, 1.0] | sortBy(1)
[i, 1.0] | sum(#)
[i, 1.0]?.[i]
[i, 1]?.[i]
[i, add]
[i, array?.[i]]
[i, array]
[i, f64 > i]
[i, f64 ?? str]
[i, f64]
[i, f64] != array
[i, foo?.String]
[i, foo]
[i, foo] | groupBy(1.0)
[i, greet]
[i, i]
[i, list]
[i, nil ?? 1.0]
[i, nil in $env]
[i, nil] | filter(true)
[i, nil] | groupBy(1.0)
[i, nil]?.[i]
[i, ok]
[i, ok]?.[i]
[i, str]
[i, sum(array)]
[i, toJSON(0)]
[i, true] | groupBy(true)
[i..i]
[i]
[i] != list
[i] == array
[i] == list
[i] ?? $env?.[foo]
[i] ?? f64
[i] ?? greet
[i] ?? i
[i] ?? ok
[i] | any(ok)
[i] | find(false)
[i] | findLast(ok)
[i] | findLast(true)
[i] | groupBy(1)
[i] | groupBy(1.0)
[i] | groupBy(foo)
[i] | groupBy(ok)
[i] | map(#)
[i] | map(add)
[i] | map(false)
[i] | reduce(add, i)
[i] | reduce(f64)
[i] | reduce(foo)
[i] | reduce(ok, nil)
[i] | reduce(ok, true)
[i] | reduce(str)
[i] | reduce(str, str)
[i] | sortBy(#)
[i] | sortBy($env)
[i] | sortBy(0)
[i] | sortBy(1.0)
[i] | sortBy(greet)
[i] | sortBy(list)
[i] | sortBy(str)
[i] | sortBy(true)
[i] | sum(#)
[i] | sum(1.0)
[i] | sum(f64)
[i][i:]
[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 false { nil } else { $env }]
[if false { true } else { false }]
[if ok { 1.0 } else { foo }]
[if ok { false } else { 1.0 }]
[if ok { foo } else { $env }]
[if ok { greet } else { nil }]
[if ok { nil } else { nil }]
[if ok { true } else { 1.0 }, $env.f64]
[if true { $env } else { false }, list]
[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 { nil }]
[if true { foo } else { ok }]
[if true { nil } else { 1 }]
[if true { nil } else { array }]
[int(0), ok]
[int(0)]
[int(1)]
[int(1.0)]
[int(f64), foo]
[int(f64)]
[int(i)]
[keys($env)]
[last($env)]
[last($env?.list)]
[last(array)]
[last(list), array]
[last(list)]
[len($env)]
[len([nil, list])]
[len(array), str]
[len(array)]
[len(list)]
[len(str)]
[len({foo: list})]
[let foobar = $env; foobar]
[let foobar = 1.0; foobar]
[let z = 1.0; 0 + z]
[list != $env]
[list != array]
[list != list]
[list != nil]
[list == $env]
[list == nil]
[list ?? 1.0]
[list ?? add]
[list ?? array]
[list ?? foo]
[list ?? greet]
[list ?? i]
[list ?? nil]
[list ?? ok]
[list | all(true)]
[list | any(ok)]
[list | find(false)]
[list | findLast(false)]
[list | groupBy(#)]
[list | groupBy(1.0)]
[list | groupBy(f64)]
[list | groupBy(i)]
[list | groupBy(str)]
[list | map(#)]
[list | map(foo)]
[list | map(i), i]
[list | reduce(#)]
[list | reduce(#, 0)]
[list | reduce(#, i)]
[list | reduce(#, nil)]
[list | reduce(#.String)]
[list | reduce(#acc)]
[list | reduce(#index)]
[list | reduce(#index, greet)]
[list | reduce($env)]
[list | reduce($env, foo)]
[list | reduce(1.0)]
[list | reduce(1.0, greet)]
[list | reduce(array)]
[list | reduce(foo)]
[list | reduce(i)]
[list | reduce(list)]
[list | sortBy(.Bar)]
[list | sortBy(1)]
[list | sortBy(1.0)]
[list, $env, 1.0] | filter(ok)
[list, $env.foo]
[list, $env.i]
[list, $env?.String]
[list, $env?.list]
[list, $env] | one(false)
[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, ok]
[list, f64]
[list, f64]?.[i]
[list, false, 1] | reduce(foo)
[list, foo.String()]
[list, foo]
[list, foo] | groupBy(foo)
[list, foo] | sum(1)
[list, foo]?.[i]
[list, greet]
[list, greet] | map(#)
[list, i ^ 1.0]
[list, i, greet]
[list, i]
[list, list]
[list, nil] | groupBy(foo)
[list, ok]
[list, ok]?.[i]
[list, round(i)]
[list, str, str]
[list, str]
[list, toJSON(nil)]
[list, true != $env]
[list, true] | reduce(f64)
[list, true] | reduce(foo, ok)
[list?.[0]]
[list?.[i], add]
[list?.[i]]
[list[:1]]
[list[i:]]
[list]
[list] != list
[list] == $env?.String
[list] == array
[list] | filter(ok)
[list] | findIndex(ok)
[list] | findLast(false)
[list] | findLastIndex(ok)
[list] | get(i)
[list] | groupBy($env.foo)
[list] | map(#)
[list] | map(1.0)
[list] | map(add)
[list] | map(i)
[list] | map(ok)
[list] | map(true)
[list] | none(ok)
[list] | one(true)
[list] | reduce(1)
[list] | reduce(foo)
[list] | reduce(foo, false)
[list] | reduce(foo, ok)
[list] | sortBy(#)
[list] | sortBy(add)
[list] | sortBy(false)
[list] | sortBy(foo)
[list] | sortBy(i)
[list] | sortBy(str)
[list] | sum(1.0)
[lower(str)]
[map($env, #index)]
[map($env, $env)]
[map($env, 1.0)]
[map($env, array)]
[map($env, foo)]
[map($env, greet)]
[map($env, list)]
[map($env, str)]
[map(array, #)]
[map(array, $env)]
[map(array, 1)]
[map(array, 1.0), foo]
[map(array, 1.0)]
[map(array, array)]
[map(array, f64)]
[map(array, false)]
[map(array, foo)]
[map(array, str), ok]
[map(array, str)]
[map(array, true)]
[map(list, #)]
[map(list, #index)]
[map(list, $env)]
[map(list, 0)]
[map(list, f64)]
[map(list, foo)]
[map(list, list)]
[map(list, ok)]
[map(list, str)]
[max($env), f64]
[max($env)]
[max(0)]
[max(0, 1.0)]
[max(1)]
[max(1.0)]
[max(1.0, 1)]
[max(array) ^ f64]
[max(array)]
[max(array, 1.0)]
[max(f64)]
[max(i)]
[mean(0)]
[mean(1)]
[mean(1, 1.0)]
[mean(1.0)]
[mean(array)]
[mean(f64)]
[mean(i)]
[median(0)]
[median(1)]
[median(1, 1.0)]
[median(1.0)]
[median(1.0, 1.0)]
[median(array)]
[median(f64)]
[median(floor(0))]
[median(i)]
[min($env ?? foo)]
[min($env)]
[min(0)]
[min(1)]
[min(1.0)]
[min(array)]
[min(f64)]
[min(i)]
[nil != $env?.f64]
[nil != $env]
[nil != 0]
[nil != 1.0]
[nil != add]
[nil != array]
[nil != f64]
[nil != foo, greet]
[nil != foo]
[nil != greet]
[nil != i]
[nil != list, add]
[nil != list]
[nil != nil, ok]
[nil != nil]
[nil != ok]
[nil != str]
[nil != true]
[nil == $env, foo]
[nil == $env]
[nil == 0]
[nil == 1.0]
[nil == add]
[nil == array]
[nil == f64]
[nil == false, str]
[nil == false]
[nil == foo]
[nil == greet]
[nil == list, f64]
[nil == list]
[nil == nil]
[nil == ok]
[nil == str]
[nil == true]
[nil ?? $env]
[nil ?? 1]
[nil ?? add]
[nil ?? false]
[nil ?? foo, greet]
[nil ?? foo]
[nil ?? greet]
[nil ?? list]
[nil ?? nil]
[nil ?? str]
[nil in $env]
[nil in list]
[nil not in $env]
[nil not in array]
[nil not in list]
[nil, $env] | reduce(0)
[nil, $env]?.[i]
[nil, 0] | reduce(i, greet)
[nil, 0]?.[i]
[nil, 1.0, 0] | all(true)
[nil, 1.0] ?? add
[nil, 1.0] | none(true)
[nil, 1.0] | reduce(#)
[nil, 1.0] | sum(f64)
[nil, 1.0]?.[i]
[nil, 1]?.[i]
[nil, add] | none(false)
[nil, add]?.[i]
[nil, f64] | groupBy(str)
[nil, false] | map($env)
[nil, foo] | findLast(ok)
[nil, foo] | map(ok)
[nil, foo]?.[i]
[nil, i] | filter(true)
[nil, i]?.[i]
[nil, nil, $env]?.[i]
[nil, nil, array]?.[i]
[nil, str, 1.0] | map(#)
[nil, true]?.[i]
[nil] == array
[nil] == list
[nil] == nil ? 1 : foo
[nil] ?? i
[nil] ?? ok
[nil] | count(ok)
[nil] | count(true)
[nil] | filter(false)
[nil] | filter(ok)
[nil] | find(false)
[nil] | find(true)
[nil] | findIndex(true)
[nil] | findLast(false)
[nil] | findLastIndex(false)
[nil] | findLastIndex(true)
[nil] | groupBy(0)
[nil] | groupBy(1)
[nil] | groupBy(str)
[nil] | groupBy(string(nil))
[nil] | groupBy(true)
[nil] | map($env)
[nil] | map(1.0)
[nil] | map(f64)
[nil] | map(foo)
[nil] | map(greet)
[nil] | map(i)
[nil] | map(true)
[nil] | one(ok)
[nil] | reduce(#index)
[nil] | reduce(0)
[nil] | reduce(array)
[nil] | reduce(array, array)
[nil] | reduce(false)
[nil] | reduce(foo)
[nil] | reduce(i)
[nil] | reduce(ok)
[nil] | reduce(true)
[nil] | sortBy($env)
[nil] | sortBy(0)
[nil] | sortBy(false)
[nil] | sortBy(foo)
[nil] | sortBy(true)
[nil] | sum(1)
[nil] | sum(1.0)
[nil] | sum(i)
[nil][:]
[nil][i:]
[none($env, false)]
[none($env, true)]
[none(array, false)]
[not false, add]
[not false]
[not ok]
[not ok] != array
[not true]
[ok != $env]
[ok != nil]
[ok != true]
[ok && $env]
[ok && false, foo?.Bar]
[ok && ok]
[ok && true]
[ok == $env]
[ok == false]
[ok == nil]
[ok == true]
[ok ? 0 : false]
[ok ? 1 : greet]
[ok ? str : i, add]
[ok ?: 0]
[ok ?: nil]
[ok ?? $env]
[ok ?? 0]
[ok ?? 1.0]
[ok ?? add]
[ok ?? array]
[ok ?? foo]
[ok ?? greet]
[ok ?? nil, $env in array]
[ok ?? nil]
[ok ?? true]
[ok and $env]
[ok and false]
[ok and ok, ok]
[ok and ok]
[ok and true]
[ok or $env]
[ok or false]
[ok or ok]
[ok or true]
[ok || $env]
[ok || false]
[ok, $env.greet]
[ok, $env?.[foobar]]
[ok, $env?.[str]]
[ok, $env?.i]
[ok, $env?.str]
[ok, $env] | find(#)
[ok, $env] | map(false)
[ok, $env]?.[i]
[ok, 0]?.[i]
[ok, 1 / 0]
[ok, 1.0 == 1.0]
[ok, 1] == array
[ok, 1] | groupBy(#)
[ok, 1] | map(1.0)
[ok, add]
[ok, array]
[ok, array]?.[i]
[ok, f64]
[ok, false] not in uniq(list)
[ok, false] | map(foo)
[ok, floor(0)]
[ok, foo not in list]
[ok, foo?.String]
[ok, foo]
[ok, foo] | any(#)
[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 == 1.0]
[ok, nil] | find(#)
[ok, nil]?.[i]
[ok, ok]
[ok, ok]?.[i]
[ok, reduce(list, str)]
[ok, str]
[ok, str] | reduce(foo)
[ok, string(add)]
[ok]
[ok] != $env?.list
[ok] != array
[ok] != list
[ok] == nil and ok
[ok] ?? f64
[ok] ?? foo
[ok] | all(#)
[ok] | any(#)
[ok] | count(#)
[ok] | filter(#)
[ok] | findIndex(#)
[ok] | findLast(#)
[ok] | findLast(false)
[ok] | groupBy(#)
[ok] | groupBy(1)
[ok] | groupBy(foo)
[ok] | groupBy(true)
[ok] | map(#)
[ok] | map(0)
[ok] | map(str)
[ok] | none(#)
[ok] | none(false)
[ok] | one(#)
[ok] | reduce($env)
[ok] | reduce(1.0)
[ok] | reduce(foo)
[ok] | reduce(string(greet))
[ok] | sortBy(#)
[ok] | sortBy($env)
[ok] | sortBy(array)
[ok] | sortBy(f64)
[ok] | sortBy(foo)
[ok] | sortBy(greet)
[ok] | sortBy(str)
[ok] | sum(1.0)
[ok] | sum(f64)
[one($env, false)]
[one($env, ok)]
[one(array, ok)]
[one(list, true)]
[reduce(array, #)]
[reduce(array, $env), add]
[reduce(array, $env)]
[reduce(array, $env, f64)]
[reduce(array, 1.0)]
[reduce(array, add)]
[reduce(array, array)]
[reduce(array, false)]
[reduce(array, foo)]
[reduce(array, i)]
[reduce(array, true)]
[reduce(list, #.String)]
[reduce(list, .String)]
[reduce(list, add)]
[reduce(list, f64)]
[reduce(list, foo)]
[reduce(list, greet)]
[reduce(list, i)]
[reduce(list, list)]
[reverse(array)]
[reverse(list)]
[round(0), ok]
[round(0)]
[round(1)]
[round(1.0)]
[round(f64)]
[round(i)]
[sort($env)?.[i], foo]
[sort($env)]
[sort(array)]
[sort(last($env)), list]
[sortBy(array, #)]
[sortBy(array, 1.0)]
[sortBy(array, i)]
[sortBy(list, .Bar)]
[sortBy(list, 1)]
[sortBy(list, 1.0)]
[sortBy(list, i)]
[str != nil]
[str < str]
[str <= str]
[str == nil]
[str >= str]
[str ?? $env]
[str ?? 1.0]
[str ?? 1]
[str ?? array]
[str ?? f64]
[str ?? false]
[str ?? foo]
[str ?? nil, ok]
[str ?? str]
[str ?? true]
[str contains str]
[str in $env]
[str in foo, foo]
[str in foo]
[str matches str]
[str not contains str]
[str not endsWith str]
[str not in $env]
[str not in foo]
[str not matches str]
[str not startsWith str]
[str startsWith str]
[str | greet()]
[str | splitAfter(str)]
[str, $env == false]
[str, $env ?? foo]
[str, $env | count(true)]
[str, $env.f64]
[str, $env.str]
[str, $env?.[Bar]]
[str, $env?.[str]]
[str, $env?.array]
[str, $env?.nil]
[str, $env?.ok]
[str, $env] | map(add)
[str, 0] | reduce(false, foo)
[str, 1.0] | map(#)
[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, foo] | findIndex(ok)
[str, foo] | map(greet)
[str, greet]
[str, i, array] | reduce(1.0)
[str, i]
[str, list | findLastIndex(true)]
[str, list]
[str, list] | any(false)
[str, map(list, $env)]
[str, nil in array]
[str, nil] | map(str)
[str, nil]?.[i]
[str, ok, greet]
[str, ok]
[str, str, 0]?.[i]
[str, str]
[str, str]?.[i]
[str[1:]]
[str[:i]]
[str]
[str] == array
[str] ?? f64
[str] ?? i
[str] ?? str
[str] | all(false)
[str] | all(ok)
[str] | any(ok)
[str] | count(true)
[str] | filter(ok)
[str] | find(false)
[str] | findLast(ok)
[str] | findLastIndex(false)
[str] | groupBy(#)
[str] | groupBy(false)
[str] | map(1)
[str] | map(false)
[str] | map(foo)
[str] | none(false)
[str] | one(ok)
[str] | one(true)
[str] | reduce(#)
[str] | reduce(#acc)
[str] | reduce(1.0, ok)
[str] | reduce(false)
[str] | reduce(str, i)
[str] | sortBy(#)
[str] | sortBy($env)
[str] | sortBy(1.0)
[str] | sortBy(add)
[str] | sortBy(array)
[str] | sortBy(foo)
[str] | sum(abs(0))
[str][i:]
[string($env)]
[string($env.f64)]
[string($env.greet)]
[string(0)]
[string(1)]
[string(1.0)]
[string(add)]
[string(array), any(array, true)]
[string(array), str]
[string(array)]
[string(f64)]
[string(false)]
[string(floor(0))]
[string(foo), add]
[string(foo), f64]
[string(foo), foo]
[string(foo)]
[string(greet)]
[string(i)]
[string(list) not in $env?.foobar]
[string(list)]
[string(nil)]
[string(str)]
[string(true)]
[sum($env, 1)]
[sum($env.array)]
[sum($env?.[str])]
[sum([i])]
[sum(array) - i]
[sum(array), i]
[sum(array)]
[sum(array, #)]
[sum(array, 1)]
[sum(array, 1.0)]
[sum(array, f64)]
[sum(array, i)]
[sum(list, 0)]
[sum(list, 1.0)]
[toBase64(str)]
[toBase64(string(1.0))]
[toJSON($env.foo)]
[toJSON($env?.[String])]
[toJSON(0)]
[toJSON(1)]
[toJSON(1.0)]
[toJSON(array)]
[toJSON(f64)]
[toJSON(false), str]
[toJSON(false)]
[toJSON(foo)]
[toJSON(foo?.Bar)]
[toJSON(i)]
[toJSON(list)]
[toJSON(nil), foo.Bar]
[toJSON(nil)]
[toJSON(ok), array]
[toJSON(ok)]
[toJSON(true)]
[toPairs($env)]
[trim(str)]
[trimPrefix(str)]
[true != $env]
[true != false]
[true != nil]
[true && $env, list]
[true && $env]
[true && false, array]
[true && false]
[true && true]
[true == $env]
[true == false]
[true == nil]
[true == true]
[true ? $env : 1.0]
[true ? f64 : foo]
[true ? i : false, list]
[true ?: 1]
[true ?: array]
[true ?: f64]
[true ?: list]
[true ?: ok]
[true ?? $env?.i]
[true ?? $env]
[true ?? 0]
[true ?? 1.0]
[true ?? 1]
[true ?? array, sum(array)]
[true ?? f64]
[true ?? foo]
[true ?? list]
[true ?? true]
[true and $env]
[true and false]
[true and ok]
[true and true]
[true or true]
[true || $env]
[true || ok]
[true || true]
[true, $env] | groupBy(foo)
[true, $env] | map(foo)
[true, 0] | map(ok)
[true, 1.0]?.[i]
[true, 1] == $env?.array
[true, 1] | any(ok)
[true, add, foo] | findLastIndex(false)
[true, add] | findLast(true)
[true, add] | reduce(array, greet)
[true, add]?.[i]
[true, f64]?.[i]
[true, false] == list
[true, foo] | find(#)
[true, foo] | groupBy(foo)
[true, foo] | sum(1.0)
[true, foo]?.[i]
[true, list]?.[i]
[true, nil, greet]?.[i]?.foo
[true, nil] | none(#)
[true, nil] | reduce(f64)
[true, nil]?.[i]
[true, ok] | find(true)
[true, ok]?.[i]
[true, str] ?? add
[true, str] | groupBy(1.0)
[true, str][i:]
[true] != [array]
[true] != array
[true] ?? i
[true] in $env?.foobar
[true] | all(#)
[true] | all(ok)
[true] | any(#)
[true] | any(false)
[true] | count(#)
[true] | filter(#)
[true] | findIndex(#)
[true] | findLastIndex(#)
[true] | findLastIndex(false)
[true] | groupBy(#)
[true] | groupBy($env != $env)
[true] | groupBy(1.0)
[true] | groupBy(foo)
[true] | groupBy(str)
[true] | groupBy(true)
[true] | map(#)
[true] | map(1.0)
[true] | map(true)
[true] | none(true)
[true] | one(#)
[true] | one(false)
[true] | reduce(#)
[true] | reduce($env)
[true] | reduce($env, str)
[true] | reduce(1.0)
[true] | reduce(true, $env)
[true] | sortBy(#)
[true] | sortBy($env)
[true] | sortBy(0)
[true] | sortBy(foo)
[true] | sortBy(greet)
[true] | sortBy(true)
[true] | sum(1)
[true] | sum(1.0)
[true][:0 ?? str]
[type($env)]
[type(0)]
[type(1)]
[type(1.0), $env?.foo]
[type(1.0)]
[type(add)]
[type(array)]
[type(f64)]
[type(false), str]
[type(false)]
[type(foo)]
[type(greet)]
[type(i)]
[type(list), array]
[type(list)]
[type(nil)]
[type(ok) not endsWith str, ok]
[type(ok)]
[type(str), foo]?.[i]
[type(str)]
[type(true)]
[uniq(array)]
[uniq(list)]
[upper(str)]
[values($env)]
[{foo: $env, foo: 1.0, foo: 0}]
[{foo: $env, foo: nil}]
[{foo: $env}]
[{foo: 0, foo: 1.0}]
[{foo: 0, foo: nil}]
[{foo: 0, foo: true}]
[{foo: 0}]
[{foo: 1.0, foo: 0}]
[{foo: 1.0}.add]
[{foo: 1.0}?.str]
[{foo: 1.0}]
[{foo: 1}]
[{foo: add, foo: i}]
[{foo: add, foo: str}]
[{foo: add}]
[{foo: array, foo: nil}]
[{foo: array}]
[{foo: f64, foo: foo}]
[{foo: f64}?.f64]
[{foo: f64}]
[{foo: false, foo: 0}]
[{foo: false}]
[{foo: foo, foo: $env}.String]
[{foo: foo, foo: false}]
[{foo: foo, foo: nil}]
[{foo: foo}]
[{foo: greet, foo: f64, foo: 0}]
[{foo: greet, foo: foo}]
[{foo: greet}]
[{foo: i, foo: $env}]
[{foo: i, foo: greet, foo: foo}]
[{foo: i}]
[{foo: list, foo: foo}]
[{foo: list}?.Bar]
[{foo: list}]
[{foo: nil, foo: 1.0}]
[{foo: nil, foo: i}]
[{foo: nil, foo: nil}]
[{foo: nil, foo: str}]
[{foo: nil}]
[{foo: ok}?.foo]
[{foo: ok}]
[{foo: str, foo: true}]
[{foo: str}]
[{foo: true}]
abs($env | count(ok))
abs($env | count(true))
abs($env | findLastIndex(ok))
abs($env | sum(1))
abs($env | sum(1.0))
abs($env.f64)
abs($env.i)
abs($env?.f64)
abs($env?.i)
abs(-0)
abs(-1)
abs(-1.0)
abs(-f64)
abs(-i)
abs(0 % i)
abs(0 * 1.0)
abs(0 ** 1.0)
abs(0 ** f64)
abs(0 ** i)
abs(0 + 0)
abs(0 + 1.0)
abs(0 + i)
abs(0 - 0)
abs(0 - 1)
abs(0 - 1.0)
abs(0 - f64)
abs(0 - i)
abs(0 / 0)
abs(0 / 1)
abs(0 / 1.0)
abs(0 / f64)
abs(0 ?? 1)
abs(0 ?? add)
abs(0 ?? array)
abs(0 ?? false)
abs(0 ?? foo)
abs(0 ?? i)
abs(0 ?? nil)
abs(0 ^ 1.0)
abs(0 ^ i)
abs(0 | mean(i, i))
abs(0 | min(f64))
abs(0) * f64
abs(0) ** $env?.i
abs(0) - f64
abs(0) - i
abs(0) / f64
abs(0) ?? add
abs(0) ?? array
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.0)
abs(1 - 1)
abs(1 - 1.0)
abs(1 - f64)
abs(1 / 1)
abs(1 / 1.0)
abs(1 / i)
abs(1 ?? 1.0)
abs(1 ?? add)
abs(1 ?? f64)
abs(1 ?? false)
abs(1 ?? foo)
abs(1 ?? greet)
abs(1 ?? i)
abs(1 ^ 0)
abs(1 ^ 1)
abs(1 ^ f64)
abs(1 ^ i)
abs(1 | bitshr(i))
abs(1 | max(array))
abs(1) != i
abs(1) * i
abs(1) + f64
abs(1) < f64
abs(1) < i
abs(1) <= nil ?? i
abs(1) >= i
abs(1) ?? array
abs(1) ^ float(1.0)
abs(1) not in $env?.foobar
abs(1) | mean(i)
abs(1.0 * 0)
abs(1.0 * 1)
abs(1.0 * 1.0)
abs(1.0 * f64)
abs(1.0 * 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 + f64)
abs(1.0 + i)
abs(1.0 - 1)
abs(1.0 - 1.0)
abs(1.0 - f64)
abs(1.0 - i)
abs(1.0 / 0)
abs(1.0 / 1)
abs(1.0 / 1.0)
abs(1.0 ?? $env[count(foobar):findLast(str, .list)])
abs(1.0 ?? 1)
abs(1.0 ?? 1.0)
abs(1.0 ?? f64)
abs(1.0 ?? foo)
abs(1.0 ?? list)
abs(1.0 ?? nil)
abs(1.0 ?? true)
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 | min(f64))
abs(1.0)
abs(1.0) != $env?.[Bar]
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) < 1.0 ?? 1
abs(1.0) <= reduce(array, #)
abs(1.0) == i
abs(1.0) > i
abs(1.0) ?? f64
abs(1.0) ^ f64 > 0
abs(1.0) ^ i
abs(1.0) in $env?.[String]
abs(1.0) in array
abs(1.0) | max(0)
abs(1.0) | median(array)
abs(1.1)
abs(abs(1))
abs(abs(1.0))
abs(abs(f64))
abs(abs(i))
abs(abs(int(1.0)))
abs(add(1, 1))
abs(array | count(true))
abs(array | find(ok))
abs(array | findLast(true))
abs(array | findLastIndex(ok))
abs(array | reduce(#))
abs(array | reduce(#acc))
abs(array | reduce(#index))
abs(array | reduce(0))
abs(array | reduce(0, array))
abs(array | reduce(1, nil))
abs(array | reduce(1.0))
abs(array | reduce(1.0, foo))
abs(array | sum(1.0))
abs(array?.[1])
abs(array?.[i])
abs(bitnot(0))
abs(bitnot(1))
abs(bitnot(i))
abs(bitor(0, 0))
abs(ceil(0))
abs(ceil(1))
abs(ceil(1.0))
abs(ceil(f64))
abs(ceil(i))
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)
abs(f64 + 1.0)
abs(f64 + f64)
abs(f64 - 1)
abs(f64 - i)
abs(f64 / 1)
abs(f64 / 1.0)
abs(f64 / f64)
abs(f64 ?? 0)
abs(f64 ?? 1)
abs(f64 ?? add)
abs(f64 ?? foo)
abs(f64 ?? nil)
abs(f64 ^ 0)
abs(f64 ^ 1)
abs(f64 ^ 1.0)
abs(f64 ^ i)
abs(f64)
abs(f64) != f64
abs(f64) != i
abs(f64) ** i
abs(f64) + i
abs(f64) - f64
abs(f64) - i
abs(f64) / i
abs(f64) == f64
abs(f64) > f64
abs(f64) ?? array
abs(f64) ?? f64
abs(f64) ?? i
abs(f64) ?? str
abs(findIndex($env, true))
abs(findIndex(array, true))
abs(findLastIndex($env, true))
abs(findLastIndex(list, true))
abs(first(array))
abs(float(0))
abs(float(1))
abs(float(1.0))
abs(float(f64))
abs(float(i))
abs(floor(0))
abs(floor(1))
abs(floor(1.0))
abs(floor(f64))
abs(floor(i))
abs(i % i)
abs(i * 0)
abs(i * 1)
abs(i * 1.0)
abs(i * f64)
abs(i * i)
abs(i ** 0)
abs(i ** 1.0)
abs(i ** i)
abs(i + 0)
abs(i + 1)
abs(i + i)
abs(i - 1.0)
abs(i - f64)
abs(i - i)
abs(i / 1.0)
abs(i / i)
abs(i ?? $env)
abs(i ?? 1.0)
abs(i ?? add)
abs(i ?? i)
abs(i ?? list)
abs(i ?? true)
abs(i ^ 1)
abs(i ^ 1.0)
abs(i ^ i)
abs(i | bitshl(0))
abs(i | bitushr(0))
abs(i)
abs(i) * i
abs(i) + f64
abs(i) < i
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 ok { 1.0 } else { i })
abs(if true { f64 } else { list })
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($env)?.f64)
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(1.0, i))
abs(mean(array))
abs(mean(array, 0))
abs(mean(f64))
abs(mean(f64, array))
abs(mean(i))
abs(median(0))
abs(median(0, 1.0))
abs(median(1))
abs(median(1, 0))
abs(median(1.0))
abs(median(1.0, 1.0))
abs(median(array))
abs(median(f64))
abs(median(f64, array))
abs(median(i))
abs(min(0))
abs(min(1))
abs(min(1.0))
abs(min(array))
abs(min(f64))
abs(min(i))
abs(nil ?? 0)
abs(nil ?? 1)
abs(nil ?? 1.0)
abs(nil ?? f64)
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(round(f64))
abs(round(i))
abs(round(median(f64)))
abs(sum($env, 1.0))
abs(sum($env, i))
abs(sum(array))
abs(sum(array, #))
abs(sum(array, 0))
abs(sum(array, f64))
abs(sum(list, 1))
abs(sum(list, 1.0))
abs(sum(list, f64))
abs(sum(list, i))
add
add != $env && $env?.ok
add != $env && ok
add != $env == $env
add != $env ?? f64
add != $env ?? false
add != $env ?? list
add != $env ?? str
add != $env and ok
add != $env or $env?.[array]
add != $env or ok
add != $env.add
add != $env?.$env?.greet
add != $env?.Bar
add != $env?.Bar?.ok
add != $env?.String
add != $env?.String?.str(foo)
add != $env?.[Bar]
add != $env?.[String]
add != $env?.[String]?.[array]
add != $env?.[String]?.str()
add != $env?.[foobar?.[foobar]]
add != $env?.[foobar?.f64]
add != $env?.[foobar]
add != $env?.[str]
add != $env?.add
add != $env?.add ?: foo
add != $env?.foobar
add != $env?.foobar?.[array]
add != 1 ?? foo
add != 1.0 ?? foo
add != add
add != add ?? count(array)
add != add ?? true
add != array ?? 1
add != array ?? 1.0
add != f64 ?? ok
add != false ?? list
add != foo ?? $env
add != i ?? foo
add != list ?? greet
add != max(array)
add != min($env)
add != nil && $env
add != nil == true
add != nil ?: 1
add != nil ?: false
add != nil and false
add != nil || ok
add != nil || true
add != ok ?? str
add == $env == false
add == $env ? 0 : 1
add == $env ? array : ok
add == $env ?? foo
add == $env ?? greet
add == $env or false
add == $env or true
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 == $env?.foobar?.[greet]
add == 0 ?? $env
add == 0 ?? array
add == 1 ?? foo
add == 1 ?? str
add == 1.0 ?? foo
add == 1.0 ?? greet
add == 1.0 ?? i
add == 1.0 ?? str
add == add
add == add && $env
add == add == true
add == add ?? 1.0
add == add and $env?.[foo]
add == add or $env
add == false ?? 0
add == foo ?? 1
add == foo ?? array
add == foo ?? f64
add == foo ?? i
add == greet ?? $env
add == i ?? str
add == last($env)
add == max($env)
add == mean(array)
add == nil != $env?.[Bar]
add == nil && $env[foobar:foobar]
add == nil == ok
add == nil ?? add
add == nil || $env
add == nil || false
add == str ?? list
add == str ?? ok
add ?? !false
add ?? $env ?? nil
add ?? $env.add
add ?? $env.array
add ?? $env.f64
add ?? $env.foo
add ?? $env.greet
add ?? $env.i
add ?? $env.list
add ?? $env.ok
add ?? $env.str
add ?? $env?.Bar
add ?? $env?.Bar()
add ?? $env?.Bar(f64 not endsWith foobar ^ true)
add ?? $env?.Bar(foobar?.[i])
add ?? $env?.String
add ?? $env?.String()
add ?? $env?.String(add)
add ?? $env?.String(array.i())
add ?? $env?.String?.f64
add ?? $env?.[Bar]
add ?? $env?.[String]
add ?? $env?.[add]
add ?? $env?.[array]
add ?? $env?.[array]?.[str]
add ?? $env?.[array]?.foo
add ?? $env?.[f64]
add ?? $env?.[f64]?.[str]
add ?? $env?.[f64]?.greet
add ?? $env?.[foo]
add ?? $env?.[foobar and String]
add ?? $env?.[foobar]
add ?? $env?.[greet]
add ?? $env?.[i]
add ?? $env?.[last(Bar, foobar, foobar)]
add ?? $env?.[list]
add ?? $env?.[list].String
add ?? $env?.[ok]
add ?? $env?.[str]
add ?? $env?.add
add ?? $env?.array
add ?? $env?.f64
add ?? $env?.findIndex(foobar)
add ?? $env?.foo
add ?? $env?.greet
add ?? $env?.i
add ?? $env?.list
add ?? $env?.ok
add ?? $env?.str
add ?? $env[$env != list:]
add ?? $env[:String?.add]
add ?? $env[:foobar]
add ?? $env[f64(Bar):]
add ?? $env[foo.ok():]
add ?? $env[foobar != 1.0:]
add ?? $env[foobar:1.0]
add ?? $env[greet && Bar:foobar]
add ?? -$env
add ?? -0
add ?? -1
add ?? -f64
add ?? -i
add ?? 0 ?? array
add ?? 1 ?? i
add ?? 1 ?? str
add ?? 1.0 ?? add
add ?? [1]
add ?? [add]
add ?? [foo]
add ?? [i]
add ?? [ok]
add ?? abs(0)
add ?? add
add ?? add ?? foo
add ?? add ?? true
add ?? array
add ?? array?.[i]
add ?? bitnot(0)
add ?? ceil(0)
add ?? ceil(1)
add ?? ceil(f64)
add ?? count($env)
add ?? count(array)
add ?? count(list)
add ?? date(false)
add ?? date(nil)
add ?? duration($env)
add ?? duration(str)
add ?? f64
add ?? false ?? foo
add ?? false ?? i
add ?? filter($env, #)
add ?? filter($env, true)
add ?? findIndex($env, #.array)
add ?? findIndex($env, #.foo)
add ?? findLast($env, #)
add ?? findLast($env, false)
add ?? findLast(list, true)
add ?? flatten(array)
add ?? float(1.0)
add ?? floor(0)
add ?? foo
add ?? foo ?? f64
add ?? foo ?? foo
add ?? foo ?? nil
add ?? foo ?? true
add ?? foo.Bar
add ?? foo.String
add ?? foo.String()
add ?? foo?.Bar
add ?? foo?.String
add ?? foo?.String()
add ?? fromBase64(str)
add ?? fromPairs(list)
add ?? greet
add ?? greet ?? 1.0
add ?? greet($env)
add ?? groupBy($env, 1)
add ?? groupBy($env, foo)
add ?? i
add ?? i ?? $env
add ?? i ?? $env?.Bar()
add ?? int(1)
add ?? list
add ?? list ?? greet
add ?? list ?? ok
add ?? list | get(ok)
add ?? list?.[i]
add ?? list[:bitshr($env, i)]
add ?? list[:i]
add ?? lower($env)
add ?? map($env, #index)
add ?? map($env, greet)
add ?? max($env)
add ?? max(i)
add ?? mean(1.0)
add ?? mean(array)
add ?? nil ?? false
add ?? nil ?? foo
add ?? nil ?? ok
add ?? not $env
add ?? not ok
add ?? not true
add ?? ok
add ?? reduce($env, #)
add ?? reduce($env, .Bar)?.array
add ?? reverse(array)
add ?? sortBy($env, $env).list(i)
add ?? sortBy(array, #)
add ?? sortBy(array, foo)
add ?? str
add ?? str ?? max(array)
add ?? string(1.0)
add ?? string(foo)
add ?? string(greet)
add ?? string(nil)
add ?? sum($env)
add ?? sum($env, 1)
add ?? sum($env, array)
add ?? sum($env, str)
add ?? sum(array, f64)
add ?? sum(list)
add ?? timezone(str)
add ?? toBase64($env)
add ?? trim($env)
add ?? true ?? 1.0
add ?? true | get(foo)
add ?? type(1.0)
add ?? type(array)
add ?? upper($env)
add ?? values($env)
add ?? {foo: foo, foo: greet}
add ?? {foo: foo}
add ?? {foo: str}
add in $env?.Bar
add in $env?.Bar?.[f64]
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 list ?? add
add in map(array, $env)
add in values($env)
add in {foo: add}?.add
add not in $env?.$env
add not in $env?.Bar
add not in $env?.Bar?.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?.[nil]
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 [array, foo]
add not in [foo, nil]
add not in [nil]
add not in find($env, false)
add not in first($env)
add not in keys($env)
add not in list ?? false
add not in list ?? str
add not in reverse(list)
add not in toPairs($env)
add not in {foo: 1}?.array
add($env.i, i)
add($env?.i, i)
add(-i, i)
add(0, 0) != i
add(0, 0) ** ceil(i)
add(0, 1) * f64
add(0, i) ?? array
add(abs(1), sum(array, #))
add(i, -i)
add(i, 1) >= f64 > i
add(i, array?.[i])
add(i, i)
add(i, list | sum(i))
add(int(0), i)
add(min(0, i), i)
add(sum(array), i)
add; $env.add
add; $env.array
add; add
add; add ?? f64
add; array
add; greet
add; list
add; ok
add; {foo: f64}
all($env | filter(false), #[.ok:$env])
all($env, false) and $env?.[add].f64
all($env, false) and f64 <= 0
all($env, ok) ?? add
all($env, ok) ?? str
all($env, true) ?: greet
all($env, true) and ok
all($env.array, 1 > #)
all($env.list, # != foo)
all($env.list, $env == #)
all($env?.[str], str != #)
all($env?.array, ok)
all($env?.list, nil == $env)
all($env?.list, ok)
all([$env], ok)
all([add], ok)
all([false], #)
all([list], 1.0 < 1.0)
all([ok], #)
all(array, # != $env)
all(array, # < #)
all(array, # < f64)
all(array, # <= #)
all(array, # <= i)
all(array, # == #)
all(array, # == $env)
all(array, # == 0)
all(array, # == 1.0)
all(array, # > #)
all(array, # >= #)
all(array, $env != #)
all(array, $env != f64)
all(array, $env == #)
all(array, 0 == i)
all(array, 1 <= 1.0)
all(array, 1 == 0)
all(array, 1.0 <= #)
all(array, 1.0 > 0)
all(array, add == $env)
all(array, f64 | min(#, 1.0) >= #)
all(array, false and ok)
all(array, false) or 1.0 ?? i
all(array, foo == nil)
all(array, i >= 0)
all(array, i >= 1)
all(array, list | one(true))
all(array, nil != #)
all(array, nil != nil)
all(array, nil == 1)
all(array, nil == true)
all(array, ok ?? $env)
all(array, ok)
all(array, ok) || $env?.Bar
all(array, str == nil)
all(array, str startsWith str)
all(array, true or $env)
all(array, true) ?? greet
all(list | map(true), #)
all(list, !false)
all(list, # != #)
all(list, # in list)
all(list, #.Bar >= str)
all(list, $env != #)
all(list, $env != 0)
all(list, $env == #)
all(list, $env?.ok)
all(list, 0 < 1.0)
all(list, 0 <= 1.0)
all(list, 1.0 <= 0)
all(list, add != $env)
all(list, array | any(ok))
all(list, f64 != $env)
all(list, f64 <= 1.0)
all(list, false != false)
all(list, false) != ok
all(list, false) == $env == nil
all(list, foo != #)
all(list, foo == #)
all(list, nil == nil)
all(list, nil not in $env)
all(list, not true)
all(list, ok)
all(list, true && ok)
all(list, true and ok)
all(list, true or true)
all(map(list, 1.0), i < 1.0)
all(nil ?? $env, ok)
all(sort($env), #)
all(sort($env), #.foo)
all(sort($env), .f64 | reduce(#, foo))
all(sort($env), .f64)
all(sort($env), .ok)
all(sort($env), .ok?.array)
all(sort($env), .str <= #)
all(sort($env), 1.0 >= #)
all(sort($env), sortBy(#, ok))
all(sort($env), str == #)
all(toPairs($env), ok)
all(uniq(list), ok)
any($env ?? 1.0, ok)
any($env, false) or $env?.[String]
any($env, ok) || $env == foo
any($env, true) ?? f64
any($env, true) || $env?.[str]
any($env.list, ok)
any($env?.[str], true and true)
any($env?.array, # == #)
any($env?.array, ok)
any($env?.list, ok)
any([$env], ok)
any([0], foo == nil)
any([1.0], not true)
any(array ?? $env, true or #)
any(array, # != #)
any(array, # != $env)
any(array, # < 0)
any(array, # <= #)
any(array, # > #)
any(array, # >= 1)
any(array, $env != #)
any(array, $env != add)
any(array, $env == 0)
any(array, $env | all(true))
any(array, $env.ok)
any(array, $env?.ok)
any(array, 0 <= 1)
any(array, 0 == #)
any(array, 1 == 1.0)
any(array, 1.0 != 0)
any(array, 1.0 <= #)
any(array, array == array)
any(array, f64 != f64)
any(array, false) ?? list
any(array, false) || $env != 0
any(array, foo == nil)
any(array, i != #)
any(array, i <= i)
any(array, nil != #)
any(array, nil == greet)
any(array, ok != ok)
any(array, ok ?? $env)
any(array, ok ?? 0)
any(array, ok or $env)
any(array, ok)
any(array, str >= str)
any(filter(list, false), ok)
any(keys($env), ok)
any(list ?? list, ok)
any(list, !true)
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 == ok)
any(list, $env == str)
any(list, $env.ok)
any(list, $env?.ok)
any(list, 0 <= 1.0)
any(list, 1 < 0)
any(list, 1.0 < 1.0)
any(list, false && true)
any(list, false) && 1.0 ?? $env
any(list, foo != #)
any(list, foo == nil)
any(list, i ^ i == 1.0)
any(list, list != array)
any(list, nil != 1)
any(list, nil == nil)
any(list, not true)
any(list, ok or $env)
any(list, ok)
any(map(array, add), ok)
any(nil ?? $env, ok)
any(sort($env), #)
any(sort($env), -#)
any(sort($env), .String)
any(sort($env), .list)
any(sort($env), f64 == #)
any(sort(array), # == ok)
any(sortBy(list, i), ok)
any(values($env), # != 1.0)
array
array != $env != $env
array != $env && false
array != $env == false
array != $env == ok
array != $env ?: str
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?.[foobar]
array != $env?.[str]
array != $env?.array
array != $env?.foobar
array != $env?.list
array != $env?.true
array != 0 ?? $env
array != 0 ?? list
array != 1.0 ?? array
array != [1.0 + f64]
array != [f64]
array != [foo]
array != [list]
array != [median(1.0)]
array != [true]
array != array
array != array != nil
array != array && ok
array != array && true
array != array ?? false
array != array or ok
array != false ?? $env
array != false ?? f64
array != false ?? greet
array != flatten(array)
array != foo ?? f64
array != i .. 1
array != i ?? foo
array != list
array != list != false
array != list != true
array != list && 1.0 > 0
array != list || ok
array != map($env, 1.0)
array != map(array, $env)
array != map(list, #)
array != map(list, 1.0)
array != min($env)
array != nil == $env
array != nil ? list : greet
array != nil and ok
array != nil and true
array != nil or $env
array != nil or false
array != nil or ok
array != str ?? greet
array != values($env)
array != {foo: $env}?.str
array != {foo: 0}.add
array == $env != ok
array == $env && false
array == $env ?? i
array == $env ?? nil
array == $env ?? str
array == $env and $env
array == $env or $env?.Bar
array == $env or false
array == $env.array
array == $env.list
array == $env?.Bar
array == $env?.Bar?.ok
array == $env?.String
array == $env?.String?.[greet]
array == $env?.String?.greet
array == $env?.[Bar]
array == $env?.[Bar]?.[add]
array == $env?.[Bar]?.add
array == $env?.[String]
array == $env?.[foobar]
array == $env?.[greet(nil)]
array == $env?.[str]
array == $env?.array
array == $env?.foobar
array == $env?.list
array == 0 ?? array
array == 1.0 ?? find($env, #.list)
array == [$env]
array == [1.0]
array == [1]
array == [foo]
array == [nil]
array == [ok, 1.0]
array == [ok]
array == [str]
array == [true]
array == add ?? foo
array == array
array == array != ok
array == f64 ?? $env
array == false ?? $env
array == false ?? i
array == foo ?? add
array == foo ?? true
array == greet ?? array
array == greet ?? ok
array == keys($env)
array == list
array == list != $env
array == list != false
array == list[:]
array == map(array, #)
array == map(list, true)
array == max($env)?.greet
array == min($env)
array == min(array)
array == nil != nil
array == nil != ok
array == nil && $env
array == nil && foo == $env
array == nil == $env
array == nil ?? nil
array == ok ?? foo
array == ok ?? list
array ?? !$env
array ?? !false
array ?? !ok
array ?? $env ?? foo
array ?? $env ?? i
array ?? $env | count(true)
array ?? $env | findLast(ok)
array ?? $env | groupBy(false)
array ?? $env | map(f64)
array ?? $env | map(foo)
array ?? $env | map(ok)
array ?? $env | median(i, f64)
array ?? $env | reduce(#)
array ?? $env | reduce(add)
array ?? $env | reduce(foo)
array ?? $env | sortBy(1.0)
array ?? $env.add
array ?? $env.array
array ?? $env.f64
array ?? $env.foo
array ?? $env.greet
array ?? $env.i
array ?? $env.list
array ?? $env.ok
array ?? $env.str
array ?? $env?.Bar
array ?? $env?.Bar()
array ?? $env?.Bar(foobar)
array ?? $env?.String
array ?? $env?.String()
array ?? $env?.String(Bar, 0)
array ?? $env?.[Bar]
array ?? $env?.[String]
array ?? $env?.[add]
array ?? $env?.[add].str
array ?? $env?.[array]
array ?? $env?.[f64]
array ?? $env?.[f64]?.[add]
array ?? $env?.[f64]?.greet()
array ?? $env?.[foo?.[array]]
array ?? $env?.[foo]
array ?? $env?.[foobar.Bar]
array ?? $env?.[foobar]
array ?? $env?.[greet()]
array ?? $env?.[greet]
array ?? $env?.[i]
array ?? $env?.[list | fromJSON(nil)]
array ?? $env?.[list]
array ?? $env?.[list]?.f64
array ?? $env?.[list]?.foo
array ?? $env?.[nil or $env]
array ?? $env?.[ok]
array ?? $env?.[ok].foo()
array ?? $env?.[str]
array ?? $env?.[str].str
array ?? $env?.add
array ?? $env?.array
array ?? $env?.f64
array ?? $env?.foo
array ?? $env?.greet
array ?? $env?.i
array ?? $env?.list
array ?? $env?.ok
array ?? $env?.sort(foobar, nil)
array ?? $env?.str
array ?? $env[1.0:foobar]
array ?? $env[:1.0]
array ?? $env[:foobar]
array ?? $env[:fromPairs(ok)]
array ?? $env[:str .. false]
array ?? $env[f64():]
array ?? $env[findLastIndex(foo, greet):]
array ?? $env[foobar .. foobar:]
array ?? $env[foobar:]
array ?? $env[str:]
array ?? $env[true != foobar:]
array ?? -$env
array ?? -0
array ?? -1
array ?? -1.0
array ?? -1.0 ^ 1.0 | map(foo)
array ?? 0 ?? f64
array ?? 0 | filter(false)
array ?? 0 | map(#)
array ?? 0 | map(add)
array ?? 0 | one(false)
array ?? 0 | one(ok)
array ?? 0 | reduce(#)
array ?? 0 | sum(i)
array ?? 1 | map(1)
array ?? 1 | map(false)
array ?? 1 | reduce($env, $env)
array ?? 1 | reduce(greet)
array ?? 1 | reduce(i)
array ?? 1.0 ?? add
array ?? 1.0 ?? foo
array ?? 1.0 | findLast(false)
array ?? 1.0 | groupBy(1)
array ?? 1.0 | map(#)
array ?? 1.0 | sortBy(#)
array ?? 1.0 | sortBy(1.0)
array ?? 1.0 | sum(#)
array ?? [1]
array ?? [add]
array ?? [list]
array ?? [ok, add]
array ?? abs(1.0)
array ?? abs(f64)
array ?? add
array ?? add | findLastIndex(ok)
array ?? add | groupBy(true)
array ?? add | map(#)
array ?? add | reduce($env)
array ?? add | reduce(i)
array ?? add($env, 1)
array ?? array
array ?? array ?? 0
array ?? array ?? f64
array ?? array | map(true)
array ?? array | one(true)
array ?? array | reduce($env)
array ?? array | reduce(str)
array ?? array?.[i]
array ?? bitnot(1)
array ?? bitushr($env, 0)
array ?? ceil(1.0)
array ?? concat(list)
array ?? count($env)
array ?? count($env, #)
array ?? count(list)
array ?? count(str ?? 1.0)
array ?? date(foo)
array ?? date(i)
array ?? date(str)
array ?? duration($env)
array ?? f64
array ?? f64 ?? 1.0
array ?? f64 | map(#)
array ?? f64 | map(foo)
array ?? f64 | sortBy(f64)
array ?? f64 | sum(#)
array ?? false ?? false
array ?? false | findLastIndex(true)
array ?? false | groupBy(#)
array ?? false | map($env)
array ?? false | one(ok)
array ?? filter($env, .str)
array ?? findIndex($env, #)
array ?? findLast($env, #.String)
array ?? findLast($env, .add)
array ?? findLastIndex($env, #)
array ?? findLastIndex($env, #.i)
array ?? floor(1.0)
array ?? foo
array ?? foo | all(ok)
array ?? foo | all(true)
array ?? foo | any(false)
array ?? foo | filter(true)
array ?? foo | groupBy(1)
array ?? foo | map(#)
array ?? foo | map(1.0)
array ?? foo | map(foo)
array ?? foo | reduce(#)
array ?? foo | reduce(#acc, true)
array ?? foo | reduce(#index * #)
array ?? foo | reduce(1)
array ?? foo | reduce(1.0)
array ?? foo | reduce(foo)
array ?? foo | reduce(foo, true)
array ?? foo | sortBy(1)
array ?? foo | sortBy(str)
array ?? foo | sum(1.0)
array ?? foo.Bar
array ?? foo.String
array ?? foo.String()
array ?? foo?.Bar
array ?? foo?.String
array ?? foo?.String()
array ?? fromBase64(str)
array ?? greet
array ?? greet ?? $env
array ?? greet | all(ok)
array ?? greet | map(true)
array ?? greet | reduce(foo)
array ?? greet | sortBy(f64)
array ?? greet | sum(0)
array ?? greet($env)
array ?? i
array ?? i ?? add
array ?? i | map(#)
array ?? i | max(0)
array ?? i | sortBy(#)
array ?? i | sum(1)
array ?? last($env)?.Bar
array ?? list
array ?? list ?? str
array ?? list | find(true)
array ?? list | findIndex(ok)
array ?? list | findIndex(true)
array ?? list | map($env)
array ?? list | map(foo)
array ?? list?.[i]
array ?? list[:]
array ?? map($env, array)
array ?? map($env?.[String], bitshr(#, #))
array ?? max(f64)
array ?? mean(f64)
array ?? min(i)
array ?? nil ?? $env?.f64
array ?? nil ?? add
array ?? nil ?? f64
array ?? nil ?? i
array ?? nil | filter(false)
array ?? nil | map(#)
array ?? nil | map(false)
array ?? nil | reduce(#)
array ?? nil | reduce(foo, $env)
array ?? nil | reduce(foo, foo)
array ?? nil | sortBy(#)
array ?? not ok
array ?? not true
array ?? ok
array ?? ok | findIndex(ok)
array ?? ok | findLastIndex(true)
array ?? ok | map(i)
array ?? ok | reduce(i, 1.0)
array ?? ok | sum(#)
array ?? one($env, #)
array ?? reduce($env, #.greet)
array ?? reduce($env, list)
array ?? round(1)
array ?? round(i)
array ?? sortBy($env, 0)
array ?? sortBy($env, 1)
array ?? sortBy($env, foo)
array ?? str
array ?? str | map(foo)
array ?? str | none(false)
array ?? str | reduce(#, f64)
array ?? str | sortBy(#)
array ?? str | sum(#)
array ?? string($env)
array ?? string(array)
array ?? string(nil)
array ?? string(ok)
array ?? sum($env)
array ?? sum($env, list)
array ?? sum(array)
array ?? sum(array, true)
array ?? toJSON(add)
array ?? true | groupBy(ok)
array ?? true | reduce(0)
array ?? true | reduce(foo)
array ?? true | sum(#)
array ?? type(array)
array ?? type(foo)
array ?? type(list)
array ?? uniq($env)
array ?? uniq(array)
array ?? {foo: 1}
array ?? {foo: add}
array ?? {foo: i}
array in $env?.Bar
array in $env?.Bar?.[array]
array in $env?.String
array in $env?.String?.array
array in $env?.String?.foo
array in $env?.[Bar]
array in $env?.[String]
array in $env?.[String]?.[greet]
array in $env?.[String]?.list
array in $env?.[foobar]
array in $env?.[foobar]?.[i]
array in $env?.foobar
array in [$env?.foobar]
array in [array]
array in [f64, list]
array in [list]
array in [nil]
array in [str, $env]
array in array ?? add
array in array ?? greet
array in flatten(array)
array in keys($env)
array in last($env)
array in reverse(list)
array in uniq(array)
array in values($env)
array not in $env and false
array not in $env?.Bar
array not in $env?.String
array not in $env?.[Bar]
array not in $env?.[Bar]?.add
array not in $env?.[String]
array not in $env?.[String]?.[add]
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?.false
array not in $env?.foobar
array not in [1, 1.0]
array not in [array]
array not in [list]
array not in first($env)
array not in last($env)
array not in list ?? none($env, #.Bar)
array not in map(array, array)
array not in toPairs($env)
array not in uniq(array)
array not in uniq(list)
array not in {foo: foo}.add
array | all(# != #)
array | all(# != nil)
array | all(# <= 1.0)
array | all(# == f64)
array | all(# >= i)
array | all($env == #)
array | all($env == $env)
array | all($env == foo)
array | all(0 < 1.0)
array | all(0 == #)
array | all(1.0 != nil)
array | all(1.0 <= #)
array | all(f64 < #)
array | all(false)
array | all(foo == foo)
array | all(foo not in list)
array | all(i != f64)
array | all(i > #)
array | all(ok)
array | all(one(list, true))
array | all(true && true)
array | all(true)
array | any(# != #)
array | any(# < #)
array | any(# <= #)
array | any(# == $env.i)
array | any(# > #)
array | any(# >= f64)
array | any($env != #)
array | any($env != nil)
array | any($env == foo)
array | any($env?.ok)
array | any(1 < #)
array | any(1.0 <= 1)
array | any(false)
array | any(i <= #)
array | any(not ok)
array | any(ok ?: nil)
array | any(ok)
array | any(true)
array | concat(array)
array | concat(array) | find(ok)
array | concat(array) | sortBy(1)
array | concat(array, array)
array | concat(list)
array | concat(list) | reduce(f64)
array | count(# != #)
array | count(# != $env)
array | count(# != nil)
array | count(# <= 0)
array | count(# > #)
array | count($env != foo)
array | count($env == #)
array | count($env == array)
array | count($env.ok)
array | count($env?.ok)
array | count(0 < 1)
array | count(0 <= #)
array | count(0 > #)
array | count(1.0 == #)
array | count(false)
array | count(i >= #)
array | count(nil not in $env)
array | count(not true)
array | count(ok)
array | count(ok) not in array
array | count(true)
array | count(true) ** i
array | filter(!true)
array | filter(# < 1.0)
array | filter(# <= #)
array | filter(# <= f64)
array | filter(# >= #)
array | filter(# >= 0)
array | filter($env == #)
array | filter($env == i)
array | filter($env == ok)
array | filter($env == str)
array | filter($env.ok)
array | filter(1 != #)
array | filter(f64 < #)
array | filter(f64 == #)
array | filter(false)
array | filter(false) | map(#)
array | filter(false) | map(array)
array | filter(false) | sortBy(#)
array | filter(false) | sortBy(foo)
array | filter(foo != foo)
array | filter(foo != nil)
array | filter(greet == $env)
array | filter(nil == #)
array | filter(nil == foo)
array | filter(ok)
array | filter(ok) | find(1.0 > #)
array | filter(ok) | map(foo)
array | filter(ok) | mean(1.0)
array | filter(ok) | sum(1)
array | filter(true)
array | filter(true) != list
array | filter(true) | groupBy(#)
array | filter(true) | take(0)
array | find(# < #)
array | find(# >= 1.0)
array | find($env != $env)
array | find($env == i)
array | find($env not in array)
array | find($env not in list)
array | find(-1 < #)
array | find(0 < 1)
array | find(1.0 != 1.0)
array | find(1.0 < #)
array | find(1.0 == 0)
array | find(1.0 == 1.0)
array | find(false)
array | find(foo in list)
array | find(i == i)
array | find(ok)
array | find(true)
array | find(true) == i
array | find(true) >= float(f64)
array | find(true) ?? ok
array | find(true) | mean(1.0)
array | find(type(true) contains str[0:])
array | findIndex(!false)
array | findIndex(# != 0)
array | findIndex(# == #)
array | findIndex(# > 1.0)
array | findIndex(# > f64)
array | findIndex(# >= 1.0)
array | findIndex($env != false)
array | findIndex($env != nil)
array | findIndex($env.ok)
array | findIndex($env?.ok)
array | findIndex(0 != #)
array | findIndex(1 not in array)
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 ?? ok)
array | findIndex(ok)
array | findIndex(true)
array | findIndex(true) + i
array | findIndex(true) | bitshl(0)
array | findLast(# <= i)
array | findLast(# > #)
array | findLast(# >= 1.0)
array | findLast($env or true)
array | findLast(0 >= #)
array | findLast(1.0 < #)
array | findLast(1.0 >= i)
array | findLast(f64 + f64 != nil)
array | findLast(f64 <= #)
array | findLast(f64 >= #)
array | findLast(false)
array | findLast(greet != nil)
array | findLast(nil != #)
array | findLast(nil not in $env)
array | findLast(none($env, true))
array | findLast(ok)
array | findLast(ok) ?? $env[false:]
array | findLast(ok) | mean(i)
array | findLast(true ?: add)
array | findLast(true)
array | findLastIndex(!true)
array | findLastIndex(# != $env)
array | findLastIndex(# < #)
array | findLastIndex(# <= #)
array | findLastIndex($env != 0)
array | findLastIndex($env != 1.0)
array | findLastIndex($env | any(false))
array | findLastIndex(0 <= 0)
array | findLastIndex(1 <= i)
array | findLastIndex(1.0 < #)
array | findLastIndex(1.0 <= #)
array | findLastIndex(1.0 <= 1.0)
array | findLastIndex(false ?: ok)
array | findLastIndex(false)
array | findLastIndex(foo in list)
array | findLastIndex(nil == nil)
array | findLastIndex(nil ?? true)
array | findLastIndex(ok)
array | findLastIndex(ok) < f64
array | findLastIndex(ok) ?? i
array | findLastIndex(str endsWith str)
array | findLastIndex(true)
array | findLastIndex(true) - i
array | get(0)
array | get(1)
array | get(i)
array | get(mean(1.0, array))
array | get(sum(array))
array | groupBy(# != #)
array | groupBy(# - #)
array | groupBy(# / 1.0)
array | groupBy(# / i)
array | groupBy(# == #)
array | groupBy(# == nil)
array | groupBy(# > #)
array | groupBy(# >= #)
array | groupBy(# ^ #)
array | groupBy(#)
array | groupBy($env != 0)
array | groupBy($env && false)
array | groupBy($env.foo)
array | groupBy($env?.[Bar])
array | groupBy($env?.[String])
array | groupBy($env?.[str])
array | groupBy($env?.foo)
array | groupBy($env?.foobar)
array | groupBy($env?.str)
array | groupBy(-#)
array | groupBy(0 ** 1.0)
array | groupBy(0)
array | groupBy(1)
array | groupBy(1.0 != #)
array | groupBy(1.0 != f64)
array | groupBy(1.0 ** 1)
array | groupBy(1.0 ** f64)
array | groupBy(1.0 == 1.0)
array | groupBy(1.0 ?? foo)
array | groupBy(1.0 ^ #)
array | groupBy(1.0)
array | groupBy(add(#, 0))
array | groupBy(array?.[i])
array | groupBy(bitnot(i))
array | groupBy(f64)
array | groupBy(false != false)
array | groupBy(false ?? false)
array | groupBy(false)
array | groupBy(first(array))
array | groupBy(foo)
array | groupBy(foo.Bar)
array | groupBy(foo.String())
array | groupBy(i)
array | groupBy(len(list))
array | groupBy(list?.[i])
array | groupBy(mean(1.0 ?? 1.0))
array | groupBy(not false)
array | groupBy(ok ?? str)
array | groupBy(ok)
array | groupBy(round(#))
array | groupBy(round(0))
array | groupBy(round(1.0))
array | groupBy(str)
array | groupBy(str[0:])
array | groupBy(string(1))
array | groupBy(sum(array))
array | groupBy(trimPrefix(str))
array | groupBy(true)
array | map(!ok)
array | map(# != 0)
array | map(# * #)
array | map(# ** i)
array | map(# + #)
array | map(# - #)
array | map(# .. #index)
array | map(# < #)
array | map(# == 0)
array | map(# > #)
array | map(# >= #)
array | map(# >= i)
array | map(# ?? #)
array | map(# ?? 0)
array | map(# ^ #)
array | map(#)
array | map(#) | any(ok)
array | map(#) | groupBy(foo)
array | map(#) | map($env?.foobar)
array | map(#) | map(1.0)
array | map(#) | map(foo)
array | map(#) | map(ok)
array | map(#) | one(ok)
array | map(#) | one(true)
array | map(#) | reduce(#)
array | map(#) | reduce(foo)
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)
array | map(#index) | filter(ok)
array | map(#index) | groupBy(#)
array | map(#index) | map(false)
array | map(#index) | map(list)
array | map($env != str)
array | map($env)
array | map($env) | any(.ok)
array | map($env) | map(#)
array | map($env.foo)
array | map($env.greet)
array | map($env.i)
array | map($env.list)
array | map($env.ok)
array | map($env.str)
array | map($env?.Bar)
array | map($env?.[Bar])
array | map($env?.[foobar])
array | map($env?.i)
array | map($env?.list)
array | map($env?.str)
array | map(-1)
array | map(0 - i)
array | map(0)
array | map(0) | reduce(#)
array | map(0) | sum(#)
array | map(0) | sum(f64)
array | map(1 ** #)
array | map(1 >= 1)
array | map(1)
array | map(1) ?? greet
array | map(1) | find(ok)
array | map(1) | groupBy(#)
array | map(1) | map(list)
array | map(1) | one(ok)
array | map(1) | reduce($env, array)
array | map(1.0 ** #)
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) | groupBy(false)
array | map(1.0) | groupBy(foo)
array | map(1.0) | map(0)
array | map(1.0) | reduce(foo)
array | map(1.0) | sortBy(#)
array | map([#])
array | map([$env])
array | map([foo])
array | map([list])
array | map(add(#, #))
array | map(add)
array | map(add) | map(greet)
array | map(add) | reduce(#)
array | map(array | findLast(true))
array | map(array)
array | map(array) == array
array | map(array) | any(false)
array | map(array) | findIndex(true)
array | map(bitshl(#, #))
array | map(f64 < 1.0)
array | map(f64 ^ #)
array | map(f64)
array | map(f64) ?? $env?.f64
array | map(f64) | findLastIndex(false)
array | map(f64) | one(array == $env)
array | map(f64) | reduce(#)
array | map(f64) | reduce(foo)
array | map(f64) | reduce(str, ok)
array | map(f64) | sortBy(i)
array | map(false && true)
array | map(false)
array | map(false) != list
array | map(false) | none(#)
array | map(foo)
array | map(foo) != array
array | map(foo) ?? greet
array | map(foo) | map(#)
array | map(foo) | reduce(#)
array | map(foo) | reduce(1.0)
array | map(foo) | sum(1.0)
array | map(foo.Bar)
array | map(foo.String)
array | map(foo?.Bar)
array | map(foo?.String())
array | map(foo?.String)
array | map(greet)
array | map(greet) | groupBy(true)
array | map(greet) | map(#)
array | map(i != $env)
array | map(i <= 1)
array | map(i ^ #)
array | map(i)
array | map(i) | filter(ok)
array | map(i) | groupBy(f64)
array | map(i) | reduce(add)
array | map(i) | sum(#)
array | map(if false { 0 } else { foo })
array | map(len($env))
array | map(let foobar = greet; foobar)
array | map(list)
array | map(list) | get(i)
array | map(max(#))
array | map(mean(#))
array | map(median(#))
array | map(nil == greet)
array | map(ok)
array | map(ok) | all(ok)
array | map(ok) | any(#)
array | map(ok) | groupBy(ok)
array | map(str)
array | map(str) | groupBy(#)
array | map(str) | map(#)
array | map(sum(array))
array | map(toJSON(f64))
array | map(toJSON(foo))
array | map(true != nil)
array | map(true ?? nil)
array | map(true)
array | map(true) | findLastIndex(#)
array | map(true) | reduce(foo)
array | map(type(foo))
array | max($env.f64)
array | max(0)
array | max(0, 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(-1.0)
array | mean(0 / 1)
array | mean(0)
array | mean(0, 1.0, array)
array | mean(1)
array | mean(1, 0)
array | mean(1, 1)
array | mean(1, 1.0)
array | mean(1.0)
array | mean(1.0) * f64
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(f64, 1.0)
array | mean(i)
array | mean(i, 0)
array | mean(i, f64)
array | median($env.array)
array | median($env?.array)
array | median(0)
array | median(0, i)
array | median(1 - 1.0)
array | median(1)
array | median(1, 1)
array | median(1.0)
array | median(1.0, 1.0)
array | median(1.0, 1.0) ** f64
array | median(1.0, f64)
array | median([array])
array | median(array)
array | median(f64)
array | median(f64) == $env?.ok
array | median(f64, 1.0)
array | median(i)
array | min(-0)
array | min(0)
array | min(0, 1.0)
array | min(0, array)
array | min(0, f64)
array | min(1)
array | min(1, 1)
array | min(1.0)
array | min(1.0, 1.0)
array | min(1.0, i)
array | min(array)
array | min(array, i)
array | min(f64 ?? f64)
array | min(f64)
array | min(f64) | max(1.0, f64)
array | min(f64, 0)
array | min(i)
array | min(i, 1.0)
array | min(i, i)
array | min(list | map(#index))
array | none(!true)
array | none(# != $env)
array | none(# != 1)
array | none(# != 1.0)
array | none(# != nil)
array | none(# < #)
array | none(# <= #)
array | none(# == #)
array | none(# == $env)
array | none(# == nil)
array | none($env != 1.0)
array | none($env.ok)
array | none(1 in array)
array | none(1.0 < #)
array | none(1.0 == i)
array | none(1.0 > #)
array | none(false ?? foo)
array | none(false)
array | none(i == #)
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 != false)
array | one(false)
array | one(false) || ok
array | one(i == nil)
array | one(list | reduce(true, ok))
array | one(nil != f64)
array | one(nil == #)
array | one(nil == 1)
array | one(nil == foo)
array | one(ok)
array | one(true)
array | one(true) ?? f64
array | reduce(# != #)
array | reduce(# * #)
array | reduce(# * i)
array | reduce(# + #)
array | reduce(# - f64)
array | reduce(# / #acc)
array | reduce(# == 1)
array | reduce(# == 1.0)
array | reduce(# > #index)
array | reduce(# >= 1.0)
array | reduce(# | bitshl(0))
array | reduce(#)
array | reduce(#) != f64
array | reduce(#) / f64
array | reduce(#) > f64
array | reduce(#) ?? array
array | reduce(#) ^ f64
array | reduce(#, $env)
array | reduce(#, 0 ^ 0)
array | reduce(#, 0)
array | reduce(#, 1 / 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(#, foo) > i
array | reduce(#, greet)
array | reduce(#, i)
array | reduce(#, list)
array | reduce(#, nil)
array | reduce(#, ok)
array | reduce(#, str)
array | reduce(#, true)
array | reduce(#acc != 1)
array | reduce(#acc * 1)
array | reduce(#acc ?? nil)
array | reduce(#acc)
array | reduce(#acc) - f64
array | reduce(#acc) == greet
array | reduce(#acc) == {foo: f64, foo: 1}
array | reduce(#acc, $env)
array | reduce(#acc, 0)
array | reduce(#acc, 1.0) in [str, foo]
array | reduce(#acc, add)
array | reduce(#acc, array)
array | reduce(#acc, f64)
array | reduce(#acc, foo)
array | reduce(#acc, greet)
array | reduce(#acc, i)
array | reduce(#acc, nil)
array | reduce(#acc, true)
array | reduce(#index <= f64)
array | reduce(#index >= 1)
array | reduce(#index)
array | reduce(#index, $env)
array | reduce(#index, array)
array | reduce(#index, f64)
array | reduce(#index, false)
array | reduce(#index, foo)
array | reduce(#index, greet) >= i
array | reduce(#index, i)
array | reduce(#index, list)
array | reduce(#index, nil)
array | reduce(#index, ok)
array | reduce(#index, str)
array | reduce($env != #)
array | reduce($env != array)
array | reduce($env == greet)
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, i)
array | reduce($env, list)
array | reduce($env, nil)
array | reduce($env, ok)
array | reduce($env, ok) | map(array)
array | reduce($env, str)
array | reduce($env, true)
array | reduce($env.ok)
array | reduce($env?.Bar)
array | reduce($env?.[Bar])
array | reduce($env?.[String])
array | reduce($env?.[String]?.foo())
array | reduce($env?.array)
array | reduce($env?.f64)
array | reduce($env?.foo)
array | reduce($env?.i)
array | reduce($env?.list, foo?.String)
array | reduce(-#)
array | reduce(-1.0, str)
array | reduce(0 + i)
array | reduce(0 .. #)
array | reduce(0 <= #index)
array | reduce(0 == #)
array | reduce(0 > #)
array | reduce(0)
array | reduce(0) ?? add
array | reduce(0, $env)
array | reduce(0, 0)
array | reduce(0, 1.0)
array | reduce(0, array)
array | reduce(0, foo)
array | reduce(0, i)
array | reduce(0, list)
array | reduce(0, ok)
array | reduce(0, str)
array | reduce(0, true)
array | reduce(1 ** #acc)
array | reduce(1 ?? str)
array | reduce(1)
array | reduce(1, 0)
array | reduce(1, 1)
array | reduce(1, 1.0)
array | reduce(1, add)
array | reduce(1, array)
array | reduce(1, f64)
array | reduce(1, false)
array | reduce(1, foo)
array | reduce(1, greet)
array | reduce(1, nil)
array | reduce(1, ok)
array | reduce(1, str)
array | reduce(1.0 * 1)
array | reduce(1.0 ** #)
array | reduce(1.0 > 1.0)
array | reduce(1.0 ?? $env)
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, greet)
array | reduce(1.0, i)
array | reduce(1.0, list)
array | reduce(1.0, nil)
array | reduce(1.0, ok)
array | reduce(1.0, str)
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, foo)
array | reduce(add, greet)
array | reduce(add, i)
array | reduce(add, list)
array | reduce(add, nil)
array | reduce(add, ok)
array | reduce(add, str)
array | reduce(all($env, true))
array | reduce(array)
array | reduce(array) | map(#)
array | reduce(array) | none(true)
array | reduce(array) | reduce(false)
array | reduce(array) | sortBy(#)
array | reduce(array, $env)
array | reduce(array, 0)
array | reduce(array, 1)
array | reduce(array, 1.0)
array | reduce(array, f64)
array | reduce(array, false)
array | reduce(array, foo)
array | reduce(array, greet)
array | reduce(array, list)
array | reduce(array, nil)
array | reduce(array, ok)
array | reduce(bitnot(#))
array | reduce(concat(list), $env.greet)
array | reduce(f64 ^ 0)
array | reduce(f64)
array | reduce(f64, $env)
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, 0)
array | reduce(false, 1)
array | reduce(false, 1.0)
array | reduce(false, add)
array | reduce(false, false)
array | reduce(false, foo)
array | reduce(false, greet)
array | reduce(false, i)
array | reduce(false, list)
array | reduce(false, nil)
array | reduce(false, ok)
array | reduce(false, true)
array | reduce(foo)
array | reduce(foo) ?? list
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, false)
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(foo.String, $env?.[Bar])
array | reduce(foo?.Bar)
array | reduce(greet != $env)
array | reduce(greet(str), int(1.0))
array | reduce(greet)
array | reduce(greet, $env)
array | reduce(greet, 0)
array | reduce(greet, 1)
array | reduce(greet, 1.0)
array | reduce(greet, add)
array | reduce(greet, array)
array | reduce(greet, f64)
array | reduce(greet, false)
array | reduce(greet, foo)
array | reduce(greet, greet)
array | reduce(greet, i)
array | reduce(greet, nil)
array | reduce(greet, str)
array | reduce(greet, true)
array | reduce(i * #)
array | reduce(i > 1)
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, array)
array | reduce(i, false)
array | reduce(i, foo)
array | reduce(i, greet)
array | reduce(i, i)
array | reduce(i, list)
array | reduce(i, nil)
array | reduce(i, ok)
array | reduce(i, true)
array | reduce(int(#))
array | reduce(list)
array | reduce(list, $env)
array | reduce(list, 0)
array | reduce(list, 1)
array | reduce(list, 1.0)
array | reduce(list, add)
array | reduce(list, array)
array | reduce(list, false)
array | reduce(list, foo)
array | reduce(list, greet)
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(#))
array | reduce(median(0))
array | reduce(nil != #)
array | reduce(not false)
array | reduce(not true)
array | reduce(ok ?? 1.0)
array | reduce(ok)
array | reduce(ok) ?? array
array | reduce(ok, $env)
array | reduce(ok, 0)
array | reduce(ok, 1.0)
array | reduce(ok, add)
array | reduce(ok, array)
array | reduce(ok, false)
array | reduce(ok, foo)
array | reduce(ok, greet)
array | reduce(ok, i)
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.0)
array | reduce(str, 1)
array | reduce(str, 1.0)
array | reduce(str, abs(1))
array | reduce(str, add)
array | reduce(str, array)
array | reduce(str, false)
array | reduce(str, foo)
array | reduce(str, greet)
array | reduce(str, i)
array | reduce(str, list)
array | reduce(str, nil)
array | reduce(str, ok)
array | reduce(string(1.0))
array | reduce(string(add))
array | reduce(toJSON(array))
array | reduce(true and true)
array | reduce(true)
array | reduce(true, $env)
array | reduce(true, 0)
array | reduce(true, 1)
array | reduce(true, 1.0)
array | reduce(true, add)
array | reduce(true, array)
array | reduce(true, foo)
array | reduce(true, i)
array | reduce(true, nil)
array | reduce(true, ok)
array | reduce(true, str)
array | reduce(true, true)
array | reduce(type(greet))
array | sortBy(# + #)
array | sortBy(# + 1.0)
array | sortBy(# + i)
array | sortBy(# / #)
array | sortBy(# / 1.0)
array | sortBy(# ?? ok)
array | sortBy(# ^ 1.0)
array | sortBy(# ^ f64)
array | sortBy(# | bitushr(#))
array | sortBy(#)
array | sortBy(#) ?? [0, $env]
array | sortBy(#) | all(ok)
array | sortBy(#) | groupBy(#)
array | sortBy(#) | groupBy(f64)
array | sortBy(#) | map(#)
array | sortBy(#) | map(#index)
array | sortBy(#) | map(foo)
array | sortBy(#) | reduce(#)
array | sortBy(#) | reduce(1.0)
array | sortBy(#) | reduce(ok)
array | sortBy(#) | sum(1)
array | sortBy($env.add(#, 1))
array | sortBy($env?.[str])
array | sortBy($env?.i)
array | sortBy(-#)
array | sortBy(-0)
array | sortBy(0 / #)
array | sortBy(0 ^ #)
array | sortBy(0)
array | sortBy(0) | median(1.0)
array | sortBy(0) | reduce(0)
array | sortBy(0) | reduce(foo, foo)
array | sortBy(1)
array | sortBy(1.0 ^ #)
array | sortBy(1.0)
array | sortBy(1.0) != list
array | sortBy(1.0) ?? i
array | sortBy(1.0) | findLastIndex(ok)
array | sortBy(1.0) | one(true)
array | sortBy(1.0) | reduce($env)
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 - 1)
array | sortBy(i)
array | sortBy(i) | sortBy(#)
array | sortBy(max(#))
array | sortBy(mean(#))
array | sortBy(median(#))
array | sortBy(reduce(array, str, foo))
array | sortBy(str + str)
array | sortBy(str)
array | sortBy(str) | reduce(#)
array | sortBy(sum(array))
array | sortBy(true ? # : $env)
array | sortBy(type(f64))
array | sortBy(type(true))
array | sum(# ** #)
array | sum(# + #)
array | sum(# - #)
array | sum(# ?? 0)
array | sum(# ^ 1)
array | sum(# ^ i)
array | sum(#)
array | sum(#) < 1.0 ^ 1.0
array | sum(#) <= f64
array | sum(#) ^ f64
array | sum($env.f64)
array | sum($env.i)
array | sum(-0)
array | sum(-1)
array | sum(-i)
array | sum(0 ** 1.0)
array | sum(0)
array | sum(0.1)
array | sum(1 * f64)
array | sum(1 + 1.0)
array | sum(1 | max(1.0))
array | sum(1)
array | sum(1) not in array
array | sum(1.0 * #)
array | sum(1.0 ** #)
array | sum(1.0 - 1.0)
array | sum(1.0)
array | sum(1.0) < i
array | sum(1.0) > 1.0 ^ i
array | sum(array?.[i])
array | sum(bitnot(1))
array | sum(bitshl(#, #))
array | sum(ceil(#))
array | sum(f64)
array | sum(f64) ?? str
array | sum(float(f64))
array | sum(i + 0)
array | sum(i | bitshr(1))
array | sum(i)
array | sum(i) > -0
array | sum(int(#))
array | sum(max(#, 1))
array | sum(median(#))
array | sum(round(1.0))
array | take(0)
array | take(0) | one(ok)
array | take(1)
array | take(i)
array; $env.ok
array; add
array; array
array; f64
array; f64; array
array; foo
array; foo.String
array; greet
array; i
array; list
array; ok
array?.[$env.i]
array?.[$env?.i]
array?.[-0]
array?.[-i]
array?.[0 % i]
array?.[1.0 ?? foo]
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 ?? f64
array?.[i] % i
array?.[i] * f64
array?.[i] * i
array?.[i] ** 0 ?? ok
array?.[i] ** i
array?.[i] + f64
array?.[i] - f64
array?.[i] - i
array?.[i] .. i
array?.[i] .. i ?? 1.0
array?.[i] / ceil(f64)
array?.[i] / f64
array?.[i] / float(0)
array?.[i] / i
array?.[i] < 0 + 1.0
array?.[i] < f64
array?.[i] < i
array?.[i] <= 1.0 <= $env
array?.[i] <= f64
array?.[i] <= i
array?.[i] == $env.i
array?.[i] == -f64
array?.[i] == array ?? $env
array?.[i] == f64
array?.[i] == i
array?.[i] > f64
array?.[i] > i
array?.[i] >= f64
array?.[i] >= i
array?.[i] ?? $env?.Bar.greet
array?.[i] ?? f64
array?.[i] ?? foo?.String()
array?.[i] ?? greet
array?.[i] ?? ok
array?.[i] ?? str
array?.[i] ^ f64
array?.[i] ^ f64 <= 1
array?.[i] ^ i
array?.[i] in array
array?.[i] not in array
array?.[i] | add(i)
array?.[i] | bitand(1)
array?.[i] | bitshr(0)
array?.[i] | max(1)
array?.[i] | mean(1)
array?.[i] | min(0)
array?.[i] | min(array)
array?.[int(1.0)]
array?.[len(list)]
array?.[list | count(ok)]
array?.[max(0)]
array?.[mean(1)]
array?.[mean(i)]
array?.[median(1)]
array[$env | count(true):]
array[$env.i:]
array[$env?.i:]
array[-i:]
array[0:] | any(ok)
array[0:] | map(greet)
array[0:] | reduce(#)
array[0:] | reduce(add)
array[0:] | reduce(str)
array[0:] | sortBy(#)
array[0:]?.[i]
array[1:] == list
array[1:] | any(ok)
array[1:] | findLast(false)
array[1:] | reduce(#)
array[1:] | reduce(foo)
array[1:] | reduce(list, nil)
array[1:] | sum(#)
array[1:] | sum(1.0)
array[1:]?.[i]
array[:$env.i]
array[:-1]
array[:-i]
array[:0 ?? foo]
array[:0] ?? ok
array[:0] | groupBy(str)
array[:0] | sortBy(#)
array[:0] | sum(str)
array[:1 ?? 0]
array[:1 ?? false]
array[:1 ?? greet]
array[:1] | findLastIndex(false)
array[:1] | sortBy(#)
array[:1] | sum(#)
array[:]
array[:] | map(f64)
array[:] | reduce(f64)
array[:]?.[i]
array[:i]
array[:i] ?? !ok
array[:i] | map(#)
array[:i] | map(f64)
array[:i] | reduce($env)
array[:i] | reduce(0)
array[:i] | sortBy(array)
array[:i] | sortBy(ok)
array[:int(1.0)]
array[:max(i)]
array[:nil ?? 0]
array[:reduce(array, 1)]
array[:sum(array)]
array[array?.[i]:]
array[bitnot(1):]
array[i % 1:]
array[i:]
array[i:] ?? list
array[i:] | findIndex(false)
array[i:] | groupBy(1)
array[i:]?.[i]
array[int(1):]
array[len($env):]
array[max(0):]
array[sum(array):]
bitand($env.i, i)
bitand(1, 1) | median(0)
bitand(1, i) * i
bitand(i, 0) + f64
bitand(i, 0) > i
bitand(i, i)
bitand(i, sum(array))
bitnand($env.i, i)
bitnand(-i, i)
bitnand(i + i, i)
bitnand(i, i)
bitnand(i, i) % i
bitnand(sum(array), i)
bitnot($env | findIndex(true))
bitnot($env | findLastIndex(ok))
bitnot($env | findLastIndex(true))
bitnot($env.i)
bitnot($env?.[str]?.[i])
bitnot($env?.i)
bitnot(-$env.i)
bitnot(-0 ?? 1)
bitnot(-0)
bitnot(-1)
bitnot(-i)
bitnot(-min(array, 1.0))
bitnot(0 * 1)
bitnot(0 * i)
bitnot(0 + 1)
bitnot(0 - 0)
bitnot(0 - 1)
bitnot(0 - i)
bitnot(0 ?? $env)
bitnot(0 ?? 1.0)
bitnot(0 ?? foo)
bitnot(0 ?? greet)
bitnot(0 ?? i)
bitnot(0 ?? str)
bitnot(0 | min(0))
bitnot(0) + f64
bitnot(0) + i
bitnot(0) - $env.i
bitnot(0) < f64
bitnot(0) <= f64
bitnot(0) == $env?.[Bar]
bitnot(0) > $env?.i
bitnot(0) ?? array
bitnot(0) ?? ok
bitnot(0) in array
bitnot(0) not in array
bitnot(0) | min(array, 0)
bitnot(1 % 1)
bitnot(1 % i)
bitnot(1 * 0)
bitnot(1 + 1)
bitnot(1 - i)
bitnot(1 ?? $env)
bitnot(1 ?? 0)
bitnot(1 ?? 1)
bitnot(1 ?? foo)
bitnot(1 ?? list)
bitnot(1 ?? ok)
bitnot(1 ?? true)
bitnot(1 | bitshr(i))
bitnot(1 | min(i))
bitnot(1) != i
bitnot(1) != i && false
bitnot(1) * i
bitnot(1) - f64
bitnot(1) == f64
bitnot(1) > i
bitnot(1) ?? list
bitnot(1) ^ f64
bitnot(1) | bitand(1)
bitnot(abs(0))
bitnot(abs(1))
bitnot(abs(i))
bitnot(array | count(false))
bitnot(array | count(ok))
bitnot(array | findIndex(ok))
bitnot(array | findLast(true))
bitnot(array | reduce(#))
bitnot(array | reduce(i))
bitnot(array | sum(#))
bitnot(array | sum(i))
bitnot(array?.[0])
bitnot(array?.[i])
bitnot(bitand(1, 0))
bitnot(bitnot(0 ?? foo))
bitnot(bitnot(0))
bitnot(bitnot(1))
bitnot(bitnot(i))
bitnot(count(array, false))
bitnot(count(array, true))
bitnot(count(list, false))
bitnot(count(list, ok))
bitnot(false ? nil : 1)
bitnot(false ?: 1)
bitnot(findIndex($env, ok))
bitnot(findIndex(array, ok))
bitnot(findIndex(list, ok))
bitnot(findLastIndex(array, true))
bitnot(findLastIndex(list, ok))
bitnot(first(array))
bitnot(i % i)
bitnot(i * 0)
bitnot(i * 1)
bitnot(i + 0)
bitnot(i - 0)
bitnot(i - 1)
bitnot(i ?? $env)
bitnot(i ?? 0)
bitnot(i ?? array)
bitnot(i ?? foo)
bitnot(i ?? list)
bitnot(i ?? ok)
bitnot(i ?? str)
bitnot(i ?? true)
bitnot(i | add(i))
bitnot(i | min(1.0))
bitnot(i)
bitnot(i) != f64
bitnot(i) != i
bitnot(i) * -1.0
bitnot(i) + i
bitnot(i) - i
bitnot(i) > f64
bitnot(i) ?? $env.str
bitnot(i) ?? ok
bitnot(i) | bitshr(0)
bitnot(i) | median(array)
bitnot(if false { f64 } else { 0 })
bitnot(if true { 1 } else { 0 })
bitnot(if true { 1 } else { foo })
bitnot(int(0))
bitnot(int(1))
bitnot(int(1.0))
bitnot(int(f64))
bitnot(int(f64)) ** i
bitnot(int(i))
bitnot(last(array))
bitnot(len($env))
bitnot(len(array))
bitnot(len(list))
bitnot(len(str))
bitnot(list | count(true))
bitnot(list | findIndex(ok))
bitnot(list | findLastIndex(ok))
bitnot(list | findLastIndex(true))
bitnot(list | reduce(1))
bitnot(list | sum(1))
bitnot(max(0))
bitnot(max(1))
bitnot(max(1, 0))
bitnot(max(array))
bitnot(max(array, 0))
bitnot(max(i))
bitnot(min(0))
bitnot(min(1))
bitnot(min(array))
bitnot(min(i))
bitnot(min(i, 0))
bitnot(nil ?? 1)
bitnot(nil ?? i)
bitnot(reduce(array, #))
bitnot(reduce(array, 0))
bitnot(reduce(list, i))
bitnot(reduce(reverse(list), #index))
bitnot(sum($env, 0))
bitnot(sum($env, 1))
bitnot(sum(array))
bitnot(sum(array, #))
bitnot(sum(list, 0))
bitnot(sum(list, 1))
bitnot(sum(list, i))
bitor($env.i, i)
bitor(1, i) > f64
bitor(i, 1) ?? add
bitor(i, array?.[i])
bitor(i, i)
bitor(i, len(list))
bitor(i, list | count(true))
bitshl(i, $env?.i)
bitshl(i, i)
bitshl(int(f64), i)
bitshr(0, 1) + f64
bitshr(1, 0) + i
bitshr(i, $env?.i)
bitshr(i, i)
bitshr(i, sum(array))
bitushr(1, 0) .. i
bitushr(array | count(ok), i)
bitushr(i, $env?.i)
bitushr(i, i)
bitxor(i, 1 ?? array)
bitxor(i, i)
bitxor(i, i) ?? $env?.f64
ceil($env | findIndex(true))
ceil($env | reduce(1.0, nil))
ceil($env | sum(0))
ceil($env | sum(1))
ceil($env | sum(1.0))
ceil($env | sum(f64))
ceil($env | sum(i))
ceil($env.f64)
ceil($env.f64) not in array
ceil($env.i)
ceil($env?.[str] | sum(1.0))
ceil($env?.array | findLast(ok))
ceil($env?.array?.[i])
ceil($env?.f64)
ceil($env?.i)
ceil($env?.i) < f64
ceil(--i)
ceil(-0)
ceil(-1)
ceil(-1.0)
ceil(-f64)
ceil(-i)
ceil(0 * 0)
ceil(0 * 1)
ceil(0 * 1.0)
ceil(0 * f64)
ceil(0 ** 1)
ceil(0 ** 1.0)
ceil(0 ** f64)
ceil(0 + 0)
ceil(0 + 1)
ceil(0 + 1.0)
ceil(0 + i)
ceil(0 - 0)
ceil(0 - 1.0)
ceil(0 - f64)
ceil(0 - i)
ceil(0 / 0)
ceil(0 / 1)
ceil(0 / 1.0)
ceil(0 / f64)
ceil(0 / i)
ceil(0 ?? $env)
ceil(0 ?? 0)
ceil(0 ?? 1)
ceil(0 ?? array)
ceil(0 ?? f64)
ceil(0 ?? false)
ceil(0 ?? foo)
ceil(0 ?? greet)
ceil(0 ?? list)
ceil(0 ?? nil)
ceil(0 ?? ok)
ceil(0 ?? true)
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) != $env?.[String]
ceil(0) != f64
ceil(0) * f64
ceil(0) ** 0 ^ 1.0
ceil(0) ** i
ceil(0) / i
ceil(0) <= f64
ceil(0) ?? list
ceil(0) ?? type(1.0)
ceil(0) in {foo: greet}?.str
ceil(0.0)
ceil(0.1)
ceil(1 % 1)
ceil(1 * 0)
ceil(1 * f64)
ceil(1 ** 1)
ceil(1 ** 1.0)
ceil(1 ** f64)
ceil(1 + 0)
ceil(1 + 1.0)
ceil(1 + f64)
ceil(1 + i)
ceil(1 - 0)
ceil(1 - 1.0)
ceil(1 / 1.0)
ceil(1 ?? $env)
ceil(1 ?? f64)
ceil(1 ?? greet)
ceil(1 ?? i)
ceil(1 ?? nil)
ceil(1 ?? true)
ceil(1 ^ 1.0)
ceil(1 ^ i)
ceil(1 | bitor(0))
ceil(1 | min(1.0))
ceil(1) != i
ceil(1) - i
ceil(1) / i
ceil(1) > f64
ceil(1) ?? i
ceil(1) ^ i
ceil(1) | median(1.0, 1)
ceil(1) | min(array)
ceil(1); f64
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 ** 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 - 0)
ceil(1.0 - 1)
ceil(1.0 - 1.0)
ceil(1.0 - f64)
ceil(1.0 - i)
ceil(1.0 / 0)
ceil(1.0 / 1)
ceil(1.0 / 1.0)
ceil(1.0 / f64)
ceil(1.0 ?? $env)
ceil(1.0 ?? 0)
ceil(1.0 ?? 1)
ceil(1.0 ?? add)
ceil(1.0 ?? array)
ceil(1.0 ?? f64)
ceil(1.0 ?? false)
ceil(1.0 ?? foo)
ceil(1.0 ?? greet)
ceil(1.0 ?? i)
ceil(1.0 ?? list)
ceil(1.0 ?? nil)
ceil(1.0 ?? ok)
ceil(1.0 ?? true)
ceil(1.0 ^ 0)
ceil(1.0 ^ 1)
ceil(1.0 ^ 1.0)
ceil(1.0 ^ f64)
ceil(1.0 ^ i)
ceil(1.0 | max(array))
ceil(1.0 | mean(1, 1.0))
ceil(1.0 | mean(1.0))
ceil(1.0 | median(array))
ceil(1.0 | min(1))
ceil(1.0) != $env or $env
ceil(1.0) != f64
ceil(1.0) ** f64
ceil(1.0) <= f64
ceil(1.0) <= i
ceil(1.0) == nil ? foo : str
ceil(1.0) > i
ceil(1.0) >= f64
ceil(1.0) ?? add
ceil(1.0) ?? list
ceil(1.0) not in array
ceil(1.0) | mean(1)
ceil(1.1)
ceil(abs(0))
ceil(abs(1.0))
ceil(abs(f64))
ceil(abs(i))
ceil(array | count(ok))
ceil(array | mean(1.0))
ceil(array | reduce(#))
ceil(array | reduce(#, greet))
ceil(array | reduce(i, f64))
ceil(array | sum(#))
ceil(array | sum(0))
ceil(array | sum(f64))
ceil(array?.[0])
ceil(array?.[i])
ceil(bitnot(0))
ceil(bitnot(1))
ceil(ceil(0))
ceil(ceil(1))
ceil(ceil(1.0))
ceil(ceil(f64))
ceil(ceil(i))
ceil(count($env, false))
ceil(count($env, true))
ceil(f64 * 0)
ceil(f64 * 1)
ceil(f64 * 1.0)
ceil(f64 * f64)
ceil(f64 ** 0)
ceil(f64 ** 1)
ceil(f64 ** 1.0)
ceil(f64 ** i)
ceil(f64 + 1)
ceil(f64 + 1.0)
ceil(f64 + f64)
ceil(f64 - 1)
ceil(f64 - 1.0)
ceil(f64 / 0)
ceil(f64 / 1)
ceil(f64 / 1.0)
ceil(f64 / f64)
ceil(f64 / i)
ceil(f64 ?? $env)
ceil(f64 ?? 0)
ceil(f64 ?? 1.0)
ceil(f64 ?? array)
ceil(f64 ?? f64)
ceil(f64 ?? false)
ceil(f64 ?? greet)
ceil(f64 ?? i)
ceil(f64 ?? true)
ceil(f64 ^ 0)
ceil(f64 ^ 1.0)
ceil(f64 ^ i)
ceil(f64 | max(1))
ceil(f64 | median(1))
ceil(f64 | min(1.0))
ceil(f64)
ceil(f64) != -f64
ceil(f64) != i
ceil(f64) * f64
ceil(f64) * i
ceil(f64) - i
ceil(f64) / 1 + i
ceil(f64) == f64
ceil(f64) == i
ceil(f64) ^ f64
ceil(f64) ^ i
ceil(f64) | median(1)
ceil(f64) | median(1.0, i, i)
ceil(false ? 1.0 : 1)
ceil(false ?: 0)
ceil(false ?: 1)
ceil(false ?: i)
ceil(findIndex($env, true))
ceil(findIndex(array, true))
ceil(findLast(array, ok))
ceil(findLastIndex($env, true))
ceil(findLastIndex(array, true))
ceil(first(array))
ceil(float(0))
ceil(float(1))
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(f64)) ?? list
ceil(floor(i))
ceil(i % 1) not in array
ceil(i % i)
ceil(i * 1)
ceil(i * 1.0)
ceil(i * i)
ceil(i ** 0)
ceil(i ** 1)
ceil(i ** 1.0)
ceil(i ** f64)
ceil(i + 1)
ceil(i + 1.0)
ceil(i + i)
ceil(i - 0)
ceil(i - 1.0)
ceil(i - i)
ceil(i / 0)
ceil(i / 1)
ceil(i / 1.0)
ceil(i / f64)
ceil(i / i)
ceil(i ?? 0)
ceil(i ?? add)
ceil(i ?? array)
ceil(i ?? foo)
ceil(i ?? true)
ceil(i ^ 0)
ceil(i ^ 1)
ceil(i ^ 1.0)
ceil(i ^ f64)
ceil(i ^ i)
ceil(i | min(0))
ceil(i | min(1.0))
ceil(i | min(array))
ceil(i)
ceil(i) != 0 ?: 1.0
ceil(i) != i
ceil(i) - i
ceil(i) == i
ceil(i) > i
ceil(i) >= f64
ceil(i) >= min(1)
ceil(i) ?? -1.0
ceil(if false { false } else { f64 })
ceil(if false { str } else { 1.0 })
ceil(if false { true } else { 0 })
ceil(if ok { 0 } else { 0 })
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(let foobar = f64; foobar + 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(array, 1.0))
ceil(max(f64))
ceil(max(f64, f64))
ceil(max(i))
ceil(mean(0))
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(mean(mean(1.0)))
ceil(median(0))
ceil(median(1))
ceil(median(1.0))
ceil(median(1.0, 0))
ceil(median(1.0, array))
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(min(i))
ceil(nil ?? 1)
ceil(nil ?? i)
ceil(reduce($env, 1, $env))
ceil(reduce(array, #))
ceil(reduce(array, #acc))
ceil(reduce(array, 1.0))
ceil(reduce(array, f64))
ceil(reduce(list, 0))
ceil(reduce(list, 1))
ceil(round(0))
ceil(round(1))
ceil(round(1.0))
ceil(round(f64))
ceil(round(i))
ceil(sum($env, f64))
ceil(sum($env.array))
ceil(sum(array))
ceil(sum(array, #))
ceil(sum(list, 1.0))
ceil(sum(list, f64))
ceil({foo: 1.0}?.foo)
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 | map(greet))
concat($env.array)
concat($env.list)
concat($env?.array | sortBy(#))
concat($env?.array)
concat($env?.list)
concat(0 .. 1)
concat(0 .. i)
concat(1 .. 0)
concat(1 .. 1)
concat(1 .. i)
concat(1..i)
concat([$env, $env])
concat([$env, 1])
concat([$env, add])
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([add, $env])
concat([add])
concat([array, 1.0])
concat([array, 1])
concat([array])
concat([f64, foo])
concat([f64])
concat([false, $env])
concat([false])
concat([foo, 1.0])
concat([foo, array])
concat([foo])
concat([greet, 0])
concat([greet])
concat([i, 1.0])
concat([i])
concat([list])
concat([nil])
concat([ok, $env])
concat([ok])
concat([str])
concat([true, list])
concat([true, str])
concat([true])
concat([true], array)
concat(array ?? $env)
concat(array ?? 1)
concat(array ?? add)
concat(array ?? f64)
concat(array ?? greet)
concat(array ?? nil)
concat(array ?? true)
concat(array | map(#))
concat(array | map($env))
concat(array | map(foo))
concat(array | sortBy(#))
concat(array | sortBy(f64))
concat(array | sortBy(i))
concat(array | take(0))
concat(array)
concat(array) == array
concat(array) == list
concat(array) | all(ok)
concat(array) | any(false)
concat(array) | any(ok)
concat(array) | count(1.0 >= f64)
concat(array) | count(ok)
concat(array) | groupBy(#)
concat(array) | groupBy(0)
concat(array) | groupBy(1.0)
concat(array) | groupBy(true)
concat(array) | map(0)
concat(array) | map(1.0)
concat(array) | map(f64)
concat(array) | map(list)
concat(array) | map(ok)
concat(array) | max(1.0)
concat(array) | reduce(#)
concat(array) | reduce(1, foo)
concat(array) | reduce(str)
concat(array) | sortBy(f64)
concat(array) | sum(#)
concat(array)?.[i]
concat(array, [greet])
concat(array, array)
concat(array, array)?.[i]
concat(array, array, [list])
concat(array, list)
concat(array[0:])
concat(array[1:])
concat(array[:0])
concat(array[:1])
concat(array[:])
concat(array[i:])
concat(concat(array))
concat(concat(array, array))
concat(concat(list))
concat(false ?: array)
concat(false ?: list)
concat(filter($env, false))
concat(flatten($env.array))
concat(flatten(array))
concat(flatten(list))
concat(i .. 0)
concat(i..i)
concat(keys($env))
concat(keys({foo: array, foo: i}))
concat(list ?? $env)
concat(list ?? 1)
concat(list ?? 1.0)
concat(list ?? foo)
concat(list ?? i)
concat(list ?? str)
concat(list ?? true)
concat(list | filter(ok))
concat(list | map(#))
concat(list | map($env))
concat(list | map(.String))
concat(list | map(1))
concat(list | map(1.0))
concat(list | map(foo))
concat(list | map(list), array)
concat(list | sortBy(1.0))
concat(list | sortBy(i))
concat(list)
concat(list) == [1, str]
concat(list) | any(ok)
concat(list) | count(false)
concat(list) | findIndex(true)
concat(list) | groupBy(#)
concat(list) | groupBy(0)
concat(list) | groupBy(1)
concat(list) | groupBy(1.0)
concat(list) | groupBy(foo)
concat(list) | map(0)
concat(list) | map(add)
concat(list) | map(f64)
concat(list) | map(foo)
concat(list) | none(ok)
concat(list) | reduce(#)
concat(list) | reduce(1.0, foo)
concat(list) | reduce(f64)
concat(list) | reduce(foo)
concat(list) | reduce(i, str)
concat(list) | sum(1)
concat(list) | sum(i)
concat(list)?.[i]
concat(list, $env.array)
concat(list, array)
concat(list, array)?.[i]
concat(list, list | sortBy(i))
concat(list, list)
concat(list, list) | any(true)
concat(list, list)?.[i]
concat(list[1:])
concat(map($env, #index))
concat(map($env, $env))
concat(map($env, 1.0))
concat(map($env, array))
concat(map($env, array), list)
concat(map($env, f64))
concat(map($env, foo))
concat(map($env, list))
concat(map($env, ok))
concat(map(array, #))
concat(map(array, $env))
concat(map(array, 1))
concat(map(array, 1.0))
concat(map(array, f64))
concat(map(array, foo))
concat(map(list, #))
concat(map(list, $env))
concat(map(list, 0))
concat(map(list, 1.0))
concat(map(list, add))
concat(map(list, greet))
concat(map(list, i))
concat(map(list, str))
concat(reduce(list, array))
concat(reverse(array))
concat(reverse(list))
concat(sort($env))
concat(sort(array))
concat(sortBy(array, #))
concat(sortBy(array, 1.0))
concat(sortBy(list, 1.0))
concat(sortBy(list, i))
concat(toPairs($env))
concat(toPairs({foo: false, foo: add}))
concat(uniq(array))
concat(values($env))
count($env ?? f64, .greet and false)
count($env | filter(false))
count($env | map(false))
count($env | map(foo), ok)
count($env | map(ok))
count($env | map(true))
count($env, false) ^ i
count($env, ok) | bitushr(0)
count($env, true) ** i
count($env, true) <= 1.0 == $env
count($env, true) <= f64
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(0 .. 0, $env == list)
count(1 .. 0)
count([$env && false])
count([$env, true], 1 == $env)
count([false, false])
count([false, true])
count([false])
count([false], #)
count([foo] | filter(false))
count([nil], 1.0 >= 1.0)
count([ok])
count([ok], #)
count([true])
count(array ?? 0, 1.0 not in array)
count(array | filter(false))
count(array | filter(nil == #))
count(array | map(false))
count(array | map(ok))
count(array, !false)
count(array, # != #)
count(array, # != i)
count(array, # <= #)
count(array, # == nil)
count(array, # > #)
count(array, # >= 1)
count(array, # >= f64)
count(array, # >= i)
count(array, # not in array)
count(array, $env != #)
count(array, $env.ok)
count(array, $env?.false != nil and ok)
count(array, 0 <= 1.0)
count(array, 0 == #)
count(array, 0 == $env)
count(array, 1 != nil)
count(array, 1 == f64)
count(array, 1 > #)
count(array, 1.0 != #)
count(array, 1.0 != nil)
count(array, 1.0 == $env)
count(array, 1.0 == nil)
count(array, array | none(true))
count(array, f64 < #)
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, nil == 1.0)
count(array, nil == nil)
count(array, nil ?? false)
count(array, ok != false)
count(array, ok)
count(array, ok) ?? ok
count(array, ok) ^ f64
count(array, true == ok)
count(array, true) in array
count(array[:0])
count(filter($env, false))
count(filter(list, # != #))
count(filter(list, false))
count(groupBy(list, 1.0).str)
count(i .. 0)
count(keys($env), ok || #)
count(list ?? $env, $env?.ok)
count(list | filter(false))
count(list | map(false))
count(list | map(true))
count(list, # != foo)
count(list, # != nil)
count(list, # == foo)
count(list, #.Bar == nil)
count(list, #.Bar matches .Bar)
count(list, $env == $env)
count(list, $env in array)
count(list, $env?.ok)
count(list, 0 != nil)
count(list, 0 <= f64)
count(list, 0 == i)
count(list, 1 < i)
count(list, 1.0 < 1.0)
count(list, 1.0 == nil)
count(list, [#] | all(true))
count(list, add == $env)
count(list, f64 == nil)
count(list, false) ?? i
count(list, foo != $env)
count(list, greet != $env)
count(list, i == nil)
count(list, nil != 1.0)
count(list, nil != true)
count(list, not ok)
count(list, ok ?: .String)
count(list, ok)
count(list, ok) .. 1 | take(1)
count(list, str != $env)
count(list, true != nil)
count(list, true) >= f64
count(list[:0])
count(list[:i], ok)
count(list[array?.[i]:])
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(array, ok))
count(map(list, false))
count(map(list, ok))
count(map(list, true))
count(sort($env))
count(sort($env), # < #.str)
count(sort($env), #)
count(sort($env), #.str && #)
count(sort($env), -#.add)
count(sort($env), .greet?.[greet])
count(toPairs($env), 0 in #)
date(str, str)
duration(string(0))
duration(toJSON(0))
f64
f64 != $env == false
f64 != $env ?: false
f64 != $env ?? f64
f64 != $env ?? foo
f64 != $env and $env
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?.String
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
f64 != -1.0
f64 != 0 != nil
f64 != 0 != ok
f64 != 0 != true
f64 != 0 ** i
f64 != 0 + i
f64 != 0 - i
f64 != 0 == $env
f64 != 0 == false
f64 != 0 == nil
f64 != 0 ?: 1.0
f64 != 0 || $env
f64 != 1 ** i
f64 != 1 + 1.0
f64 != 1 / i
f64 != 1 == $env
f64 != 1 ?? $env
f64 != 1 and $env
f64 != 1 || $env
f64 != 1.0 != $env
f64 != 1.0 != nil
f64 != 1.0 * 1.0
f64 != 1.0 ** 0
f64 != 1.0 ** i
f64 != 1.0 + 1.0
f64 != 1.0 - 0
f64 != 1.0 - 1
f64 != 1.0 - i
f64 != 1.0 == true
f64 != 1.0 ?: add
f64 != 1.0 ?? $env?.[greet]
f64 != 1.0 ?? i
f64 != 1.0 ^ 1.0
f64 != 1.0 ^ i
f64 != 1.0 and $env
f64 != 1.0 and false
f64 != 1.0 or $env
f64 != 1.0 or true
f64 != abs(1.0)
f64 != abs(i)
f64 != array?.[i]
f64 != bitxor(i, i)
f64 != f64
f64 != f64 != $env
f64 != f64 && $env
f64 != f64 + 0
f64 != f64 == ok
f64 != f64 ?? foo
f64 != f64 ?? greet
f64 != f64 ^ f64 && false
f64 != f64 and true
f64 != false ?? foo
f64 != false ?? list
f64 != findIndex(list, true)
f64 != first($env)
f64 != float(i)
f64 != floor(f64)
f64 != floor(i)
f64 != foo ?? 0
f64 != greet ?? 1
f64 != greet ?? foo
f64 != greet ?? true
f64 != i
f64 != i != false
f64 != i && $env
f64 != i * f64
f64 != i + 1
f64 != i / 1
f64 != i == nil
f64 != i ?? 0
f64 != i ?? f64
f64 != i ^ 0
f64 != i ^ f64
f64 != i and $env
f64 != i and nil not in array
f64 != i and true
f64 != i or ok
f64 != int(1.0)
f64 != last($env)
f64 != last(array)
f64 != len($env)
f64 != len(array)
f64 != max(f64)
f64 != max(i)
f64 != mean(0)
f64 != mean(1.0)
f64 != mean(array)
f64 != mean(f64)
f64 != median(1.0)
f64 != median(array)
f64 != median(f64)
f64 != min(0)
f64 != min(1.0)
f64 != min(array, 1)
f64 != nil != $env
f64 != nil != false
f64 != nil != nil
f64 != nil && $env
f64 != nil ?: greet
f64 != nil ?? 1.0
f64 != nil ?? nil
f64 != nil or $env
f64 != nil || false
f64 != ok ?? $env
f64 != round(1)
f64 != round(1.0)
f64 != str ?? $env
f64 != sum($env, 0)
f64 != sum(array)
f64 * $env.f64
f64 * $env.i
f64 * $env?.f64
f64 * $env?.i
f64 * -f64
f64 * -i
f64 * 0 * 1.0
f64 * 0 + 1
f64 * 0 - 1.0
f64 * 0 - f64
f64 * 0 == $env
f64 * 0 ?? str
f64 * 0 ^ f64
f64 * 0 ^ max(i)
f64 * 0 in array
f64 * 1 != nil
f64 * 1 * 0
f64 * 1 * i
f64 * 1 < 1.0
f64 * 1 <= 0
f64 * 1 <= i
f64 * 1 == nil
f64 * 1 ?? $env?.String
f64 * 1 ?? false
f64 * 1 ?? i
f64 * 1 in array
f64 * 1.0
f64 * 1.0 != $env
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 <= f64
f64 * 1.0 == $env
f64 * 1.0 == 1
f64 * 1.0 == nil
f64 * 1.0 > 0
f64 * 1.0 ?? str
f64 * 1.0 ^ f64
f64 * 1.0 | max(0)
f64 * abs(1.0)
f64 * array?.[1]
f64 * array?.[i]
f64 * bitnot(0)
f64 * ceil(1.0)
f64 * ceil(f64)
f64 * f64
f64 * f64 * i
f64 * f64 + $env.f64
f64 * f64 - f64
f64 * f64 / i
f64 * f64 > 1
f64 * f64 ?? true
f64 * f64 ^ 1.0
f64 * float(0)
f64 * float(f64)
f64 * float(i)
f64 * floor(f64)
f64 * i
f64 * i != $env?.i
f64 * i != sum(array)
f64 * i ** 1.0
f64 * i == i
f64 * i == nil
f64 * i > $env?.f64
f64 * i ?? $env
f64 * i ?? groupBy($env, .greet)
f64 * i ?? str
f64 * i | max(array)
f64 * int(0)
f64 * int(1)
f64 * int(1.0)
f64 * int(i)
f64 * len($env)
f64 * len(foo.Bar)
f64 * len(str)
f64 * max(map(array, #))
f64 * median(1.0)
f64 * median(f64)
f64 * min(1.0, 0)
f64 * min(array)
f64 * reduce(array, #)
f64 * round(1.0)
f64 * sum($env, 1)
f64 * sum(array | sortBy(#))
f64 * sum(array)
f64 ** $env.f64
f64 ** $env.i
f64 ** $env?.array?.[i]
f64 ** $env?.f64
f64 ** $env?.i
f64 ** -1
f64 ** -1.0
f64 ** -f64
f64 ** -i
f64 ** 0 * i
f64 ** 0 ** f64
f64 ** 0 < f64
f64 ** 0 <= i
f64 ** 0 > i
f64 ** 0 >= 1.0
f64 ** 0 ?? i
f64 ** 0 ?? list / 0
f64 ** 0 ?? ok
f64 ** 1 != nil
f64 ** 1 - i
f64 ** 1 / 0
f64 ** 1 < f64
f64 ** 1 == i
f64 ** 1 > len($env)
f64 ** 1 ^ 1
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 >= 1.0
f64 ** 1.0 ?? f64
f64 ** 1.0 ?? list
f64 ** 1.0 ^ 1.0
f64 ** 1.0 ^ f64
f64 ** 1.0 not in array
f64 ** abs(mean(1.0))
f64 ** array?.[i]
f64 ** bitnot(0)
f64 ** f64
f64 ** f64 != $env || $env
f64 ** f64 * 0
f64 ** f64 * i
f64 ** f64 + 1.0
f64 ** f64 - 1.0
f64 ** f64 ?? $env?.[i]
f64 ** f64 ^ i
f64 ** f64 | median(0)
f64 ** float(0)
f64 ** float(1.0)
f64 ** floor(1.0)
f64 ** floor(i)
f64 ** i
f64 ** i + $env?.f64
f64 ** i == nil
f64 ** i >= i
f64 ** i ?? $env
f64 ** i ?? true
f64 ** i ^ i
f64 ** int(i)
f64 ** mean(1.0)
f64 ** mean(f64)
f64 ** min(1.0)
f64 ** min(f64)
f64 ** round(f64)
f64 ** sum(array)
f64 + $env or true
f64 + $env.f64
f64 + $env.i
f64 + $env?.f64
f64 + $env?.i
f64 + -0
f64 + -1
f64 + -1.0
f64 + -f64
f64 + -i
f64 + 0 * f64
f64 + 0 + array?.[i]
f64 + 0 - 1.0
f64 + 0 - f64
f64 + 0 ?? !false
f64 + 0 ^ 1.0
f64 + 0 ^ f64
f64 + 0.1
f64 + 1 * 0
f64 + 1 * f64
f64 + 1 * i
f64 + 1 ** 1.0
f64 + 1 / 1.0
f64 + 1 < 1.0
f64 + 1 <= 1.0
f64 + 1 > $env and false
f64 + 1 > 0
f64 + 1 ?? foo
f64 + 1 ^ f64
f64 + 1.0 != 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 <= 1.0
f64 + 1.0 == 0
f64 + 1.0 == i
f64 + 1.0 == nil
f64 + 1.0 > 0
f64 + 1.0 > i
f64 + 1.0 >= 1
f64 + 1.0 ?? 1
f64 + 1.0 ^ 0
f64 + 1.0 ^ 1.0
f64 + 1.0 not in array
f64 + 1.0 | max(1.0)
f64 + abs(f64)
f64 + abs(i)
f64 + array?.[i]
f64 + bitnot(i)
f64 + ceil(0)
f64 + ceil(1)
f64 + ceil(1.0)
f64 + count($env, true)
f64 + f64
f64 + f64 ** 1.0
f64 + f64 ?? 1
f64 + f64 ^ i
f64 + floor(0)
f64 + floor(i)
f64 + i
f64 + i != 0
f64 + i ** 1
f64 + i - 1
f64 + i / i
f64 + i == f64
f64 + i == i
f64 + i > 1.0
f64 + i > f64
f64 + i in array
f64 + i not in array
f64 + int(i)
f64 + mean(1.0)
f64 + median(f64)
f64 + min(f64)
f64 + min(i)
f64 + nil ?? i ?? greet
f64 + round(1.0)
f64 + sum(array)
f64 + sum(list, 1)
f64 - $env.f64
f64 - $env.i
f64 - $env?.f64
f64 - $env?.i
f64 - -0
f64 - -1
f64 - -1.0
f64 - -i
f64 - 0 % i
f64 - 0 ** 1.0
f64 - 0 / 1
f64 - 0 / f64
f64 - 0 < 0
f64 - 0 < 1
f64 - 0 > 0
f64 - 0 > f64
f64 - 0 in array
f64 - 1 != $env
f64 - 1 * $env.f64
f64 - 1 <= -1
f64 - 1 <= 1
f64 - 1 <= 1 + f64
f64 - 1 > i
f64 - 1 ?? $env.ok
f64 - 1 ^ i
f64 - 1 not in $env?.[Bar]
f64 - 1 | mean(1.0)
f64 - 1.0 * 1
f64 - 1.0 ** i
f64 - 1.0 - 0
f64 - 1.0 - 1
f64 - 1.0 - 1.0
f64 - 1.0 / i
f64 - 1.0 < f64 + 0
f64 - 1.0 <= i
f64 - 1.0 == f64
f64 - 1.0 == nil
f64 - 1.0 > 1
f64 - 1.0 ?? list
f64 - 1.0 ^ f64
f64 - 1.0 | mean(array)
f64 - abs(0)
f64 - array?.[i]
f64 - bitnot(i)
f64 - bitxor(i, i)
f64 - ceil(f64)
f64 - count(list, true)
f64 - f64
f64 - f64 < i
f64 - f64 <= f64
f64 - f64 > 0
f64 - float(1.0)
f64 - floor(0)
f64 - floor(f64)
f64 - floor(i)
f64 - i
f64 - i % 1
f64 - i >= 1
f64 - i >= i
f64 - i ^ 1.0
f64 - i | median(1.0)
f64 - int(0)
f64 - int(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 - reduce(array, i)
f64 - sum(array)
f64 / $env.f64
f64 / $env.i
f64 / $env?.f64
f64 / $env?.i
f64 / -0
f64 / -1
f64 / -1.0
f64 / -i
f64 / 0 != 1.0
f64 / 0 + i
f64 / 0 - 1.0
f64 / 0 < f64
f64 / 0 ^ $env?.i
f64 / 0 ^ 1.0
f64 / 0 not in array
f64 / 1 * f64
f64 / 1 * i ?? 1.0
f64 / 1 / 1.0
f64 / 1 / i
f64 / 1 <= 0
f64 / 1 == 0
f64 / 1 == int(f64)
f64 / 1 ?? array
f64 / 1.0 != 1
f64 / 1.0 != f64
f64 / 1.0 ** 1.0
f64 / 1.0 - 1
f64 / 1.0 / $env?.i
f64 / 1.0 / 1.0
f64 / 1.0 <= 1.0
f64 / 1.0 == 1.0
f64 / 1.0 > 1
f64 / 1.0 >= 0
f64 / 1.0 >= 1.0
f64 / 1.0 ?? list
f64 / 1.0 ?? nil + 1.0
f64 / 1.0 ?? true >= 1.0
f64 / 1.0 ^ 1.0
f64 / 1.0 ^ f64
f64 / 1.0 ^ i
f64 / abs(1.0)
f64 / abs(i)
f64 / add(i, 1)
f64 / array?.[i]
f64 / ceil(1.0)
f64 / f64
f64 / f64 != 1
f64 / f64 ** i
f64 / f64 + 0
f64 / f64 / 1.0
f64 / f64 <= f64
f64 / f64 ?? 0
f64 / f64 ?? ok
f64 / f64 not in array
f64 / first(array)
f64 / float(1.0)
f64 / i
f64 / i * i
f64 / i - sum(array)
f64 / i == 0
f64 / i >= 1.0
f64 / i ?? i
f64 / i ?? nil
f64 / i ^ 0 * 1.0
f64 / i ^ 1.0
f64 / int(f64)
f64 / len($env)
f64 / len(array)
f64 / max(1)
f64 / max(f64, f64)
f64 / max(i)
f64 / mean(0)
f64 / mean(1)
f64 / mean(1.0)
f64 / mean(1.0, array)
f64 / mean(array)
f64 / min(array)
f64 / nil ?? 1.0
f64 / reduce(list, i)
f64 / round(1.0)
f64 / sum(array)
f64 / sum(array, 0)
f64 < $env.f64
f64 < $env.i
f64 < $env?.f64
f64 < $env?.i
f64 < -1.0
f64 < -f64
f64 < 0 % 1
f64 < 0 * 1
f64 < 0 ** f64
f64 < 0 + 0
f64 < 0 + 1
f64 < 0 + 1.0
f64 < 0 + i
f64 < 0 < $env > $env
f64 < 0 <= $env?.[array]
f64 < 0 == false
f64 < 0 == true
f64 < 0 ?? array
f64 < 0 ?? nil
f64 < 0 ?? str
f64 < 0 or true
f64 < 1 % 1
f64 < 1 ** 1.0
f64 < 1 / 0
f64 < 1 / 1.0
f64 < 1 <= f64
f64 < 1 > 1.0
f64 < 1 >= 1
f64 < 1 >= 1.0
f64 < 1 ?? i
f64 < 1 or ok
f64 < 1 or true
f64 < 1.0 != true
f64 < 1.0 && $env
f64 < 1.0 * 1.0
f64 < 1.0 * i
f64 < 1.0 ** 0
f64 < 1.0 + f64
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 >= i
f64 < 1.0 ?: true
f64 < 1.0 ?? ok
f64 < 1.0 and false
f64 < abs(1)
f64 < abs(1.0)
f64 < array?.[i]
f64 < bitnot(i)
f64 < ceil(1.0)
f64 < count(list, true)
f64 < f64
f64 < f64 < 1.0
f64 < f64 <= 1.0
f64 < f64 > 0
f64 < f64 >= 1.0
f64 < f64 ?: ok
f64 < f64 ?? 1.0
f64 < f64 ?? greet
f64 < f64 and $env
f64 < f64 in $env?.String
f64 < findIndex($env, ok)
f64 < float(1)
f64 < float(f64)
f64 < floor(1)
f64 < floor(f64)
f64 < i
f64 < i != nil
f64 < i % 1
f64 < i % i
f64 < i && $env
f64 < i < $env.i
f64 < i < max(0)
f64 < i == nil
f64 < i >= f64
f64 < i ?? f64
f64 < i ?? greet
f64 < i || true
f64 < len($env)
f64 < max(array)
f64 < max(f64)
f64 < mean(f64)
f64 < median(array)
f64 < min(0)
f64 < min(1.0)
f64 < min(i)
f64 < nil ?? i
f64 < round(1.0)
f64 < sum($env, 1)
f64 < sum(array)
f64 <= $env.f64
f64 <= $env.i
f64 <= $env?.f64
f64 <= $env?.i
f64 <= -0
f64 <= 0 ** 1.0
f64 <= 0 - f64
f64 <= 0 <= 1.0
f64 <= 0 > i
f64 <= 0 >= mean(1.0)
f64 <= 0.1
f64 <= 1 != true and $env
f64 <= 1 && true
f64 <= 1 * i
f64 <= 1 - i
f64 <= 1 / 1
f64 <= 1 / f64
f64 <= 1 >= 1.0
f64 <= 1 >= f64
f64 <= 1 ?? $env.f64
f64 <= 1 ?? foo
f64 <= 1 ^ 0
f64 <= 1 ^ i
f64 <= 1 or true
f64 <= 1 || $env
f64 <= 1.0
f64 <= 1.0 != nil
f64 <= 1.0 != true
f64 <= 1.0 && $env
f64 <= 1.0 && true
f64 <= 1.0 * $env?.i
f64 <= 1.0 * min(i)
f64 <= 1.0 + 1.0
f64 <= 1.0 / 1.0
f64 <= 1.0 < 1.0 ^ i
f64 <= 1.0 <= f64
f64 <= 1.0 <= i
f64 <= 1.0 <= mean(1.0)
f64 <= 1.0 > 1
f64 <= 1.0 > i
f64 <= 1.0 ?? add
f64 <= 1.0 ?? greet
f64 <= 1.0 ?? str
f64 <= 1.0 ^ 0
f64 <= 1.0 ^ 1.0
f64 <= 1.0 ^ f64
f64 <= 1.0 and $env
f64 <= 1.0 and ok
f64 <= 1.0 || true
f64 <= 1.1 <= 1
f64 <= abs(0)
f64 <= abs(1)
f64 <= abs(f64)
f64 <= add(i, i)
f64 <= array?.[i]
f64 <= bitnand(i, 1)
f64 <= f64
f64 <= f64 && $env
f64 <= f64 * i
f64 <= f64 - 0
f64 <= f64 == false
f64 <= f64 ?? $env
f64 <= f64 and $env
f64 <= f64 || $env
f64 <= findIndex(list, ok)
f64 <= floor(1.0)
f64 <= i
f64 <= i + f64
f64 <= i - 0
f64 <= i == $env?.Bar
f64 <= i > i
f64 <= i ?? ok
f64 <= int(1.0)
f64 <= last(array)
f64 <= len(list)
f64 <= mean(1)
f64 <= mean(1.0)
f64 <= mean(i)
f64 <= median(1.0)
f64 <= median(f64)
f64 <= min(f64)
f64 <= reduce(array, 1.0, true)
f64 <= sum(array)
f64 <= sum(array, #)
f64 == $env && true
f64 == $env == $env
f64 == $env ? add : $env
f64 == $env ?? add
f64 == $env ?? greet
f64 == $env or $env
f64 == $env or ok
f64 == $env.f64
f64 == $env.i
f64 == $env?.Bar
f64 == $env?.String
f64 == $env?.[Bar]
f64 == $env?.[String]
f64 == $env?.[String]?.[greet]
f64 == $env?.[foobar]
f64 == $env?.[str]
f64 == $env?.f64
f64 == $env?.foobar
f64 == $env?.foobar?.str
f64 == $env?.i
f64 == -1
f64 == -1.0
f64 == 0 % i
f64 == 0 && $env?.[add]
f64 == 0 && 0 == nil
f64 == 0 && sum($env)
f64 == 0 ** 1.0
f64 == 0 - 1.0
f64 == 0 / $env.i
f64 == 0 == nil
f64 == 0 or ok
f64 == 1 != ok
f64 == 1 * i
f64 == 1 + 1.0
f64 == 1 - 1.0
f64 == 1 - f64
f64 == 1 ?: 1.0
f64 == 1 ?? f64
f64 == 1 || i <= 0
f64 == 1.0 != false
f64 == 1.0 ** 0
f64 == 1.0 + f64
f64 == 1.0 == nil
f64 == 1.0 == ok
f64 == 1.0 ?: nil
f64 == 1.0 ?? 1
f64 == 1.0 ?? ok
f64 == 1.0 ^ 1.0
f64 == 1.0 and ok
f64 == 1.0 and true
f64 == 1.0 || $env
f64 == abs(1.0)
f64 == abs(i)
f64 == add ?? false
f64 == add ?? greet
f64 == add ?? list
f64 == array ?? greet
f64 == array?.[i]
f64 == bitnot(i)
f64 == bitor(i, 1)
f64 == ceil(1)
f64 == ceil(1.0)
f64 == count(array, ok)
f64 == f64
f64 == f64 * 1
f64 == f64 * f64
f64 == f64 / 0
f64 == f64 ?? false
f64 == f64 ^ i
f64 == f64 || false
f64 == findLastIndex($env, true)
f64 == floor(1)
f64 == foo ?? f64
f64 == foo ?? list
f64 == greet ?? add
f64 == i
f64 == i % 1
f64 == i - i
f64 == i / f64
f64 == i / i
f64 == i ?? [foo]
f64 == i ?? any($env, false)
f64 == i ^ 0
f64 == i or ok
f64 == i || false
f64 == int(f64)
f64 == len(string(nil))
f64 == list ?? $env
f64 == list ?? array
f64 == max(0)
f64 == mean(1.0)
f64 == median(1.0)
f64 == median(i)
f64 == min($env)
f64 == min(1.0)
f64 == nil != nil
f64 == nil != ok
f64 == nil ?: list
f64 == nil or $env
f64 == nil || max(array)
f64 == nil || true
f64 == ok ?? foo
f64 == ok ?? str
f64 == round(f64)
f64 == str ?? 0
f64 == str ?? i
f64 == sum(array)
f64 > $env.f64
f64 > $env.i
f64 > $env?.[str]?.[f64]
f64 > $env?.f64
f64 > $env?.i
f64 > -0
f64 > -1
f64 > -1.0
f64 > 0 + 1.0
f64 > 0 / 1.0
f64 > 0 / i
f64 > 0 >= 0
f64 > 0 >= 1.0
f64 > 0 ? 1 : 1.0
f64 > 0 ?? $env.f64
f64 > 0 ?? false
f64 > 0 ?? foo
f64 > 0 and $env?.String
f64 > 0 or true
f64 > 0 || $env
f64 > 1 != ok
f64 > 1 && $env
f64 > 1 * i
f64 > 1 ** i
f64 > 1 / 1.0
f64 > 1 / f64
f64 > 1 / i
f64 > 1 <= i
f64 > 1 >= f64
f64 > 1 >= i
f64 > 1 ? array : false
f64 > 1 ?? list
f64 > 1 or true
f64 > 1.0 != nil
f64 > 1.0 != ok
f64 > 1.0 && $env
f64 > 1.0 * 1.0
f64 > 1.0 * i
f64 > 1.0 ** f64
f64 > 1.0 - nil ?? i
f64 > 1.0 / 0
f64 > 1.0 <= f64
f64 > 1.0 <= i
f64 > 1.0 == true
f64 > 1.0 > $env
f64 > 1.0 > median(list, 1)
f64 > 1.0 ? i : false
f64 > 1.0 ?? 1.0
f64 > 1.0 ?? add
f64 > 1.0 ?? foo
f64 > 1.0 ^ f64
f64 > 1.0 and true
f64 > 1.0 or ok
f64 > 1.0 || $env?.[Bar]
f64 > array?.[i]
f64 > bitnot(1)
f64 > ceil(0)
f64 > ceil(f64)
f64 > ceil(i)
f64 > f64
f64 > f64 != true
f64 > f64 * f64
f64 > f64 - 1
f64 > f64 >= 1.0
f64 > f64 and true
f64 > f64 or ok
f64 > first(array)
f64 > float(1.0)
f64 > i
f64 > i - f64
f64 > i < f64 ?: $env
f64 > i == $env
f64 > i >= max($env)
f64 > i ^ 1
f64 > i and ok
f64 > max(array)
f64 > mean(1)
f64 > mean(1.0)
f64 > median(f64)
f64 > round(1)
f64 > round(1.0)
f64 > round(i)
f64 > sum($env | filter(false))
f64 > sum($env, f64)
f64 >= $env && false
f64 >= $env ^ 1 and false
f64 >= $env or true
f64 >= $env || true
f64 >= $env.f64
f64 >= $env.i
f64 >= $env?.f64
f64 >= $env?.i
f64 >= -1.0
f64 >= -i
f64 >= 0 != $env
f64 >= 0 - 0
f64 >= 0 == true
f64 >= 0 >= f64
f64 >= 0 ? add : 0
f64 >= 0 ? greet : 1
f64 >= 0 ?? i
f64 >= 0 || ok
f64 >= 1 != nil
f64 >= 1 != true
f64 >= 1 / f64
f64 >= 1 < i
f64 >= 1 == false
f64 >= 1 >= f64
f64 >= 1 ? 0 : foo
f64 >= 1 ? foo : str
f64 >= 1 ^ 1.0
f64 >= 1.0 != add ?? foo
f64 >= 1.0 != nil
f64 >= 1.0 && ok
f64 >= 1.0 ** i < f64
f64 >= 1.0 + $env.f64
f64 >= 1.0 + 1.0
f64 >= 1.0 / i
f64 >= 1.0 > i
f64 >= 1.0 ?: greet
f64 >= 1.0 ?: list
f64 >= 1.0 ?? nil
f64 >= 1.0 and $env in str
f64 >= 1.0 and $env?.[str]
f64 >= 1.0 and not ok
f64 >= 1.0 || ok
f64 >= 1.1
f64 >= array?.[i]
f64 >= bitnot(i)
f64 >= ceil(0)
f64 >= ceil(i)
f64 >= f64
f64 >= f64 * 1.0
f64 >= f64 == ok
f64 >= f64 >= i
f64 >= f64 ?? str
f64 >= f64 ^ f64
f64 >= f64 || 1.0 == 1.0
f64 >= f64 || true
f64 >= float(0)
f64 >= float(1)
f64 >= float(1.0)
f64 >= floor(-0)
f64 >= floor(1.0)
f64 >= floor(f64)
f64 >= floor(i)
f64 >= i
f64 >= i != $env
f64 >= i * f64
f64 >= i + 1.0
f64 >= i / f64
f64 >= i < f64
f64 >= i ?: true
f64 >= i ?? $env
f64 >= i ?? $env.list
f64 >= i ?? false
f64 >= i || $env
f64 >= int(1.0)
f64 >= mean(0)
f64 >= mean(1)
f64 >= mean(1.0)
f64 >= min(0)
f64 >= min(i)
f64 >= nil ?? f64
f64 >= nil ?? i
f64 >= round(1)
f64 >= sum(array)
f64 ?? !$env
f64 ?? !false
f64 ?? !ok
f64 ?? $env ?? $env
f64 ?? $env ?? add
f64 ?? $env ?? f64
f64 ?? $env ?? nil
f64 ?? $env ?? ok
f64 ?? $env | get(greet)
f64 ?? $env | max(1)
f64 ?? $env.add
f64 ?? $env.array
f64 ?? $env.f64
f64 ?? $env.foo
f64 ?? $env.greet
f64 ?? $env.i
f64 ?? $env.list
f64 ?? $env.ok
f64 ?? $env.str
f64 ?? $env?.Bar
f64 ?? $env?.Bar($env < 1.0)
f64 ?? $env?.Bar()
f64 ?? $env?.String
f64 ?? $env?.String()
f64 ?? $env?.[$env?.String()]
f64 ?? $env?.[Bar]
f64 ?? $env?.[String]
f64 ?? $env?.[String].str()
f64 ?? $env?.[add]
f64 ?? $env?.[add]?.[greet]
f64 ?? $env?.[array]
f64 ?? $env?.[array].list()
f64 ?? $env?.[f64]
f64 ?? $env?.[false - 1]
f64 ?? $env?.[foo]
f64 ?? $env?.[foobar.Bar]
f64 ?? $env?.[foobar?.[f64]]
f64 ?? $env?.[foobar]
f64 ?? $env?.[greet(foo)]
f64 ?? $env?.[greet]
f64 ?? $env?.[greet].array()
f64 ?? $env?.[i]
f64 ?? $env?.[i]?.[str]
f64 ?? $env?.[list]
f64 ?? $env?.[not foo]
f64 ?? $env?.[ok]
f64 ?? $env?.[ok].array()
f64 ?? $env?.[str]
f64 ?? $env?.[str][:i(i < foobar)]
f64 ?? $env?.add
f64 ?? $env?.all(foobar)
f64 ?? $env?.array
f64 ?? $env?.f64
f64 ?? $env?.foo
f64 ?? $env?.foobar
f64 ?? $env?.foobar?.list
f64 ?? $env?.greet
f64 ?? $env?.i
f64 ?? $env?.list
f64 ?? $env?.ok
f64 ?? $env?.str
f64 ?? $env[0:foobar]
f64 ?? $env[:1]
f64 ?? $env[:add[:]]
f64 ?? $env[:foo]
f64 ?? $env[:foobar]
f64 ?? $env[:nil]
f64 ?? $env[:sum(0, foobar)].ok
f64 ?? $env[Bar | none(#):]
f64 ?? $env[Bar():i(1)]
f64 ?? $env[f64 / foo:]
f64 ?? $env[f64:replace(foobar, 1.0)]
f64 ?? $env[false > Bar:]
f64 ?? $env[foo - 1:foobar].ok
f64 ?? $env[foobar:]
f64 ?? $env[foobar:foobar and array]
f64 ?? $env[list:greet]
f64 ?? -$env
f64 ?? -$env?.[1]
f64 ?? -0
f64 ?? -1
f64 ?? -1.0
f64 ?? -f64
f64 ?? 0 ?? $env?.nil
f64 ?? 0 ?? [1.0]
f64 ?? 0 ?? true
f64 ?? 1 ?? foo
f64 ?? 1.0 ?? date(f64)
f64 ?? [$env]
f64 ?? [f64, f64]
f64 ?? abs(1.0)
f64 ?? add
f64 ?? add(i, $env)
f64 ?? array
f64 ?? array ?? array
f64 ?? array ?? true
f64 ?? array | mean(1.0)
f64 ?? array?.[i]
f64 ?? bitnot(i)
f64 ?? count($env | map(#.add))
f64 ?? count($env)
f64 ?? count($env, #)
f64 ?? count($env?.[i])
f64 ?? count(array)
f64 ?? count(list)
f64 ?? date($env, 1)
f64 ?? date(foo)
f64 ?? date(sum(list))
f64 ?? f64
f64 ?? f64 ?? ok
f64 ?? false ?? 1.0
f64 ?? false | max(0)
f64 ?? findLast($env, #.f64)
f64 ?? findLast(array, false)
f64 ?? first($env)?.ok()
f64 ?? floor($env)
f64 ?? foo
f64 ?? foo ?? $env
f64 ?? foo ?? foo
f64 ?? foo | get(1.0)
f64 ?? foo | max(0)
f64 ?? foo.Bar
f64 ?? foo.String
f64 ?? foo.String()
f64 ?? foo?.Bar
f64 ?? foo?.String
f64 ?? foo?.String()
f64 ?? fromBase64($env)
f64 ?? greet
f64 ?? greet($env)
f64 ?? groupBy($env, #)
f64 ?? groupBy($env, true)
f64 ?? groupBy(list, #)
f64 ?? i
f64 ?? i ?? add
f64 ?? int(1)
f64 ?? int(f64)
f64 ?? int(str)
f64 ?? len(str)
f64 ?? list
f64 ?? list?.[i]
f64 ?? lower($env)
f64 ?? map($env, #)
f64 ?? map($env, #.Bar)
f64 ?? map(array, #index)
f64 ?? max(1.0)
f64 ?? mean($env)
f64 ?? median(1.0)
f64 ?? min($env?.[add])
f64 ?? min(0)
f64 ?? min(list)
f64 ?? nil ?? 0
f64 ?? not $env
f64 ?? not ok
f64 ?? not true
f64 ?? ok
f64 ?? ok ?? 1.0
f64 ?? ok ?? greet
f64 ?? reduce($env, add)
f64 ?? reduce($env, foo)
f64 ?? reduce(array, #, $env)
f64 ?? reduce(list, str)
f64 ?? reverse($env)
f64 ?? reverse(array)
f64 ?? round(i)
f64 ?? sortBy(list, ok)
f64 ?? str
f64 ?? str[$env:i]
f64 ?? string(f64)
f64 ?? string(str)
f64 ?? string(true)
f64 ?? sum($env, #.foo)
f64 ?? sum($env, .str)
f64 ?? sum($env, foo)
f64 ?? sum($env?.[list])
f64 ?? sum(array)
f64 ?? toJSON(0)
f64 ?? toJSON(1.0)
f64 ?? true ?? 0
f64 ?? type(1)
f64 ?? uniq($env)
f64 ?? {foo: 1.0, foo: list}
f64 ?? {foo: 1}
f64 ?? {foo: greet}
f64 ?? {foo: i, foo: str}
f64 ?? {foo: list}
f64 ^ $env.f64
f64 ^ $env.i
f64 ^ $env?.f64
f64 ^ $env?.i
f64 ^ -1
f64 ^ -1.0
f64 ^ -f64
f64 ^ 0 - 1.0
f64 ^ 0 - i
f64 ^ 0 / i
f64 ^ 0 < 0
f64 ^ 0 >= 1.0 ?: greet
f64 ^ 1 != 1
f64 ^ 1 * 1.0
f64 ^ 1 + 1
f64 ^ 1 + 1.0
f64 ^ 1 + f64
f64 ^ 1 > 1
f64 ^ 1 > f64
f64 ^ 1 ?? nil
f64 ^ 1 in [1.0]
f64 ^ 1.0
f64 ^ 1.0 != $env
f64 ^ 1.0 != 1.0
f64 ^ 1.0 != f64
f64 ^ 1.0 != i
f64 ^ 1.0 ** 1.0
f64 ^ 1.0 / i
f64 ^ 1.0 > 1
f64 ^ 1.0 >= i
f64 ^ 1.0 ?? str
f64 ^ array?.[i]
f64 ^ bitand(0, 0)
f64 ^ bitnot(1)
f64 ^ ceil(0)
f64 ^ f64
f64 ^ f64 != $env
f64 ^ f64 != 0
f64 ^ f64 != 1
f64 ^ f64 * 1.0
f64 ^ f64 ** i
f64 ^ f64 + 1.0
f64 ^ f64 == i
f64 ^ f64 > f64
f64 ^ f64 ?? greet
f64 ^ f64 ^ f64
f64 ^ f64 in array
f64 ^ find(array, ok)
f64 ^ float(i)
f64 ^ floor(i)
f64 ^ i
f64 ^ i ** 1.0
f64 ^ i ** i
f64 ^ i / $env.i
f64 ^ i <= 1.0
f64 ^ i >= 0 || $env
f64 ^ i not in array
f64 ^ int(0)
f64 ^ int(1.0)
f64 ^ int(f64)
f64 ^ len($env)
f64 ^ mean(0)
f64 ^ mean(i)
f64 ^ median(0)
f64 ^ min(0)
f64 ^ nil ?? 1
f64 ^ round(1.0)
f64 ^ sum(array)
f64 in $env && false
f64 in $env.array
f64 in $env?.Bar
f64 in $env?.Bar?.[str]
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 [foo, nil]
f64 in [i]
f64 in [list, 1.0]
f64 in [nil]
f64 in [true, $env]
f64 in array
f64 in array != nil
f64 in array ? foo : foo
f64 in array ? type(false) : foo
f64 in array ?? 0
f64 in array ?? nil
f64 in array and $env
f64 in array or false
f64 in last($env)
f64 in list ?? foo
f64 in list ?? i
f64 in reverse(array)
f64 in sort($env)
f64 in uniq(array)
f64 in uniq(list)
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?.foobar?.String
f64 not in 0..i
f64 not in [$env]
f64 not in [1.0]
f64 not in [array | groupBy(#), i]
f64 not in array
f64 not in array ?? 0
f64 not in array ?? foo or false
f64 not in array || sum($env)
f64 not in i .. i
f64 not in keys($env)
f64 not in list ?? str
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, array)
f64 | max(1.0)
f64 | max(1.0, 1)
f64 | max(1.0, 1.0)
f64 | max(1.0, f64)
f64 | max(1.0, i)
f64 | max([1.0])
f64 | max(array)
f64 | max(array, 0)
f64 | max(array, 1)
f64 | max(bitnot(1))
f64 | max(f64)
f64 | max(f64, i)
f64 | max(i)
f64 | max(i, 1)
f64 | max(i, 1.0)
f64 | max(i, i)
f64 | max(sortBy(array, #))
f64 | mean($env?.i)
f64 | mean(0)
f64 | mean(0, 0)
f64 | mean(0, 1.0)
f64 | mean(0, array)
f64 | mean(1)
f64 | mean(1) > f64
f64 | mean(1.0 ?? 1.0)
f64 | mean(1.0)
f64 | mean(1.0, 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, 1.0)
f64 | mean(f64, array)
f64 | mean(f64, array) != add
f64 | mean(f64, f64)
f64 | mean(f64, i)
f64 | mean(i)
f64 | mean(i, 1)
f64 | median($env?.i)
f64 | median(-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(1.0, 1)
f64 | median(1.0, 1.0)
f64 | median(array)
f64 | median(array) >= f64
f64 | median(array, 0)
f64 | median(array, 1.0)
f64 | median(array, i)
f64 | median(f64)
f64 | median(f64, 1.0)
f64 | median(i)
f64 | median(i, 1.0)
f64 | min($env?.array)
f64 | min($env?.f64)
f64 | min(0)
f64 | min(0, 1)
f64 | min(0, i)
f64 | min(1)
f64 | min(1, f64)
f64 | min(1, i, 1.0, 1.0)
f64 | min(1.0)
f64 | min(1.0, 0)
f64 | min(array)
f64 | min(array, 1)
f64 | min(array, array)
f64 | min(array, i)
f64 | min(f64)
f64 | min(f64, 1.0)
f64 | min(i)
f64 | min(i, i)
f64 | min(mean(f64))
f64; $env?.list
f64; array
f64; f64
f64; foo?.String
f64; greet
f64; i
f64; min(foo ?? true)
f64; ok
f64; str
false != $env ?? -1
false != $env and ok
false != $env.ok
false != $env?.Bar
false != $env?.Bar?.greet()
false != $env?.String
false != $env?.[Bar]
false != $env?.[String]
false != $env?.[foobar]
false != $env?.[str]
false != $env?.foobar
false != $env?.ok
false != $env?.true?.[list].i
false != 0 ?? str
false != 1.0 ?? i
false != add ?? f64 ?: foo
false != array ?? list
false != greet ?? $env?.[ok]
false != greet ?? str
false != i ?? array
false != nil == nil ?: list
false != nil == ok
false != nil ?: add
false != nil ?: f64 != $env
false != nil or sum($env)
false != str ?? filter($env, true)
false && $env + i
false && $env == add
false && $env == count(array)
false && $env > findLastIndex($env, #)
false && $env >= sum($env)?.[array]
false && $env ?? ok
false && $env ^ f64 <= 1
false && $env contains array ?? list
false && $env in list
false && $env in str
false && $env not contains str
false && $env not in list
false && $env or ok
false && $env.ok
false && $env?.Bar
false && $env?.Bar()
false && $env?.Bar(ok(), f64(), foobar)[foobar?.add.str:]
false && $env?.Bar.add()
false && $env?.String
false && $env?.String()
false && $env?.String(foobar.Bar)
false && $env?.String?.[str]
false && $env?.[0 in foobar]
false && $env?.[Bar]
false && $env?.[Bar]?.[f64]
false && $env?.[String]
false && $env?.[add]
false && $env?.[add].array
false && $env?.[array()]
false && $env?.[array]
false && $env?.[array]?.[ok]
false && $env?.[f64 > str]
false && $env?.[f64()]
false && $env?.[f64]
false && $env?.[f64]?.array
false && $env?.[findLastIndex(greet, #.ok)]
false && $env?.[foo]
false && $env?.[foobar - foobar]
false && $env?.[foobar >= foobar]
false && $env?.[foobar.add]
false && $env?.[foobar]
false && $env?.[greet]
false && $env?.[greet].i
false && $env?.[i]
false && $env?.[i].foo
false && $env?.[list]
false && $env?.[ok]
false && $env?.[ok].add
false && $env?.[str]
false && $env?.[str].String
false && $env?.[str]?.list()
false && $env?.[type($env, foobar, 1)]
false && $env?.foobar
false && $env?.min(foobar)
false && $env?.ok
false && $env[:$env | toPairs(foobar)]
false && $env[:Bar < 0]
false && $env[:Bar()]
false && $env[:add(1.0)]
false && $env[:ok()]
false && $env[:trimPrefix(foobar)]
false && $env[String():str(foobar)]
false && $env[count(foo):]
false && $env[foobar < true:]
false && $env[foobar | toPairs(foobar, false):]
false && $env[foobar.list(foobar):ok endsWith foobar]
false && $env[foobar:Bar]
false && $env[foobar:foobar?.[String]]
false && $env[foobar?.ok(foobar):]
false && $env[hasPrefix(i):foobar[$env:true]].ok
false && $env[i:-foobar]
false && $env[i:]
false && $env[i?.str:]
false && $env[ok.String:all(foobar, #.foo)]
false && 0 >= i
false && 0 not in map($env, i)
false && 1 - findLast($env, #)
false && 1 == 1 ** $env
false && 1 > 1.0 ** $env
false && 1.0 <= f64 > $env
false && 1.0 == i
false && 1.0 == int(1)
false && 1.0 > $env[:ok]
false && 1.0 > i
false && 1.0 >= f64
false && 1.0 >= false ?? 1.0
false && array == [$env]
false && f64 - $env?.[foobar]
false && f64 < i
false && false ?? ok
false && foo != foo
false && foo ?? array
false && foo ?? greet
false && greet ?? array
false && i < f64
false && i in $env.array
false && i in array
false && nil != greet
false && nil == add
false && nil == greet
false && nil == ok
false && nil in reduce($env, #)
false && ok || ok
false && str ?? ok
false && true ?? foo
false == $env && ok
false == $env ?? reverse($env)
false == $env.ok
false == $env?.Bar
false == $env?.String
false == $env?.String?.list
false == $env?.[Bar]
false == $env?.[String]
false == $env?.[String]?.[f64]
false == $env?.[String]?.greet
false == $env?.[foobar]
false == $env?.[foobar]?.[str]
false == $env?.[str]
false == $env?.[str]?.[f64]
false == $env?.ok
false == 1.0 ?? $env?.foo
false == 1.0 ?? add
false == false && $env == str
false == foo ?? i
false == i ?? ok
false == nil && ok
false == nil and foo in $env
false == nil || $env in list
false == true ? $env | map(.array) : array
false == true ?? greet
false == true ?? list
false ? $env : $env | map($env)
false ? $env : $env.array
false ? $env : $env.greet
false ? $env : $env.list
false ? $env : $env?.[str]
false ? $env : $env?.add
false ? $env : $env?.f64
false ? $env : foo.Bar
false ? $env : foo?.Bar
false ? 0 : array?.[i]
false ? 0 : foo?.Bar
false ? 1 : $env.foo
false ? 1 : $env.list
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?.Bar
false ? 1.0 : foo?.String()
false ? 1.0 : str contains str
false ? add : $env not matches $env?.String
false ? add : $env.array
false ? add : $env?.String
false ? add : foo.Bar
false ? add : list | map($env.add)
false ? add : list | reduce(true)
false ? add : list?.[i]
false ? add : nil not in array
false ? array : $env.f64
false ? array : $env?.f64
false ? array : $env?.foo
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.str
false ? f64 : $env?.[String]
false ? f64 : $env?.greet
false ? f64 : $env?.str
false ? f64 : foo.Bar
false ? f64 : list | groupBy(#)
false ? false : $env?.list
false ? false : foo ?? greet
false ? false : foo?.Bar
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?.list
false ? foo : $env?.ok
false ? foo : array | map(0)
false ? foo : array?.[i]
false ? foo : foo.Bar
false ? foo : foo.String
false ? foo : foo?.Bar
false ? foo : foo?.String
false ? foo : i ^ i
false ? greet : $env | map(1.0)
false ? greet : $env?.greet
false ? greet : foo.String
false ? i : $env.str
false ? i : $env?.[String]
false ? i : $env?.foo
false ? i : foo.Bar
false ? list : $env ?? list
false ? list : $env.array
false ? list : $env.i
false ? list : $env?.foo
false ? list : foo.Bar
false ? nil : $env.f64
false ? nil : $env.foo
false ? nil : $env.ok
false ? nil : $env?.Bar
false ? nil : $env?.[foobar]
false ? nil : $env?.greet
false ? nil : $env?.ok
false ? nil : $env?.str
false ? nil : 1.0 / f64
false ? nil : foo.String
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 | map(add)
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.i
false ? true : $env?.String
false ? true : foo.Bar
false ? true : foo?.Bar
false ? true : list != $env?.[str]
false ?: $env.add
false ?: $env.foo
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?.array
false ?: $env?.f64
false ?: $env?.foo
false ?: $env?.i
false ?: $env?.list
false ?: $env?.str
false ?: array | sum(1.0)
false ?: array?.[i]
false ?: f64 - i
false ?: foo.Bar
false ?: foo.String
false ?: foo?.Bar
false ?: foo?.String
false ?: foo?.String()
false ?: i | mean(1)
false ?: list | map(foo)
false ?? $env ?? $env?.[foo]
false ?? $env.add
false ?? $env.array
false ?? $env.f64
false ?? $env.foo
false ?? $env.greet
false ?? $env.i
false ?? $env.list
false ?? $env.ok
false ?? $env.str
false ?? $env?.Bar
false ?? $env?.Bar().String
false ?? $env?.String
false ?? $env?.String()
false ?? $env?.String?.ok
false ?? $env?.[!String]
false ?? $env?.[0 .. greet]
false ?? $env?.[1.0 | any(String)]
false ?? $env?.[Bar]
false ?? $env?.[String]
false ?? $env?.[add | groupBy(1)]
false ?? $env?.[add]
false ?? $env?.[add]?.[f64]?.[foo]
false ?? $env?.[array]
false ?? $env?.[f64]
false ?? $env?.[foo]
false ?? $env?.[foobar.list]
false ?? $env?.[greet]
false ?? $env?.[greet]?.add()
false ?? $env?.[greet]?.f64
false ?? $env?.[i != foobar]
false ?? $env?.[i]
false ?? $env?.[list()]
false ?? $env?.[list]
false ?? $env?.[list]?.[i]
false ?? $env?.[ok]
false ?? $env?.[str ^ String]
false ?? $env?.[str]
false ?? $env?.add
false ?? $env?.all(array)
false ?? $env?.array
false ?? $env?.f64
false ?? $env?.foo
false ?? $env?.foobar
false ?? $env?.foobar?.f64
false ?? $env?.greet
false ?? $env?.i
false ?? $env?.list
false ?? $env?.none(i)
false ?? $env?.ok
false ?? $env?.str
false ?? $env[1.0 | trimPrefix(1):foobar < true]
false ?? $env[:String.f64]
false ?? $env[:array || foo]
false ?? $env[:array()]
false ?? $env[:foo?.str]
false ?? $env[Bar matches foobar:]
false ?? $env[date(str, true):]
false ?? 1.0 ?: f64
false ?? array?.[i]
false ?? foo ?? ok ?: greet
false ?? foo.Bar
false ?? foo.String
false ?? foo.String()
false ?? foo?.Bar
false ?? foo?.String
false ?? foo?.String()
false ?? nil ?? [$env, 1.0]
false ?? nil ?? list
false ?? nil ?? ok
false ?? ok ?? foo
false ?? true ?? $env?.String
false and $env != f64
false and $env + $env?.[f64]
false and $env + str
false and $env <= $env[foobar:foobar]
false and $env == add
false and $env == str
false and $env >= str
false and $env ?? $env?.[Bar]
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.Bar
false and $env?.$env?.ok
false and $env?.Bar
false and $env?.Bar != foo
false and $env?.Bar()
false and $env?.Bar(1 | filter(list)) || ok
false and $env?.Bar(array, foobar)
false and $env?.Bar.f64()
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?.[foo].greet
false and $env?.[foobar?.[add]]
false and $env?.[foobar]
false and $env?.[greet]
false and $env?.[i]
false and $env?.[i].array
false and $env?.[i]?.list
false and $env?.[len(foo, Bar, foo)]
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]?.[f64].array
false and $env?.[str]?.list(filter(String / foobar, f64 >= 1.0))
false and $env?.[trim(foobar)]
false and $env?.[true | findLast(foobar)]
false and $env?.all(foobar, foo)
false and $env?.concat(Bar, 1, foobar)
false and $env?.foobar
false and $env?.none(foobar)
false and $env?.ok
false and $env?.repeat(nil)
false and $env?.type(foobar, str)
false and $env[$env .. add:foo ? true : foobar]?.greet
false and $env[$env[array:foo]:]
false and $env[:Bar]
false and $env[:String($env, ok)]
false and $env[:add()]
false and $env[:false > nil]?.[greet]
false and $env[:foo.foobar]
false and $env[:foo]?.list(first(foobar ?? String), array && foobar >= String, foobar && list?.[1])
false and $env[:foobar?.Bar]
false and $env[Bar(foo):]
false and $env[array():]
false and $env[bitshr(foobar, array):foobar | reduce(.String)]
false and $env[foobar:]
false and $env[greet(str):true in list]
false and $env[i():]
false and $env[i:nil ^ 1.0]
false and 0 == i
false and 0 > count(array, false)
false and 0 >= -1
false and 0 ?? $env[:nil]
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 + $env?.Bar
false and 1.0 <= f64
false and 1.0 <= f64 / f64
false and 1.0 == i
false and 1.0 > 0 ?? 0
false and 1.0 > sum($env)
false and 1.0 ?? greet
false and f64 >= i
false and f64 in array
false and false != $env?.[i]
false and foo != foo
false and foo ?? greet
false and foo ?? i
false and greet ?? ok
false and greet not in $env?.[Bar]
false and i != $env?.[add]
false and i == median(list)
false and nil == str
false and ok and ok
false and str > str
false and str >= foo?.Bar
false and str not in foo
false and true ?: add
false and true ?? sum($env)
false and true || ok
false in $env?.Bar
false in $env?.String
false in $env?.[Bar]
false in $env?.[String]
false in $env?.[foobar?.[foo]]
false in $env?.[foobar]
false in $env?.[foobar]?.[array]
false in $env?.foobar
false in $env?.foobar?.String
false in list ?? foo
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?.[String]?.String
false not in $env?.[String]?.[list]
false not in $env?.[first(foobar)]
false not in $env?.[foobar?.list]
false not in $env?.[foobar]
false not in $env?.foobar
false not in array ?? {foo: $env}
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?.[foobar]
false or $env?.[str]
false or $env?.foobar
false or $env?.ok
false or 0 < 1.0 ^ 1
false or 0 == i
false or 0 >= i || true
false or 0 not in array
false or 1 > i
false or 1 ?? list
false or 1 in array
false or 1.0 >= i
false or 1.0 ?? foo
false or array == list
false or f64 ?? $env?.ok
false or false ?: ok
false or false ?? foo
false or foo ?? i
false or foo ?? ok
false or foo in list
false or greet == greet
false or i == i
false or i ?? foo
false or i ?? list
false or list ?? ok
false or nil != array
false or nil != f64
false or nil == array
false or nil == foo
false or ok == ok
false or str != str
false or str >= string(0)
false or str in foo == $env
false or str not matches str
false || $env != f64 and $env
false || $env == [foo]
false || $env == array ? foo : foo
false || $env == i
false || $env ?? f64
false || $env in list
false || $env.ok
false || $env?.Bar
false || $env?.Bar?.[ok]
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?.foobar
false || $env?.ok
false || 0 != $env?.String
false || 1 == $env?.[foobar]
false || 1 == array?.[i]
false || 1 > f64
false || 1 in array
false || 1.0 <= 1.0 ?: 1
false || 1.0 <= i
false || 1.0 >= f64
false || 1.0 ?? array
false || add != add
false || array != list
false || f64 != i
false || false ?? foo
false || foo ?? array
false || foo ?? str
false || foo in list
false || foo.Bar matches str
false || i == i
false || i > median(f64)
false || i >= i
false || i ?? greet($env)
false || i ?? str
false || nil != f64
false || nil != i
false || nil == greet
false || str not endsWith str
false || true == ok
false; $env?.Bar
false; $env?.String
false; $env?.[Bar]
false; $env?.foo
filter($env | map(0), !true)
filter($env, #.list) | filter(false)
filter($env, .f64) | filter(false)
filter($env, .ok) | filter(false)
filter($env, .str) | filter(false)
filter($env, false) | all(#)
filter($env, false) | all(#.str not matches .str)
filter($env, false) | all(false)
filter($env, false) | find(#)
filter($env, false) | find(true)
filter($env, false) | findIndex(#)
filter($env, false) | findLastIndex(.f64 not contains #)
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(.Bar)
filter($env, false) | sum(.i)
filter($env, false) | sum(foo)
filter($env, false) | sum(greet)
filter($env, ok) | map(foo)
filter($env.array, foo != foo)
filter($env.array, i == 1)
filter($env.array, ok)
filter($env.list, ok)
filter($env.list, true || true)
filter($env?.[str], false && $env)
filter($env?.[str], ok)
filter($env?.array, # <= #)
filter($env?.array, ok)
filter($env?.list, ok)
filter([0], ok)
filter([1], # != 1.0)
filter([greet], ok)
filter([i], ok)
filter([true, $env], 1 < 1)
filter(array, !ok)
filter(array, # != #)
filter(array, # != 1)
filter(array, # < #)
filter(array, # <= #)
filter(array, # not in array)
filter(array, $env != $env)
filter(array, $env == $env)
filter(array, $env and false)
filter(array, $env.ok)
filter(array, 0 <= #)
filter(array, 1 != f64)
filter(array, 1 <= #)
filter(array, 1 >= #)
filter(array, 1.0 != #)
filter(array, 1.0 <= f64)
filter(array, 1.0 == $env)
filter(array, 1.0 > #)
filter(array, 1.0 > 1.0)
filter(array, f64 <= #)
filter(array, false != $env)
filter(array, false) | all($env[1.0:])
filter(array, false) | groupBy(#)
filter(array, false) | sortBy($env)
filter(array, false) | sortBy(add)
filter(array, false) | sum(f64)
filter(array, foo == foo)
filter(array, i > #)
filter(array, list == nil)
filter(array, nil != #)
filter(array, nil != list)
filter(array, nil ?? false)
filter(array, not true)
filter(array, ok && i != #)
filter(array, ok ?? i)
filter(array, ok and true)
filter(array, ok)
filter(array, ok) | findIndex(false)
filter(array, ok) | groupBy(foo)
filter(array, ok) | sortBy(0)
filter(array, ok)?.[i]
filter(array, str in foo)
filter(array, true) | findLast(ok)
filter(array, true) | map(foo)
filter(array, true) | none(true)
filter(array, true)?.[i]
filter(concat(array), #.greet || true)
filter(keys($env), ok)
filter(list | map($env), ok == nil)
filter(list, !false)
filter(list, # != #)
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 == str)
filter(list, $env?.ok)
filter(list, 1 > 1.0)
filter(list, 1.0 < 1)
filter(list, 1.0 == nil)
filter(list, 1.0 > f64)
filter(list, 1.0 not in array)
filter(list, array != array)
filter(list, f64 <= 1.0)
filter(list, false != nil)
filter(list, false && $env)
filter(list, false ?? 1.0)
filter(list, false) | groupBy(#)
filter(list, false) | groupBy(ok)
filter(list, false) | map(array)
filter(list, false) | sum($env)
filter(list, false) | sum(foo)
filter(list, foo != nil)
filter(list, greet == nil)
filter(list, nil == nil)
filter(list, nil in $env)
filter(list, not true)
filter(list, ok)
filter(list, ok) | findIndex(true)
filter(list, ok) | reduce(add)
filter(list, ok)?.[i]
filter(list, one(array, true))
filter(list, str != $env)
filter(list, true) | all(true)
filter(list, true) | groupBy(#)
filter(list, true) | groupBy(1.0)
filter(list, true) | reduce(#acc)
filter(list, true) | reduce(i)
filter(list, true)?.[i]
filter(map($env, foo), # != #)
filter(sort($env), #.String?.list)
filter(sort($env), #.foo?.String)
filter(sort($env), #.i || #)
filter(sort($env), nil not in .list)
find($env ?? ok, $env == 1.0)
find($env | filter(false), # endsWith .Bar)
find($env | map(greet), not true)
find($env, false) != f64
find($env, false) ?? ok
find($env, false)?.Bar
find($env, false)?.Bar()
find($env, false)?.String
find($env, false)?.String?.foo
find($env, false)?.[add]
find($env, false)?.[array]
find($env, false)?.[f64]
find($env, false)?.[foo]
find($env, false)?.[greet]
find($env, false)?.[greet].i()
find($env, false)?.[greet].str
find($env, false)?.[i]
find($env, false)?.[i]?.foo
find($env, false)?.[list]
find($env, false)?.[ok]
find($env, false)?.[str]
find($env, false)?.[str]?.greet
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)?.f64?.[array]
find($env, false)?.foo
find($env, false)?.foo()
find($env, false)?.greet
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, false)?.ok()
find($env, false)?.str
find($env.array, # > #)
find($env.array, $env.ok)
find($env.array, i != 1.0)
find($env.array, ok)
find($env.list, $env != .String)
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([$env], .ok)
find([1, greet], f64 < 1.0)
find([array], nil in $env)
find([array], ok)
find([false], #)
find([ok], #)
find([str, true], ok)
find([str], ok)
find(array, !false)
find(array, # != 0)
find(array, # != nil)
find(array, # < #)
find(array, # < 0)
find(array, # <= #)
find(array, # <= 0)
find(array, # <= i)
find(array, # == 1)
find(array, # > #)
find(array, $env != $env)
find(array, $env == foo)
find(array, $env | any(false))
find(array, $env.ok)
find(array, $env?.ok)
find(array, 0 != f64)
find(array, 0 <= 1)
find(array, 0 >= #)
find(array, 1 != f64)
find(array, 1 > i)
find(array, 1.0 != #)
find(array, 1.0 != nil)
find(array, 1.0 <= #)
find(array, 1.0 == nil)
find(array, 1.0 >= 1.0)
find(array, array != list)
find(array, array | one(true))
find(array, f64 != #)
find(array, false == nil)
find(array, i != nil)
find(array, nil != ok)
find(array, nil != true)
find(array, not false)
find(array, ok or false)
find(array, ok)
find(array, str not contains str)
find(array, true ?? #)
find(array, true ?? 1)
find(array, true) - i
find(array, true) | max(array)
find(filter($env, false), .list in #.list)
find(list ?? list, ok)
find(list, # != #)
find(list, #.String == .String)
find(list, $env != list)
find(list, $env == nil)
find(list, $env == ok)
find(list, $env not in array)
find(list, $env.ok)
find(list, $env?.ok)
find(list, 0 > i)
find(list, 1 == 1.0)
find(list, 1.0 != 1)
find(list, 1.0 <= i)
find(list, 1.0 > f64)
find(list, array != $env)
find(list, array == list)
find(list, false != nil)
find(list, false) ?? list
find(list, false)?.Bar
find(list, foo != #)
find(list, foo != $env)
find(list, foo != nil)
find(list, nil != #.Bar)
find(list, nil == str)
find(list, nil == true)
find(list, ok)
find(list, ok).Bar
find(list, ok).String
find(list, ok)?.Bar
find(list, ok)?.String
find(list, str == $env)
find(list, true ?? $env)
find(list, true).Bar
find(list, true).String
find(list, true)?.Bar
find(list, true)?.String
find(map($env, $env), foo == #)
find(map(array, 1.0), i != 1.0)
find(map(list, #), ok)
find(map(list, 0), ok)
find(max($env), $env == i)
find(nil ?? array, # > #)
find(nil ?? list, # == #)
find(sort($env), #.array.f64)
find(sort($env), #.f64 not startsWith .String)
find(sort($env), #.foo)
find(sort($env), .foo?.[greet])
find(sort($env), .greet.Bar)
find(sort($env), .list?.foobar)
find(sort($env), .str?.ok)?.[ok]
find(toPairs($env), $env.ok)
find(toPairs($env), ok)
find(values($env), ok ?? 1)
findIndex($env | map(i), # > f64)
findIndex($env, ok) > -f64
findIndex($env, ok) >= f64
findIndex($env, ok) ?? f64
findIndex($env, ok) ?? foo
findIndex($env, true) <= f64
findIndex($env, true) ?? 1.0 ?? $env
findIndex($env.array, ok)
findIndex($env.list, ok)
findIndex($env?.[str], 1.0 == nil)
findIndex($env?.array, # < #)
findIndex($env?.array, nil == greet)
findIndex($env?.list, ok)
findIndex([0], # <= 1)
findIndex([1.0, foo], not ok)
findIndex([1.0], # > 1.0)
findIndex([add], ok)
findIndex([array], ok)
findIndex([f64], ok)
findIndex([false], #)
findIndex([false], ok)
findIndex([foo], ok)
findIndex([list], $env == add)
findIndex([ok], #)
findIndex([str], $env?.ok)
findIndex([true], #)
findIndex(array | sortBy(1.0), ok)
findIndex(array, !false)
findIndex(array, !true)
findIndex(array, # != #)
findIndex(array, # != nil)
findIndex(array, # <= #)
findIndex(array, # == 1.0)
findIndex(array, # > #)
findIndex(array, # >= #)
findIndex(array, $env != $env)
findIndex(array, $env != 0)
findIndex(array, $env != true)
findIndex(array, $env == #)
findIndex(array, $env.ok)
findIndex(array, $env?.ok)
findIndex(array, 0 == #)
findIndex(array, 0 == i)
findIndex(array, 1 <= #)
findIndex(array, 1.0 != $env)
findIndex(array, 1.0 < #)
findIndex(array, 1.0 == $env)
findIndex(array, 1.0 >= #)
findIndex(array, add == nil)
findIndex(array, f64 > f64)
findIndex(array, false || ok)
findIndex(array, foo == nil)
findIndex(array, nil != #)
findIndex(array, nil != foo)
findIndex(array, not true)
findIndex(array, ok)
findIndex(array, ok) ^ f64
findIndex(array, reduce(list, true))
findIndex(array, true || $env)
findIndex(array, true || false)
findIndex(array, true) / i
findIndex(array, true) == $env != nil
findIndex(array, true) | min(array)
findIndex(filter($env, false), #.list(foobar))
findIndex(flatten(list), # != list)
findIndex(flatten(list), .String != ok)
findIndex(list | map(add), not ok)
findIndex(list, !ok)
findIndex(list, !true)
findIndex(list, # != nil)
findIndex(list, # == #)
findIndex(list, # == nil)
findIndex(list, $env != .String)
findIndex(list, $env != true)
findIndex(list, $env == false)
findIndex(list, $env == i)
findIndex(list, .Bar == $env)
findIndex(list, all($env, true))
findIndex(list, f64 <= f64)
findIndex(list, f64 == 1.0)
findIndex(list, foo != $env)
findIndex(list, foo == foo)
findIndex(list, greet == nil)
findIndex(list, nil != $env)
findIndex(list, none(array, ok))
findIndex(list, not false)
findIndex(list, ok ?? ok)
findIndex(list, ok)
findIndex(list, ok) * f64
findIndex(list, str in #)
findIndex(list, str not contains str)
findIndex(list, true) | min(1.0)
findIndex(map($env, $env), #.String contains #)
findIndex(map($env, $env), ok) ?? add
findIndex(max($env), i > f64)
findIndex(nil ?? $env, ok)
findIndex(sort($env), #.String?.list(foobar))
findIndex(sort($env), #.f64 - #.i)
findIndex(sort($env), #.str && #.f64)
findIndex(sort($env), .array)
findIndex(sort($env), list not in .Bar)
findIndex(sort(array), # == false)
findIndex(values($env), 1 != 1.0)
findLast($env, false) == greet
findLast($env, false)?.Bar
findLast($env, false)?.String
findLast($env, false)?.String?.str
findLast($env, false)?.[add]
findLast($env, false)?.[array]
findLast($env, false)?.[f64]
findLast($env, false)?.[foo]
findLast($env, false)?.[greet]
findLast($env, false)?.[greet]?.Bar
findLast($env, false)?.[i]
findLast($env, false)?.[i].array
findLast($env, false)?.[list]
findLast($env, false)?.[ok]
findLast($env, false)?.[str]
findLast($env, false)?.add()
findLast($env, false)?.array
findLast($env, false)?.array()
findLast($env, false)?.f64
findLast($env, false)?.f64()
findLast($env, false)?.f64?.[str]
findLast($env, false)?.foo
findLast($env, false)?.fromPairs(i)
findLast($env, false)?.greet
findLast($env, false)?.greet()
findLast($env, false)?.i
findLast($env, false)?.i()
findLast($env, false)?.list
findLast($env, false)?.list()
findLast($env, false)?.list(foobar?.f64)
findLast($env, false)?.ok
findLast($env, false)?.ok()
findLast($env, false)?.reduce(String)
findLast($env, false)?.str
findLast($env.array, # >= #)
findLast($env.array, ok)
findLast($env.array, str in $env)
findLast($env.list, !false)
findLast($env.list, ok)
findLast($env?.[str], # not in array)
findLast($env?.[str], 1 == 1.0)
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([$env], .Bar != str)
findLast([1.0], ok)
findLast([f64, true], if # { # } else { # })
findLast([f64], 1 != $env)
findLast([false], $env | none(true))
findLast([foo], ok)
findLast([list], ok)
findLast([ok], #)
findLast([ok], ok)
findLast([true], ok)
findLast(array ?? 0, # != 1.0)
findLast(array | map(#index), ok)
findLast(array | sortBy(0), 1 < 1)
findLast(array, # != #)
findLast(array, # < #)
findLast(array, # < f64)
findLast(array, # <= #)
findLast(array, # > 1)
findLast(array, # > 1.0)
findLast(array, # >= #)
findLast(array, # >= 1.0)
findLast(array, # >= i)
findLast(array, $env != 1)
findLast(array, $env == $env)
findLast(array, $env == true)
findLast(array, $env?.ok)
findLast(array, 0 >= 1.0)
findLast(array, 0 in array)
findLast(array, 1 != #)
findLast(array, 1 < 1)
findLast(array, 1 > 1.0)
findLast(array, 1.0 == nil)
findLast(array, 1.0 >= 1.0)
findLast(array, f64 < 0)
findLast(array, f64 < 1.0)
findLast(array, f64 < f64)
findLast(array, f64 > #)
findLast(array, f64 >= 1.0)
findLast(array, f64 >= i)
findLast(array, false || true)
findLast(array, i < #)
findLast(array, nil != #)
findLast(array, nil != nil)
findLast(array, none($env, false))
findLast(array, not ok)
findLast(array, ok ?: 1.0)
findLast(array, ok ?? #)
findLast(array, ok)
findLast(array, ok) + i
findLast(array, ok) >= f64
findLast(array, ok) in array
findLast(array, str not in foo)
findLast(concat(list), !true)
findLast(filter(list, false), $env?.[array])
findLast(flatten(array), true ?? .ok)
findLast(flatten(list), ok)
findLast(keys($env), foo == foo)
findLast(list ?? list, ok)
findLast(list | sortBy(0), # == #)
findLast(list, # != #)
findLast(list, # != $env)
findLast(list, # != nil)
findLast(list, # == $env)
findLast(list, # == foo)
findLast(list, #.Bar in #)
findLast(list, #.String != nil)
findLast(list, $env != 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, .Bar matches str)
findLast(list, 0 != 1.0)
findLast(list, 1 != f64)
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, f64 > i)
findLast(list, false)?.Bar
findLast(list, foo != #)
findLast(list, foo == #)
findLast(list, i == $env)
findLast(list, i > 0)
findLast(list, nil == #)
findLast(list, nil == greet)
findLast(list, ok)
findLast(list, ok).Bar
findLast(list, ok).String
findLast(list, ok).String()
findLast(list, ok)?.Bar
findLast(list, str != nil)
findLast(list, str not contains str)
findLast(list, str startsWith str)
findLast(list, true && false)
findLast(list, true ?? add)
findLast(list, true) ?? i
findLast(list, true).Bar
findLast(list, true).String
findLast(list, true).String()
findLast(list, true)?.Bar
findLast(map(list, ok), #)
findLast(min($env), .array and false)
findLast(sort($env), #)
findLast(sort($env), .array)
findLast(sort($env), .f64 != #.i)
findLast(sort($env), .greet.array)?.list
findLast(sort($env), .list?.list)
findLast(sort($env), 1.0 != #.list)
findLast(uniq(array), ok)
findLast(values($env), # != foo)
findLast(values($env), ok)
findLastIndex($env ?? 1, true || #)
findLastIndex($env ?? foo, ok)
findLastIndex($env | filter(false), #.add)
findLastIndex($env, ok) > i
findLastIndex($env, ok) ^ f64
findLastIndex($env, true) + i
findLastIndex($env, true) <= f64
findLastIndex($env, true) ^ i
findLastIndex($env, true) | bitor(1)
findLastIndex($env, true) | bitshl(1)
findLastIndex($env.array, # >= 1)
findLastIndex($env.array, ok)
findLastIndex($env.array, true == ok)
findLastIndex($env?.[str], 1.0 > #)
findLastIndex($env?.[str], ok)
findLastIndex($env?.array, # != #)
findLastIndex($env?.array, $env != $env)
findLastIndex($env?.array, ok)
findLastIndex([$env], #.f64 == true)
findLastIndex([$env], #.f64 not endsWith .String)
findLastIndex([false, 0], ok)
findLastIndex([false, true, $env], #.greet != true)
findLastIndex([list], foo not in #)
findLastIndex([true], #)
findLastIndex([true], str < str)
findLastIndex(array ?? 1.0, ok)
findLastIndex(array ?? foo, ok)
findLastIndex(array, !false)
findLastIndex(array, # != 0)
findLastIndex(array, # < #)
findLastIndex(array, # < i)
findLastIndex(array, # <= #)
findLastIndex(array, # == $env)
findLastIndex(array, # == f64)
findLastIndex(array, # > #)
findLastIndex(array, $env != false)
findLastIndex(array, $env == 1.0)
findLastIndex(array, $env.ok)
findLastIndex(array, $env?.ok)
findLastIndex(array, 0 == $env)
findLastIndex(array, 1 >= 1.0)
findLastIndex(array, 1.0 == #)
findLastIndex(array, add == nil)
findLastIndex(array, any($env, false))
findLastIndex(array, false && $env)
findLastIndex(array, false) != 1.0 + 1.0
findLastIndex(array, i >= # != false)
findLastIndex(array, nil != 1.0)
findLastIndex(array, nil != array)
findLastIndex(array, nil == ok)
findLastIndex(array, not false)
findLastIndex(array, ok ?? false)
findLastIndex(array, ok)
findLastIndex(array, str in foo)
findLastIndex(array, str not in $env)
findLastIndex(array, true ?? ok)
findLastIndex(array, true || $env)
findLastIndex(array, true) * 1.0 + 1
findLastIndex(array, true) * f64
findLastIndex(array, true) ?? sortBy(array, 1.0)
findLastIndex(array, true) | bitushr(i)
findLastIndex(false ? nil : $env, ok)
findLastIndex(flatten(array), ok)
findLastIndex(flatten(list), ok)
findLastIndex(list, !true)
findLastIndex(list, # == #)
findLastIndex(list, #.Bar == nil)
findLastIndex(list, #.Bar matches str)
findLastIndex(list, $env.ok)
findLastIndex(list, .Bar in foo)
findLastIndex(list, 0 != 1)
findLastIndex(list, 0 > 1.0)
findLastIndex(list, 0 >= 1.0)
findLastIndex(list, 1.0 >= f64)
findLastIndex(list, false ? foo : ok)
findLastIndex(list, foo != #)
findLastIndex(list, foo != $env)
findLastIndex(list, foo == #)
findLastIndex(list, foo not in list)
findLastIndex(list, i > f64)
findLastIndex(list, nil != #)
findLastIndex(list, nil != foo)
findLastIndex(list, nil != nil)
findLastIndex(list, nil == 1)
findLastIndex(list, nil in $env)
findLastIndex(list, not false)
findLastIndex(list, ok != false)
findLastIndex(list, ok)
findLastIndex(list, ok) < i
findLastIndex(list, one(list, false))
findLastIndex(list, str == $env)
findLastIndex(list, str not in #)
findLastIndex(list, str not startsWith .Bar)
findLastIndex(list, true) > f64
findLastIndex(list, true) ?? greet
findLastIndex(map($env, str), ok)
findLastIndex(map(array, ok), #)
findLastIndex(map(list, add), ok)
findLastIndex(sort($env), # contains #)
findLastIndex(sort($env), #.foo?.greet)
findLastIndex(sort($env), $env ?: #.i)
findLastIndex(sort($env), ok)
first($env ?? $env)
first($env ?? 0)
first($env ?? 1)
first($env ?? 1.0)
first($env ?? foo)
first($env ?? foo) not in list
first($env ?? greet)
first($env ?? i)
first($env ?? str)
first($env ?? true)
first($env ?? true)?.i
first($env | findLast(false))
first($env | map(#index))
first($env | map($env))
first($env | map($env))?.foo
first($env | map(1))
first($env) != $env?.f64
first($env) != foo
first($env) != i
first($env) == i
first($env) == str
first($env) ?? array
first($env) ?? list
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) | get(1.0)
first($env)?.$env?.array()
first($env)?.Bar
first($env)?.Bar()
first($env)?.Bar(add)
first($env)?.Bar?.add
first($env)?.String
first($env)?.String()
first($env)?.String?.array
first($env)?.String?.foo
first($env)?.[add]
first($env)?.[add].list()
first($env)?.[add]?.[foo]
first($env)?.[add]?.i
first($env)?.[array]
first($env)?.[f64]
first($env)?.[f64].String
first($env)?.[f64].list
first($env)?.[f64]?.String
first($env)?.[foo]
first($env)?.[foo]?.[greet].String
first($env)?.[greet]
first($env)?.[greet]?.[greet]
first($env)?.[greet]?.f64
first($env)?.[greet]?.str
first($env)?.[i]
first($env)?.[i]?.String
first($env)?.[i]?.[foo]
first($env)?.[i]?.add
first($env)?.[i]?.i
first($env)?.[i]?.str
first($env)?.[list]
first($env)?.[list].Bar?.str().ok?.[str]
first($env)?.[list].list
first($env)?.[ok]
first($env)?.[ok].add()
first($env)?.[ok].list
first($env)?.[str]
first($env)?.[str].String
first($env)?.[str].f64
first($env)?.[str]?.[str]
first($env)?.[str]?.f64
first($env)?.[str]?.ok
first($env)?.[str]?.str
first($env)?.add
first($env)?.add()
first($env)?.add()?.add()
first($env)?.add.String
first($env)?.add.f64
first($env)?.add.greet()
first($env)?.add?.String
first($env)?.add?.[greet]
first($env)?.add?.[i]
first($env)?.add?.[list]
first($env)?.any(foobar)
first($env)?.any(foobar, ok)
first($env)?.array
first($env)?.array()
first($env)?.array(foobar)
first($env)?.array.ok
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()?.Bar
first($env)?.foo(foo)?.[list]
first($env)?.foo(foobar not contains foobar)
first($env)?.foo(foobar)
first($env)?.foo?.[greet]
first($env)?.foobar
first($env)?.foobar not in $env
first($env)?.foobar.greet
first($env)?.foobar.list
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?.Bar
first($env)?.greet?.[f64]
first($env)?.greet?.[i]
first($env)?.greet?.[str]
first($env)?.greet?.str
first($env)?.i
first($env)?.i()
first($env)?.i.i
first($env)?.i?.add
first($env)?.indexOf(foobar)
first($env)?.list
first($env)?.list()
first($env)?.list().Bar
first($env)?.list(Bar)
first($env)?.list(foo)
first($env)?.list(foobar)
first($env)?.list(foobar).String
first($env)?.list(foobar?.[Bar])
first($env)?.list.str
first($env)?.list?.[foo]
first($env)?.list?.[str]
first($env)?.list?.add
first($env)?.map(add)
first($env)?.ok
first($env)?.ok()
first($env)?.ok()?.[ok]
first($env)?.ok(foobar)
first($env)?.str
first($env)?.str()
first($env)?.str(f64)
first($env)?.toJSON(String)
first($env.array)
first($env.list)
first($env?.$env)
first($env?.$env?.f64)
first($env?.Bar)
first($env?.Bar)?.array
first($env?.Bar?.[array])
first($env?.Bar?.[foo])
first($env?.Bar?.f64)
first($env?.String)
first($env?.String)?.String
first($env?.String)?.String()
first($env?.String)?.i
first($env?.[Bar])
first($env?.[Bar])?.[i]
first($env?.[Bar])?.[str]
first($env?.[Bar])?.str
first($env?.[Bar]?.String)
first($env?.[Bar]?.f64)
first($env?.[String])
first($env?.[String])?.String()
first($env?.[String])?.str
first($env?.[String]?.f64)
first($env?.[String]?.foo)
first($env?.[foobar])
first($env?.[foobar])?.Bar
first($env?.[nil])
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?.foobar?.str)
first($env?.greet ?? ok)
first($env?.list)
first($env?.nil)
first($env?.nil)?.f64
first($env?.true)
first(0 .. 0)
first(0 .. i)
first(0 ?? $env)
first(0 ?? array)
first(0 ?? false)
first(0 ?? foo)
first(0 ?? greet)
first(0 ?? str)
first(0 ?? true)
first(0..i)
first(1 .. 0)
first(1 .. i)
first(1 ?? $env)
first(1 ?? 1.0)
first(1 ?? foo)
first(1 ?? ok)
first(1 ?? true)
first(1 | median(array))
first(1.0 ?? $env)
first(1.0 ?? $env.list)
first(1.0 ?? 0)
first(1.0 ?? 1)
first(1.0 ?? add)
first(1.0 ?? false)
first(1.0 ?? foo)
first(1.0 ?? greet)
first(1.0 ?? i)
first(1.0 ?? list)
first(1.0 | min(array))
first([$env, array])
first([$env?.array])
first([$env])
first([0, array])
first([0])
first([1 > 1.0])
first([1, add])
first([1.0, 1.0])
first([1.0])
first([1])
first([add, $env, greet])
first([add])
first([array])
first([f64])
first([false, $env])
first([false, str])
first([false])
first([floor(f64)])
first([foo ?? foo])
first([foo])
first([greet])
first([i])
first([list])
first([nil, array])
first([nil])
first([ok])
first([str])
first([true])
first([type(greet)])
first(add ?? $env)?.f64
first(add ?? 0)
first(add ?? 1)
first(add ?? foo)
first(add ?? list)
first(add ?? str)
first(add ?? true)
first(array ?? $env)
first(array ?? add)
first(array ?? array)
first(array ?? i)
first(array ?? nil)
first(array ?? ok)
first(array | map(#))
first(array | map($env))
first(array | map(0))
first(array | map(1.0))
first(array | map(foo))
first(array | reduce($env, foo))
first(array | reduce(list, nil))
first(array | sortBy(#))
first(array | sortBy(1.0))
first(array | take(1))
first(array)
first(array) != i
first(array) * $env?.i
first(array) / i != nil
first(array) == i
first(array) > 1.0 > $env
first(array) > f64
first(array) >= $env.f64
first(array) ?? $env?.String()
first(array) ?? foo
first(array) ?? list
first(array) | bitand(1)
first(array) | bitshr(1)
first(array[:0])
first(array[:1])
first(concat(array) | reduce(#))
first(concat(array))
first(concat(list))
first(f64 ?? $env)?.[foo]
first(f64 ?? 1)
first(f64 ?? array)
first(f64 ?? greet)
first(f64 ?? i)
first(f64 ?? list)
first(f64 ?? str)
first(f64 | mean(array, 1))
first(false ? i : list)
first(false ?? $env)
first(false ?? 1)
first(false ?? 1.0)
first(false ?? add)
first(false ?? foo)
first(false ?? str)
first(filter($env, false))
first(filter(list, ok))
first(find($env, false))
first(find($env, false))?.foo
first(first($env))
first(first($env))?.[add]
first(flatten(array))
first(flatten(list))
first(foo ?? $env)
first(foo ?? $env.add)
first(foo ?? 0)
first(foo ?? 1)
first(foo ?? 1.0)
first(foo ?? add)
first(foo ?? array)
first(foo ?? f64)
first(foo ?? false)
first(foo ?? greet)
first(foo ?? i)
first(foo ?? list)
first(foo ?? ok)
first(foo ?? str)
first(foo ?? true)
first(greet ?? 1)
first(greet ?? 1.0)
first(greet ?? f64)
first(greet ?? foo.Bar)
first(greet ?? i)
first(greet ?? list)
first(greet ?? true)
first(i .. 1)
first(i ?? $env)
first(i ?? f64)
first(i ?? false)
first(i ?? greet)
first(i ?? ok)
first(i..i)
first(if false { 0 } else { foo })
first(if false { foo } else { greet })
first(if false { foo } else { str })
first(if ok { foo } else { false })
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 ?? add)
first(list ?? f64)
first(list ?? false)
first(list ?? str)
first(list | map(#))
first(list | map(#.Bar))
first(list | map(0))
first(list | map(add))
first(list | map(false))
first(list | map(true))
first(list | reduce(list))
first(list | sortBy(#.Bar))
first(list)
first(list) == $env?.String
first(list) ?? $env?.[add]
first(list) ?? f64
first(list) ?? foo
first(list) ?? greet
first(list).Bar
first(list).String
first(list).String()
first(list)?.Bar
first(list)?.String
first(list)?.String()
first(list[:0])
first(list[:1])
first(list[:i])
first(map($env, $env))
first(map($env, 0))
first(map($env, 1))
first(map($env, array))
first(map($env, f64))
first(map($env, false))
first(map($env, i))
first(map($env, ok))
first(map(array, #))
first(map(array, #index))
first(map(array, $env))
first(map(array, 0))
first(map(array, 1))
first(map(array, 1.0))
first(map(array, false))
first(map(array, greet))
first(map(array, list))
first(map(array, str))
first(map(array, true))
first(map(list, #))
first(map(list, $env) | findLast(true))
first(map(list, 0))
first(map(list, array))
first(map(list, f64))
first(map(list, foo))
first(max($env))
first(max(array))
first(mean(array))
first(median(array))
first(min($env))
first(min($env))?.add
first(min($env)?.f64)
first(min(array))
first(min(array, 1, 1))
first(nil ?? $env)
first(nil ?? array)
first(ok ? 0 : 1.0)
first(ok ? add : false)
first(ok ? ok : $env)
first(ok ?: $env)
first(ok ?: add)
first(ok ?: list)
first(ok ?? $env)
first(ok ?? 0)
first(ok ?? 1.0)
first(ok ?? foo)
first(ok ?? foo)?.[list]
first(ok ?? greet)
first(reduce(array, $env))
first(reduce(list, list, $env))
first(reverse(array))
first(reverse(list))
first(sort($env))
first(sort(array))
first(sortBy(array, #))
first(sortBy(array, 1))
first(sortBy(array, f64))
first(sortBy(list, .Bar))
first(str ?? 0)
first(str ?? 1)
first(str ?? 1.0)
first(str ?? add)
first(str ?? i)
first(str ?? ok)
first(take(array, i))
first(toPairs($env))
first(true ? 1.0 : foo)
first(true ?: 1.0)?.str
first(true ?: str)
first(true ?? add)
first(true ?? foo)
first(true ?? list)
first(uniq(array))
first(uniq(list))
first(values($env))
first({foo: 1.0}.f64)
first({foo: greet, foo: nil}.ok)
first({foo: i, foo: f64}.String)
flatten($env | map($env))
flatten($env | map(1.0))
flatten($env | map(add))
flatten($env | map(array))
flatten($env | map(foo))
flatten($env | map(i))
flatten($env | map(list))
flatten($env.array)
flatten($env.list)
flatten($env?.array)
flatten($env?.list)
flatten($env?.list)?.[i]
flatten(0 .. i)
flatten(1 .. 0)
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, i])
flatten([add])
flatten([array, f64])
flatten([array, ok])
flatten([array])
flatten([f64, $env, 1])
flatten([f64, nil])
flatten([f64])
flatten([false, list])
flatten([false])
flatten([foo, 0])
flatten([foo, 1.0])
flatten([foo, str])
flatten([foo])
flatten([greet, foo])
flatten([greet])
flatten([i, list])
flatten([i])
flatten([list])
flatten([nil == ok])
flatten([nil])
flatten([ok, array])
flatten([ok, true])
flatten([ok])
flatten([str, list])
flatten([str])
flatten([true])
flatten(array ?? 0)
flatten(array ?? 1)
flatten(array ?? add)
flatten(array ?? f64)
flatten(array ?? foo)
flatten(array ?? list)
flatten(array ?? nil)
flatten(array ?? true)
flatten(array | map(#))
flatten(array | map(1.0))
flatten(array | map(array))
flatten(array | map(false))
flatten(array | reduce(array, false))
flatten(array | sortBy(#))
flatten(array | sortBy(1.0))
flatten(array | sortBy(i))
flatten(array)
flatten(array) != array
flatten(array) == array
flatten(array) == list
flatten(array) ?? greet
flatten(array) ?? i
flatten(array) | filter(ok)
flatten(array) | groupBy(#)
flatten(array) | groupBy(1.0)
flatten(array) | groupBy(f64)
flatten(array) | map(#)
flatten(array) | map(ok)
flatten(array) | min(1.0)
flatten(array) | one(true)
flatten(array) | reduce(#)
flatten(array) | reduce(1.0)
flatten(array) | reduce(foo)
flatten(array) | reduce(true)
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(flatten(list))
flatten(groupBy(array, #).String)
flatten(groupBy(list, #).i)
flatten(i .. 0)
flatten(i..i)
flatten(if ok { array } else { foo })
flatten(if ok { list } else { array })
flatten(if true { array } else { add })
flatten(keys($env))
flatten(let z = array; z)
flatten(list ?? $env)
flatten(list ?? 1)
flatten(list ?? 1.0)
flatten(list ?? nil)
flatten(list | map(#))
flatten(list | map(i))
flatten(list | sortBy(0))
flatten(list | sortBy(f64))
flatten(list | sortBy(str))
flatten(list)
flatten(list) == list
flatten(list) | filter(true)
flatten(list) | findLast(ok)
flatten(list) | findLastIndex(false)
flatten(list) | groupBy(!ok)
flatten(list) | groupBy(#)
flatten(list) | groupBy(foo)
flatten(list) | groupBy(i)
flatten(list) | map(1.0)
flatten(list) | map(add)
flatten(list) | map(f64)
flatten(list) | map(false)
flatten(list) | map(foo)
flatten(list) | map(ok)
flatten(list) | none(true)
flatten(list) | reduce(#)
flatten(list) | reduce($env, $env)
flatten(list) | reduce(1.0)
flatten(list) | sortBy(0)
flatten(list) | sortBy(1.0)
flatten(list) | sortBy(str)
flatten(list) | sum(1)
flatten(list)?.[i]
flatten(list)[:]
flatten(list[0:])
flatten(list[1:])
flatten(list[:])
flatten(map($env, $env))
flatten(map($env, 0))
flatten(map($env, 1.0))
flatten(map($env, f64))
flatten(map($env, false))
flatten(map(array, f64))
flatten(map(array, i))
flatten(map(array, true))
flatten(map(list, #))
flatten(map(list, $env))
flatten(map(list, .Bar))
flatten(map(list, f64))
flatten(map(list, ok))
flatten(nil ?? array)
flatten(nil ?? list)
flatten(reduce(array, array))
flatten(reverse(array))
flatten(reverse(list))
flatten(sort($env))
flatten(sort(array))
flatten(sortBy(array, #))
flatten(sortBy(array, 1))
flatten(sortBy(array, 1.0))
flatten(sortBy(array, f64))
flatten(sortBy(list, 1.0))
flatten(sortBy(list, i))
flatten(toPairs($env))
flatten(true ? list : list)
flatten(uniq(array))
flatten(uniq(list))
flatten(values($env))
float($env | findIndex(true))
float($env | findLastIndex(ok))
float($env | findLastIndex(true))
float($env | sum(0))
float($env | sum(1.0))
float($env | sum(f64))
float($env | sum(i))
float($env.f64)
float($env.i)
float($env?.f64)
float($env?.i)
float(-0)
float(-1)
float(-1.0)
float(-f64)
float(-i)
float(0 % 1)
float(0 % i)
float(0 * 1)
float(0 * 1.0)
float(0 * f64)
float(0 ** 1)
float(0 ** 1.0)
float(0 ** f64)
float(0 ** i)
float(0 + 1)
float(0 + i)
float(0 - 1)
float(0 - 1.0)
float(0 - i)
float(0 / 0)
float(0 / 1.0)
float(0 / f64)
float(0 / i)
float(0 ?? $env)
float(0 ?? $env?.[i])
float(0 ?? false)
float(0 ?? greet)
float(0 ?? nil)
float(0 ?? true)
float(0 ^ 0)
float(0 ^ 1)
float(0 ^ 1.0)
float(0 ^ f64)
float(0 ^ i)
float(0 | median(1.0))
float(0) != $env && ok
float(0) != 1.0 && false
float(0) ** f64
float(0) + $env?.f64
float(0) - float(0)
float(0) > f64
float(0) > i
float(0) >= -1
float(0) ^ f64
float(1 % 1)
float(1 % i)
float(1 * 1)
float(1 * 1.0)
float(1 * f64)
float(1 * i)
float(1 ** 1)
float(1 ** 1.0)
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 / 0)
float(1 / 1)
float(1 / 1.0)
float(1 ?? $env)
float(1 ?? $env?.array)
float(1 ?? 0)
float(1 ?? 1.0)
float(1 ?? add)
float(1 ?? nil)
float(1 ?? ok)
float(1 ^ 0)
float(1 ^ 1)
float(1 ^ 1.0)
float(1 ^ i)
float(1) + i
float(1) - f64
float(1) < f64
float(1) == f64
float(1) == i
float(1) ?? f64
float(1) ?? foo ?? $env
float(1) ?? str
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 ** 0)
float(1.0 ** 1)
float(1.0 ** 1.0)
float(1.0 ** f64)
float(1.0 ** i)
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 / 0)
float(1.0 / 1)
float(1.0 / 1.0)
float(1.0 / f64)
float(1.0 / i)
float(1.0 ?? $env)
float(1.0 ?? 0)
float(1.0 ?? 1)
float(1.0 ?? 1.0)
float(1.0 ?? add)
float(1.0 ?? array)
float(1.0 ?? f64)
float(1.0 ?? false)
float(1.0 ?? foo)
float(1.0 ?? i)
float(1.0 ?? list)
float(1.0 ?? nil)
float(1.0 ?? str)
float(1.0 ^ 0)
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) ** i
float(1.0) - f64
float(1.0) - i
float(1.0) / i
float(1.0) < i
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(1.0) | median(1.0)
float(abs(0))
float(abs(1))
float(abs(1.0))
float(abs(f64))
float(abs(i))
float(add(0, i))
float(add(1, 1))
float(array | findLastIndex(true))
float(array | max(1))
float(array | reduce(#acc))
float(array | reduce(#index, 1.0))
float(array | reduce(1))
float(array | sum(#))
float(array | sum(0))
float(array | sum(1.0))
float(array?.[i])
float(bitand(0, i))
float(bitnot(0))
float(bitnot(1))
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($env, ok))
float(count(array, true))
float(count(list, false))
float(count(list, ok))
float(f64 * 1)
float(f64 * 1.0)
float(f64 * f64)
float(f64 ** 0)
float(f64 ** 1)
float(f64 ** 1.0)
float(f64 + 0)
float(f64 + 1.0)
float(f64 + f64)
float(f64 + i)
float(f64 - 1.0)
float(f64 / 0)
float(f64 / 1)
float(f64 / 1.0)
float(f64 / f64)
float(f64 / i)
float(f64 ?? 1)
float(f64 ?? 1.0)
float(f64 ?? add)
float(f64 ?? f64)
float(f64 ?? greet)
float(f64 ?? true)
float(f64 ^ 0)
float(f64 ^ 1)
float(f64 ^ 1.0)
float(f64)
float(f64) != f64
float(f64) * 1.0 ** i
float(f64) ** f64
float(f64) / max(1)
float(f64) == i
float(f64) ?? greet
float(f64) ?? upper(str)
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, ok))
float(findLastIndex($env, true))
float(findLastIndex(array, ok))
float(first(array))
float(float(0))
float(float(1))
float(float(1.0))
float(float(f64))
float(float(i))
float(floor(0))
float(floor(1))
float(floor(1.0))
float(floor(f64))
float(floor(i))
float(i % 1)
float(i * 0)
float(i * 1.0)
float(i * f64)
float(i ** 1.0)
float(i ** i)
float(i + 0)
float(i + 1)
float(i + 1.0)
float(i - 0)
float(i - 1)
float(i - 1.0)
float(i - f64)
float(i - i)
float(i / 0)
float(i / 1)
float(i / 1.0)
float(i ?? $env)
float(i ?? 1)
float(i ?? 1.0)
float(i ?? add)
float(i ?? foo)
float(i ?? nil)
float(i ?? true)
float(i ^ i)
float(i | bitor(0))
float(i)
float(i) + first(array)
float(i) == i
float(i) > f64
float(i) in $env?.[String]
float(i) | max(f64)
float(if false { 1.0 } else { 1 })
float(if false { greet } else { 1 })
float(if false { greet } else { 1.0 })
float(if false { ok } else { 1.0 })
float(if true { 0 } else { $env })
float(if true { 1.0 } else { $env })
float(if true { 1.0 } else { i })
float(int(0))
float(int(1))
float(int(1.0))
float(int(f64))
float(int(i))
float(last(array))
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(1.0))
float(list | sum(f64))
float(max($env?.f64))
float(max(0))
float(max(1))
float(max(1.0))
float(max(f64, 1))
float(max(f64, 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(f64, 1))
float(mean(i))
float(median(0))
float(median(1))
float(median(1.0))
float(median(1.0, 0, 0))
float(median(1.0, i))
float(median(array))
float(median(array, f64))
float(median(f64))
float(median(i))
float(min($env).f64)
float(min($env?.array))
float(min(0))
float(min(0, 1))
float(min(1))
float(min(1.0))
float(min(array))
float(min(f64))
float(min(i))
float(nil ?? 1.0)
float(reduce($env, 1.0, 1.0))
float(reduce(array, #))
float(reduce(list, 0))
float(reduce(list, 1))
float(reduce(list, i))
float(round(0))
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(string(i))
float(sum($env, 0))
float(sum($env, 1))
float(sum($env, 1.0))
float(sum($env.array))
float(sum($env?.array))
float(sum(array))
float(sum(array, #))
float(sum(array, 1))
float(sum(array, i))
float(sum(list, 1))
float(toJSON(0))
float(toJSON(1))
float(toJSON(1.0))
float(toJSON(f64))
float(toJSON(i))
float(toJSON(min(1.0)))
float(true ? 1.0 : ok)
float(true ? f64 : foo)
float(true ? f64 : str)
floor($env | count(true))
floor($env | findIndex(ok))
floor($env | findLastIndex(true))
floor($env | reduce(f64, f64))
floor($env.array?.[i])
floor($env.f64)
floor($env.i)
floor($env?.add(i, 1))
floor($env?.f64)
floor($env?.i ^ f64)
floor($env?.i)
floor(-0)
floor(-1)
floor(-1.0)
floor(-f64)
floor(-i)
floor(0 % i)
floor(0 * 1)
floor(0 * 1.0)
floor(0 * f64)
floor(0 * i)
floor(0 ** 0)
floor(0 ** 1.0)
floor(0 ** f64)
floor(0 ** i)
floor(0 + 1.0)
floor(0 + f64)
floor(0 - 0)
floor(0 - 1)
floor(0 - 1.0)
floor(0 - f64)
floor(0 - i)
floor(0 / 0)
floor(0 / 1)
floor(0 / f64)
floor(0 / i)
floor(0 ?? add)
floor(0 ?? array)
floor(0 ?? foo)
floor(0 ?? greet)
floor(0 ?? i)
floor(0 ?? str)
floor(0 ?? true)
floor(0 ^ 0)
floor(0 ^ 1.0)
floor(0 ^ f64)
floor(0 | bitxor(i))
floor(0 | min(1.0))
floor(0) * i
floor(0) * reduce(array, #)
floor(0) < array?.[i]
floor(0) < f64
floor(0) < i
floor(0) <= f64
floor(0) >= i
floor(0) ?? f64
floor(0) ?? greet(str)
floor(0) ?? list
floor(0.0)
floor(1 % 1)
floor(1 % i)
floor(1 * 1)
floor(1 * 1.0)
floor(1 * f64)
floor(1 * i)
floor(1 ** 0)
floor(1 ** 1)
floor(1 ** 1.0)
floor(1 ** i)
floor(1 + 1)
floor(1 + 1.0)
floor(1 + f64)
floor(1 + i)
floor(1 - 1)
floor(1 - i)
floor(1 / 0)
floor(1 / 1.0)
floor(1 / f64)
floor(1 ?? $env?.[array])
floor(1 ?? 0)
floor(1 ?? 1)
floor(1 ?? false)
floor(1 ?? foo)
floor(1 ?? greet)
floor(1 ?? i)
floor(1 ?? nil)
floor(1 ?? str)
floor(1 ?? true)
floor(1 ^ 0)
floor(1 ^ 1.0)
floor(1 ^ f64)
floor(1 ^ i)
floor(1) != f64
floor(1) * f64
floor(1) * i
floor(1) ** f64
floor(1) + $env?.f64
floor(1) - i
floor(1) <= i
floor(1) ?? str
floor(1) in array
floor(1) | mean(1.0)
floor(1) | min(1.0)
floor(1.0 * 0)
floor(1.0 * 1)
floor(1.0 * 1.0)
floor(1.0 * f64)
floor(1.0 * i)
floor(1.0 ** 0)
floor(1.0 ** 1)
floor(1.0 ** 1.0)
floor(1.0 ** f64)
floor(1.0 ** i)
floor(1.0 + 0)
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)
floor(1.0 / 1.0)
floor(1.0 / f64)
floor(1.0 ?? $env)
floor(1.0 ?? 0)
floor(1.0 ?? 1)
floor(1.0 ?? 1.0)
floor(1.0 ?? add)
floor(1.0 ?? false)
floor(1.0 ?? foo)
floor(1.0 ?? greet)
floor(1.0 ?? i)
floor(1.0 ?? nil)
floor(1.0 ?? str)
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 | min(f64))
floor(1.0) != $env?.f64
floor(1.0) + f64
floor(1.0) - $env.i
floor(1.0) <= i
floor(1.0) == f64
floor(1.0) > i
floor(1.0) ?? array
floor(1.0) | mean(1.0)
floor(1.0) | median(0)
floor(1.0) | min(f64)
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 | findLastIndex(ok))
floor(array | findLastIndex(true))
floor(array | mean(1))
floor(array | mean(f64))
floor(array | reduce(#))
floor(array | reduce(#index))
floor(array | sum(#))
floor(array | sum(f64))
floor(array | sum(i))
floor(array?.[0])
floor(array?.[1])
floor(array?.[i])
floor(bitand(i, 1))
floor(bitnot(-0))
floor(bitnot(0))
floor(bitnot(1))
floor(bitnot(i))
floor(bitshr(1, i))
floor(bitxor(0, 1))
floor(ceil(0))
floor(ceil(1))
floor(ceil(1.0))
floor(ceil(f64 + 0))
floor(ceil(f64))
floor(ceil(i))
floor(count($env, true))
floor(count(list, ok))
floor(f64 * 1)
floor(f64 * 1.0)
floor(f64 * i)
floor(f64 ** 1.0)
floor(f64 ** i)
floor(f64 + 0)
floor(f64 + 1)
floor(f64 + 1.0)
floor(f64 + f64)
floor(f64 + i)
floor(f64 - 1)
floor(f64 - 1.0)
floor(f64 - f64)
floor(f64 - i)
floor(f64 / 1.0)
floor(f64 / f64)
floor(f64 ?? $env)
floor(f64 ?? 0)
floor(f64 ?? 1)
floor(f64 ?? 1.0)
floor(f64 ?? foo)
floor(f64 ?? greet)
floor(f64 ^ 0)
floor(f64 ^ 1.0)
floor(f64 ^ i)
floor(f64)
floor(f64) ** f64
floor(f64) / i
floor(f64) < f64
floor(f64) >= f64
floor(f64) >= i ^ f64
floor(f64) in array
floor(false ? $env : i)
floor(false ?: 1)
floor(findIndex($env, ok))
floor(findIndex(list, true))
floor(findLast(array, ok))
floor(findLastIndex(array, true))
floor(findLastIndex(list, ok))
floor(first(array))
floor(float(0))
floor(float(1))
floor(float(1.0))
floor(float(f64))
floor(float(i))
floor(floor(0))
floor(floor(1))
floor(floor(1.0))
floor(floor(f64))
floor(floor(i))
floor(i * 1.0)
floor(i * i)
floor(i ** 0)
floor(i ** 1)
floor(i ** 1.0)
floor(i ** f64)
floor(i ** i)
floor(i + 1)
floor(i + 1.0)
floor(i + i)
floor(i - 0)
floor(i - 1.0)
floor(i - f64)
floor(i / 0)
floor(i / 1)
floor(i / 1.0)
floor(i / f64)
floor(i ?? 0)
floor(i ?? foo)
floor(i ?? greet)
floor(i ?? i)
floor(i ?? ok)
floor(i ?? str)
floor(i ?? true)
floor(i ^ 0)
floor(i ^ 1)
floor(i ^ 1.0)
floor(i ^ f64)
floor(i ^ i)
floor(i | add(1))
floor(i | median(array))
floor(i | min(0))
floor(i)
floor(i) * f64 < 1.0
floor(i) ** 1.0 >= 1.0
floor(i) ** i
floor(i) - f64
floor(i) / 1.0 >= 1.0
floor(i) / sum(array)
floor(i) == $env != ok
floor(i) == f64
floor(i) == i
floor(i) > f64
floor(i) ^ f64
floor(i) | max(1.0)
floor(if ok { f64 } else { nil })
floor(if ok { i } else { $env })
floor(if true { 1.0 } else { f64 })
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(let x = f64; x)
floor(list | sum(1))
floor(max(0 ^ 0))
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, 1))
floor(mean(1.0))
floor(mean(array))
floor(mean(f64))
floor(mean(i))
floor(median(0))
floor(median(0, 1.0))
floor(median(1))
floor(median(1.0))
floor(median(array))
floor(median(f64))
floor(median(i))
floor(min(0))
floor(min(1))
floor(min(1.0))
floor(min(1.0, 0))
floor(min(array))
floor(min(array, 1))
floor(min(f64))
floor(min(i))
floor(nil ?? 0)
floor(nil ?? 1.0)
floor(nil ?? f64)
floor(ok ? 1.0 : nil)
floor(ok ? i : greet)
floor(reduce(array, #))
floor(reduce(array, #, list))
floor(reduce(array, 1))
floor(reduce(list, 1))
floor(reduce(list, f64))
floor(round(0))
floor(round(1))
floor(round(1.0))
floor(round(add(0, i)))
floor(round(f64))
floor(round(i))
floor(sum($env, 0))
floor(sum($env, 1.0))
floor(sum(array))
floor(sum(array, #))
floor(sum(array, 1.0))
floor(sum(list, 0))
floor(sum(list, 1.0))
foo
foo != $env != ok
foo != $env && ok and ok
foo != $env == ok
foo != $env == true
foo != $env ? $env : nil
foo != $env ?? greet
foo != $env ?? list
foo != $env and ok
foo != $env or $env[foobar:]
foo != $env || false
foo != $env || ok
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?.array
foo != $env?.String?.greet
foo != $env?.[Bar?.[greet]]
foo != $env?.[Bar]
foo != $env?.[String]
foo != $env?.[String]?.add
foo != $env?.[String]?.list
foo != $env?.[foobar?.[foo]]
foo != $env?.[foobar]
foo != $env?.[str]
foo != $env?.foo
foo != $env?.foobar
foo != $env?.not
foo != 0 ?? ok
foo != 1 ?? f64
foo != 1.0 ?? add
foo != 1.0 ?? greet
foo != 1.0 ?? ok
foo != add ?? array
foo != array ?? ok
foo != array ?? str
foo != first($env)
foo != first(list)
foo != foo
foo != foo != $env
foo != foo && $env.ok
foo != foo && f64 == 0
foo != foo && get($env, 1)
foo != foo == $env || false
foo != foo == false
foo != foo == true
foo != foo ?: i
foo != foo ?? $env.array
foo != foo ?? add
foo != foo ?? foo
foo != foo ?? list
foo != foo ?? nil
foo != foo and find($env, .f64)
foo != foo and true
foo != foo or 0 ?? false
foo != foo or ok
foo != foo || ok
foo != greet ?? add
foo != greet ?? false
foo != i ?? false
foo != i ?? ok
foo != last(list)
foo != list ?? $env
foo != list ?? greet(str)
foo != list?.[i]
foo != mean(array)
foo != nil != $env
foo != nil == $env.ok
foo != nil ? 1.0 : $env
foo != nil ? str : foo
foo != nil ?: $env
foo != nil ?? foo
foo != nil || sum($env, $env)
foo != str ?? f64
foo == $env != nil
foo == $env != ok
foo == $env && ok
foo == $env ?: $env | map(foo)
foo == $env ?? array
foo == $env ?? greet
foo == $env and $env
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?.Bar?.[list]
foo == $env?.String
foo == $env?.String?.[array]
foo == $env?.[Bar]
foo == $env?.[String]
foo == $env?.[String]?.[f64]
foo == $env?.[foo?.Bar]
foo == $env?.[foobar?.[foobar]]
foo == $env?.[foobar?.greet]
foo == $env?.[foobar]
foo == $env?.[str]
foo == $env?.foo
foo == $env?.foobar
foo == $env?.foobar?.array()
foo == $env?.foobar?.ok
foo == $env?.nil
foo == $env?.not
foo == 0 ?? foo?.String
foo == 0 ?? i ?? $env
foo == 1 ?? f64
foo == 1.0 ?? $env
foo == 1.0 ?? false
foo == 1.0 ?? foo == false
foo == add ?? 0
foo == add ?? 1
foo == array ?? foo
foo == f64 ?? str
foo == false ?? 1.0
foo == false ?? i
foo == foo
foo == foo != ok
foo == foo && 0 ?? true
foo == foo == false
foo == foo == ok
foo == foo ? $env : $env
foo == foo ?: f64
foo == foo ?: i
foo == foo ?? 0
foo == foo ?? 1.0
foo == foo ?? greet
foo == foo ?? ok
foo == foo ?? str
foo == foo or $env?.[greet]
foo == foo or ok
foo == foo || $env?.[array]
foo == foo || false
foo == foo || ok
foo == i ?? add
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 && nil != foo
foo == nil == $env
foo == nil ? foo : i
foo == nil ? true : i
foo == nil ?: str
foo == nil and ok
foo == nil || false
foo == ok ?? $env?.[foo]
foo == ok ?? f64
foo == ok ?? foo
foo == true ?? foo
foo == true ?? str
foo ?? !$env
foo ?? !ok
foo ?? $env ?? f64
foo ?? $env ?? foo
foo ?? $env ?? list
foo ?? $env ?? str
foo ?? $env.add
foo ?? $env.array
foo ?? $env.f64
foo ?? $env.foo
foo ?? $env.greet
foo ?? $env.i
foo ?? $env.list
foo ?? $env.ok
foo ?? $env.str
foo ?? $env?.Bar
foo ?? $env?.Bar()
foo ?? $env?.Bar()?.list
foo ?? $env?.Bar.Bar()
foo ?? $env?.String
foo ?? $env?.String()
foo ?? $env?.[$env?.list()]
foo ?? $env?.[$env][:Bar].list
foo ?? $env?.[Bar]
foo ?? $env?.[String]
foo ?? $env?.[String].String
foo ?? $env?.[add(ok)]
foo ?? $env?.[add?.f64]
foo ?? $env?.[add]
foo ?? $env?.[add]?.ok
foo ?? $env?.[array]
foo ?? $env?.[array]?.[array]
foo ?? $env?.[f64]
foo ?? $env?.[f64]?.[i]
foo ?? $env?.[f64]?.count(foobar)?.foobar?.i()
foo ?? $env?.[f64]?.i()
foo ?? $env?.[foo ?? nil]
foo ?? $env?.[foo]
foo ?? $env?.[foo]?.str
foo ?? $env?.[foobar not contains ok]
foo ?? $env?.[foobar | none(#)]
foo ?? $env?.[foobar.str()]
foo ?? $env?.[foobar?.i]
foo ?? $env?.[foobar]
foo ?? $env?.[foobar]?.array
foo ?? $env?.[greet]
foo ?? $env?.[i]
foo ?? $env?.[i]?.ok()
foo ?? $env?.[lastIndexOf(foo)]
foo ?? $env?.[list]
foo ?? $env?.[list].array(foobar)
foo ?? $env?.[nil | sortBy(.Bar, foo)]
foo ?? $env?.[nil]
foo ?? $env?.[ok]
foo ?? $env?.[ok]?.String
foo ?? $env?.[one(f64, foo)]
foo ?? $env?.[sort($env, list)]
foo ?? $env?.[str]
foo ?? $env?.[str]?.[str]
foo ?? $env?.[str]?.array
foo ?? $env?.[str]?.foo
foo ?? $env?.add
foo ?? $env?.array
foo ?? $env?.f64
foo ?? $env?.foo
foo ?? $env?.foobar
foo ?? $env?.greet
foo ?? $env?.groupBy(nil, str, nil)?.i
foo ?? $env?.i
foo ?? $env?.list
foo ?? $env?.nil
foo ?? $env?.nil?.[greet]
foo ?? $env?.ok
foo ?? $env?.str
foo ?? $env[$env < ok:]
foo ?? $env[:$env]
foo ?? $env[:array]
foo ?? $env[:false].array
foo ?? $env[:foo]
foo ?? $env[:foobar]
foo ?? $env[:i]
foo ?? $env[:list]
foo ?? $env[Bar?.str(foobar):]
foo ?? $env[add:]
foo ?? $env[foo.greet(ok):add | find(0)]
foo ?? $env[foobar - true:]
foo ?? $env[foobar.ok(foo):foobar?.foo]
foo ?? $env[foobar:]
foo ?? $env[foobar:true]
foo ?? $env[get(greet, foobar):]
foo ?? $env[i || nil:i($env, 1.0)]
foo ?? $env[sortBy(foo, .greet):]
foo ?? -$env
foo ?? -1
foo ?? -1.0
foo ?? -i
foo ?? 1 ?? add
foo ?? 1.0 ?? sortBy(array, 1)
foo ?? [0]
foo ?? [1]
foo ?? [f64]
foo ?? [foo, str]
foo ?? [i]
foo ?? [true, foo]
foo ?? add
foo ?? add ?? add
foo ?? add ?? str
foo ?? all($env, #)
foo ?? all($env, #.Bar)
foo ?? any($env, $env)
foo ?? array
foo ?? array ?? f64
foo ?? array ?? greet
foo ?? array?.[i]
foo ?? array[:0]
foo ?? array[:]
foo ?? array[:count($env)]
foo ?? concat(list)
foo ?? concat(map(list, str))?.[i]
foo ?? count($env)
foo ?? count(array)
foo ?? count(list)
foo ?? date(1)
foo ?? date(array)
foo ?? date(array, list, ok)
foo ?? date(foo)
foo ?? date(true)
foo ?? duration(str)
foo ?? f64
foo ?? f64 ?? add
foo ?? false ?? list
foo ?? false ?? nil
foo ?? filter($env, #)
foo ?? find($env, #.add)
foo ?? findLastIndex($env, .add)
foo ?? findLastIndex(list, $env)
foo ?? float(1.0)
foo ?? floor(0)
foo ?? floor(i)
foo ?? foo
foo ?? foo ?? 1.0
foo ?? foo ?? add
foo ?? foo ?? f64
foo ?? foo ?? foo
foo ?? foo ?? greet
foo ?? foo ?? i
foo ?? foo ?? list
foo ?? foo ?? str
foo ?? foo.Bar
foo ?? foo.String
foo ?? foo.String()
foo ?? foo?.Bar
foo ?? foo?.String
foo ?? foo?.String()
foo ?? fromPairs($env)
foo ?? greet
foo ?? greet($env)
foo ?? greet(str)
foo ?? groupBy($env, #.add)
foo ?? groupBy(array, i)
foo ?? i
foo ?? i ?? i
foo ?? int(1)
foo ?? list
foo ?? list?.[1]
foo ?? list?.[i]
foo ?? lower($env)
foo ?? map($env, i)
foo ?? mean(array)
foo ?? mean(i)
foo ?? mean(list, str)
foo ?? median($env .. $env)
foo ?? median(0)
foo ?? median(array)
foo ?? median(f64)
foo ?? min(array, 1.0)
foo ?? nil ?? 1.0
foo ?? nil ?? add
foo ?? nil ?? array
foo ?? nil ?? str
foo ?? not $env
foo ?? not false
foo ?? not ok
foo ?? ok
foo ?? ok ?? foo?.String
foo ?? ok ?? i
foo ?? reduce($env, #.i)
foo ?? reduce($env, .array)
foo ?? reverse(list)
foo ?? sort($env)
foo ?? sortBy(array, ok)
foo ?? str
foo ?? string($env)
foo ?? string(add)
foo ?? string(greet)
foo ?? sum($env ?? foo).ok
foo ?? sum($env).array
foo ?? sum($env, true)
foo ?? sum(list)
foo ?? toJSON(1)
foo ?? toJSON(array)
foo ?? trimPrefix(str)
foo ?? true ?? list
foo ?? type(false)
foo ?? uniq($env)
foo ?? {foo: 0, foo: foo}
foo ?? {foo: array}
foo ?? {foo: f64}
foo ?? {foo: foo}
foo ?? {foo: ok}
foo in $env and false
foo in $env.list
foo in $env?.Bar
foo in $env?.Bar?.[add]?.[str]
foo in $env?.String
foo in $env?.String?.[greet]
foo in $env?.String?.[i]
foo in $env?.String?.[ok]
foo in $env?.String?.add
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?.[String]?.i
foo in $env?.[foobar?.foo]
foo in $env?.[foobar]
foo in $env?.[foobar]?.i
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 [foo, 0]
foo in [foo]
foo in [list, 1]
foo in [nil]
foo in array ?? 0
foo in array ?? 1.0 != nil
foo in array ?? f64
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 ?? add
foo in list ?? greet
foo in list or $env
foo in list || false
foo in list[0:]
foo in map(list, foo)
foo in nil ?? list
foo in toPairs($env)
foo in uniq(list)
foo in values($env)
foo in {foo: 1.0}.f64
foo not in $env.list
foo not in $env?.Bar
foo not in $env?.String
foo not in $env?.String?.[greet]
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?.[String]?.greet
foo not in $env?.[foobar?.[add]]
foo not in $env?.[foobar?.f64]
foo not in $env?.[foobar?.foo]
foo not in $env?.[foobar]
foo not in $env?.[foobar]?.[greet]
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 [foo]
foo not in [nil]
foo not in array ?? foo
foo not in find($env, false)?.[i]
foo not in first($env)
foo not in flatten(array)
foo not in groupBy(list, #)
foo not in keys($env)
foo not in list
foo not in list != false
foo not in list && ok
foo not in list ?? 1
foo not in list ?? foo
foo not in list || ok
foo not in toPairs($env)
foo not in {foo: 1}?.array
foo not in {foo: str}.str
foo.Bar
foo.Bar != $env == nil
foo.Bar != foo?.Bar
foo.Bar != str
foo.Bar + str
foo.Bar < foo.Bar
foo.Bar < str
foo.Bar <= str
foo.Bar == $env ?? 0
foo.Bar == $env.str
foo.Bar == $env?.Bar
foo.Bar == foo?.Bar
foo.Bar == str
foo.Bar > foo.String()
foo.Bar > str
foo.Bar >= str
foo.Bar >= string(foo)
foo.Bar >= type(ok)
foo.Bar ?? $env ?? true
foo.Bar ?? $env?.Bar
foo.Bar ?? $env?.f64
foo.Bar ?? add
foo.Bar ?? array
foo.Bar ?? foo
foo.Bar ?? greet
foo.Bar ?? i
foo.Bar ?? list
foo.Bar ?? round(f64)
foo.Bar ?? str
foo.Bar ?? {foo: foo}
foo.Bar contains $env?.String
foo.Bar contains $env?.[str]
foo.Bar contains str
foo.Bar endsWith $env?.Bar
foo.Bar endsWith str
foo.Bar in $env
foo.Bar in $env?.String
foo.Bar in foo
foo.Bar matches foo.Bar
foo.Bar matches greet(str)
foo.Bar matches str
foo.Bar not contains $env?.Bar
foo.Bar not contains str
foo.Bar not contains type(0)
foo.Bar not endsWith str
foo.Bar not endsWith type(list)
foo.Bar not in foo
foo.Bar not in foo == $env
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 foo?.String()
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 | lastIndexOf(str)
foo.Bar | repeat(0)
foo.Bar | split($env?.str)
foo.Bar | trimSuffix(str)
foo.Bar[:]
foo.Bar[:i]
foo.Bar[:int(1)]
foo.Bar[i:]
foo.String
foo.String != $env?.foobar
foo.String != ok ?? $env
foo.String == $env?.[String]
foo.String ?? $env?.[Bar]
foo.String ?? $env?.array
foo.String ?? $env?.list
foo.String ?? add
foo.String ?? array
foo.String ?? ceil(f64)
foo.String ?? first(list)
foo.String ?? foo
foo.String ?? greet
foo.String ?? i
foo.String ?? len(array)
foo.String ?? ok
foo.String ?? str
foo.String()
foo.String() != max(array)
foo.String() != str
foo.String() + str
foo.String() < $env.str
foo.String() < str
foo.String() <= $env.str
foo.String() <= str
foo.String() <= type(0 != 1.0)
foo.String() == str
foo.String() > foo.Bar
foo.String() > str
foo.String() >= $env?.[str]
foo.String() >= str
foo.String() ?? $env.i
foo.String() ?? add
foo.String() ?? array
foo.String() ?? f64
foo.String() ?? foo
foo.String() ?? greet
foo.String() ?? i
foo.String() contains str
foo.String() endsWith str
foo.String() in $env?.[Bar]
foo.String() in foo
foo.String() matches str
foo.String() not contains str
foo.String() not in foo
foo.String() not in foo == false
foo.String() not startsWith str
foo.String() startsWith str
foo.String() | greet()
foo.String() | lastIndexOf(str)
foo.String() | trimPrefix(str)
foo.String()[0 ?? 1.0:]
foo.String()[:]
foo.String()[i:]
foo; $env?.foo
foo; $env?.ok
foo; $env?.str
foo; 1.0; $env?.add
foo; 1.0; $env?.ok
foo; array
foo; f64
foo; foo; nil != ok
foo; foo?.Bar
foo; greet
foo; i
foo; list
foo; str
foo?.Bar
foo?.Bar != list ?? 0
foo?.Bar != nil == $env
foo?.Bar != str
foo?.Bar != type(f64)
foo?.Bar + foo.Bar
foo?.Bar + str
foo?.Bar + string(foo)
foo?.Bar + toJSON(1)
foo?.Bar + type(i)
foo?.Bar < $env?.str
foo?.Bar < str
foo?.Bar < string(0)
foo?.Bar <= str
foo?.Bar == $env.str
foo?.Bar == foo?.Bar
foo?.Bar == nil and false
foo?.Bar == str
foo?.Bar > str
foo?.Bar > trimPrefix(str)
foo?.Bar > type(false)
foo?.Bar > type(list)
foo?.Bar >= $env.str
foo?.Bar >= str
foo?.Bar >= toJSON(foo)
foo?.Bar ?? !true
foo?.Bar ?? $env?.[add].greet
foo?.Bar ?? $env?.[str]
foo?.Bar ?? $env[foobar:]
foo?.Bar ?? add
foo?.Bar ?? array
foo?.Bar ?? f64
foo?.Bar ?? flatten(array)
foo?.Bar ?? foo
foo?.Bar ?? greet
foo?.Bar ?? i
foo?.Bar ?? list
foo?.Bar ?? map($env, 0)
foo?.Bar ?? ok
foo?.Bar ?? str
foo?.Bar ?? toJSON(f64)
foo?.Bar contains $env?.Bar
foo?.Bar contains $env?.[Bar]
foo?.Bar contains str
foo?.Bar contains str ?? list
foo?.Bar endsWith $env?.String
foo?.Bar endsWith first($env)
foo?.Bar endsWith str
foo?.Bar in $env?.[Bar]
foo?.Bar in foo
foo?.Bar in list?.[i]
foo?.Bar in uniq(list)
foo?.Bar in {foo: array}
foo?.Bar in {foo: str}
foo?.Bar matches $env.str
foo?.Bar matches str
foo?.Bar matches str and true
foo?.Bar matches toJSON(array)
foo?.Bar not contains str
foo?.Bar not contains type(nil)
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(0)
foo?.Bar not startsWith toJSON(nil)
foo?.Bar not startsWith type(str)
foo?.Bar startsWith $env?.[Bar]
foo?.Bar startsWith str
foo?.Bar | greet()
foo?.Bar | hasSuffix(str)
foo?.Bar | lastIndexOf(str)
foo?.Bar | repeat(i)
foo?.Bar | splitAfter(str)
foo?.Bar[:]
foo?.Bar[i:]
foo?.String
foo?.String != $env && $env
foo?.String != $env?.[Bar]
foo?.String != $env?.[str]
foo?.String != nil && $env
foo?.String == $env or $env
foo?.String == $env?.[String]
foo?.String == nil || true
foo?.String ?? $env?.list
foo?.String ?? -$env
foo?.String ?? add
foo?.String ?? array
foo?.String ?? f64
foo?.String ?? findLast($env, #)
foo?.String ?? foo
foo?.String ?? greet
foo?.String ?? groupBy($env, 0)
foo?.String ?? i
foo?.String ?? list
foo?.String ?? ok
foo?.String ?? str
foo?.String ?? str ?? foo
foo?.String ?? string(foo)
foo?.String()
foo?.String() != str
foo?.String() + foo.String()
foo?.String() < str
foo?.String() == str
foo?.String() > foo?.Bar
foo?.String() > str
foo?.String() >= str
foo?.String() >= toJSON(f64)
foo?.String() ?? foo
foo?.String() ?? greet
foo?.String() ?? keys($env)
foo?.String() ?? list
foo?.String() ?? reverse($env)
foo?.String() ?? str
foo?.String() contains str
foo?.String() endsWith str
foo?.String() in foo
foo?.String() matches str
foo?.String() not contains $env?.[str]
foo?.String() not contains 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(string(true))
fromBase64(toBase64(str))
fromBase64(toJSON(nil))
fromBase64(toJSON(ok))
fromBase64(toJSON(true))
fromBase64(type(add))
fromBase64(type(false))
fromBase64(type(greet))
fromBase64(type(ok))
fromBase64(type(true))
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(i))
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($env).true && false
fromPairs([list])
fromPairs(array | take(0))
fromPairs(array[:0])
fromPairs(filter($env, false))
fromPairs(filter(list, false))
fromPairs(list[:0])
fromPairs(map($env, list))
fromPairs(sort($env))
fromPairs(take(array, 0))
fromPairs(toPairs($env))
fromPairs(toPairs($env)).ok
fromPairs(toPairs($env))?.[f64]
get($env, nil) != array
get($env, nil) == add
get($env, nil)?.String
get($env, nil)?.[add]
get($env, nil)?.[add].add
get($env, nil)?.[array]
get($env, nil)?.[f64]
get($env, nil)?.[foo]
get($env, nil)?.[i]
get($env, nil)?.[ok]
get($env, nil)?.[str]
get($env, nil)?.add
get($env, nil)?.array()
get($env, nil)?.f64
get($env, nil)?.foo
get($env, nil)?.foo(foobar)
get($env, nil)?.greet().add
get($env, nil)?.list()
get($env, nil)?.ok
get($env, nil)?.ok(foobar)
get($env, nil)?.str()
get($env, str) | reduce($env)
get($env, str)?.[f64]
get($env?.[Bar], foo)
get($env?.[String], foo.String)
get(0 ?? list, add)
get(1.0 ?? $env, false ?? list)
get(add ?? f64, add)
get(add ?? str, i)
get(array, $env.i)
get(array, i)
get(array, i) < i
get(false ? false : add, foo)
get(i ?? $env, foo ?? $env)
get(if ok { i } else { array }, list)
get(list ?? add, i)
get(list, -0)
get(list, 1)?.String
get(list, i)
get(list, i).String
get(mean(array), foo.String)
get(median(array), true && $env)
get(str ?? $env, i)
greet
greet != $env != nil
greet != $env && $env
greet != $env == nil
greet != $env ?: add
greet != $env ?? array
greet != $env ?? list
greet != $env and $env
greet != $env or sum(array, true)
greet != $env || ok
greet != $env || true
greet != $env.greet
greet != $env?.Bar
greet != $env?.String
greet != $env?.String?.add()
greet != $env?.[Bar]
greet != $env?.[String]
greet != $env?.[String]?.[greet]
greet != $env?.[foobar?.String($env)]
greet != $env?.[foobar]
greet != $env?.[str]
greet != $env?.foobar
greet != $env?.greet
greet != $env?.true
greet != 0 ?? 1.0
greet != 0 ?? greet
greet != 1 ?? str
greet != 1.0 ?? add
greet != array ?? !true
greet != array ?? ok
greet != first($env)
greet != foo ?? array
greet != foo ?? f64
greet != foo ?? list
greet != get($env, str)
greet != greet
greet != greet != nil
greet != greet != ok
greet != greet && true
greet != greet ?: greet
greet != greet or ok
greet != greet || $env
greet != greet || false
greet != max($env)
greet != nil == nil
greet != nil ? foo : true
greet != nil ?? $env
greet != nil and $env
greet != nil || $env?.[i]
greet != ok ?? i
greet != ok ?? str
greet != reduce(array, $env, 0)
greet != str ?? $env
greet != {foo: nil}.Bar?.list
greet != {foo: str}.foobar
greet != {foo: true}?.list
greet == $env && $env
greet == $env ?? foo
greet == $env ?? true
greet == $env and false
greet == $env or ok
greet == $env.greet
greet == $env?.Bar
greet == $env?.Bar?.array()
greet == $env?.String
greet == $env?.[Bar]
greet == $env?.[Bar]?.[foo]
greet == $env?.[String]
greet == $env?.[String]?.ok
greet == $env?.[foobar]
greet == $env?.[str]
greet == $env?.foobar
greet == $env?.foobar?.String
greet == $env?.greet
greet == 0 ?? f64
greet == 1.0 ?? array
greet == 1.0 ?? i
greet == add ?? f64
greet == array ?? add
greet == foo ?? 1.0
greet == foo ?? true
greet == greet
greet == greet && $env
greet == greet == ok
greet == greet ? 1.0 : foo
greet == greet and $env
greet == min($env)
greet == nil != nil
greet == nil != ok
greet == nil == true
greet == nil or $env
greet == nil or ok
greet == nil || true
greet == ok ?? 1.0
greet == str ?? greet
greet == str ?? true
greet ?? !$env
greet ?? !false
greet ?? !ok
greet ?? !true
greet ?? $env ?? f64
greet ?? $env ?? foo
greet ?? $env ?? str
greet ?? $env.add
greet ?? $env.array
greet ?? $env.f64
greet ?? $env.foo
greet ?? $env.greet
greet ?? $env.i
greet ?? $env.list
greet ?? $env.ok
greet ?? $env.str
greet ?? $env?.Bar
greet ?? $env?.Bar()
greet ?? $env?.Bar()?.i
greet ?? $env?.Bar(foobar)
greet ?? $env?.Bar.array
greet ?? $env?.Bar?.foo
greet ?? $env?.String
greet ?? $env?.String()
greet ?? $env?.String?.[array]
greet ?? $env?.String?.[i]
greet ?? $env?.String?.greet
greet ?? $env?.[Bar]
greet ?? $env?.[String not in foobar]
greet ?? $env?.[String]
greet ?? $env?.[add]
greet ?? $env?.[add]?.[add]
greet ?? $env?.[array]
greet ?? $env?.[f64]
greet ?? $env?.[foo.f64()].filter(get(foobar))
greet ?? $env?.[foo.f64]
greet ?? $env?.[foo]
greet ?? $env?.[foobar.f64]
greet ?? $env?.[foobar]
greet ?? $env?.[greet]
greet ?? $env?.[i]
greet ?? $env?.[list]
greet ?? $env?.[ok()]
greet ?? $env?.[ok]
greet ?? $env?.[str]
greet ?? $env?.[str]?.[add]
greet ?? $env?.add
greet ?? $env?.array
greet ?? $env?.f64
greet ?? $env?.foo
greet ?? $env?.foobar
greet ?? $env?.greet
greet ?? $env?.i
greet ?? $env?.list
greet ?? $env?.nil?.String
greet ?? $env?.ok
greet ?? $env?.str
greet ?? $env[$env:]
greet ?? $env[:bitor(f64)]
greet ?? $env[:foobar?.[add]]
greet ?? $env[:foobar]
greet ?? $env[:foobar].i()
greet ?? $env[Bar(list):count(foobar)]
greet ?? $env[array():]
greet ?? $env[foo ^ foo:]
greet ?? $env[foobar < foo:]
greet ?? $env[foobar?.list:String]
greet ?? $env[list(0):foo[:$env]]
greet ?? -$env
greet ?? -0
greet ?? -i
greet ?? 0 ?? 1
greet ?? 0 ?? str
greet ?? [1]
greet ?? [false]
greet ?? [list]
greet ?? [true]
greet ?? abs($env)
greet ?? abs(i)
greet ?? add
greet ?? array
greet ?? array ?? add
greet ?? array ?? true
greet ?? array?.[i]
greet ?? count($env)
greet ?? date($env)
greet ?? date(false)
greet ?? date(foo)
greet ?? f64
greet ?? f64 ?? foo
greet ?? findLast($env, #.foo)
greet ?? findLastIndex(list, ok)
greet ?? flatten($env)
greet ?? float(i)
greet ?? foo
greet ?? foo ?? $env
greet ?? foo ?? array
greet ?? foo ?? greet
greet ?? foo ?? i
greet ?? foo | get(array)
greet ?? foo | get(foo)
greet ?? foo.Bar
greet ?? foo.String
greet ?? foo.String()
greet ?? foo?.Bar
greet ?? foo?.String
greet ?? foo?.String()
greet ?? fromJSON($env)
greet ?? fromPairs(list)
greet ?? greet
greet ?? greet ?? array
greet ?? groupBy($env, add)
greet ?? groupBy(list, $env)
greet ?? groupBy(list, list)
greet ?? i
greet ?? i ?? foo
greet ?? i ?? list
greet ?? int(1.0)
greet ?? int(f64)
greet ?? keys($env)
greet ?? list
greet ?? list ?? 0
greet ?? list ?? array
greet ?? list ?? str
greet ?? list?.[i]
greet ?? lower($env)
greet ?? map($env, #.ok)
greet ?? map(list, #index * 1.0)
greet ?? map(list, #index)
greet ?? max(1.0, $env)
greet ?? mean(1.0)
greet ?? median(0)
greet ?? min($env)
greet ?? min(1.0)
greet ?? min(i)
greet ?? nil ?? 1.0
greet ?? nil ?? add
greet ?? not false
greet ?? not true
greet ?? ok
greet ?? one($env, .str)
greet ?? reduce($env, true)
greet ?? round(i)
greet ?? sortBy(list, #)
greet ?? str
greet ?? str[:$env]
greet ?? string($env)
greet ?? string(array)
greet ?? string(nil)
greet ?? sum($env)
greet ?? sum($env, #.ok)
greet ?? sum(array)
greet ?? sum(list)
greet ?? sum(list, $env)
greet ?? toJSON(add)
greet ?? toJSON(foo)
greet ?? toJSON(list)
greet ?? toPairs($env)
greet ?? trimSuffix($env)
greet ?? type(1.0)
greet ?? type(add)
greet ?? type(str)
greet ?? type(true)
greet ?? {foo: foo}.i()
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?.[f64]]
greet in $env?.[foobar?.[i]]
greet in $env?.[foobar]
greet in $env?.foobar
greet in $env?.foobar?.[foo]
greet in $env?.nil
greet in $env?.true
greet in [$env, foo]
greet in [nil]
greet in array ?? foo
greet in first($env)
greet in flatten(list)
greet in list ?? $env?.[array]
greet in list ?? $env?.[i]
greet in map($env, $env)
greet in reverse(list)
greet in sort($env)
greet in toPairs($env)
greet in uniq(list)
greet not in $env and false
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?.[Bar]?.list()
greet not in $env?.[String]
greet not in $env?.[foobar?.[add]]
greet not in $env?.[foobar]
greet not in $env?.foobar
greet not in [foo, 1.0]
greet not in array ?? add
greet not in array ?? i
greet not in first($env)
greet not in flatten(array)
greet not in flatten(list)
greet not in last($env)
greet not in list ?? str
greet not in toPairs($env)
greet not in {foo: foo}.list and ok
greet($env) != $env or true
greet($env.foo?.Bar)
greet($env.greet(str))
greet($env.str)
greet($env?.[foobar] ?? str)
greet($env?.[str])
greet($env?.foo?.Bar)
greet($env?.greet(str))
greet($env?.str)
greet(false ? foo : str)
greet(foo.Bar)
greet(foo.String())
greet(foo?.Bar)
greet(foo?.Bar) not endsWith str
greet(foo?.Bar) | repeat(nil ?? i)
greet(foo?.String())
greet(get($env, str))
greet(greet($env?.[str]))
greet(greet(foo.String()))
greet(greet(greet(str)))
greet(greet(str ?? foo?.Bar))
greet(greet(str))
greet(greet(str[:i]))
greet(greet(string($env)))
greet(greet(string(0)))
greet(greet(type($env)))
greet(greet(type(add)))
greet(greet(type(true)))
greet(if false { 1.0 } else { str })
greet(if ok { str } else { nil })
greet(if true { str } else { $env })
greet(join($env | map(str)))
greet(keys($env)?.[i])
greet(last(list).Bar)
greet(let x = str; x)
greet(list | reduce(#.Bar))
greet(list | reduce(str))
greet(list | reduce(str, str))
greet(list?.[i].Bar)
greet(list?.[i].String())
greet(lower(greet(str)))
greet(lower(str))
greet(min($env)?.str)
greet(nil ?? str)
greet(ok ? str : 1)
greet(reduce(array, str))
greet(reduce(list, str))
greet(str + str)
greet(str ?? $env)
greet(str ?? 0)
greet(str ?? 1)
greet(str ?? 1.0)
greet(str ?? add)
greet(str ?? array)
greet(str ?? f64)
greet(str ?? false)
greet(str ?? foo)
greet(str ?? greet)
greet(str ?? i)
greet(str ?? list)
greet(str ?? nil)
greet(str ?? ok)
greet(str ?? str)
greet(str ?? true)
greet(str | greet())
greet(str | repeat(0))
greet(str | trim(str))
greet(str | trimPrefix(str))
greet(str)
greet(str) != $env && $env
greet(str) != list ?? 0
greet(str) != str
greet(str) + str
greet(str) < lower(str)
greet(str) < str
greet(str) <= $env?.str
greet(str) <= str
greet(str) <= type(i)
greet(str) == nil ? foo : nil
greet(str) == str
greet(str) > str
greet(str) > type(0)
greet(str) >= $env.str
greet(str) >= foo?.String()
greet(str) >= str
greet(str) ?? [array]
greet(str) ?? f64
greet(str) ?? list
greet(str) ?? str
greet(str) contains str
greet(str) contains string(true)
greet(str) endsWith $env?.[str]
greet(str) endsWith str
greet(str) in $env == $env
greet(str) in foo
greet(str) matches str
greet(str) not contains str
greet(str) not endsWith $env?.str
greet(str) not endsWith string(foo)
greet(str) not endsWith type(nil)
greet(str) not in foo
greet(str) not matches str
greet(str) not startsWith $env?.Bar
greet(str) not startsWith $env?.String
greet(str) not startsWith foo.Bar
greet(str) not startsWith str
greet(str) startsWith foo.Bar
greet(str) startsWith str
greet(str) startsWith toJSON(1)
greet(str) | greet()
greet(str)[:]
greet(str)[:i]
greet(str)[i:]
greet(str[0:])
greet(str[1:0])
greet(str[1:])
greet(str[:0])
greet(str[:1])
greet(str[:])
greet(str[:i])
greet(str[i:1])
greet(str[i:])
greet(str[i:i])
greet(string($env))
greet(string($env?.Bar))
greet(string($env?.i))
greet(string(0))
greet(string(1))
greet(string(1.0 * f64))
greet(string(1.0))
greet(string(abs(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 != add))
greet(string(nil))
greet(string(ok))
greet(string(str))
greet(string(true))
greet(toBase64(str))
greet(toJSON($env.array))
greet(toJSON($env.foo))
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 % i))
greet(toJSON(i))
greet(toJSON(list))
greet(toJSON(max(0)))
greet(toJSON(nil))
greet(toJSON(ok))
greet(toJSON(str))
greet(toJSON(true))
greet(trim(str))
greet(trim(trimSuffix(str)))
greet(trimPrefix(str ?? nil))
greet(trimPrefix(str))
greet(trimSuffix(foo.String()))
greet(trimSuffix(str))
greet(trimSuffix(str, str))
greet(true ? str : add)
greet(true ? str : i)
greet(true ? str : nil)
greet(true ? str : ok)
greet(type($env != 1.0))
greet(type($env))
greet(type($env.ok))
greet(type($env?.foo))
greet(type(0))
greet(type(1))
greet(type(1.0))
greet(type([list]))
greet(type([ok]))
greet(type(add))
greet(type(array))
greet(type(f64))
greet(type(false))
greet(type(foo))
greet(type(foo.String))
greet(type(greet))
greet(type(i * f64))
greet(type(i))
greet(type(list))
greet(type(map(array, ok)))
greet(type(nil == f64))
greet(type(nil))
greet(type(not ok))
greet(type(ok))
greet(type(str))
greet(type(true))
greet(upper(str))
greet; $env?.[Bar]
greet; $env?.add
greet; $env?.foobar
greet; add
greet; array
greet; array | sum(0)
greet; f64
greet; float(f64)
greet; foo
greet; foo; i
greet; greet
greet; i
greet; ok
greet; ok ?? i
greet; {foo: nil}
groupBy($env | map(false), i)?.ok
groupBy($env | map(i), ok)
groupBy($env.array, # >= #)
groupBy($env.array, #)
groupBy($env.array, -#)?.f64
groupBy($env.array, 0 * 1.0)
groupBy($env.array, f64)
groupBy($env.array, foo)
groupBy($env.array, i / #)
groupBy($env.list, #)
groupBy($env.list, f64)
groupBy($env.list, foo)
groupBy($env.list, i)
groupBy($env.list, nil != #.String)
groupBy($env.list, not ok)
groupBy($env.list, str)
groupBy($env?.[str], #)
groupBy($env?.[str], 1.0 <= i)
groupBy($env?.[str], 1.0 > 1.0)
groupBy($env?.[str], any($env, true))
groupBy($env?.[str], f64)
groupBy($env?.[str], i)
groupBy($env?.[str], mean(#))
groupBy($env?.[str], ok)
groupBy($env?.[str], ok)?.add
groupBy($env?.[str], str)
groupBy($env?.array, #)
groupBy($env?.array, #)?.[i]
groupBy($env?.array, $env?.i)
groupBy($env?.array, -#)
groupBy($env?.array, 0 <= #)
groupBy($env?.array, f64)
groupBy($env?.array, foo)?.ok
groupBy($env?.array, i)
groupBy($env?.array, ok)
groupBy($env?.array, str)
groupBy($env?.list, #)
groupBy($env?.list, #.Bar)
groupBy($env?.list, $env?.i)
groupBy($env?.list, 0 == $env)
groupBy($env?.list, int(1.0))
groupBy($env?.list, ok)
groupBy($env?.list, str)
groupBy(1 .. 0, #)
groupBy(1 .. 1, ok)
groupBy([$env], .String startsWith .str)
groupBy([$env], i)
groupBy([0, 0], #)
groupBy([0], #)
groupBy([1.0], # / f64)
groupBy([1.0], #)
groupBy([1.0], foo)
groupBy([1.0], ok)
groupBy([1], #)
groupBy([1], i)
groupBy([f64], ok)
groupBy([f64], str)
groupBy([false, str], ok)
groupBy([false], #)
groupBy([foo], .Bar not matches #.Bar)
groupBy([foo], 0 >= i)
groupBy([foo], foo)?.[ok]
groupBy([foo], i)
groupBy([greet], i)
groupBy([i], foo)
groupBy([list], abs(1.0))
groupBy([ok], #)
groupBy([str], str)
groupBy(array ?? $env, foo)
groupBy(array ?? add, 1.0 ?? foo)
groupBy(array ?? array, foo)
groupBy(array ?? foo, str == #)
groupBy(array ?? greet, #)
groupBy(array ?? greet, ok)
groupBy(array | filter(false), greet)
groupBy(array | map(#), ok)
groupBy(array | map($env), #.ok)
groupBy(array | map(0), str)
groupBy(array | map(1), #)
groupBy(array | sortBy(#), 1 + #)
groupBy(array | sortBy(1.0), #)
groupBy(array, !false)
groupBy(array, # != 1.0)
groupBy(array, # % #)
groupBy(array, # % #)?.[str]
groupBy(array, # * i)
groupBy(array, # ** 0)
groupBy(array, # + #)
groupBy(array, # - 1.0)
groupBy(array, # / #)
groupBy(array, # < 1)
groupBy(array, # <= f64)
groupBy(array, # == #)
groupBy(array, # > #)
groupBy(array, # >= #).String
groupBy(array, # >= 0)
groupBy(array, # >= f64)
groupBy(array, # ?? 1.0)
groupBy(array, # ?? array)
groupBy(array, # ?? nil)
groupBy(array, # ?? str)
groupBy(array, # ^ #)
groupBy(array, # ^ 1.0)
groupBy(array, # | bitor(#))
groupBy(array, #)
groupBy(array, #).Bar
groupBy(array, #).String
groupBy(array, #).add
groupBy(array, #).array
groupBy(array, #).f64
groupBy(array, #).foo
groupBy(array, #).foobar
groupBy(array, #).foobar | any(true)
groupBy(array, #).greet
groupBy(array, #).i
groupBy(array, #).i | any(#.ok.array)
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 != i)?.[ok]
groupBy(array, $env == array).str
groupBy(array, $env == foo)
groupBy(array, $env | sum(1.0))
groupBy(array, $env.f64)
groupBy(array, $env.foo)
groupBy(array, $env.i)
groupBy(array, $env.ok)
groupBy(array, $env.str)
groupBy(array, $env?.[String])
groupBy(array, $env?.[foobar])
groupBy(array, $env?.[str])
groupBy(array, $env?.f64)
groupBy(array, $env?.i)
groupBy(array, $env?.nil)
groupBy(array, $env?.ok)
groupBy(array, $env?.str)
groupBy(array, -#)
groupBy(array, -#)?.str
groupBy(array, -0)
groupBy(array, -1.0)
groupBy(array, -i)
groupBy(array, 0 + #)
groupBy(array, 0 == 1.0)
groupBy(array, 0) ?? foo
groupBy(array, 0).Bar
groupBy(array, 0).String
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, 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)?.f64
groupBy(array, 0)?.foo
groupBy(array, 0)?.foobar
groupBy(array, 0)?.greet
groupBy(array, 0)?.i
groupBy(array, 0)?.list
groupBy(array, 0)?.str
groupBy(array, 1 >= #)
groupBy(array, 1).Bar
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)?.String
groupBy(array, 1)?.[foo]
groupBy(array, 1)?.[i]
groupBy(array, 1)?.[ok]
groupBy(array, 1)?.[str]
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)?.ok
groupBy(array, 1)?.str
groupBy(array, 1.0 != $env)
groupBy(array, 1.0 != 1.0)
groupBy(array, 1.0 ** #)
groupBy(array, 1.0 - 1.0)
groupBy(array, 1.0 < #)
groupBy(array, 1.0 < 0)?.ok
groupBy(array, 1.0 <= 0)
groupBy(array, 1.0 <= f64)
groupBy(array, 1.0 ?? str)
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).foobar
groupBy(array, 1.0).greet
groupBy(array, 1.0).i
groupBy(array, 1.0).list
groupBy(array, 1.0).ok
groupBy(array, 1.0).ok?.[i]
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)?.[i]
groupBy(array, 1.0)?.[ok]
groupBy(array, 1.0)?.[str]
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, abs(#))
groupBy(array, array | sum(#))
groupBy(array, bitand(#, #))
groupBy(array, bitshr(#, 0))
groupBy(array, ceil(#))
groupBy(array, ceil(floor(1.0)))
groupBy(array, f64 ** i)
groupBy(array, f64 - 1)
groupBy(array, f64 / #)
groupBy(array, f64 < #)
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).foo
groupBy(array, f64).foobar
groupBy(array, f64).greet
groupBy(array, f64).i
groupBy(array, f64).list
groupBy(array, f64).ok
groupBy(array, f64).str
groupBy(array, f64)?.Bar
groupBy(array, f64)?.String
groupBy(array, f64)?.[f64]
groupBy(array, f64)?.[foo]
groupBy(array, f64)?.[i]
groupBy(array, f64)?.[ok]
groupBy(array, f64)?.[str]
groupBy(array, f64)?.add
groupBy(array, f64)?.array
groupBy(array, f64)?.foo
groupBy(array, f64)?.greet
groupBy(array, f64)?.i
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).i
groupBy(array, false).list
groupBy(array, false).ok
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)?.[ok]
groupBy(array, false)?.[str]
groupBy(array, false)?.add
groupBy(array, false)?.array
groupBy(array, false)?.f64
groupBy(array, false)?.foo
groupBy(array, false)?.greet
groupBy(array, false)?.i
groupBy(array, false)?.list
groupBy(array, false)?.ok
groupBy(array, false)?.str
groupBy(array, float(1.0))
groupBy(array, float(i))
groupBy(array, floor(#))
groupBy(array, foo == $env)
groupBy(array, foo ?? #)
groupBy(array, foo in list)
groupBy(array, foo not in list)
groupBy(array, foo)
groupBy(array, foo) ?? ok
groupBy(array, foo).Bar
groupBy(array, foo).String
groupBy(array, foo).add
groupBy(array, foo).array
groupBy(array, foo).f64
groupBy(array, foo).foo
groupBy(array, foo).foobar
groupBy(array, foo).foobar | groupBy(0)
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, foo)?.String
groupBy(array, foo)?.[f64]
groupBy(array, foo)?.[foo]
groupBy(array, foo)?.[i]
groupBy(array, foo)?.[ok]
groupBy(array, foo)?.[str]
groupBy(array, foo)?.add
groupBy(array, foo)?.array
groupBy(array, foo)?.f64
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.Bar)
groupBy(array, greet == $env)
groupBy(array, greet(str))
groupBy(array, i - 1.0)
groupBy(array, i / 1.0)
groupBy(array, i > #)
groupBy(array, i ^ #)
groupBy(array, i | bitand(#))?.list
groupBy(array, i)
groupBy(array, i) ?? $env.f64
groupBy(array, i).Bar
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)?.String
groupBy(array, i)?.[f64]
groupBy(array, i)?.[foo]
groupBy(array, i)?.[ok]
groupBy(array, i)?.[str]
groupBy(array, i)?.add
groupBy(array, i)?.array
groupBy(array, i)?.f64
groupBy(array, i)?.foo
groupBy(array, i)?.foobar
groupBy(array, i)?.greet
groupBy(array, i)?.i
groupBy(array, i)?.list
groupBy(array, i)?.ok
groupBy(array, i)?.str
groupBy(array, if true { nil } else { f64 })
groupBy(array, max(#))
groupBy(array, max(i))
groupBy(array, mean(1.0))
groupBy(array, nil == $env)
groupBy(array, nil == 0)
groupBy(array, not false)
groupBy(array, not ok)
groupBy(array, ok ?? #)
groupBy(array, ok or true)
groupBy(array, ok)
groupBy(array, ok).Bar
groupBy(array, ok).String
groupBy(array, ok).add
groupBy(array, ok).array
groupBy(array, ok).f64
groupBy(array, ok).foo
groupBy(array, ok).greet
groupBy(array, ok).i
groupBy(array, ok).list
groupBy(array, ok).str
groupBy(array, ok)?.Bar
groupBy(array, ok)?.String
groupBy(array, ok)?.[f64]
groupBy(array, ok)?.[foo]
groupBy(array, ok)?.[i]
groupBy(array, ok)?.[ok]
groupBy(array, ok)?.[str]
groupBy(array, ok)?.add
groupBy(array, ok)?.array
groupBy(array, ok)?.foo
groupBy(array, ok)?.list
groupBy(array, ok)?.ok
groupBy(array, ok)?.str
groupBy(array, one(array, true))
groupBy(array, round(i))
groupBy(array, str endsWith str)
groupBy(array, str)
groupBy(array, str).Bar
groupBy(array, str).String
groupBy(array, str).add
groupBy(array, str).array
groupBy(array, str).foo
groupBy(array, str).greet
groupBy(array, str).i
groupBy(array, str).list
groupBy(array, str).ok
groupBy(array, str).str
groupBy(array, str)?.Bar
groupBy(array, str)?.String
groupBy(array, str)?.[f64]
groupBy(array, str)?.[i]
groupBy(array, str)?.[ok]
groupBy(array, str)?.[str]
groupBy(array, str)?.add
groupBy(array, str)?.array
groupBy(array, str)?.f64
groupBy(array, str)?.foo
groupBy(array, str)?.greet
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, toJSON(nil))
groupBy(array, toJSON(ok))
groupBy(array, true && true)
groupBy(array, true || ok)
groupBy(array, true).Bar
groupBy(array, true).String
groupBy(array, true).add
groupBy(array, true).array
groupBy(array, true).f64
groupBy(array, true).foo
groupBy(array, true).greet
groupBy(array, true).i
groupBy(array, true).list
groupBy(array, true).ok
groupBy(array, true).str
groupBy(array, true)?.Bar
groupBy(array, true)?.[f64]
groupBy(array, true)?.[foo]
groupBy(array, true)?.[i]
groupBy(array, true)?.[ok]
groupBy(array, true)?.[str]
groupBy(array, true)?.add
groupBy(array, true)?.array
groupBy(array, true)?.f64
groupBy(array, true)?.foo
groupBy(array, true)?.i
groupBy(array, true)?.list
groupBy(array, true)?.ok
groupBy(array, true)?.str
groupBy(array, type(#))
groupBy(array, type(i))
groupBy(array, type(nil))
groupBy(concat(array), #)
groupBy(concat(list), true ?? #).array
groupBy(false ? nil : array, f64)
groupBy(filter($env, false), .ok.greet())
groupBy(filter(array, false), #)
groupBy(flatten(array), #)
groupBy(flatten(list), #)
groupBy(flatten(list), .Bar)
groupBy(groupBy(array, ok).i, #?.[ok][.f64:])
groupBy(i..i, #)
groupBy(if false { ok } else { list }, ok)
groupBy(keys($env), #)
groupBy(list | map(#), f64)
groupBy(list | map(#), ok)
groupBy(list | map(array), $env?.f64)
groupBy(list | map(false), #)
groupBy(list | map(list), ok)
groupBy(list, # != foo)
groupBy(list, # == #)
groupBy(list, # ?? nil)
groupBy(list, #)
groupBy(list, #) ?? foo
groupBy(list, #) ?? str
groupBy(list, #).Bar
groupBy(list, #).String
groupBy(list, #).add
groupBy(list, #).array
groupBy(list, #).f64
groupBy(list, #).foo
groupBy(list, #).foobar
groupBy(list, #).greet
groupBy(list, #).i
groupBy(list, #).list
groupBy(list, #).ok
groupBy(list, #).str
groupBy(list, #)?.Bar
groupBy(list, #)?.String
groupBy(list, #)?.[$env?.[str]]
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 not in $env)
groupBy(list, #.Bar)
groupBy(list, #.Bar).Bar
groupBy(list, #.Bar).array
groupBy(list, #.Bar).f64
groupBy(list, #.Bar).foo
groupBy(list, #.Bar).list
groupBy(list, #.Bar).ok
groupBy(list, #.Bar).str
groupBy(list, #.Bar)?.String
groupBy(list, #.Bar)?.[f64]
groupBy(list, #.Bar)?.[ok]
groupBy(list, #.Bar)?.add
groupBy(list, #.Bar)?.array
groupBy(list, #.Bar)?.f64
groupBy(list, #.Bar)?.foo
groupBy(list, #.Bar)?.greet
groupBy(list, #.Bar)?.i
groupBy(list, #.Bar)?.list
groupBy(list, #.Bar)?.ok
groupBy(list, #.String == $env)
groupBy(list, #?.Bar)
groupBy(list, #?.Bar)?.[f64]
groupBy(list, #?.String())
groupBy(list, $env != f64)
groupBy(list, $env != greet)
groupBy(list, $env != true)
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?.[str])
groupBy(list, $env?.f64)
groupBy(list, $env?.foo)
groupBy(list, $env?.foobar)
groupBy(list, $env?.nil)
groupBy(list, $env?.str)
groupBy(list, -i)
groupBy(list, .Bar)
groupBy(list, .Bar) ?? str
groupBy(list, .Bar).Bar
groupBy(list, .Bar).String
groupBy(list, .Bar).add
groupBy(list, .Bar).array
groupBy(list, .Bar).f64
groupBy(list, .Bar).greet
groupBy(list, .Bar).i
groupBy(list, .Bar).list
groupBy(list, .Bar)?.Bar
groupBy(list, .Bar)?.[f64]
groupBy(list, .Bar)?.[foo]
groupBy(list, .Bar)?.[ok]
groupBy(list, .Bar)?.[str]
groupBy(list, .Bar)?.f64
groupBy(list, .Bar)?.greet
groupBy(list, .Bar)?.i
groupBy(list, .Bar)?.ok
groupBy(list, .Bar)?.str
groupBy(list, 0 + 1)
groupBy(list, 0 == 1)
groupBy(list, 0).Bar
groupBy(list, 0).String
groupBy(list, 0).f64
groupBy(list, 0).foo
groupBy(list, 0).greet
groupBy(list, 0).i
groupBy(list, 0).list
groupBy(list, 0).str
groupBy(list, 0)?.Bar
groupBy(list, 0)?.String
groupBy(list, 0)?.[f64]
groupBy(list, 0)?.[foo]
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)?.list
groupBy(list, 0)?.ok
groupBy(list, 0)?.str
groupBy(list, 0.1)
groupBy(list, 1 * 0)
groupBy(list, 1 * i)
groupBy(list, 1 not in array)
groupBy(list, 1).Bar
groupBy(list, 1).String
groupBy(list, 1).add
groupBy(list, 1).array
groupBy(list, 1).f64
groupBy(list, 1).foo
groupBy(list, 1).foobar
groupBy(list, 1).greet
groupBy(list, 1).i
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)?.foo
groupBy(list, 1)?.greet
groupBy(list, 1)?.i
groupBy(list, 1.0 > 1.0)?.[f64]
groupBy(list, 1.0 >= f64)
groupBy(list, 1.0 ?? foo)
groupBy(list, 1.0 ^ 1.0)
groupBy(list, 1.0) ?? list
groupBy(list, 1.0) | get(1)
groupBy(list, 1.0).String
groupBy(list, 1.0).add
groupBy(list, 1.0).array
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).ok
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)?.list
groupBy(list, 1.0)?.ok
groupBy(list, 1.0)?.str
groupBy(list, abs(1))
groupBy(list, add != add)
groupBy(list, array | sum(1))
groupBy(list, bitor(i, i))
groupBy(list, ceil(0))
groupBy(list, f64 - 1.0)
groupBy(list, f64)
groupBy(list, f64).Bar
groupBy(list, f64).String
groupBy(list, f64).add
groupBy(list, f64).array
groupBy(list, f64).f64
groupBy(list, f64).foo
groupBy(list, f64).greet
groupBy(list, f64).i
groupBy(list, f64).list
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)?.add
groupBy(list, f64)?.array
groupBy(list, f64)?.f64
groupBy(list, f64)?.foo
groupBy(list, f64)?.greet
groupBy(list, f64)?.i
groupBy(list, f64)?.list
groupBy(list, f64)?.ok
groupBy(list, f64)?.str
groupBy(list, false).Bar
groupBy(list, false).String
groupBy(list, false).add
groupBy(list, false).array
groupBy(list, false).f64
groupBy(list, false).foo
groupBy(list, false).foobar
groupBy(list, false).greet
groupBy(list, false).i
groupBy(list, false).list
groupBy(list, false).str
groupBy(list, false)?.String
groupBy(list, false)?.[f64]
groupBy(list, false)?.[i]
groupBy(list, false)?.[i]?.[i]
groupBy(list, false)?.[ok]
groupBy(list, false)?.[str]
groupBy(list, false)?.add
groupBy(list, false)?.array
groupBy(list, false)?.f64
groupBy(list, false)?.greet
groupBy(list, false)?.i
groupBy(list, false)?.list
groupBy(list, false)?.ok
groupBy(list, false)?.str
groupBy(list, float(0))
groupBy(list, foo != foo)
groupBy(list, foo != nil)
groupBy(list, foo == #)
groupBy(list, foo == foo)
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).foobar
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)?.[i]
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, foo?.String())
groupBy(list, greet(.Bar))
groupBy(list, i + i)
groupBy(list, i == i)
groupBy(list, i)
groupBy(list, i).Bar
groupBy(list, i).String
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)?.Bar
groupBy(list, i)?.String
groupBy(list, i)?.[f64]
groupBy(list, i)?.[foo]
groupBy(list, i)?.[i]
groupBy(list, i)?.[ok]
groupBy(list, i)?.[str]
groupBy(list, i)?.add
groupBy(list, i)?.array
groupBy(list, i)?.f64
groupBy(list, i)?.foo
groupBy(list, i)?.greet
groupBy(list, i)?.i
groupBy(list, i)?.list
groupBy(list, i)?.ok
groupBy(list, i)?.str
groupBy(list, if false { # } else { #.Bar })
groupBy(list, if true { # } else { false })
groupBy(list, nil != 0)
groupBy(list, nil == $env)
groupBy(list, nil == 1.0)
groupBy(list, nil == true)
groupBy(list, nil ?? #)
groupBy(list, none($env, true))
groupBy(list, ok and ok)
groupBy(list, ok)
groupBy(list, ok).String
groupBy(list, ok).add
groupBy(list, ok).array
groupBy(list, ok).f64
groupBy(list, ok).foo
groupBy(list, ok).i
groupBy(list, ok).list
groupBy(list, ok).ok
groupBy(list, ok).ok?.[i]
groupBy(list, ok).str
groupBy(list, ok)?.Bar
groupBy(list, ok)?.String
groupBy(list, ok)?.[f64]
groupBy(list, ok)?.[foo]
groupBy(list, ok)?.[i]
groupBy(list, ok)?.[ok]
groupBy(list, ok)?.add
groupBy(list, ok)?.f64
groupBy(list, ok)?.foo
groupBy(list, ok)?.greet
groupBy(list, ok)?.i
groupBy(list, ok)?.list
groupBy(list, ok)?.ok
groupBy(list, ok)?.str
groupBy(list, reduce(list, false)).ok
groupBy(list, str == nil)
groupBy(list, str ?? true)
groupBy(list, str)
groupBy(list, str).Bar
groupBy(list, str).String
groupBy(list, str).add
groupBy(list, str).array
groupBy(list, str).f64
groupBy(list, str).foo
groupBy(list, str).greet
groupBy(list, str).i
groupBy(list, str).list
groupBy(list, str).ok
groupBy(list, str).str
groupBy(list, str)?.Bar
groupBy(list, str)?.String
groupBy(list, str)?.[f64]
groupBy(list, str)?.[foo]
groupBy(list, str)?.[i]
groupBy(list, str)?.[ok]
groupBy(list, str)?.[str]
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, sum(array))
groupBy(list, toJSON(list))
groupBy(list, toJSON(ok))
groupBy(list, trimSuffix(str))
groupBy(list, true ?? str)
groupBy(list, true).Bar
groupBy(list, true).String
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)?.array
groupBy(list, true)?.f64
groupBy(list, true)?.greet
groupBy(list, true)?.list
groupBy(list, true)?.ok
groupBy(list, true)?.str
groupBy(list, type(0))
groupBy(list, type(1.0))?.i
groupBy(list, type(foo))
groupBy(map($env, 1.0), f64)
groupBy(map($env, 1.0), sum(array))
groupBy(map($env, foo), min(1.0))
groupBy(map(array, list), $env?.[str])
groupBy(map(list, #index), #)
groupBy(reverse(array), # <= 1)
groupBy(reverse(array), foo)
groupBy(reverse(array), i + f64)
groupBy(reverse(array), ok)
groupBy(sort($env), # != .array)
groupBy(sort($env), #.Bar)
groupBy(sort($env), #.add not contains str)
groupBy(sort($env), #.foo.str)
groupBy(sort($env), #.greet)
groupBy(sort($env), #.greet?.[i])
groupBy(sort($env), #.list.Bar(1.0))
groupBy(sort($env), 1.0 <= .array)
groupBy(sort($env), 1.0 | min(#.f64, str))
groupBy(sort($env), i)
groupBy(sort($env), max(#))
groupBy(sort(array), foo)
groupBy(str ?? $env, toJSON(false))
groupBy(str ?? 1, foo)
groupBy(str ?? add, str)
groupBy(str ?? f64, # ^ #)
groupBy(str ?? foo, str)
groupBy(str ?? i, f64)
groupBy(toPairs($env), 1 <= 1.0)
groupBy(values($env), foo)
groupBy(values($env), i)
groupBy(values($env), str)
hasPrefix(str, foo?.String())
hasPrefix(str, str)
hasPrefix(str, string(i))
hasSuffix(foo.Bar, str)
hasSuffix(foo.String(), str)
hasSuffix(str, greet(str))
hasSuffix(str, str)
hasSuffix(string(1), str)
hasSuffix(string(nil), foo?.Bar)
i
i != $env != $env
i != $env != true
i != $env && false
i != $env ?? 1.0
i != $env ?? f64
i != $env ?? str
i != $env and false
i != $env || $env
i != $env.f64
i != $env.i
i != $env?.$env?.list(add, nil)
i != $env?.Bar
i != $env?.Bar?.[f64]
i != $env?.Bar?.[greet]
i != $env?.String
i != $env?.[Bar]
i != $env?.[Bar]?.[i]
i != $env?.[String]
i != $env?.[String]?.[array]
i != $env?.[foobar]
i != $env?.[str]
i != $env?.f64
i != $env?.foobar
i != $env?.i
i != $env?.true
i != $env?.true?.str()
i != -0
i != -1.0
i != -f64
i != 0 != $env
i != 0 - 1.0 + 1.0
i != 0 == ok
i != 0 == true != true
i != 0 ?? i
i != 0 ^ 0
i != 0 or $env
i != 0 or ok
i != 0 or true
i != 0 || $env
i != 1 && ok
i != 1 / 1
i != 1 == nil
i != 1 ?? list
i != 1 ^ f64
i != 1 or ok
i != 1.0 != $env
i != 1.0 && str not endsWith str
i != 1.0 * 1.0
i != 1.0 * array?.[i]
i != 1.0 ** 0
i != 1.0 ** 1.0
i != 1.0 + 1.0
i != 1.0 + i
i != 1.0 - 1.0
i != 1.0 == false
i != 1.0 == nil
i != 1.0 == ok
i != 1.0 == true
i != 1.0 ?: $env
i != 1.0 ?? false
i != 1.0 ?? nil
i != 1.0 ^ i
i != 1.0 and false
i != 1.0 or $env
i != 1.0 || $env
i != abs(f64)
i != abs(i)
i != add ?? [foo]
i != add ?? i
i != array?.[i]
i != f64
i != f64 && $env
i != f64 && false
i != f64 && true
i != f64 + 1.0
i != f64 + f64
i != f64 ^ i
i != f64 and $env
i != false ?? list
i != first($env)
i != float(1.0)
i != floor(0)
i != floor(1)
i != floor(1.0)
i != floor(i)
i != foo ?? greet
i != foo ?? list
i != i
i != i != $env.ok
i != i * f64
i != i ?: greet
i != i ?? 1.0
i != i ^ 0 || true
i != int(i)
i != last($env)
i != len($env)
i != list ?? str
i != max(1.0)
i != mean(f64)
i != median(1.0)
i != min($env)
i != min(0)
i != min(i)
i != nil != $env
i != nil != false
i != nil != ok
i != nil && ok
i != nil or ok
i != sum(array)
i != {foo: foo}.foo
i % $env.i
i % $env?.i
i % -1
i % -i
i % 1 != 1.0
i % 1 * f64
i % 1 - 1
i % 1 <= i
i % 1 == i
i % 1 > 0
i % add(i, i)
i % array?.[i]
i % i
i % i != $env
i % i - 1
i % i < i
i % i <= 1
i % i <= 1.0
i % i == i ^ i
i % i > 1.0
i % len(str)
i % min(i)
i % nil ?? i
i % sum(array)
i * $env or true
i * $env || true
i * $env.f64
i * $env.i
i * $env?.f64
i * $env?.i
i * - - f64
i * -1
i * -1.0
i * -i
i * 0 != f64
i * 0 != nil
i * 0 + i
i * 0 - i
i * 0 == i
i * 0 ?? i
i * 0 | min(array)
i * 1 != 0
i * 1 != 1.0
i * 1 % i
i * 1 - i
i * 1 < f64
i * 1 | bitshl(i)
i * 1.0 != 1.0
i * 1.0 != nil
i * 1.0 * 1.0
i * 1.0 * f64
i * 1.0 * i
i * 1.0 + 1.0
i * 1.0 + f64
i * 1.0 - i
i * 1.0 < 1
i * 1.0 < i / 0
i * 1.0 <= 0
i * 1.0 <= 1.0
i * 1.0 == $env?.[String]
i * 1.0 == 0
i * 1.0 ?? str
i * 1.0 | min(i)
i * abs(i)
i * array?.[i]
i * f64
i * f64 ** 1
i * f64 + f64
i * f64 / f64
i * f64 == i
i * f64 ?? nil
i * f64 ^ f64
i * f64 ^ i
i * floor(0)
i * floor(f64)
i * i
i * i != i
i * i % i
i * i ** 1.0
i * i / 1.0
i * i / i
i * i <= i
i * i == $env
i * i == 0
i * i > i
i * i ?? list
i * i in array
i * i | median(1)
i * int(0)
i * int(1.0)
i * len(array)
i * len(str)
i * max(i)
i * mean(array)
i * mean(i)
i * median(f64)
i * median(i)
i * min(0, f64)
i * min(i)
i * round(1.0)
i * sum($env, 0)
i * sum(array)
i ** $env.f64
i ** $env.i
i ** $env?.f64
i ** $env?.i
i ** -0
i ** -1.0
i ** -f64
i ** -i
i ** 0 != nil
i ** 0 - abs(i)
i ** 0 in array
i ** 1 != $env
i ** 1 + i
i ** 1 <= 1
i ** 1 > 1.0
i ** 1 ?? true
i ** 1 ^ 1.0
i ** 1.0 != i
i ** 1.0 ** i
i ** 1.0 + 1.0
i ** 1.0 - 1
i ** 1.0 - i
i ** 1.0 / i
i ** 1.0 == $env
i ** 1.0 == nil
i ** 1.0 >= f64 <= f64
i ** 1.0 ?? foo
i ** 1.0 ?? list
i ** 1.0 ^ 1
i ** 1.0 ^ i
i ** 1.0 | max(1)
i ** abs(1.0)
i ** array?.[i]
i ** bitshl(1, 0)
i ** ceil(f64)
i ** count($env, true)
i ** f64
i ** f64 * 1.0
i ** f64 + 0
i ** f64 < 1
i ** f64 == nil
i ** f64 ^ i
i ** float(1.0)
i ** float(i)
i ** floor(f64)
i ** i
i ** i ** 1.0
i ** i + f64
i ** i / 1.0
i ** i < 1
i ** i == 1.0
i ** i > 0
i ** i >= i
i ** i ^ 1
i ** i | max(array, i)
i ** int(i)
i ** len($env)
i ** len(list)
i ** max(0)
i ** max(1)
i ** mean(1, array)
i ** min(0)
i ** min(1)
i ** min(1.0)
i ** min(1.0, array)
i ** min(array)
i ** min(f64)
i ** nil ?? 1
i ** sum($env, 1.0)
i ** sum($env?.[str])
i ** sum(array)
i + $env != str || true
i + $env.f64
i + $env.i
i + $env?.f64
i + $env?.i
i + -1
i + -i
i + 0 ** f64
i + 0 - 0
i + 0 - i
i + 0 / 1
i + 0 <= 1.0
i + 0 ?? i
i + 0 ?? ok
i + 0 ?? true
i + 1 != 1
i + 1 != 1.0
i + 1 - 1.0
i + 1 .. i
i + 1 < 0
i + 1 ^ $env.f64
i + 1 in array
i + 1 | min(1.0, 1.0)
i + 1.0 != nil
i + 1.0 * len(array)
i + 1.0 ** f64
i + 1.0 - 1
i + 1.0 < f64
i + 1.0 < i
i + 1.0 <= 1.0
i + 1.0 == f64
i + 1.0 > 1.0
i + 1.0 >= 1.0 && $env
i + 1.0 ?? $env
i + 1.0 ?? false
i + 1.0 ?? nil
i + abs(1)
i + abs(1.0)
i + abs(i)
i + array?.[i]
i + bitnot(0)
i + ceil($env.i)
i + ceil(0)
i + f64
i + f64 != nil
i + f64 ** i
i + f64 <= i
i + f64 > 1.0
i + f64 ?? nil < 1.0
i + first(array)
i + float(1)
i + float(1.0)
i + floor(1.0)
i + floor(i)
i + i
i + i ** f64
i + i .. i
i + i / 0
i + i <= i
i + i == $env
i + i > 1.0
i + i > i <= 0
i + i | add(1)
i + i | bitand(0)
i + len($env)
i + len(str)
i + max(1)
i + max(array)
i + max(array, array)
i + max(f64)
i + max(i)
i + mean(0)
i + mean(1)
i + mean(1.0)
i + mean(i)
i + reduce(list, 1.0)
i + sum(array)
i + sum(list, 0)
i - $env and false and ok
i - $env.f64
i - $env.i
i - $env?.f64
i - $env?.i
i - -0
i - -1.0
i - -f64
i - -i
i - 0 != 1.0
i - 0 % i
i - 0 * 1.0
i - 0 ** 1
i - 0 ** 1.0
i - 0 ** f64
i - 0 ** i
i - 0 / 1.0
i - 0 == f64
i - 0 >= 0
i - 0 | mean(1.0)
i - 1 ** 1.0 ^ 1
i - 1 / f64
i - 1 < i
i - 1 ?? array
i - 1 ?? nil
i - 1 ^ f64
i - 1 in array
i - 1.0 != $env?.String
i - 1.0 != 1.0
i - 1.0 * 0
i - 1.0 ** 1.0
i - 1.0 ** i
i - 1.0 + 1
i - 1.0 - 1.0
i - 1.0 < 0
i - 1.0 < f64
i - 1.0 <= 0
i - 1.0 <= f64
i - 1.0 == $env
i - 1.0 == i
i - 1.0 > f64
i - 1.0 >= 1
i - 1.0 >= f64
i - 1.0 ?? list
i - 1.0 ^ i
i - 1.0 ^ round(f64)
i - 1.0 not in array
i - 1.0 | min(1.0)
i - array?.[0]
i - array?.[i]
i - ceil(0)
i - ceil(1)
i - ceil(1.0)
i - f64
i - f64 != 1
i - f64 != 1.0
i - f64 - i
i - f64 >= f64
i - f64 >= i
i - f64 ^ 1.0 == 0
i - f64 in array
i - float(f64)
i - floor(1.0)
i - floor(f64)
i - floor(i)
i - i
i - i != 1.0
i - i != i
i - i % i < 0
i - i ** i
i - i + i
i - i / i
i - i < f64
i - i == 1.0
i - i > 0
i - i >= i
i - i ?? $env
i - i ?? array
i - i ^ 1.0
i - i not in $env?.String
i - i | min(array)
i - i..i
i - int(0)
i - int(1.0)
i - len(array)
i - len(list)
i - max(1.0)
i - max(array)
i - mean(1.0)
i - median(array, 1)
i - min(0)
i - min(1)
i - min(1.0)
i - min(f64)
i - min(i)
i - nil ?? f64
i - reduce($env, #acc, i)
i - reduce(array, #index)
i - sum($env, f64)
i .. $env.i
i .. $env?.i
i .. -i
i .. 0 != $env
i .. 0 * i
i .. 0 == list
i .. 0 ?? $env
i .. 0 ?? list
i .. 0 | all($env[.Bar:])
i .. 0 | count($env)
i .. 0 | groupBy($env)
i .. 0 | groupBy(greet)
i .. 0 | map(#)
i .. 0 | median(f64)
i .. 0 | reduce(#, $env)
i .. 0 | sum(1)
i .. 0 | sum(foo)
i .. 0 | sum(str)
i .. 1 - i
i .. 1 ?? f64
i .. 1 | filter(false)
i .. 1 | groupBy(#)
i .. 1 | groupBy(1.0)
i .. 1 | map(#)
i .. 1 | reduce(true)
i .. 1 | sortBy(#)
i .. 1 | sortBy(1)
i .. 1 | sortBy(foo.Bar)
i .. 1.0 ?? i
i .. 1.0 ?? list
i .. abs(i)
i .. array?.[i]
i .. bitnot(1)
i .. f64 * 1.0 ?? 0
i .. f64 ?? array
i .. f64 ?? true
i .. i
i .. i != nil
i .. i % 1
i .. i ?? 1.0
i .. i | filter(ok)
i .. i | groupBy(#)
i .. i | map(#)
i .. i | reduce(#)
i .. i | reduce($env)
i .. i | reduce(1.0)
i .. i | reduce(false)
i .. i | reduce(foo)
i .. i | sortBy(1)
i .. i | sortBy(false)
i .. int(0)
i .. len(array)
i .. max(0)
i .. max(i)
i .. median(i)
i .. min(1)
i .. sum(array)
i / $env.f64
i / $env.i
i / $env?.f64
i / $env?.i
i / -0
i / -1
i / -1.0
i / -f64
i / -i
i / 0 + f64 == i
i / 0 - f64
i / 0 < 1
i / 0 <= i
i / 0 == 1.0
i / 0 not in array
i / 1 != i
i / 1 * i
i / 1 ** f64
i / 1 + f64
i / 1 / 1
i / 1 ?? foo
i / 1 not in array
i / 1 | median(f64, 1.0)
i / 1.0 != 1
i / 1.0 != 1.0
i / 1.0 * ceil(1.0)
i / 1.0 ** i
i / 1.0 + f64
i / 1.0 - 0
i / 1.0 - f64
i / 1.0 / i
i / 1.0 < 0
i / 1.0 < i
i / 1.0 <= 1.0
i / 1.0 > 1.0
i / 1.0 ?? 1
i / 1.0 ?? add
i / 1.0 ?? foo
i / 1.0 ?? greet
i / 1.0 ?? list
i / 1.0 ?? str
i / 1.0 in array
i / abs(1.0)
i / array?.[i]
i / bitnot(0)
i / ceil(0)
i / count(array, false)
i / f64
i / f64 * 1.0
i / f64 / 1.0
i / f64 < 1.0
i / f64 == $env
i / f64 > i
i / f64 ?? 1
i / f64 ^ i
i / f64 in list ?? str
i / float(1)
i / floor(1.0)
i / i
i / i ** f64
i / i + 1.0
i / i < 0
i / i < f64 ?? foo
i / i <= 0
i / i == 1.0
i / i == i
i / i == nil
i / i ?? add
i / i in array
i / len($env)
i / mean(1.0, 1.0)
i / median(1)
i / median(1.0)
i / min(i)
i / nil ?? i
i / reduce(array, 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
i < -f64
i < -i
i < 0 != ok
i < 0 && false
i < 0 / i
i < 0 < i
i < 0 <= f64
i < 0 > 0
i < 0 ?? $env?.[Bar]
i < 0 and ok
i < 0 || $env
i < 1 != $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 ?? foo
i < 1 ?? i
i < 1 ?? nil
i < 1 || $env
i < 1.0 != nil
i < 1.0 != ok
i < 1.0 * f64
i < 1.0 ** 0
i < 1.0 / i
i < 1.0 < $env?.f64
i < 1.0 < 0
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 == nil
i < 1.0 == true
i < 1.0 > 1.0
i < 1.0 ?? 0
i < 1.0 ?? greet
i < 1.0 || ok
i < abs(1)
i < abs(1.0)
i < abs(i)
i < array?.[i]
i < bitnot(i)
i < ceil(1.0)
i < ceil(f64)
i < f64
i < f64 != ok
i < f64 != true
i < f64 ** ceil(1.0)
i < f64 + 1.0
i < f64 < 0
i < f64 < f64 < i
i < f64 == $env
i < f64 >= $env
i < f64 ? 1 : foo
i < f64 or $env
i < f64 || true
i < findIndex($env, ok)
i < first(array)
i < float(0)
i < float(i)
i < floor(0)
i < floor(f64)
i < i
i < i + i
i < i / 0
i < i <= i
i < i == $env
i < i >= i
i < i ^ 0
i < i || $env
i < int(0)
i < len($env)
i < max(array)
i < max(f64)
i < mean(0, array)
i < min(1.0)
i < reduce(array, 1.0)
i < round(1.0)
i < sum(array)
i < sum(array, 1.0)
i <= $env.f64
i <= $env.i
i <= $env?.f64
i <= $env?.i
i <= -0
i <= -1.0
i <= -f64
i <= 0 && $env
i <= 0 * i
i <= 0 + f64
i <= 0 < $env
i <= 0 >= 0
i <= 0 >= f64
i <= 0 ?? 0
i <= 0 ?? nil
i <= 0 and $env
i <= 0 or false
i <= 1 / 1
i <= 1 / 1.0
i <= 1 == nil
i <= 1 >= 1
i <= 1 || ok
i <= 1.0 && ok
i <= 1.0 * i
i <= 1.0 - 1.0
i <= 1.0 / f64
i <= 1.0 / i
i <= 1.0 < 0
i <= 1.0 < f64
i <= 1.0 <= 1
i <= 1.0 == nil
i <= 1.0 > 1.0
i <= 1.0 > i
i <= 1.0 ?? greet
i <= 1.0 ^ i
i <= 1.0 or $env
i <= 1.0 or ok
i <= 1.0 || $env.ok
i <= 1.0 || ok
i <= abs(f64)
i <= array?.[i]
i <= bitnot(1)
i <= ceil(1.0)
i <= f64
i <= f64 * 1.0
i <= f64 < 1.0
i <= f64 > $env
i <= f64 and false
i <= f64 and true
i <= f64 in $env?.String
i <= f64 || $env
i <= float(i)
i <= floor(0)
i <= floor(1)
i <= floor(1.0)
i <= i
i <= i && true
i <= i + i
i <= i - 0
i <= i / 1
i <= i <= 1
i <= i == nil
i <= i >= i
i <= i ?: add
i <= i ?? f64
i <= i ^ i
i <= len(array)
i <= max(1)
i <= max(1.0)
i <= max(array)
i <= mean(1.0)
i <= mean(i)
i <= mean(i, i)
i <= median(1.0)
i <= median(array)
i <= nil ?? 1.0
i <= round(0)
i <= sum(array, #)
i == $env != $env
i == $env != ok
i == $env && ok
i == $env == $env
i == $env ? array : array
i == $env ?: 1.0
i == $env ?: f64
i == $env ?? 0 ?? array
i == $env ?? array
i == $env and $env?.[String]
i == $env and nil == 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?.[Bar]?.String()
i == $env?.[Bar]?.add
i == $env?.[String]
i == $env?.[foobar]
i == $env?.[str]
i == $env?.f64
i == $env?.false?.[str]
i == $env?.foobar
i == $env?.i
i == -0 ** 0
i == -1
i == -1.0
i == -i
i == 0 != ok
i == 0 ** i
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 && true
i == 1 * 0
i == 1 ** 1.0
i == 1 - 1.0
i == 1 / f64
i == 1 / max(array)
i == 1 == false
i == 1 ?? 0
i == 1 ?? true
i == 1 ^ i
i == 1 and true
i == 1 || ok
i == 1.0 != $env
i == 1.0 != ok ?: foo
i == 1.0 != true
i == 1.0 * 1.0
i == 1.0 ** 1.0
i == 1.0 + 1.0
i == 1.0 - 1
i == 1.0 == nil
i == 1.0 == true
i == 1.0 ?? 1.0
i == 1.0 ?? foo
i == 1.0 ?? nil
i == 1.0 ^ 1
i == 1.0 ^ 1.0
i == 1.0 || $env
i == 1.0 || max($env)
i == abs(f64)
i == abs(i)
i == add ?? ok
i == array?.[i]
i == bitnot(1)
i == bitor(1, 0)
i == ceil(1.0)
i == count(list, false)
i == f64
i == f64 != $env
i == f64 && $env
i == f64 * 0
i == f64 * 1
i == f64 * f64
i == f64 / f64
i == f64 ? f64 : foo
i == f64 ?: array
i == f64 ?? foo
i == float(1.0)
i == floor(1)
i == floor(i)
i == foo ?? 1
i == foo ?? ok
i == i
i == i + $env?.i
i == i + 0
i == i + f64
i == i == $env
i == i == nil
i == i ?? 1.0
i == i ?? false
i == i ^ 0
i == i ^ 1.0
i == i or $env
i == int(1.0)
i == int(i)
i == len(array)
i == len(list)
i == len(str)
i == list ?? 1
i == list ?? str
i == max(array)
i == max(i)
i == mean(1.0)
i == median(f64)
i == min($env)
i == min(f64)
i == nil == $env
i == nil ? $env?.[i] : list
i == nil ?: foo
i == nil ?? $env
i == nil ?? 1
i == nil or false
i == nil || $env
i == ok ?? 0
i == round(1)
i == round(f64)
i == sum(array)
i == sum(array, 1.0)
i == true ?? add
i > $env.f64
i > $env.i
i > $env?.f64
i > $env?.i
i > -1.0
i > 0 + 1
i > 0 + i
i > 0 / f64
i > 0 <= 1.0
i > 0 == nil
i > 0 > 1.0
i > 0 > f64
i > 0 ?: ok
i > 0 and $env
i > 0 or false
i > 0.0
i > 1 && ok
i > 1 * 0
i > 1 * f64
i > 1 - 0
i > 1 - 1.0
i > 1 < 1.0
i > 1 == ok
i > 1 >= $env
i > 1 >= $env[:0]
i > 1 >= 0
i > 1 ?? 1.0
i > 1 or ok
i > 1 || $env
i > 1.0
i > 1.0 ** 0
i > 1.0 ** f64
i > 1.0 - $env?.i
i > 1.0 - 1
i > 1.0 / 1
i > 1.0 / i
i > 1.0 < $env
i > 1.0 < $env == nil
i > 1.0 < -$env
i > 1.0 == $env
i > 1.0 == ok
i > 1.0 > $env
i > 1.0 > 1.0
i > 1.0 >= 1.0
i > 1.0 ?: array
i > 1.0 ?? f64
i > 1.0 ?? nil
i > 1.0 or $env
i > 1.0 or ok
i > abs(i)
i > array?.[i]
i > ceil(1)
i > ceil(1.0)
i > f64
i > f64 != nil
i > f64 != ok
i > f64 && $env
i > f64 ** i
i > f64 + 1
i > f64 / 1.0
i > f64 <= i
i > f64 >= 1
i > f64 >= 1.0
i > f64 ?? $env.foo
i > f64 ?? i
i > find(array, ok)
i > float(0)
i > floor(1)
i > floor(1.0)
i > get(array, 0)
i > i
i > i ** f64
i > i + 0
i > i - 1.0
i > i <= 1
i > i ?? greet
i > i and $env
i > last(array)
i > len($env)
i > max(1.0)
i > max(i)
i > mean(1.0)
i > median(f64)
i > min(0)
i > min(i)
i > round(-1.0)
i > sum(array)
i >= $env or true
i >= $env || true
i >= $env.f64
i >= $env.i
i >= $env?.f64
i >= $env?.i
i >= -1
i >= -f64
i >= -i
i >= 0 != nil
i >= 0 != ok
i >= 0 - f64
i >= 0 - i
i >= 0 / max(1.0)
i >= 0 <= i
i >= 0 >= 1
i >= 0 >= f64
i >= 0 >= i
i >= 0 ^ 1
i >= 0 ^ f64
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 ?? $env?.[add]
i >= 1 and $env
i >= 1 and $env?.[str]
i >= 1.0 != $env
i >= 1.0 != nil
i >= 1.0 && true
i >= 1.0 * 0
i >= 1.0 ** i
i >= 1.0 + 1.0
i >= 1.0 + i
i >= 1.0 - sum($env, 0)
i >= 1.0 ?? 1.0
i >= 1.0 ^ i
i >= 1.0 and $env
i >= 1.0 or $env
i >= 1.0 or false
i >= abs(1)
i >= array?.[i]
i >= ceil(0)
i >= f64
i >= f64 != $env
i >= f64 * 0
i >= f64 * 1
i >= f64 * 1.0
i >= f64 ** f64
i >= f64 ** i
i >= f64 + 1
i >= f64 - 0
i >= f64 < i
i >= f64 > 1.0
i >= f64 ?? foo
i >= f64 ?? ok
i >= f64 and $env
i >= f64 || $env
i >= float(1)
i >= float(1.0)
i >= float(f64)
i >= floor(i)
i >= i
i >= i != $env
i >= i != ok
i >= i * 0
i >= i ** 0
i >= i - i
i >= i / 1.0
i >= i ?? list
i >= i ?? nil == nil
i >= i || $env
i >= i || false
i >= int(1)
i >= int(1.0)
i >= last(array)
i >= max(array)
i >= mean(1.0)
i >= mean(f64)
i >= median(0)
i >= median(1.0)
i >= median(array)
i >= min(1)
i >= min(1.0)
i >= min(array)
i >= reduce($env, 0, 0)
i >= round(f64)
i >= round(i)
i >= sum(array)
i ?? !$env
i ?? !ok
i ?? !true
i ?? $env.add
i ?? $env.array
i ?? $env.f64
i ?? $env.foo
i ?? $env.greet
i ?? $env.i
i ?? $env.list
i ?? $env.ok
i ?? $env.str
i ?? $env?.Bar
i ?? $env?.Bar()
i ?? $env?.String
i ?? $env?.String()
i ?? $env?.String(foobar, foobar startsWith foobar?.list)
i ?? $env?.String?.[i]
i ?? $env?.[Bar]
i ?? $env?.[String]
i ?? $env?.[add]
i ?? $env?.[array]
i ?? $env?.[f64]
i ?? $env?.[f64].str
i ?? $env?.[foo]
i ?? $env?.[foobar and foobar]
i ?? $env?.[foobar]
i ?? $env?.[greet]
i ?? $env?.[i.f64]
i ?? $env?.[i]
i ?? $env?.[i].Bar()
i ?? $env?.[list | median(true)]
i ?? $env?.[list]
i ?? $env?.[list]?.[list]
i ?? $env?.[list]?.str()
i ?? $env?.[ok]
i ?? $env?.[str]
i ?? $env?.add
i ?? $env?.array
i ?? $env?.f64
i ?? $env?.foo
i ?? $env?.foobar
i ?? $env?.foobar?.[list]
i ?? $env?.i
i ?? $env?.list
i ?? $env?.ok
i ?? $env?.str
i ?? $env?.true.foobar
i ?? $env[$env.greet():]
i ?? $env[:find(i, #acc)]
i ?? $env[:foobar]
i ?? $env[add:]
i ?? $env[any(foo, i):]
i ?? $env[f64?.String():]
i ?? $env[false:foobar]
i ?? $env[find(f64, 1.0):]?.[f64]
i ?? $env[foo:foobar]
i ?? $env[foobar:]
i ?? $env[nil:1]
i ?? -$env
i ?? -0
i ?? -1.0
i ?? -abs($env?.String(foobar))?.ok
i ?? -i
i ?? 0 ?? foo
i ?? 0 ?? nil
i ?? 1.0 ?? $env.greet
i ?? 1.0 ?? ok
i ?? 1.0 ?? str
i ?? 1.0 | bitand(0)
i ?? 1.0 | max(0)
i ?? [1.0]
i ?? [false]
i ?? [nil]
i ?? [ok]
i ?? abs($env - $env)?.[f64]
i ?? abs($env)
i ?? add
i ?? add ?? 1
i ?? all($env, #.add)
i ?? array
i ?? array ?? ok
i ?? array?.[i]
i ?? bitand(i, $env)
i ?? ceil(i)
i ?? count(array)
i ?? count(list)
i ?? date(false)
i ?? date(foo)
i ?? date(foo, array)
i ?? date(nil)
i ?? date(true, true)
i ?? f64
i ?? f64 ?? nil
i ?? false ?? str
i ?? findLast($env, .f64)
i ?? findLastIndex($env, #)
i ?? findLastIndex($env, $env)
i ?? first($env)
i ?? first(array)
i ?? foo
i ?? foo ?? foo
i ?? foo | bitshl(0)
i ?? foo | get(true)
i ?? foo.Bar
i ?? foo.String
i ?? foo.String()
i ?? foo?.Bar
i ?? foo?.String
i ?? foo?.String()
i ?? fromBase64(str)
i ?? fromJSON($env)
i ?? fromPairs($env)
i ?? greet
i ?? greet ?? f64
i ?? greet($env - 1.0)
i ?? greet($env)
i ?? greet(str)
i ?? groupBy($env, i)
i ?? hasSuffix($env, $env)
i ?? i
i ?? i ?? add
i ?? join($env)
i ?? list
i ?? list ?? f64
i ?? list ?? ok
i ?? list?.[i]
i ?? map($env, 0)
i ?? map($env, 1)
i ?? max($env)
i ?? max(1.0)
i ?? max(array)
i ?? max(array)?.[f64]
i ?? median(f64)
i ?? median(list, list)
i ?? min($env)
i ?? nil ?? $env
i ?? not $env
i ?? not $env?.String(false)
i ?? not $env?.[greet]
i ?? not false
i ?? not true
i ?? ok
i ?? ok ?? greet
i ?? reduce(array, #acc)
i ?? reduce(array, ok)
i ?? round(0)
i ?? sort(array)
i ?? sortBy(list, #)
i ?? str
i ?? string(1)
i ?? string(1.0)
i ?? string(list)
i ?? string(str)
i ?? sum($env)
i ?? sum($env, #.greet)
i ?? sum($env, array)
i ?? sum(array, #)
i ?? sum(array, $env)
i ?? sum(list)
i ?? sum(list)?.String
i ?? toBase64(str)
i ?? toJSON(1.0)
i ?? toJSON(ok)
i ?? true ?? i
i ?? true | get(0)
i ?? type(greet)
i ?? upper($env)
i ?? {foo: 0}
i ?? {foo: 1, foo: nil, foo: nil}
i ?? {foo: 1.0}
i ?? {foo: array}
i ?? {foo: foo, foo: greet}.Bar
i ?? {foo: foo}
i ?? {foo: list}
i ?? {foo: nil, foo: str}
i ?? {foo: true}
i ^ $env.f64
i ^ $env.i
i ^ $env?.f64
i ^ $env?.i
i ^ -1
i ^ -1.0
i ^ -f64
i ^ -i
i ^ 0 != 1.0
i ^ 0 * abs(1)
i ^ 0 + 1
i ^ 0 < 1.0
i ^ 0 < i
i ^ 0 > f64
i ^ 0 not in array
i ^ 1 != $env
i ^ 1 - f64
i ^ 1 < i
i ^ 1 == 0
i ^ 1 >= i
i ^ 1 | median(1, i, 0)
i ^ 1.-0
i ^ 1.0 != $env
i ^ 1.0 != i
i ^ 1.0 != nil
i ^ 1.0 - 0
i ^ 1.0 - 1
i ^ 1.0 / i
i ^ 1.0 < 1
i ^ 1.0 < 1.0
i ^ 1.0 < f64
i ^ 1.0 <= 0
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 ?? 1.0
i ^ 1.0 ?? add
i ^ 1.0 | max(0)
i ^ abs(0)
i ^ array?.[i]
i ^ bitnot(1)
i ^ ceil(1)
i ^ ceil(1.0)
i ^ count($env, false)
i ^ f64
i ^ f64 * 0
i ^ f64 ** f64
i ^ f64 + i
i ^ f64 == $env
i ^ f64 == 1
i ^ f64 == float(1.0)
i ^ f64 >= 1
i ^ f64 ?? 1
i ^ f64 ^ 1.0
i ^ findIndex($env, true)
i ^ findIndex(array, true)
i ^ first(array)
i ^ float(1.0)
i ^ floor(1)
i ^ floor(1.0)
i ^ i
i ^ i != f64
i ^ i * i
i ^ i / f64
i ^ i < i
i ^ i == nil
i ^ i > f64
i ^ i >= i
i ^ i ?? $env?.i
i ^ i ?? array
i ^ i ^ 0 ?? list
i ^ i ^ 1.0
i ^ i in array
i ^ i not in array
i ^ int(1)
i ^ int(1.0)
i ^ int(i)
i ^ len($env)
i ^ max(array)
i ^ mean(1.0)
i ^ mean(array)
i ^ mean(f64)
i ^ median(1.0)
i ^ min(0)
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?.Bar?.[list]
i in $env?.String
i in $env?.[Bar]
i in $env?.[String]
i in $env?.[String]?.foo
i in $env?.[foobar?.[list]]
i in $env?.array
i in $env?.nil
i in [0]
i in array
i in array != $env
i in array ?? ok
i in array and $env
i in array and ok
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 i .. 0
i in last($env)
i in list ?? str
i in map($env, f64)
i in sort(array)
i in toPairs($env)
i in {foo: 1.0}.greet
i in {foo: nil}?.greet
i not in $env or true
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?.[String]?.str
i not in $env?.[foobar]
i not in $env?.array
i not in $env?.foobar?.[i]
i not in $env?.nil?.[add]
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 == ok
i not in array == true
i not in concat(array)
i not in flatten(array)
i not in flatten(list)
i not in groupBy(array, #)
i not in groupBy(list, i)
i not in last($env)
i not in map(list, 1)
i not in map(list, f64)
i not in values($env)
i | add(0)
i | add(0) ?? foo
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(array?.[i])
i | bitnand(i)
i | bitor(0)
i | bitor(1 % 1)
i | bitor(1)
i | bitor(i)
i | bitor(sum(array))
i | bitshl($env.i)
i | bitshl(0)
i | bitshl(1)
i | bitshl(i)
i | bitshl(sum(array))
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(array, 0)
i | max(array, 1)
i | max(f64)
i | max(f64, 0)
i | max(f64, f64)
i | max(i)
i | max(i, array)
i | mean(0 / 1.0)
i | mean(0)
i | mean(0, array, 0)
i | mean(1)
i | mean(1, array)
i | mean(1.0)
i | mean(array)
i | mean(f64 * 1)
i | mean(f64)
i | mean(f64, 1)
i | mean(i)
i | mean(i, f64)
i | median(0)
i | median(0, 0)
i | median(0, 1.0)
i | median(0, array, array)
i | median(1)
i | median(1) / f64
i | median(1, 1)
i | median(1, f64)
i | median(1.0)
i | median(1.0, 0)
i | median(1.0, 1)
i | median(1.0, i)
i | median(array)
i | median(f64)
i | median(i)
i | median(i) != f64
i | median(i, 1.0)
i | median(i, i)
i | min(0)
i | min(0) <= i
i | min(0) | median(1.0)
i | min(0, array)
i | min(0, f64)
i | min(1)
i | min(1.0 ?? add)
i | min(1.0)
i | min(1.0, 0)
i | min(array)
i | min(array, f64)
i | min(array, i, f64)
i | min(f64)
i | min(f64, 1)
i | min(f64, array)
i | min(i)
i | min(i, 1)
i | min(i, 1.0)
i..array?.[i]
i..i
i..i - 0
i..i == $env
i..i == nil
i..i | map(#)
i..i | map(ok)
i..i | reduce(foo)
i..i | sortBy(ok)
i; 1.0; $env.foo
i; add
i; array
i; ceil(1.0)
i; f64
i; foo
i; greet
i; i
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 $env?.ok { greet } else { foo }
if 0 > 1 { list } else { false ? ok : ok }
if 0 > f64 { f64 } else { array }
if 1.0 != $env { ok } else { $env <= $env }
if 1.0 >= 0 { foo } else { ok }
if array == $env { i } else { median(0) }
if f64 > 1.0 { array } else { round(1.0) }
if f64 not in array { map(list, list) } else { add }
if foo == foo { true != true } else { list | groupBy(1) }
if i < 0 { str } else { str }
if i > $env?.i { greet } else { list }
if nil != nil { $env | bitshl(i) } else { 0 != $env }
if nil != str { greet } else { array }
if nil == nil { greet } else { array }
if nil == ok { ok } else { greet }
if nil not in list { array } else { f64 }
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 { 1.0 ?? 0 } else { $env != $env }
if ok { add } else { add }
if ok { add } else { array }
if ok { add } else { f64 }
if ok { add } else { foo != $env }
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 { array } else { i }
if ok { array } else { str }
if ok { ceil(i) } else { list }
if ok { f64 } else { array }
if ok { f64 } else { f64 }
if ok { f64 } else { findLastIndex($env, $env) }
if ok { f64 } else { foo }
if ok { f64 } else { list }
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 { i }
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 { greet }
if ok { greet } else { i }
if ok { greet } else { str }
if ok { i } else { $env | filter($env) }
if ok { i } else { add }
if ok { i } else { array }
if ok { i } else { date($env) }
if ok { i } else { str }
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 { add }
if ok { ok } else { array }
if ok { ok } else { date(1.0) }
if ok { ok } else { foo }
if ok { ok } else { greet }
if ok { ok } else { ok }
if ok { str } else { array }
if ok { str } else { foo }
if ok { str } else { i }
if ok { str } else { list }
if ok { str } else { ok }
if ok { str } else { str }
if ok { type(f64) } else { foo }
if str == $env { foo?.String() } else { $env.foo }
if str > str { str } else { find(array, ok) }
if true != true { i } else { array }
if true && ok { array } else { greet }
indexOf($env?.[str], str)
indexOf($env?.str, $env?.str)
indexOf(str, str)
indexOf(toJSON(1.0), toJSON(true))
int($env | count(ok))
int($env | findIndex(ok))
int($env | findIndex(true))
int($env | findLastIndex(true))
int($env | reduce(1, f64))
int($env | sum(f64))
int($env | sum(i))
int($env.f64)
int($env.i)
int($env?.f64)
int($env?.i)
int(-$env?.i)
int(-0)
int(-1)
int(-1.0)
int(-f64)
int(-i)
int(0 % 1)
int(0 % i)
int(0 * 1)
int(0 * 1.0)
int(0 * f64)
int(0 * i)
int(0 ** 0)
int(0 ** 1)
int(0 ** 1.0)
int(0 + 1)
int(0 + 1.0)
int(0 + f64)
int(0 - $env.i)
int(0 - 1.0)
int(0 - f64)
int(0 - i)
int(0 / 0)
int(0 / 1)
int(0 / 1.0)
int(0 / i)
int(0 ?? 0)
int(0 ?? 1)
int(0 ?? 1.0)
int(0 ?? array)
int(0 ?? list)
int(0 ?? true)
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) > 0 + i
int(0) > 1.0 > 1
int(0) ^ i
int(0) | bitshl(0)
int(0) | mean(i)
int(0) | median(array)
int(0)..i
int(0.0)
int(1 % 1)
int(1 * 0)
int(1 * 1.0)
int(1 * i)
int(1 ** 1.0)
int(1 ** f64)
int(1 ** i)
int(1 + f64)
int(1 - 0)
int(1 - 1)
int(1 - 1.0)
int(1 - f64)
int(1 - i)
int(1 / 1.0)
int(1 / f64)
int(1 ?? 1)
int(1 ?? 1.0)
int(1 ?? add)
int(1 ?? false)
int(1 ?? foo)
int(1 ?? ok)
int(1 ?? true)
int(1 ^ 0)
int(1 ^ 1.0)
int(1 ^ f64)
int(1 ^ i)
int(1 | bitxor(i))
int(1 | max(i))
int(1 | median(f64))
int(1) != i
int(1) * f64
int(1) - f64
int(1) <= f64
int(1) == f64
int(1) == i
int(1) ?? add
int(1) ?? str
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 ** i)
int(1.0 + 0)
int(1.0 + 1)
int(1.0 + 1.0)
int(1.0 + f64)
int(1.0 + i)
int(1.0 - 0)
int(1.0 - 1)
int(1.0 - 1.0)
int(1.0 - f64)
int(1.0 / 0)
int(1.0 / 1)
int(1.0 / 1.0)
int(1.0 / f64)
int(1.0 / i)
int(1.0 ?? $env)
int(1.0 ?? 0)
int(1.0 ?? 1.0)
int(1.0 ?? add)
int(1.0 ?? array)
int(1.0 ?? f64)
int(1.0 ?? foo)
int(1.0 ?? foo?.Bar)
int(1.0 ?? i)
int(1.0 ?? list)
int(1.0 ?? nil)
int(1.0 ?? ok)
int(1.0 ?? str)
int(1.0 ?? true)
int(1.0 ^ 0)
int(1.0 ^ 1)
int(1.0 ^ 1.0)
int(1.0 ^ f64)
int(1.0 ^ i)
int(1.0 | median(1))
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) * f64
int(1.0) * i
int(1.0) ** f64
int(1.0) ** i
int(1.0) + i / 1
int(1.0) .. i
int(1.0) / i
int(1.0) < f64
int(1.0) == f64
int(1.0) == i
int(1.0) > 1 > 1.0
int(1.0) >= f64
int(1.0) ?? foo
int(1.0) ?? greet
int(1.0) ?? greet($env)
int(1.0) in array
int(1.0) | bitushr(i)
int(1.0) | median(array)
int(1.0)..i
int(abs(0))
int(abs(1))
int(abs(1.0))
int(abs(f64))
int(abs(i))
int(array | count(false))
int(array | count(ok))
int(array | find(not false))
int(array | max(f64, array, 0))
int(array | median(f64, i))
int(array | min(1.0))
int(array | reduce(#))
int(array | reduce(#index))
int(array | reduce(0))
int(array | sum(#))
int(array | sum(0))
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(1.0))
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 + 1.0)
int(f64 + i)
int(f64 - 0)
int(f64 - 1)
int(f64 - 1.0)
int(f64 - f64)
int(f64 - i)
int(f64 / 0)
int(f64 / 1)
int(f64 / 1.0)
int(f64 ?? $env)
int(f64 ?? 0)
int(f64 ?? 1.0)
int(f64 ?? false)
int(f64 ?? foo)
int(f64 ?? i)
int(f64 ^ 0)
int(f64 ^ 1.0)
int(f64 ^ f64)
int(f64 ^ i)
int(f64 | mean(i))
int(f64 | min(1.0))
int(f64)
int(f64) != f64
int(f64) / i
int(f64) <= ceil(1.0)
int(f64) <= f64
int(f64) == i
int(f64) in array
int(f64) not in array ?? nil
int(f64)..i
int(false ?: 1.0)
int(findIndex(array, true))
int(findIndex(list, ok))
int(findLast(array, true))
int(findLastIndex($env, ok))
int(findLastIndex(list, true))
int(first(array))
int(float(0))
int(float(1))
int(float(1.0))
int(float(f64))
int(float(i))
int(floor(1))
int(floor(1.0))
int(floor(f64))
int(floor(i))
int(i % 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 + f64)
int(i - 1)
int(i - 1.0)
int(i - f64)
int(i - i)
int(i / 0)
int(i / 1.0)
int(i / i)
int(i ?? 1.0)
int(i ?? add)
int(i ?? false)
int(i ?? foo)
int(i ?? i)
int(i ?? nil)
int(i ^ 1.0)
int(i | bitxor(1))
int(i)
int(i) != f64
int(i) * i
int(i) ** f64
int(i) .. i
int(i) < i
int(i) == sum(array)
int(i) ?? array
int(i) ?? foo
int(i) ?? foo ?? list
int(i) | min(array)
int(if ok { 1 } else { f64 })
int(if true { 1.0 } else { $env })
int(int(0))
int(int(1))
int(int(1.0))
int(int(f64))
int(int(i))
int(last(array))
int(len($env))
int(len(0 .. i))
int(len(array))
int(len(list))
int(len(str))
int(let foobar = 1.0; foobar)
int(list | findLastIndex(ok))
int(list | reduce(#index))
int(list | reduce(0))
int(list | reduce(1, false))
int(list | reduce(1.0))
int(list | reduce(i))
int(list | sum(1))
int(list | sum(f64))
int(max(0))
int(max(1))
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(1.0, i))
int(min(array))
int(min(f64))
int(min(i))
int(min(i, array))
int(nil ?? 0)
int(nil ?? 1.0)
int(nil ?? i)
int(ok ? 1.0 : greet)
int(ok ? f64 : list)
int(reduce($env, 1.0, i))
int(reduce(array, #))
int(reduce(array, f64))
int(reduce(list, 1.0))
int(round(1))
int(round(1.0))
int(round(f64))
int(round(i))
int(string(0))
int(string(1))
int(string(1.0))
int(string(i))
int(sum($env, 0))
int(sum($env, 1))
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(toJSON(i))
int(toPairs($env) | reduce(i))
int(true ? 1 : array)
int(true ? 1.0 : $env)
int(true ? f64 : foo)
int(true ? i : nil)
join($env | filter(false))
join([str])
join(array | map(str))
join(keys($env))
join(list | map(str))
join(map(list, #.Bar))
join(sort($env))
keys($env ?? 0)
keys($env ?? 1)
keys($env ?? 1.0)
keys($env ?? array)
keys($env ?? f64)
keys($env ?? false)
keys($env ?? foo)
keys($env ?? greet)
keys($env ?? nil)
keys($env ?? true)
keys($env | reduce($env, add))
keys($env) != array
keys($env) != foo ?? 1.0
keys($env) == foo ?? f64
keys($env) == list
keys($env) == nil && true
keys($env) | any(ok)
keys($env) | count(ok)
keys($env) | count(true)
keys($env) | filter(true)
keys($env) | find(false)
keys($env) | findLast(true)
keys($env) | findLastIndex(false)
keys($env) | groupBy(#)
keys($env) | groupBy($env?.i)
keys($env) | groupBy(sum(#))
keys($env) | map(#)
keys($env) | map(1)
keys($env) | map(1.0)
keys($env) | map(add)
keys($env) | map(f64)
keys($env) | map(greet)
keys($env) | map(str)
keys($env) | none(false)
keys($env) | one(false)
keys($env) | one(ok)
keys($env) | one(true)
keys($env) | reduce(#)
keys($env) | reduce(#index)
keys($env) | reduce($env)
keys($env) | reduce(1.0)
keys($env) | reduce(f64, ok)
keys($env) | reduce(greet, $env)
keys($env) | reduce(i)
keys($env) | reduce(ok)
keys($env) | sortBy(#)
keys($env) | sortBy(str)
keys($env)?.[i]
keys(array | reduce($env))
keys(groupBy(array, #))
keys(groupBy(array, 1))
keys(groupBy(array, 1.0))
keys(groupBy(array, false))
keys(groupBy(array, foo))
keys(groupBy(list, #))
keys(groupBy(list, #.Bar))
keys(groupBy(list, foo))
keys(groupBy(list, ok))
keys(if true { $env } else { str })
keys(list | groupBy(#))
keys(list | groupBy(1))
keys(max($env))
keys(min($env))
keys(nil ?? $env)
keys(reduce(list, $env))
keys({foo: $env})
keys({foo: 0})
keys({foo: 1, foo: 0})
keys({foo: 1, foo: false})
keys({foo: 1, foo: i})
keys({foo: 1.0})
keys({foo: 1})
keys({foo: add})
keys({foo: array, foo: i})
keys({foo: array})
keys({foo: f64})
keys({foo: false})
keys({foo: foo, foo: $env?.f64})
keys({foo: foo, foo: 0})
keys({foo: foo, foo: 1.0})
keys({foo: foo, foo: i})
keys({foo: foo})
keys({foo: greet, foo: $env})
keys({foo: greet})
keys({foo: i, foo: true})
keys({foo: i})
keys({foo: list})
keys({foo: nil, foo: 0})
keys({foo: nil})
keys({foo: ok, foo: str})
keys({foo: ok})
keys({foo: str, foo: $env})
keys({foo: str, foo: f64})
keys({foo: str, foo: nil})
keys({foo: str})
keys({foo: true, foo: $env})
keys({foo: true, foo: list})
keys({foo: true})
last($env ?? $env)
last($env ?? $env.greet)
last($env ?? 1)
last($env ?? 1.0)
last($env ?? false)
last($env ?? foo)
last($env ?? greet)
last($env ?? i)
last($env ?? nil)
last($env ?? str)
last($env | map(#index))
last($env | map(1))
last($env | map(add))
last($env | map(array))
last($env | map(f64))
last($env | map(foo))
last($env | map(greet))
last($env | map(ok))
last($env | reduce($env, add))
last($env) != array
last($env) != list
last($env) == i
last($env) == ok
last($env) contains foo.Bar
last($env) contains str
last($env) in array
last($env) matches foo?.Bar
last($env) not contains foo.Bar
last($env) not in array
last($env) not matches str
last($env) not startsWith str
last($env) startsWith str
last($env)?.Bar
last($env)?.Bar()
last($env)?.Bar()?.[f64]
last($env)?.Bar()?.foo
last($env)?.Bar()?.str()
last($env)?.Bar(foobar)
last($env)?.Bar?.[array]
last($env)?.Bar?.[i]
last($env)?.Bar?.greet
last($env)?.String
last($env)?.String()
last($env)?.String().add
last($env)?.String()?.ok
last($env)?.String(foobar)
last($env)?.String(greet)
last($env)?.String?.[add]
last($env)?.String?.[array]
last($env)?.[add]
last($env)?.[add].Bar
last($env)?.[add]?.String
last($env)?.[array]
last($env)?.[array].foo
last($env)?.[array].i
last($env)?.[f64]
last($env)?.[f64] == i
last($env)?.[f64].add()
last($env)?.[f64]?.[list]
last($env)?.[f64]?.f64(foobar, greet)
last($env)?.[f64]?.foo()
last($env)?.[foo]
last($env)?.[foo].Bar
last($env)?.[foo].list
last($env)?.[foo]?.foo
last($env)?.[greet]
last($env)?.[greet]?.[i]
last($env)?.[greet]?.[ok]
last($env)?.[greet]?.list
last($env)?.[i]
last($env)?.[list]
last($env)?.[list].greet
last($env)?.[list].ok
last($env)?.[ok]
last($env)?.[ok] != i
last($env)?.[ok].ok()
last($env)?.[str]
last($env)?.[str]?.[foo]
last($env)?.[str]?.i
last($env)?.[str]?.ok
last($env)?.[{foo: add}]
last($env)?.add
last($env)?.add()
last($env)?.add(f64)
last($env)?.add(foobar)
last($env)?.add.add()
last($env)?.add.i
last($env)?.add?.[ok]
last($env)?.add?.f64
last($env)?.array
last($env)?.array()
last($env)?.array.list()
last($env)?.array?.[add]
last($env)?.array?.[greet]
last($env)?.f64
last($env)?.f64($env?.[String])
last($env)?.f64()
last($env)?.f64() == array
last($env)?.f64(greet(foobar))
last($env)?.f64(list)
last($env)?.f64?.[list]
last($env)?.f64?.greet
last($env)?.false != 0
last($env)?.findLast(foo, foobar)
last($env)?.foo
last($env)?.foo()
last($env)?.foo()?.greet()
last($env)?.foo(String, foobar?.greet)
last($env)?.foo(add)
last($env)?.foo.String
last($env)?.foo?.[foo]
last($env)?.foo?.[greet]
last($env)?.foo?.array
last($env)?.foobar
last($env)?.foobar.str()
last($env)?.foobar?.[str]
last($env)?.foobar?.ok()
last($env)?.fromPairs(foobar, foobar)
last($env)?.greet
last($env)?.greet()
last($env)?.greet?.Bar
last($env)?.greet?.[add]
last($env)?.greet?.[foo].foo()
last($env)?.greet?.array
last($env)?.greet?.i
last($env)?.i
last($env)?.i()
last($env)?.i(foobar endsWith add)
last($env)?.i.Bar(foobar)
last($env)?.i.foo
last($env)?.i.foo(foobar, f64)
last($env)?.i?.greet
last($env)?.i?.i
last($env)?.int(String)
last($env)?.join(1.0)
last($env)?.list
last($env)?.list()
last($env)?.list(foobar)
last($env)?.list.array
last($env)?.list?.[list]
last($env)?.none(foobar)?.String()
last($env)?.ok
last($env)?.ok()
last($env)?.ok?.add
last($env)?.str
last($env)?.str()
last($env)?.str(foobar)
last($env)?.str?.[list]
last($env)?.str?.array?.[ok]
last($env)?.str?.foo
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)?.add()
last($env?.Bar?.String)
last($env?.Bar?.[list])
last($env?.Bar?.[ok])
last($env?.String)
last($env?.String)?.[ok]
last($env?.String)?.greet()
last($env?.String?.[add])
last($env?.String?.[f64])
last($env?.[Bar])
last($env?.[Bar])?.foo.add
last($env?.[Bar]?.[foo])
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?.[String]?.ok)
last($env?.[foobar])
last($env?.[foobar])?.String
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?.false)?.[greet]
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(0 ?? 1.0)
last(0 ?? false)
last(0 ?? greet)
last(0 ?? str)
last(0 ?? true)
last(0..i)
last(1 .. 0)
last(1 .. 1)
last(1 .. i)
last(1 ?? foo)
last(1 ?? greet)
last(1.0 ?? $env)
last(1.0 ?? $env?.i)
last(1.0 ?? 0)
last(1.0 ?? array)
last(1.0 ?? false)
last(1.0 ?? foo)
last(1.0 ?? greet)
last(1.0 ?? true)
last(1.0 | min(array))
last([$env, true])
last([$env.ok, array])
last([$env])
last([$env]).i
last([0])
last([1, 0])
last([1, add])
last([1, nil])
last([1.0, str])
last([1.0])
last([1])
last([add, $env])
last([add, 1])
last([add])
last([array, 0])
last([array, false])
last([array])
last([f64])
last([false, 0])
last([false, foo])
last([false])
last([foo, $env])
last([foo, str])
last([foo])
last([greet, 1])
last([greet, false])
last([greet, nil])
last([greet])
last([i])
last([list])
last([nil])
last([ok])
last([str, $env])
last([str])
last([true, 1.0])
last(add ?? 1)
last(add ?? 1.0)
last(add ?? foo)
last(add ?? foo)?.add
last(add ?? true)
last(array ?? 0)
last(array ?? 1)
last(array ?? array)
last(array ?? greet)
last(array ?? i)
last(array ?? nil)
last(array ?? str)
last(array | map(#))
last(array | map(f64))
last(array | map(false))
last(array | map(foo))
last(array | map(list))
last(array | min(1.0))
last(array | reduce(#acc))
last(array | sortBy(1.0))
last(array)
last(array) != i
last(array) % i
last(array) >= i
last(array) ?? -0
last(array) ?? add
last(array) in array != false
last(array) | mean(1.0)
last(array[:])
last(array[:i])
last(concat(array))
last(concat(list))
last(f64 ?? $env)
last(f64 ?? add)?.f64()
last(f64 ?? false)
last(f64 ?? i)
last(f64 ?? list)
last(f64 ?? str)
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(false ?? $env?.f64)
last(false ?? 1.0)
last(false ?? array)?.list()
last(false ?? str)
last(filter($env, false))
last(filter(array, true))
last(filter(list, false))
last(filter(list, true))
last(first($env))
last(first($env)?.[list])
last(first({foo: greet}?.list))
last(flatten(array))
last(flatten(list))
last(foo ?? $env)
last(foo ?? $env.greet)
last(foo ?? 0)
last(foo ?? 1.0)
last(foo ?? add)
last(foo ?? add)?.[array]
last(foo ?? array)
last(foo ?? f64)
last(foo ?? false)
last(foo ?? greet)
last(foo ?? i)
last(foo ?? ok)
last(foo ?? str)
last(foo ?? true)
last(greet ?? 1.0)
last(greet ?? foo)
last(greet ?? str)
last(greet ?? true)
last(groupBy(list, f64)?.[ok])
last(i ?? $env)
last(i ?? foo)
last(i ?? ok)
last(if false { $env } else { i })
last(if false { nil } else { list })
last(if ok { $env } else { 1 })
last(if ok { false } else { $env })
last(if ok { foo } else { true })
last(if ok { list } else { $env })
last(if ok { list } else { true })
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(if true { ok } else { 1.0 })
last(keys($env))
last(keys($env)) | all(ok)
last(last($env))
last(last($env)?.[list])
last(list ?? array)
last(list ?? greet)
last(list ?? true)
last(list | map(#))
last(list | map(#.Bar))
last(list | map(foo))
last(list | map(greet))
last(list | map(list))
last(list | map(ok))
last(list | map(str))
last(list | reduce(array))
last(list | reduce(array, foo))
last(list | sortBy(0))
last(list)
last(list) != $env != ok
last(list) == foo
last(list) ?? foo
last(list) in list
last(list).Bar
last(list).String
last(list).String()
last(list)?.Bar
last(list)?.String
last(list)?.String()
last(list[1:])
last(list[:1])
last(map($env, $env))
last(map($env, $env)).ok
last(map($env, 1))
last(map($env, 1.0))
last(map($env, f64))
last(map($env, foo))
last(map($env, greet))
last(map($env, str))
last(map(array, #))
last(map(array, false))
last(map(array, foo))
last(map(array, true))
last(map(list, #))
last(map(list, 1))
last(map(list, 1.0))
last(map(list, array))
last(map(list, foo))
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(nil ?? $env)
last(nil ?? array)
last(ok ? list : ok)
last(ok ? true : list)
last(ok ?? $env)
last(ok ?? 1)
last(ok ?? array)
last(ok ?? foo)
last(ok ?? i)
last(ok ?? str)
last(reduce(list, #acc))
last(reduce(list, $env))
last(reduce(list, list, foo))
last(reverse(array))
last(reverse(list))
last(sort($env))
last(sort(array))
last(sortBy(array, #))
last(sortBy(array, 0))
last(sortBy(array, f64))
last(sortBy(list, .Bar))
last(sortBy(list, 1.0))
last(sortBy(list, str))
last(str ?? 0)
last(str ?? false)
last(str ?? foo)
last(str ?? i)
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(true ? true : array)
last(true ?: greet)
last(true ?? 0)
last(true ?? array)
last(true ?? f64)
last(true ?? foo)
last(true ?? list)
last(uniq(array))
last(uniq(list))
last(values($env))
last({foo: $env}.str)
last({foo: $env}?.foobar?.add)
last({foo: f64, foo: str}.foo)
last({foo: foo, foo: 1}?.[str])
last({foo: foo}.greet)
last({foo: ok, foo: foo}?.str)
last({foo: str}?.f64)
lastIndexOf(foo.Bar, str)
lastIndexOf(foo?.Bar, str)
lastIndexOf(str, false ? $env : str)
lastIndexOf(str, str)
lastIndexOf(str, str) ?? ok
len($env ?? 0)
len($env ?? 1)
len($env ?? 1.0)
len($env ?? add)
len($env ?? false)
len($env ?? foo)
len($env ?? greet)
len($env ?? list)
len($env ?? nil)
len($env ?? ok)
len($env ?? str)
len($env | filter(false))
len($env | filter(ok))
len($env | filter(true))
len($env | get(str))
len($env | map(0))
len($env | map(1.0))
len($env | map(false))
len($env | map(foo))
len($env | map(i))
len($env | map(true))
len($env | reduce(str, i))
len($env) != f64
len($env) * i
len($env) ** int(f64)
len($env) + i
len($env) == $env || $env
len($env) == add ?? false
len($env) >= i
len($env) ?? add
len($env) ?? list
len($env) ^ 1.0 < f64
len($env) ^ max(f64)
len($env) ^ min(f64)
len($env) not in array
len($env) | bitand(1)
len($env.array | groupBy(1))
len($env.array)
len($env.list)
len($env.str)
len($env?.[str] | map(add))
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, add])
len([$env])
len([0, str])
len([0])
len([1.0, false, f64])
len([1.0])
len([1])
len([add, i])
len([add])
len([array, foo])
len([array])
len([f64, 0])
len([f64])
len([false])
len([foo, 1.0])
len([foo, 1])
len([foo, array])
len([foo, foo])
len([foo, i])
len([foo])
len([greet])
len([i, foo])
len([i])
len([list, f64])
len([list])
len([nil, 1])
len([nil, foo, add])
len([nil, nil])
len([nil])
len([ok, 1.0])
len([ok])
len([str, nil])
len([str])
len([true, list])
len([true])
len(array ?? 1)
len(array ?? 1.0)
len(array ?? array)
len(array ?? greet)
len(array ?? nil)
len(array | filter(false))
len(array | groupBy(#))
len(array | groupBy(1))
len(array | groupBy(1.0))
len(array | groupBy(false))
len(array | groupBy(true))
len(array | map(#))
len(array | map(1.0))
len(array | map(array))
len(array | map(f64))
len(array | map(foo))
len(array | reduce($env))
len(array | reduce(array, 0))
len(array | sortBy(#))
len(array)
len(array) % i
len(array) * i
len(array) - i
len(array) .. i
len(array) == nil && false
len(array) > findIndex(list, true)
len(array) | bitshr(1)
len(array[0:])
len(array[1:])
len(array[:0])
len(array[:1])
len(array[:i])
len(concat(array))
len(concat(list))
len(false ? array : list)
len(false ?: str)
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(foo?.Bar))
len(greet(greet(str)))
len(greet(str))
len(groupBy(array, 0))
len(groupBy(array, 1.0))
len(groupBy(array, f64))
len(groupBy(array, false))
len(groupBy(array, foo))
len(groupBy(array, i))
len(groupBy(array, true))
len(groupBy(list, #))
len(groupBy(list, .Bar))
len(groupBy(list, foo))
len(groupBy(list, str))
len(i .. 0)
len(if true { str } else { nil })
len(keys($env))
len(let y = $env; y)
len(list ?? $env)
len(list ?? array)
len(list ?? f64)
len(list ?? foo)
len(list ?? list)
len(list ?? nil)
len(list ?? ok)
len(list ?? true)
len(list | filter(false))
len(list | filter(true))
len(list | groupBy(#))
len(list | groupBy(foo))
len(list | groupBy(str))
len(list | map(#))
len(list | map(#.String))
len(list | map($env))
len(list | map(1))
len(list | map(1.0))
len(list | map(false))
len(list | map(foo))
len(list | map(list))
len(list | map(str))
len(list | reduce(#.Bar))
len(list | reduce(.Bar))
len(list)
len(list) % i
len(list) ** i
len(list) < 1 and true
len(list) < i
len(list) <= i
len(list) == f64
len(list) > i
len(list) ^ f64
len(list) in $env?.array
len(list)..i
len(list[:0])
len(list[:1])
len(list[:])
len(lower(str))
len(map($env, #index))
len(map($env, 1))
len(map($env, 1.0))
len(map($env, add))
len(map($env, array))
len(map($env, f64))
len(map($env, foo))
len(map($env, greet))
len(map($env, i))
len(map($env, list))
len(map($env, str))
len(map(array, #))
len(map(array, $env))
len(map(array, 1))
len(map(array, foo))
len(map(array, list))
len(map(list, #))
len(map(list, #.String))
len(map(list, #index))
len(map(list, add))
len(map(list, f64))
len(map(list, true))
len(max($env))
len(min($env))
len(nil ?? array)
len(nil ?? str)
len(ok ? list : $env)
len(reduce($env, $env, 1))
len(reduce($env, array, 0))
len(reduce(array, $env))
len(reduce(array, array))
len(reduce(list, $env, foo))
len(reduce(list, list))
len(reduce(list, str, f64))
len(reverse(array))
len(reverse(list))
len(sort($env))
len(sort(array))
len(sortBy(list, #.Bar))
len(sortBy(list, .Bar))
len(sortBy(list, 1))
len(sortBy(list, i))
len(sortBy(list, str))
len(str ?? $env)
len(str ?? 1.0)
len(str ?? greet)
len(str ?? i)
len(str ?? list)
len(str ?? nil)
len(str ?? ok)
len(str ?? true)
len(str | trimSuffix(str))
len(str)
len(str) * i
len(str) + 1.0 - i
len(str) .. 0 | find($env)
len(str) .. i
len(str) / f64 ^ f64
len(str) <= i
len(str) == i
len(str) >= f64
len(str) ?? add
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(0))
len(string(1))
len(string(1.0))
len(string(add))
len(string(array))
len(string(f64))
len(string(false))
len(string(foo))
len(string(greet))
len(string(i))
len(string(list))
len(string(nil))
len(string(ok))
len(string(str))
len(string(true))
len(toBase64(str))
len(toJSON($env.ok))
len(toJSON(0))
len(toJSON(1))
len(toJSON(1.0))
len(toJSON(array))
len(toJSON(f64))
len(toJSON(false))
len(toJSON(foo))
len(toJSON(i))
len(toJSON(list))
len(toJSON(nil))
len(toJSON(ok))
len(toJSON(str))
len(toJSON(true != false))
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(f64))
len(type(false))
len(type(foo))
len(type(greet))
len(type(i))
len(type(list))
len(type(nil))
len(type(ok))
len(type(str))
len(type(true))
len(uniq(array))
len(uniq(list))
len(upper(str))
len(values($env))
len({foo: $env ?? $env})
len({foo: $env, foo: $env})
len({foo: $env, foo: 0})
len({foo: $env, foo: 1.0})
len({foo: $env, foo: true})
len({foo: $env})
len({foo: 0, foo: nil})
len({foo: 0, foo: str, foo: str})
len({foo: 0})
len({foo: 1, foo: false})
len({foo: 1, foo: nil})
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: greet})
len({foo: array, foo: str})
len({foo: array})
len({foo: f64})
len({foo: false})
len({foo: foo, foo: $env})
len({foo: foo, foo: 1.0})
len({foo: foo, foo: foo})
len({foo: foo, foo: nil})
len({foo: foo, foo: ok})
len({foo: foo})
len({foo: greet, foo: str})
len({foo: greet})
len({foo: i, foo: $env})
len({foo: i})
len({foo: list, foo: foo})
len({foo: list})
len({foo: nil, foo: 1.0})
len({foo: nil, foo: add})
len({foo: nil, foo: array})
len({foo: nil})
len({foo: ok, foo: $env})
len({foo: ok})
len({foo: str, foo: $env})
len({foo: str, foo: f64, foo: f64})
len({foo: str, foo: greet})
len({foo: str, foo: str})
len({foo: str})
len({foo: true})
let bar = $env == f64; bar
let bar = $env.f64; bar
let bar = $env.str; bar
let bar = $env; bar.array
let bar = $env; bar.foo
let bar = $env?.list; bar
let bar = 0 == $env; bar
let bar = 1 == $env; bar
let bar = [1.0]; bar
let bar = add; bar
let bar = array == list; bar
let bar = array ?? foo; bar
let bar = array; bar
let bar = f64; bar
let bar = f64; bar + f64
let bar = f64; let tmp = add; bar
let bar = foo ?? f64; bar
let bar = foo.Bar; bar
let bar = foo.Bar; let x = add; bar
let bar = foo.String(); bar
let bar = foo; bar
let bar = foo; bar.String
let bar = greet ?? i; bar
let bar = greet; bar
let bar = i; bar
let bar = i; let z = !ok; bar
let bar = list; bar
let bar = list; let foobar = greet; bar
let bar = list[1:]; bar
let bar = nil != add; bar
let bar = ok == true; bar
let bar = ok; bar
let bar = str; bar
let bar = str; let foobar = greet; bar
let bar = string($env); bar
let bar = type(f64); bar
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.foo
let foobar = $env; foobar.greet
let foobar = $env; foobar.list
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
let foobar = $env?.String; foobar
let foobar = $env?.[Bar]; foobar?.list
let foobar = $env?.[String]; foobar
let foobar = $env?.[String]; foobar?.[str]
let foobar = $env?.[str]; foobar
let foobar = $env?.f64; foobar > foobar
let foobar = $env?.true; foobar
let foobar = 0 + f64; foobar
let foobar = 0; foobar != 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 != f64
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; let bar = foobar; foobar
let foobar = array?.[i]; f64 + foobar
let foobar = f64 ?? nil; 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 = false; foobar == $env and foobar
let foobar = flatten(list); 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; let z = foobar; foobar
let foobar = greet; {foo: foobar}
let foobar = i <= i; foobar
let foobar = i; 1.0 == foobar
let foobar = i; floor(foobar) + foobar
let foobar = i; foobar
let foobar = i; foobar != 0
let foobar = i; foobar % foobar
let foobar = i; foobar ** foobar / foobar
let foobar = i; 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 = len(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 = nil != nil; foobar
let foobar = not true; foobar
let foobar = ok ? nil : $env; foobar?.Bar
let foobar = ok; foobar
let foobar = ok; foobar == foobar
let foobar = ok; let bar = foo; 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
let foobar = {foo: nil}; foobar
let tmp = $env.add; tmp
let tmp = $env; tmp.greet
let tmp = $env; tmp.str
let tmp = $env?.array; tmp
let tmp = 1.0 < 1; tmp
let tmp = [$env]; tmp
let tmp = add; tmp
let tmp = array; tmp
let tmp = f64 ?? $env; tmp
let tmp = f64; tmp
let tmp = foo; let y = foo; tmp
let tmp = foo; tmp
let tmp = greet; tmp
let tmp = i; tmp
let tmp = list; tmp
let tmp = min(i, f64); tmp
let tmp = ok; let y = foo; tmp
let tmp = ok; tmp
let tmp = str endsWith $env?.String; tmp
let tmp = str; tmp
let x = $env != true; x
let x = $env; let tmp = 1.0; x?.ok
let x = $env; x.add
let x = $env; x.str
let x = $env; x?.add
let x = $env; x?.f64
let x = $env; x?.str
let x = $env?.[foobar]; x
let x = add; x
let x = array; x
let x = f64; x
let x = foo.Bar; x
let x = foo; x
let x = foo; x.Bar
let x = foo; x?.String
let x = greet; x
let x = i; let y = ok; x
let x = i; x
let x = list; let bar = foo; x
let x = list; x
let x = ok and $env; x
let x = ok; x
let x = str; x
let x = trimSuffix(str); x
let x = {foo: 1.0}; x
let y = $env ?? $env; y
let y = $env.array; y
let y = $env; let tmp = i; y?.[str]
let y = $env; y.greet
let y = $env; y.list
let y = $env; y?.String
let y = $env; y?.add
let y = $env; y?.greet
let y = $env?.[String]; y
let y = $env?.add; y
let y = -1.0; y
let y = 1.0 * i; y
let y = add; y
let y = array; y
let y = concat(list); y
let y = f64; y
let y = false != ok; y
let y = findLastIndex($env, true); y
let y = foo.Bar; y
let y = foo; y
let y = foo?.String; y
let y = greet; y
let y = i; let bar = foo; y
let y = i; y
let y = list; y
let y = nil ?? false; y
let y = not false; y
let y = ok; y
let y = sort($env); y
let y = str; y
let z = $env != nil; z
let z = $env == greet; z
let z = $env.i; z
let z = $env.ok; z
let z = $env; z.Bar
let z = $env; z.String
let z = $env; z.array
let z = $env; z.f64
let z = $env; z.greet
let z = $env; z?.greet
let z = $env?.ok; z
let z = [foo]; z
let z = add; z
let z = array == list; z
let z = array; z
let z = array; z | groupBy(foo)
let z = f64 != $env; z
let z = f64; z
let z = foo.String; z
let z = foo; z
let z = greet; z
let z = i; z
let z = list; let x = f64; z
let z = list; z
let z = map($env, add); z
let z = ok or true; z
let z = ok; z
let z = str != $env; z
let z = str; let tmp = array; z
let z = str; z
let z = {foo: ok, foo: nil}; z
list
list != $env != false
list != $env != nil
list != $env && ok
list != $env ? list : i
list != $env ?? $env?.add
list != $env ?? 1
list != $env ?? f64
list != $env ?? i
list != $env and ok
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?.[Bar]?.list
list != $env?.[String]
list != $env?.[foobar?.[foo]]
list != $env?.[foobar]
list != $env?.[str]
list != $env?.array
list != $env?.foobar
list != $env?.list
list != $env?.nil
list != 0 ?? ok
list != 1 ?? false
list != 1..i
list != 1.0 ?? add
list != 1.0 ?? foo
list != [0]
list != [foo]
list != [nil]
list != [str]
list != array
list != array and ok
list != array or $env
list != array or false
list != array || $env
list != false ?? foo
list != flatten(list)
list != foo ?? f64
list != foo ?? ok
list != foo ?? true
list != greet ?? list
list != i .. i
list != i ?? foo
list != keys($env)
list != list
list != list != ok
list != list && $env
list != list && true
list != list == false
list != list ?? 0
list != list ?? date(list)
list != list ?? greet
list != list and false
list != list or false
list != map(list, #)
list != map(list, str)
list != max($env)
list != median(array)
list != min(array)
list != nil ? 1.0 : f64
list != nil ? ok : 1.0
list != nil ?: list
list != nil ?? nil
list != nil || false
list != nil || true
list != ok ?? 1.0
list != reverse($env.list)
list != reverse(array)
list != str ?? ok
list != true ?? str
list == $env == nil
list == $env == ok
list == $env == true
list == $env ? foo : i
list == $env ?: list == nil
list == $env ?? 0
list == $env ?? f64
list == $env ?? i
list == $env and false
list == $env || $env
list == $env.array
list == $env.list
list == $env?.$env
list == $env?.Bar
list == $env?.Bar?.add
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 ?? foo
list == 1 ?? add
list == 1.0 ?? $env
list == 1.0 ?? $env && $env
list == 1.0 ?? greet
list == 1.0 ?? str
list == [$env]
list == [0]
list == [add]
list == [false]
list == [foo]
list == [greet, 0]
list == [greet]
list == [list]
list == [nil]
list == [str]
list == [true]
list == add ?? array
list == add ?? false
list == array
list == array == $env == true
list == array == nil
list == array ? nil : foo
list == array ?: list
list == array or ok
list == array[:i]
list == concat(array)
list == f64 ?? $env ?? 1.0
list == false ?? greet
list == flatten(array)
list == foo ?? true
list == i ?? f64
list == keys($env)
list == list
list == list != $env
list == list != nil
list == list == true
list == list and true
list == list[:i]
list == map($env, str)
list == map(list, $env)
list == nil != false
list == nil && false
list == nil == nil
list == nil ? add : $env
list == nil ?: $env
list == nil ?: nil
list == nil or $env
list == ok ?? greet
list == ok ?? str
list == reverse(array)
list == str ?? array
list == toPairs($env)
list == values($env)
list ?? !$env
list ?? !false
list ?? !true
list ?? $env ?? $env
list ?? $env ?? add
list ?? $env ?? nil
list ?? $env | count(ok)
list ?? $env | filter(true)
list ?? $env | findIndex(false)
list ?? $env | findLast(false)
list ?? $env | groupBy(1)
list ?? $env | map(0)
list ?? $env | reduce(#)
list ?? $env | reduce($env)
list ?? $env | reduce(.String)
list ?? $env | reduce(ok)
list ?? $env | sortBy(1)
list ?? $env.add
list ?? $env.array
list ?? $env.f64
list ?? $env.foo
list ?? $env.greet
list ?? $env.i
list ?? $env.list
list ?? $env.ok
list ?? $env.str
list ?? $env?.Bar
list ?? $env?.Bar()
list ?? $env?.Bar()?.[list]
list ?? $env?.String
list ?? $env?.String()
list ?? $env?.String(foobar)?.ok()
list ?? $env?.String(ok | filter(String))
list ?? $env?.[$env]
list ?? $env?.[Bar]
list ?? $env?.[Bar].foo()
list ?? $env?.[Bar]?.[array]
list ?? $env?.[String]
list ?? $env?.[add]
list ?? $env?.[add].Bar
list ?? $env?.[array]
list ?? $env?.[f64]
list ?? $env?.[f64]?.add()
list ?? $env?.[foo]
list ?? $env?.[foobar | keys(foobar)]
list ?? $env?.[foobar]
list ?? $env?.[greet]
list ?? $env?.[i]
list ?? $env?.[list]
list ?? $env?.[list]?.[ok]
list ?? $env?.[list]?.i()?.String
list ?? $env?.[ok]
list ?? $env?.[ok][add:foobar]
list ?? $env?.[str]
list ?? $env?.[true]
list ?? $env?.add
list ?? $env?.array
list ?? $env?.f64
list ?? $env?.foo
list ?? $env?.foobar
list ?? $env?.greet
list ?? $env?.i
list ?? $env?.list
list ?? $env?.nil
list ?? $env?.ok
list ?? $env?.str
list ?? $env[:count(1.0)]
list ?? $env[:foo.foo]
list ?? $env[:str(nil)]
list ?? $env[foobar:]
list ?? -$env?.[nil]
list ?? --1.0
list ?? -f64
list ?? 0 ?? $env
list ?? 0 ?? array
list ?? 0 | map(foo)
list ?? 0 | none(true)
list ?? 0 | sortBy(0)
list ?? 0 | sortBy(str)
list ?? 1 | groupBy(foo)
list ?? 1 | map(1.0)
list ?? 1.0
list ?? 1.0 ?? foo
list ?? 1.0 | count(true)
list ?? 1.0 | groupBy(0)
list ?? 1.0 | groupBy(str)
list ?? 1.0 | map(0)
list ?? 1.0 | one(true)
list ?? 1.0 | reduce(.Bar)
list ?? [array]
list ?? [list]
list ?? [ok]
list ?? [str]
list ?? abs($env).greet
list ?? add
list ?? add | groupBy(#)
list ?? add | groupBy(ok)
list ?? add | reduce(1.0)
list ?? add | sum(0)
list ?? any($env, #)
list ?? any($env, $env)
list ?? array
list ?? array ?? $env?.[greet]
list ?? array | reduce($env)
list ?? array?.[i]
list ?? bitnot($env)
list ?? bitshr($env, $env)
list ?? ceil($env)
list ?? count($env)
list ?? count(array)
list ?? count(foo ?? $env)
list ?? date(greet)
list ?? date(list)
list ?? date(nil)
list ?? f64
list ?? f64 ?? str
list ?? f64 | count(true)
list ?? f64 | groupBy(foo)
list ?? f64 | map(#)
list ?? f64 | map(ok)
list ?? f64 | reduce(#, i)
list ?? f64 | reduce(#acc, $env)
list ?? false ?? greet
list ?? false | filter(ok)
list ?? false | find(true)
list ?? false | map(1.0)
list ?? false | map(false)
list ?? false | map(foo)
list ?? false | reduce(i)
list ?? false | sortBy(1)
list ?? filter(list, false)
list ?? find($env, .add)
list ?? find(array, ok)
list ?? findIndex($env, .i)
list ?? findLast($env, #)
list ?? findLastIndex($env, #.ok)
list ?? flatten($env)
list ?? float(1.0)
list ?? foo
list ?? foo ?? foo
list ?? foo ?? sortBy($env, 0)
list ?? foo | all(false)
list ?? foo | any(true)
list ?? foo | findIndex(ok)
list ?? foo | groupBy(i)
list ?? foo | map(#)
list ?? foo | map(#index)
list ?? foo | map(ok)
list ?? foo | reduce(#)
list ?? foo | reduce(#) ?? foo
list ?? foo | reduce($env)
list ?? foo | reduce(1.0)
list ?? foo | sum(0)
list ?? foo | sum(1)
list ?? foo.Bar
list ?? foo.String
list ?? foo.String()
list ?? foo?.Bar
list ?? foo?.String
list ?? foo?.String()
list ?? fromBase64($env)
list ?? greet
list ?? greet ?? list
list ?? greet | all(false)
list ?? greet | any(true)
list ?? greet | findLastIndex(true)
list ?? greet | map(#)
list ?? greet | map(1)
list ?? greet | reduce(foo, foo)
list ?? greet | sum(1.0)
list ?? greet($env)
list ?? greet(str)
list ?? i
list ?? i | groupBy(1.0)
list ?? i | groupBy(false)
list ?? i | reduce($env)
list ?? i | reduce(.Bar)
list ?? int($env)
list ?? len($env)
list ?? list
list ?? list | one(true)
list ?? list | sum(1)
list ?? map($env, $env)
list ?? max($env)
list ?? max(1, $env)?.list
list ?? max(list)
list ?? mean(1.0)
list ?? mean(array)
list ?? mean(i)
list ?? median($env)
list ?? min(f64)
list ?? nil ?? str
list ?? nil | all(true)
list ?? nil | count(ok)
list ?? nil | groupBy(#)
list ?? nil | groupBy(1.0)
list ?? nil | groupBy(foo)
list ?? nil | map(#)
list ?? nil | map(#index)
list ?? nil | reduce(str)
list ?? nil | reduce(true)
list ?? nil | sortBy(f64)
list ?? nil | sum(0)
list ?? not $env
list ?? not $env?.[array]
list ?? not foo ?? str
list ?? ok
list ?? ok ?? 0
list ?? ok ?? false
list ?? ok ?? i
list ?? ok | all(true)
list ?? ok | findLastIndex(ok)
list ?? ok | map(#)
list ?? ok | none(true)
list ?? ok | reduce(list)
list ?? ok | sortBy(str)
list ?? ok | sum(i)
list ?? one($env, #.Bar)
list ?? reduce($env, #.String, add)
list ?? reduce($env?.String(false, 1.0), #.foo[str:])
list ?? repeat($env, i)
list ?? reverse($env)
list ?? reverse(list)
list ?? round($env)
list ?? sortBy($env, .add)
list ?? str
list ?? str | any(true)
list ?? str | findLast(true)
list ?? str | map(foo)
list ?? str | reduce(#)
list ?? str | reduce(1.0)
list ?? string($env)
list ?? string(1)
list ?? string(i)
list ?? string(nil)
list ?? sum($env)
list ?? sum($env)?.[add]
list ?? sum(array)
list ?? sum(array, $env)
list ?? sum(list)
list ?? sum(list, add)
list ?? toJSON(add)
list ?? true ?? $env?.array
list ?? true | count(false)
list ?? true | groupBy(#)
list ?? true | map(#)
list ?? true | map(str)
list ?? true | reduce(#)
list ?? type(1)
list ?? type(nil)
list ?? upper($env)
list ?? {foo: 1.0}
list ?? {foo: 1}
list ?? {foo: add}
list in $env?.Bar
list in $env?.String
list in $env?.String?.[foo]
list in $env?.String?.f64
list in $env?.[Bar]
list in $env?.[Bar]?.Bar
list in $env?.[Bar]?.[array]
list in $env?.[String]
list in $env?.[String]?.[ok]
list in $env?.[String]?.[str]
list in $env?.[foobar?.[Bar]]
list in $env?.[foobar]
list in $env?.foobar
list in [$env, 1.0]
list in [$env, nil]
list in [array]
list in [nil, $env]
list in [nil]
list in array ?? $env
list in array ?? i
list in concat(list)
list in last($env)
list in sort($env)
list in {foo: 0}.array
list not in $env?.$env?.list
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?.[ok]]
list not in $env?.[foobar]
list not in $env?.foobar
list not in [array, true]
list not in [list]
list not in array ?? 1
list not in last($env)
list not in list ?? $env?.[f64]
list not in list ?? array
list not in list ?? i
list not in toPairs($env)
list | all(!true)
list | all(# != $env)
list | all(# == nil)
list | all($env | any(true))
list | all($env?.ok)
list | all(.Bar not in #)
list | all(0 == nil)
list | all(1.0 != f64)
list | all(false && $env)
list | all(false or false)
list | all(false)
list | all(false) ?: f64
list | all(foo != #)
list | all(list != array)
list | all(nil != 1.0)
list | all(ok)
list | all(ok) ?? f64
list | all(str >= .Bar)
list | all(true)
list | any(# == $env)
list | any($env != #)
list | any($env != 1.0)
list | any($env == $env)
list | any($env == foo)
list | any($env.ok)
list | any($env?.ok)
list | any(.Bar in foo)
list | any(array | any(ok))
list | any(f64 != 1.0)
list | any(false)
list | any(false) ?? list
list | any(i == nil)
list | any(i >= 1.0)
list | any(nil == i)
list | any(ok != nil)
list | any(ok)
list | any(true ?: nil)
list | any(true)
list | concat(array)
list | concat(array) ?? i
list | concat(i .. i)
list | concat(list)
list | concat(list) | any(true)
list | concat(sortBy(array, #))
list | count(!false)
list | count(# != nil)
list | count($env != foo)
list | count($env == #)
list | count($env.ok)
list | count(1.0 != $env)
list | count(1.0 != nil)
list | count(1.0 <= i)
list | count(false)
list | count(false) | bitxor(i)
list | count(nil != ok)
list | count(ok)
list | count(ok) ?? $env?.String?.Bar
list | count(ok) | median(f64)
list | count(true != true)
list | count(true and false)
list | count(true or false)
list | count(true)
list | filter(!ok)
list | filter(# != $env)
list | filter(# == #)
list | filter(#.String != nil)
list | filter($env != false)
list | filter($env.ok)
list | filter(0 <= 1)
list | filter(1.0 > 0)
list | filter(false)
list | filter(false) | find(true)
list | filter(false) | findLast(true)
list | filter(false) | map(1.0)
list | filter(i <= 1)
list | filter(list == $env)
list | filter(nil != #.String)
list | filter(nil == foo)
list | filter(not false)
list | filter(ok == nil)
list | filter(ok)
list | filter(ok) | reduce(1.0)
list | filter(ok) | sum(1.0)
list | filter(str not startsWith .Bar)
list | filter(true)
list | filter(true) ?? !$env
list | filter(true) | groupBy(foo)
list | filter(true) | groupBy(ok)
list | filter(true) | map(#)
list | filter(true) | sum(1.0)
list | find(# != $env)
list | find(# == #)
list | find(# == $env)
list | find($env != i)
list | find(0 < 0)
list | find(1.0 > 0)
list | find(array | one(true))
list | find(f64 == 0)
list | find(f64 > 1.0)
list | find(false)
list | find(foo == #)
list | find(foo == $env)
list | find(foo == foo)
list | find(nil != $env?.f64)
list | find(nil != foo)
list | find(nil == foo)
list | find(not ok)
list | find(ok)
list | find(true)
list | findIndex(!ok)
list | findIndex(# != #)
list | findIndex(# != foo)
list | findIndex(#.Bar in #)
list | findIndex(#.String != $env)
list | findIndex($env.ok)
list | findIndex(1.0 >= 1)
list | findIndex(false && $env)
list | findIndex(false)
list | findIndex(list != nil)
list | findIndex(nil != greet)
list | findIndex(nil == .Bar)
list | findIndex(nil not in $env)
list | findIndex(ok == true)
list | findIndex(ok)
list | findIndex(ok) ?? foo
list | findIndex(ok) not in array
list | findIndex(true == ok)
list | findIndex(true)
list | findLast(# == #)
list | findLast($env == $env)
list | findLast($env == 0)
list | findLast($env.ok)
list | findLast(.Bar in foo)
list | findLast(0 > 1.0)
list | findLast(1.0 <= 1)
list | findLast(f64 < 0)
list | findLast(false)
list | findLast(nil != str)
list | findLast(not false)
list | findLast(ok ?? .String)
list | findLast(ok)
list | findLast(ok) ?? foo
list | findLast(true)
list | findLastIndex(!false)
list | findLastIndex(!true)
list | findLastIndex(# == #)
list | findLastIndex(# == $env)
list | findLastIndex(#.Bar == #.Bar)
list | findLastIndex($env != nil)
list | findLastIndex(all(array, true))
list | findLastIndex(array == $env)
list | findLastIndex(false or true)
list | findLastIndex(false)
list | findLastIndex(foo == #)
list | findLastIndex(greet != $env)
list | findLastIndex(i <= 0)
list | findLastIndex(nil not in list)
list | findLastIndex(ok)
list | findLastIndex(true)
list | get(0)
list | get(1)
list | get(1.0 ?? $env)
list | get(i)
list | groupBy(# != #)
list | groupBy(# != nil)
list | groupBy(# == #)
list | groupBy(# == nil)
list | groupBy(# in list)
list | groupBy(#)
list | groupBy(#.Bar)
list | groupBy(#.String())
list | groupBy($env != #)
list | groupBy($env != 0)
list | groupBy($env == 0)
list | groupBy($env.f64)
list | groupBy($env.i)
list | groupBy($env.ok)
list | groupBy($env?.Bar)
list | groupBy($env?.String)
list | groupBy($env?.f64)
list | groupBy($env?.i)
list | groupBy(-0)
list | groupBy(.Bar)
list | groupBy(0 > i)
list | groupBy(0 ?? $env)
list | groupBy(0)
list | groupBy(1 ** 1.0)
list | groupBy(1 / 1.0)
list | groupBy(1)
list | groupBy(1.0 != $env)
list | groupBy(1.0 + i)
list | groupBy(1.0 <= 1.0)
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(false)
list | groupBy(foo)
list | groupBy(foo.Bar)
list | groupBy(greet(.Bar))
list | groupBy(i)
list | groupBy(i) | get(true)
list | groupBy(let foobar = true; foobar)
list | groupBy(list?.[i])
list | groupBy(mean(f64))
list | groupBy(nil != #)
list | groupBy(nil != $env)
list | groupBy(ok)
list | groupBy(ok) | get(str)
list | groupBy(str)
list | groupBy(string(#))
list | groupBy(string(str))
list | groupBy(toJSON(array))
list | groupBy(toJSON(foo))
list | groupBy(true && ok)
list | groupBy(true && true)
list | groupBy(true)
list | groupBy(type(#))
list | groupBy(type(#?.Bar))
list | groupBy(type(1.0))
list | map(# != foo)
list | map(# != nil)
list | map(# == #)
list | map(#)
list | map(#) == array
list | map(#) | all(true)
list | map(#) | findIndex(false)
list | map(#) | get(0)
list | map(#) | groupBy(#)
list | map(#) | groupBy(foo)
list | map(#) | map(#)
list | map(#) | map(#.Bar)
list | map(#) | map(foo)
list | map(#) | map(greet)
list | map(#) | none(ok)
list | map(#) | one(false)
list | map(#) | reduce(#)
list | map(#.Bar)
list | map(#.Bar) | reduce(#, nil)
list | map(#.Bar) | sortBy(#)
list | map(#.String())
list | map(#.String)
list | map(#.String) | reduce(#)
list | map(#?.Bar)
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) | map(0)
list | map($env) | reduce(greet(.str))
list | map($env) | reduce(str)
list | map($env.ok)
list | map($env?.Bar)
list | map($env?.String)
list | map($env?.[Bar])
list | map($env?.[String])
list | map($env?.f64)
list | map($env?.i)
list | map($env?.list)
list | map($env?.nil)
list | map($env?.str)
list | map(-0)
list | map(-i)
list | map(.Bar)
list | map(.Bar) ?? i
list | map(.String)
list | map(.String) == array
list | map(0)
list | map(0) ?? list
list | map(0) | all(ok)
list | map(0) | map(array)
list | map(0) | none(ok)
list | map(0) | reduce(#)
list | map(0) | reduce(0)
list | map(1 > 1)
list | map(1 >= 0)
list | map(1)
list | map(1.0 * f64)
list | map(1.0 + 1)
list | map(1.0)
list | map(1.0) | any(true)
list | map(1.0) | findLastIndex(true)
list | map(1.0) | map(str)
list | map(1.0) | reduce(1.0)
list | map(1.0) | reduce(foo)
list | map(1.0) | sortBy(#)
list | map([#])
list | map([.Bar, str])
list | map([false])
list | map(add)
list | map(add) | find(ok)
list | map(add) | reduce(add)
list | map(array == nil)
list | map(array)
list | map(array) == array
list | map(bitnot(i))
list | map(concat(list))
list | map(f64 < 1.0)
list | map(f64)
list | map(f64) | sum(#)
list | map(f64); f64
list | map(false or $env)
list | map(false)
list | map(false) ?? greet
list | map(false) | all(#)
list | map(false) | map(#)
list | map(false) | reduce(0)
list | map(false) | sortBy(str)
list | map(false) | sum(f64)
list | map(foo == #)
list | map(foo == $env)
list | map(foo ?? 0)
list | map(foo ?? i)
list | map(foo)
list | map(foo) != list
list | map(foo) | count(ok)
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(.Bar))
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(last($env))
list | map(let foobar = str; foobar)
list | map(let x = array; x)
list | map(list ?? 0)
list | map(list)
list | map(list) | map(#)
list | map(list) | none(ok)
list | map(map(array, list))
list | map(nil != 1)
list | map(nil != nil)
list | map(nil ?? $env)
list | map(not true)
list | map(ok or $env)
list | map(ok)
list | map(ok) | findLast(ok)
list | map(ok) | reduce(1.0, 0)
list | map(sortBy(array, #))
list | map(str <= .Bar)
list | map(str)
list | map(str) | groupBy(foo)
list | map(str) | sortBy(f64)
list | map(string(#.Bar))
list | map(string(greet))
list | map(true || ok)
list | map(true)
list | map(true) | find(true)
list | map(true) | groupBy(0)
list | map(type(#))
list | map(type(.String))
list | map(type(ok))
list | none(# != #)
list | none(# == $env)
list | none(#.Bar in foo)
list | none($env != $env)
list | none($env == #)
list | none($env == i)
list | none($env.ok)
list | none($env?.f64 <= f64)
list | none($env?.ok)
list | none(.String == .String)
list | none(1 < 0)
list | none(1.0 <= 1)
list | none(all(array, true))
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 == $env)
list | none(ok)
list | none(true == nil)
list | none(true)
list | one(# != foo)
list | one(# != nil)
list | one(# == foo)
list | one($env == $env)
list | one($env == false)
list | one($env.ok)
list | one($env?.ok)
list | one(.Bar not endsWith str)
list | one(0 != 1.0)
list | one(1 >= 1)
list | one(add != nil)
list | one(add == nil)
list | one(f64 != 0)
list | one(false)
list | one(foo == $env)
list | one(i == i)
list | one(nil ?? false)
list | one(ok ?: 0)
list | one(ok)
list | one(str == str)
list | one(true)
list | reduce(!ok)
list | reduce(# ?? #)
list | reduce(# ?? $env)
list | reduce(# ?? 1.0)
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 ?? array)
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, add)
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 ?? nil)
list | reduce(#.String)
list | reduce(#.String, $env)
list | reduce(#.String, 1)
list | reduce(#.String, 1.0)
list | reduce(#.String, f64)
list | reduce(#.String, foo)
list | reduce(#.String, greet)
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, array)
list | reduce(#acc, array) | map($env)
list | reduce(#acc, f64)
list | reduce(#acc, foo)
list | reduce(#acc, i)
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, add)
list | reduce(#index, false)
list | reduce(#index, foo)
list | reduce(#index, list)
list | reduce(#index, nil)
list | reduce(#index, ok)
list | reduce(#index, str)
list | reduce(#index, true)
list | reduce($env != #)
list | reduce($env == #.Bar)
list | reduce($env not in array)
list | reduce($env)
list | reduce($env, $env)
list | reduce($env, 0)
list | reduce($env, 1)
list | reduce($env, 1.0)
list | reduce($env, add)
list | reduce($env, array)
list | reduce($env, f64)
list | reduce($env, false)
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.ok)
list | reduce($env?.String)
list | reduce($env?.[Bar])
list | reduce($env?.[String])
list | reduce($env?.[foobar])
list | reduce($env?.[str])
list | reduce($env?.add)
list | reduce($env?.add, ok)
list | reduce($env?.greet, max(1))
list | reduce(-1)
list | reduce(.Bar not in $env)
list | reduce(.Bar)
list | reduce(.Bar, $env)
list | reduce(.Bar, 0)
list | reduce(.Bar, 1.0)
list | reduce(.Bar, add)
list | reduce(.Bar, array)
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)
list | reduce(.String, 1.0)
list | reduce(.String, array)
list | reduce(.String, f64)
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) == sum(array)
list | reduce(0) ^ f64
list | reduce(0) | median(1.0)
list | reduce(0, $env)
list | reduce(0, 1.0)
list | reduce(0, add)
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, foo) | max(array)
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, 1.0)
list | reduce(1.0, add)
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, ok)
list | reduce(1.0, str)
list | reduce(1.0, true)
list | reduce([1.0])
list | reduce([ok, foo])
list | reduce([true, #])
list | reduce(add ?? #)
list | reduce(add)
list | reduce(add, $env)
list | reduce(add, 1)
list | reduce(add, 1.0)
list | reduce(add, add)
list | reduce(add, array)
list | reduce(add, f64)
list | reduce(add, false)
list | reduce(add, foo)
list | reduce(add, nil)
list | reduce(add, ok)
list | reduce(array ?? .String)
list | reduce(array)
list | reduce(array) | groupBy(0)
list | reduce(array) | groupBy(ok)
list | reduce(array) | map(#)
list | reduce(array) | map($env)
list | reduce(array) | none(ok)
list | reduce(array) | reduce(0, list)
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, list)
list | reduce(array, nil)
list | reduce(array, ok)
list | reduce(array, str)
list | reduce(array, true)
list | reduce(f64 != $env)
list | reduce(f64 != nil)
list | reduce(f64 <= 1.0)
list | reduce(f64)
list | reduce(f64) < f64
list | reduce(f64) ?? $env?.foo
list | reduce(f64, $env)
list | reduce(f64, 0)
list | reduce(f64, 1)
list | reduce(f64, 1.0)
list | reduce(f64, add)
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 != nil)
list | reduce(false ? # : foo)
list | reduce(false || $env)
list | reduce(false)
list | reduce(false, $env)
list | reduce(false, 0)
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, nil)
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 ?? 1)
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(foo?.Bar)
list | reduce(greet ?? 1)
list | reduce(greet)
list | reduce(greet) != greet
list | reduce(greet, $env)
list | reduce(greet, 1.0)
list | reduce(greet, add)
list | reduce(greet, array)
list | reduce(greet, f64)
list | reduce(greet, false)
list | reduce(greet, foo)
list | reduce(greet, greet)
list | reduce(greet, i)
list | reduce(greet, list)
list | reduce(greet, nil)
list | reduce(greet, str)
list | reduce(greet, true)
list | reduce(groupBy(list, f64)?.[foo])
list | reduce(i ^ i)
list | reduce(i)
list | reduce(i, 0)
list | reduce(i, 1.0)
list | reduce(i, add)
list | reduce(i, array)
list | reduce(i, f64)
list | reduce(i, false)
list | reduce(i, foo)
list | reduce(i, greet)
list | reduce(i, i)
list | reduce(i, list)
list | reduce(i, list) != $env?.String
list | reduce(i, nil)
list | reduce(i, ok)
list | reduce(i, str)
list | reduce(i, true)
list | reduce(list)
list | reduce(list) ?? not $env
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, false)
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(map(list, greet))
list | reduce(mean([1]))
list | reduce(nil ?? foo)
list | reduce(ok and #acc)
list | reduce(ok)
list | reduce(ok) == ok
list | reduce(ok, $env)
list | reduce(ok, add)
list | reduce(ok, array)
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(ok, true)
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)
list | reduce(str, 1.0)
list | reduce(str, add)
list | reduce(str, array)
list | reduce(str, f64)
list | reduce(str, false)
list | reduce(str, foo)
list | reduce(str, i)
list | reduce(str, list)
list | reduce(str, nil)
list | reduce(str, ok)
list | reduce(str, str)
list | reduce(str, true)
list | reduce(trim(str))
list | reduce(true ?? #index)
list | reduce(true and ok)
list | reduce(true)
list | reduce(true, $env)
list | reduce(true, 0)
list | reduce(true, array)
list | reduce(true, f64)
list | reduce(true, false)
list | reduce(true, foo)
list | reduce(true, greet)
list | reduce(true, i)
list | reduce(true, ok)
list | reduce(true, str)
list | reduce(type(#))
list | reduce(values($env))
list | sortBy(#.Bar)
list | sortBy(#.Bar) | groupBy(foo)
list | sortBy(#.String())
list | sortBy(#?.Bar)
list | sortBy($env?.i)
list | sortBy(-0)
list | sortBy(-1.0)
list | sortBy(-i)
list | sortBy(.Bar)
list | sortBy(.Bar) | groupBy(f64)
list | sortBy(.Bar) | reduce($env)
list | sortBy(0)
list | sortBy(0) | one(ok)
list | sortBy(0) | sortBy(str)
list | sortBy(1)
list | sortBy(1) | map(greet)
list | sortBy(1) | map(str)
list | sortBy(1) | sum(0)
list | sortBy(1.0 ** 0)
list | sortBy(1.0)
list | sortBy(1.0) ?? i
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(1.0) | sum(i)
list | sortBy(ceil(1.0))
list | sortBy(f64 ** 0)
list | sortBy(f64)
list | sortBy(f64) == array
list | sortBy(float(1))
list | sortBy(foo.String())
list | sortBy(foo?.Bar)
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 | sortBy(str) | reduce(ok, true)
list | sortBy(string(true))
list | sum($env.i)
list | sum($env?.f64)
list | sum(-f64)
list | sum(-i)
list | sum(0 * 0)
list | sum(0 - 1.0)
list | sum(0)
list | sum(0) != i
list | sum(0) >= 1.0 == false
list | sum(0) >= bitnot(i)
list | sum(1)
list | sum(1) / 0 ** 1
list | sum(1) <= f64
list | sum(1) | median(array)
list | sum(1.0 ^ 1)
list | sum(1.0)
list | sum(array | findLastIndex(true))
list | sum(ceil(1.0))
list | sum(f64 * 1.0)
list | sum(f64)
list | sum(f64) ?? i
list | sum(f64) in array
list | sum(i)
list | sum(int(i))
list | sum(round(1))
list | take(0)
list | take(0) | sortBy(#)
list | take(1)
list | take(1) | sum(0)
list | take(i)
list; $env.i
list; $env; $env?.ok
list; $env?.ok
list; add
list; f64
list; foo
list; foo; $env.array
list; foo?.Bar
list; foo?.String
list; greet
list; i
list; list
list; nil == nil
list; nil; foo?.String
list; ok
list; str
list; toJSON(i)
list?.[$env | count(false)]
list?.[$env.i]
list?.[$env?.i]
list?.[-0]
list?.[-1]
list?.[-i]
list?.[0 % 1]
list?.[0 ?? nil]
list?.[0]
list?.[0].Bar
list?.[0].String
list?.[0]?.Bar
list?.[0]?.String
list?.[1 + 0]
list?.[1 ?? 1.0]
list?.[1 ?? foo]
list?.[1.0 ?? greet]
list?.[1]
list?.[1] != f64 ?? ok
list?.[1].Bar
list?.[1].String
list?.[1].String()
list?.[1]?.Bar
list?.[1]?.String
list?.[1]?.String()
list?.[array?.[0]]
list?.[f64 ?? $env?.[add]]
list?.[i ?? add]
list?.[i ?? f64]
list?.[i]
list?.[i] != foo
list?.[i] != foo && $env
list?.[i] == foo
list?.[i] == nil && $env
list?.[i] ?? $env?.ok
list?.[i] ?? add
list?.[i] ?? array
list?.[i] ?? f64
list?.[i] ?? greet
list?.[i] ?? ok
list?.[i] ?? str
list?.[i] ?? type(foo)
list?.[i] not in list
list?.[i] not in list ?? f64
list?.[i].Bar
list?.[i].Bar ?? foo
list?.[i].String
list?.[i].String()
list?.[i]?.Bar
list?.[i]?.String
list?.[i]?.String()
list?.[int(1.0)]
list?.[max(i)]
list?.[mean(i)]
list?.[median(0)]
list[$env.i:]
list[$env?.i:]
list[-1:]
list[-i:]
list[0:] | map(foo)
list[0:] | reduce(#.Bar)
list[0:] | reduce(1.0)
list[0:] | reduce(str)
list[0:]?.[i]
list[1 + 0:]
list[1 ?? 0:]
list[1:] | findLast(true)
list[1:] | map(0)
list[1:] | map(ok)
list[1:] | reduce(foo)
list[1:][:i]
list[:$env.i]
list[:$env?.i]
list[:-i]
list[:0 * 0]
list[:0] | findIndex(nil != foo)
list[:0] | map(str)
list[:1] ?? list
list[:1] | groupBy(ok)
list[:1] | one(ok)
list[:1] | sortBy(foo)
list[:]
list[:] | map(#index)
list[:]?.[i]
list[:array?.[i]]
list[:bitnot(1)]
list[:bitnot(i)]
list[:count(array, ok)]
list[:i]
list[:i] | any(ok)
list[:i] | filter(true)
list[:i] | groupBy(ok)
list[:i] | sum(f64)
list[:mean(i)]
list[:median(0)]
list[:median(array)]
list[:min(i)]
list[:sum(array)]
list[add(1, 0):]
list[array?.[i]:]
list[f64 ?? false:]
list[i:]
list[i:] ?? greet
list[i:] | findIndex(ok)
list[i:] | groupBy(true)
list[i:] | sortBy(0)
list[i:i]
list[int(1.0):]
list[len($env):]
list[min(array):]
list[sum(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($env?.str))
lower(greet(str))
lower(greet(string(nil)))
lower(greet(toJSON(array)))
lower(list?.[i]?.Bar)
lower(lower(str))
lower(reduce(array, str))
lower(repeat(str, 0))
lower(str + str)
lower(str ?? $env)
lower(str ?? 0)
lower(str ?? 1.0)
lower(str ?? array)
lower(str ?? f64)
lower(str ?? foo)
lower(str ?? foo?.Bar)
lower(str ?? ok)
lower(str ?? true)
lower(str | greet())
lower(str)
lower(str) < str
lower(str) == $env != false
lower(str) == str
lower(str) > str
lower(str) ?? add
lower(str) ?? f64
lower(str) ?? trim(str)
lower(str) endsWith str
lower(str) | greet()
lower(str[1:])
lower(string($env))
lower(string(0))
lower(string(1))
lower(string(1.0))
lower(string(add))
lower(string(array))
lower(string(f64))
lower(string(false))
lower(string(foo))
lower(string(i))
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(trim(foo?.Bar))
lower(trim(str))
lower(trimPrefix(str))
lower(trimSuffix(str))
lower(type($env))
lower(type(0))
lower(type(1))
lower(type(1.0))
lower(type(add))
lower(type(array))
lower(type(f64))
lower(type(false))
lower(type(foo))
lower(type(greet))
lower(type(i))
lower(type(list))
lower(type(nil))
lower(type(ok))
lower(type(str))
lower(type(true))
lower(upper(str))
map($env ?? $env, ok)
map($env ?? 1.0, ok)
map($env | filter(false), #.add)
map($env | filter(false), $env - #.str)
map($env | map(#index), f64)
map($env | map(foo), #.String)
map($env, #index) | filter(false)
map($env, #index) | map(greet)
map($env, #index) | reduce($env)
map($env, #index) | reduce(0, $env)
map($env, #index)?.[i]
map($env, $env) ?? timezone(str)
map($env, $env) in last($env)
map($env, $env) | any(f64 == .foo)
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(.f64, false)
map($env, $env) | reduce(0)
map($env, $env) | sum(1)
map($env, $env)?.[i]
map($env, 0) != i .. 0
map($env, 0) ?? greet
map($env, 0) ?? list
map($env, 0) | map($env)
map($env, 0) | map(str)
map($env, 0) | reduce(ok, i)
map($env, 0) | sortBy(1.0)
map($env, 0)?.[i]
map($env, 1) | any(ok)
map($env, 1) | count(ok)
map($env, 1) | groupBy(foo)
map($env, 1) | map(#)
map($env, 1) | none(ok)
map($env, 1) | reduce(foo)
map($env, 1) | sum(#)
map($env, 1)?.[i]
map($env, 1.0) ?? f64
map($env, 1.0) | all(true)
map($env, 1.0) | filter(ok)
map($env, 1.0) | find(true)
map($env, 1.0) | groupBy(#)
map($env, 1.0) | map(str)
map($env, 1.0) | reduce(ok, add)
map($env, 1.0)?.[i]
map($env, add) | groupBy(i)
map($env, add) | map(false)
map($env, add) | reduce(1.0)
map($env, add) | reduce(add, false)
map($env, add) | sum(f64)
map($env, add)?.[i]
map($env, array) | findIndex(ok)
map($env, array) | map(0)
map($env, array) | reduce(f64)
map($env, array)?.[i]
map($env, f64) | count(ok)
map($env, f64) | count(true)
map($env, f64) | groupBy(#)
map($env, f64) | reduce(#)
map($env, f64) | reduce(foo)
map($env, f64) | reduce(greet)
map($env, f64) | sortBy(#)
map($env, f64) | sortBy(i)
map($env, f64) | sum(#)
map($env, f64)?.[i]
map($env, f64)[:]
map($env, false) | filter(false)
map($env, false) | find(#)
map($env, false) | map(#)
map($env, false) | map(1.0)
map($env, false) | map(greet)
map($env, false) | reduce(str, nil)
map($env, false)?.[i]
map($env, foo) == list
map($env, foo) ?? list
map($env, foo) ?? str
map($env, foo) not in [add, f64]
map($env, foo) | all(.Bar not startsWith .Bar)
map($env, foo) | findLastIndex(true)
map($env, foo) | get(1)
map($env, foo) | groupBy(#)
map($env, foo) | map($env)
map($env, foo) | map(f64)
map($env, foo) | map(foo)
map($env, foo) | map(greet)
map($env, foo) | map(list)
map($env, foo) | none(true)
map($env, foo) | reduce(#)
map($env, foo) | reduce(list)
map($env, foo) | sortBy(.Bar)
map($env, foo) | sortBy(str)
map($env, foo)?.[i]
map($env, greet) ?? list
map($env, greet) | all(ok)
map($env, greet) | findLast(false)
map($env, greet) | map(1)
map($env, greet) | map(greet)
map($env, greet) | reduce(list)
map($env, greet) | sortBy(i)
map($env, greet)?.[i]
map($env, i) == list
map($env, i) | any(true)
map($env, i) | groupBy(f64)
map($env, i) | one(ok)
map($env, i) | sortBy(1.0)
map($env, i)?.[i]
map($env, list) ?? str
map($env, list) | filter(false)
map($env, list) | map($env)
map($env, list) | map(greet)
map($env, list) | map(str)
map($env, list) | reduce(1.0)
map($env, list) | reduce(foo)
map($env, list) | reduce(list)
map($env, list)?.[i]
map($env, ok) | findLastIndex(#)
map($env, ok) | findLastIndex(false)
map($env, ok) | one(1.0 == nil)
map($env, ok) | reduce(false)
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) | map(1)
map($env, str) | sortBy(str)
map($env, str)?.[i]
map($env, true) ?? ok
map($env, true) | any(#)
map($env, true) | filter(true)
map($env, true) | find(#)
map($env, true) | groupBy(0)
map($env, true) | map(#)
map($env, true) | map(f64)
map($env, true) | reduce(foo)
map($env, true) | sortBy(1.0)
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.array, not true)
map($env.array, ok)
map($env.array, str)
map($env.list, #)
map($env.list, #index)
map($env.list, .String)
map($env.list, 0 >= 1.0)
map($env.list, array)
map($env.list, f64 ^ f64)
map($env.list, greet)
map($env.list, i)
map($env.list, list)
map($env.list, ok)
map($env.list, sortBy(array, 1.0))?.[i]
map($env.list, str)
map($env?.[str], # ** #)
map($env?.[str], #)
map($env?.[str], #index != #)
map($env?.[str], #index)
map($env?.[str], 0 <= 1.0)
map($env?.[str], array)
map($env?.[str], f64 - 1.0)
map($env?.[str], foo ?? #.array)
map($env?.[str], foo)
map($env?.[str], greet)
map($env?.[str], i != f64)
map($env?.[str], i)
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, foo)
map($env?.array, greet == greet)
map($env?.array, list)
map($env?.array, str)
map($env?.list, # != $env)
map($env?.list, #)
map($env?.list, $env?.[String])
map($env?.list, add)
map($env?.list, count($env, false))
map($env?.list, foo)
map($env?.list, greet)
map($env?.list, i)
map($env?.list, list[1:])
map($env?.list, median(i))
map($env?.list, ok)
map($env?.list, trimSuffix(str))
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([$env], true || .array)
map([0], #)
map([1.0], #)
map([1.0], greet)
map([1.0], ok)
map([1], greet)
map([add, i], array)
map([array], #)
map([false], -1)
map([false], list)
map([false], ok)
map([foo, 1.0], #index)
map([foo, true], #)
map([foo], #)
map([foo], #?.Bar)
map([foo], .String)
map([foo], 1.0 < 0)
map([foo], add)
map([foo], f64)
map([foo], foo)
map([foo], str)
map([greet], #)
map([greet], array)
map([greet], foo)
map([i / 1.0], #)
map([i, 1.0], #)
map([i], #)
map([i], ok)
map([i], str)
map([list], array)
map([list], f64 + 1.0)
map([list], f64)
map([nil], 1.0 <= 1)
map([nil], foo)
map([nil], list)
map([nil], ok)
map([nil], str ?? f64)
map([ok], #)
map([ok], array)
map([str], greet)
map([true], #)
map([true], foo)
map([true], i ^ 1.0)
map(array ?? 1, i)
map(array ?? 1, ok)
map(array ?? 1.0, false ? #.add : #)
map(array ?? array, add)
map(array ?? foo, # > #)
map(array ?? foo, add)
map(array | map(#), 1.1)
map(array | reduce($env), list)
map(array | sortBy(#), ok)
map(array, !false)
map(array, !true)
map(array, # != #)
map(array, # % i)
map(array, # ** #)
map(array, # ** 1.0)
map(array, # + #)
map(array, # + 1)
map(array, # .. #)
map(array, # .. 0)
map(array, # < f64)
map(array, # <= #)
map(array, # <= 1.0)
map(array, # == #)
map(array, # > #)
map(array, # > 0)
map(array, # >= #)
map(array, # >= 0)
map(array, # ?? #)
map(array, # ?? i)
map(array, # ^ #)
map(array, # ^ 1.0)
map(array, # | bitshr(#))
map(array, #)
map(array, #) ?? add
map(array, #) ?? greet
map(array, #) | filter(false)
map(array, #) | findLastIndex(ok)
map(array, #) | findLastIndex(true)
map(array, #) | groupBy(#)
map(array, #) | map($env)
map(array, #) | map(bitnot(1))
map(array, #) | map(foo)
map(array, #) | map(greet)
map(array, #) | reduce($env?.foobar)
map(array, #) | reduce(1.0)
map(array, #) | sortBy(#)
map(array, #)?.[i]
map(array, #..i)
map(array, #index < 1.0)
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) | all(#.list || true)
map(array, $env) | count(#.ok)
map(array, $env) | none(.String matches #)
map(array, $env) | reduce(1.0)
map(array, $env) | reduce(add)
map(array, $env) | sortBy(1)
map(array, $env)?.[i]
map(array, $env.array)
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?.[String])
map(array, $env?.[foobar])
map(array, $env?.[str])
map(array, $env?.add)
map(array, $env?.array)
map(array, $env?.f64)
map(array, $env?.greet)
map(array, $env?.list)
map(array, $env?.ok)
map(array, -1)
map(array, -1.0)
map(array, -f64)
map(array, -i)
map(array, 0 != #)
map(array, 0 % #)
map(array, 0 - #)
map(array, 0 - 1)
map(array, 0 <= #)
map(array, 0 | bitxor(#))
map(array, 0) | find(false)
map(array, 0) | map(array)
map(array, 0) | reduce(#)
map(array, 0) | sortBy(f64)
map(array, 0)?.[i]
map(array, 1 != #)
map(array, 1 - #)
map(array, 1 ^ #)
map(array, 1) | map(1)
map(array, 1) | one(ok)
map(array, 1) | reduce($env)
map(array, 1)?.[i]
map(array, 1.0 != #)
map(array, 1.0 != 1.0)
map(array, 1.0 ** #)
map(array, 1.0 + #)
map(array, 1.0 + 1.0)
map(array, 1.0 / 0)
map(array, 1.0 <= #)
map(array, 1.0 == #)
map(array, 1.0 == nil)
map(array, 1.0 ?? nil)
map(array, 1.0 ^ f64)
map(array, 1.0) != array
map(array, 1.0) != f64 ?? greet
map(array, 1.0) == list
map(array, 1.0) | groupBy(#)
map(array, 1.0) | groupBy(1.0)
map(array, 1.0) | groupBy(ok)
map(array, 1.0) | map(#)
map(array, 1.0) | map(foo)
map(array, 1.0) | reduce($env)
map(array, 1.0) | reduce(1.0)
map(array, 1.0) | reduce(true)
map(array, 1.0) | take(1)
map(array, 1.0)?.[i]
map(array, [#])
map(array, [0, $env])
map(array, [f64])
map(array, [i])
map(array, [nil])
map(array, add)
map(array, add) | groupBy(foo)
map(array, add)?.[i]
map(array, array | map(1.0))
map(array, array)
map(array, array) | all(true)
map(array, array) | sum(i)
map(array, array)?.[i]
map(array, array?.[1])
map(array, bitnot(#))
map(array, f64 - 1.0)
map(array, f64 <= f64)
map(array, f64 >= i)
map(array, f64)
map(array, f64) != list
map(array, f64) ?? -1.0
map(array, f64) | groupBy(foo)
map(array, f64) | reduce(#)
map(array, f64)?.[i]
map(array, false) | any(#)
map(array, false) | count(false)
map(array, false) | reduce(greet)
map(array, false) | sortBy(str)
map(array, false)?.[i]
map(array, findIndex($env, ok))
map(array, flatten(array))
map(array, flatten(list))
map(array, float(#))
map(array, float(1))
map(array, foo != $env)
map(array, foo != foo)
map(array, foo == foo)
map(array, foo ?? ok)
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(#)
map(array, foo) | reduce(list)
map(array, foo) | reduce(str, f64)
map(array, foo) | reduce(true)
map(array, foo) | sum(0 + 1)
map(array, foo)?.[i]
map(array, foo)[:]
map(array, foo.Bar)
map(array, foo.String)
map(array, foo?.Bar)
map(array, foo?.String)
map(array, greet)
map(array, greet) | sum(f64)
map(array, greet)?.[i]
map(array, i * f64)
map(array, i < 0)
map(array, i == #index)
map(array, i)
map(array, i) | find(ok)
map(array, i)?.[i]
map(array, if ok { $env } else { 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, list?.[i])
map(array, median(#))
map(array, median(1.0))
map(array, min(0))
map(array, nil != 1.0)
map(array, nil != array)
map(array, nil == 1.0)
map(array, nil ?? list)
map(array, not false)
map(array, not true)
map(array, ok != true)
map(array, ok == nil)
map(array, ok ?? str)
map(array, ok || false)
map(array, ok)
map(array, ok) ?? float($env)
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, ok)?.[i]
map(array, reduce(array, foo, #index))
map(array, reverse(list))
map(array, round(1))
map(array, sort(array))
map(array, str == nil)
map(array, str in foo)
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, sum(array))
map(array, true ? 1 : #)
map(array, true ?? #)
map(array, true ?? foo)
map(array, true) != array
map(array, true) | findLast(#)
map(array, true)?.[i]
map(array, type(1.0))
map(array, type(list))
map(array[i:], $env?.ok)
map(concat(array), # == f64)
map(concat(array), greet)
map(concat(list), foo)
map(false ? foo : list, $env.ok)
map(filter(array, true), greet)
map(flatten(array), #)
map(flatten(array), i)
map(flatten(array), str)
map(i .. i, array)
map(if false { $env } else { list }, #index)
map(keys($env), #)
map(keys($env), str)
map(list ?? 0, # == str)
map(list ?? false, f64)
map(list ?? true, list)
map(list | map($env), #)
map(list | map(.Bar), #)
map(list | map(.Bar), greet)
map(list | sortBy(1.0), .String)
map(list | sortBy(1.0), string(#))
map(list | sortBy(str), f64)
map(list, # != #)
map(list, # == #)
map(list, # == foo)
map(list, # ?? #)
map(list, # ?? #index)
map(list, # ?? $env)
map(list, # ?? .Bar)
map(list, # ?? greet)
map(list, #)
map(list, #) == array
map(list, #) ?? greet
map(list, #) | any(false)
map(list, #) | any(ok)
map(list, #) | findIndex(ok)
map(list, #) | findIndex(true)
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(false)
map(list, #) | one(true)
map(list, #) | reduce(#.String, foo)
map(list, #) | reduce(#acc, 1)
map(list, #) | reduce(1.0, nil)
map(list, #) | reduce(f64, list)
map(list, #) | sortBy(1.0)
map(list, #) | take(1)
map(list, #)?.[i]
map(list, #.Bar <= #.Bar)
map(list, #.Bar)
map(list, #.String)
map(list, #.String) ?? i
map(list, #.String)?.[i]
map(list, #?.Bar)
map(list, #?.String)
map(list, #index + i)
map(list, #index - 1)
map(list, #index | add(i))
map(list, #index)
map(list, #index) ?? $env ?? nil
map(list, #index)?.[i]
map(list, $env != #)
map(list, $env != foo)
map(list, $env != greet)
map(list, $env != nil)
map(list, $env ?? 1.0)
map(list, $env) ?? $env.ok
map(list, $env) ?? array
map(list, $env) | findIndex(.ok)
map(list, $env) | findLastIndex(#.foo != #)
map(list, $env) | map(1.0)
map(list, $env) | map(foo)
map(list, $env) | reduce(#.ok)
map(list, $env) | reduce(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?.[String])
map(list, $env?.[str])
map(list, $env?.add)
map(list, $env?.array)
map(list, $env?.f64)
map(list, $env?.foo)
map(list, $env?.foobar)
map(list, $env?.greet)
map(list, $env?.i)
map(list, $env?.ok)
map(list, $env?.str)
map(list, -#index)
map(list, .Bar)
map(list, .Bar) | sum(1)
map(list, .String)
map(list, .String) | filter(true)
map(list, .String) | map(#)
map(list, .String) | sum(i)
map(list, .String)?.[i]
map(list, 0 <= 1.0)
map(list, 0 > 1)
map(list, 0) | groupBy(foo)
map(list, 0) | sortBy(#)
map(list, 0) | sum(#)
map(list, 1 == 1.0)
map(list, 1) | all(false)
map(list, 1) | groupBy(#)
map(list, 1) | map(list)
map(list, 1)?.[i]
map(list, 1.0 / i)
map(list, 1.0 >= 1.0)
map(list, 1.0 ?? #.Bar)
map(list, 1.0 ?? list)
map(list, 1.0) != array
map(list, 1.0) ?? array
map(list, 1.0) | any(# < 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, [foo])
map(list, [ok])
map(list, abs(1))
map(list, abs(1.0))
map(list, add ?? #)
map(list, add ?? list)
map(list, add)
map(list, add)?.[i]
map(list, array)
map(list, array) ?? list
map(list, array) | one(ok)
map(list, array) | one(true)
map(list, array)?.[i]
map(list, array?.[i])
map(list, bitnot(0))
map(list, bitnot(i))
map(list, ceil(1.0))
map(list, f64 != 1.0)
map(list, f64 * 0)
map(list, f64 / 1.0)
map(list, f64)
map(list, f64) | groupBy(#)
map(list, f64) | map($env)
map(list, f64) | none(true)
map(list, f64) | reduce(1)
map(list, false ?? foo)
map(list, false) | groupBy(foo)
map(list, false) | map(#)
map(list, float(0))
map(list, floor(1.0))
map(list, foo == #)
map(list, foo ?? #)
map(list, foo ?? foo)
map(list, foo not in list)
map(list, foo)
map(list, foo) ?? f64
map(list, foo) | none(false)
map(list, foo) | reduce(#, add)
map(list, foo) | reduce(#.String)
map(list, foo) | reduce(1)
map(list, foo) | reduce(array)
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 ?? nil)
map(list, greet(#.Bar))
map(list, greet(str))
map(list, greet)
map(list, greet) | findIndex(true)
map(list, greet)?.[i]
map(list, i == $env)
map(list, i >= 0)
map(list, i)
map(list, i) != list
map(list, i) != nil or true
map(list, i) | groupBy(# < #)
map(list, i) | reduce(#)
map(list, i) | sortBy(#)
map(list, i)?.[i]
map(list, list)
map(list, list) | map(str)
map(list, list) | sum(f64)
map(list, list)?.[i]
map(list, max(1))
map(list, max(f64))
map(list, mean(array))
map(list, nil != add)
map(list, nil ?? #)
map(list, nil in $env)
map(list, none($env, true))
map(list, not true)
map(list, ok ? str : foo)
map(list, ok ?? 0)
map(list, ok or ok)
map(list, ok)
map(list, ok) | map(false)
map(list, ok)?.[i]
map(list, reverse(list))
map(list, round(f64))
map(list, sort(array))
map(list, str ?? 0)
map(list, str not in #)
map(list, str)
map(list, str) | findLast(false)
map(list, str) | map(#)
map(list, str) | reduce(#)
map(list, string(#))
map(list, string(f64))
map(list, sum(array))
map(list, toJSON(1))
map(list, trim(str))
map(list, true ? array : f64)
map(list, true ?? #index)
map(list, true)?.[i]
map(list, type(#))
map(list, type($env))
map(list, upper(#.Bar))
map(list[:1], f64)
map(map($env, $env), greet)
map(map($env, 0), str == str)
map(map(array, #), #)
map(map(array, array), greet)
map(map(array, list), str)
map(map(list, 1), list)
map(map(list, f64), ok)
map(map(list, str), map($env, 1.0))
map(max($env), greet)
map(min($env), f64)
map(nil ?? $env, str)
map(nil ?? array, 1.0 != 1.0)
map(reduce($env, list, $env), foo)
map(reduce(array, $env), foo.String())
map(reverse(array), str)
map(sort($env), #.String contains #.list)
map(sort($env), #.String.i)
map(sort($env), #.array.greet)
map(sort($env), #.greet.foo)
map(sort($env), #.greet?.Bar(Bar))
map(sort($env), add)
map(sort($env), array?.[#])
map(sort($env), lower(#))
map(sort($env), ok)
map(sort($env), str not matches $env)
map(sort($env), str)
map(sort(array), list?.[i])
map(sort(array), ok)
map(sortBy(array, 1.0), #)
map(sortBy(array, str), # >= #index)
map(str ?? foo, #)
map(str ?? foo, f64)
map(str ?? foo, i)
map(toPairs($env), f64)
map(toPairs($env), list | sortBy(1))
map(true ? array : false, $env?.greet)
map(uniq(list), ok)
map(uniq(list), reduce(list, foo))
map(values($env), #)
max($env ?? $env)
max($env ?? 1)
max($env ?? add)
max($env ?? array)
max($env ?? f64)
max($env ?? foo)
max($env ?? list)
max($env ?? nil)
max($env ?? str)
max($env ?? true)
max($env | count(ok))
max($env | count(true))
max($env | find(false))
max($env | findIndex(ok))
max($env | findLast(false))
max($env | findLastIndex(false))
max($env | findLastIndex(ok))
max($env | findLastIndex(true))
max($env | map(#index))
max($env | map(0))
max($env | map(1))
max($env | sum(i))
max($env) != $env?.array
max($env) != greet
max($env) == $env?.foo
max($env) == f64
max($env) == list
max($env) == ok
max($env) ?? i
max($env) ?? list
max($env) not in list
max($env) | all(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) | none(ok)
max($env) | sum(0)
max($env) | sum(1.0)
max($env).Bar
max($env).Bar?.i().str
max($env).Bar?.str
max($env).String
max($env).String?.[array]
max($env).String?.[str]
max($env).add
max($env).array
max($env).f64
max($env).foo
max($env).foobar
max($env).foobar?.[add]
max($env).foobar?.[greet]
max($env).foobar?.foo
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)?.$env?.Bar
max($env)?.$env?.foo(1.0)
max($env)?.Bar
max($env)?.String
max($env)?.String?.[str]
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?.[add]
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)?.str?.[f64]
max($env.array ?? array)
max($env.array)
max($env.array, array)
max($env.f64)
max($env.f64, sum(array))
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)?.[foo]
max($env?.String)?.[i]
max($env?.String?.[array])
max($env?.String?.foo())
max($env?.String?.i())
max($env?.[Bar])
max($env?.[Bar])?.[ok]
max($env?.[String])
max($env?.[String])?.[i]
max($env?.[String])?.foo
max($env?.[String]?.[f64])
max($env?.[String]?.[str])
max($env?.[String]?.ok)
max($env?.[foobar])
max($env?.[nil])
max($env?.[str])
max($env?.[str]) | reduce(ceil(#))
max($env?.[str]?.[f64])
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)
max(-1)
max(-1.0)
max(-f64)
max(-i)
max(-median(1, 0))
max(0 % 1)
max(0 % i)
max(0 * 0)
max(0 * 1)
max(0 * 1.0)
max(0 ** 1)
max(0 ** f64)
max(0 + 0)
max(0 + 1)
max(0 + 1.0)
max(0 + f64)
max(0 - 0)
max(0 - 1)
max(0 - 1.0)
max(0 - f64)
max(0 - i)
max(0 .. 1)
max(0 .. 1, i)
max(0 .. i)
max(0 / 0)
max(0 / 1)
max(0 ?? $env)
max(0 ?? 1)
max(0 ?? add)
max(0 ?? array)
max(0 ?? f64)
max(0 ?? false)
max(0 ?? greet)
max(0 ?? ok)
max(0 ^ 0)
max(0 ^ 1)
max(0 ^ 1.0)
max(0 ^ f64)
max(0 ^ i)
max(0 | min(1.0, 1.0))
max(0) != 0 || ok
max(0) - i
max(0) < i
max(0) == f64
max(0) ?? -f64
max(0) ?? f64
max(0) not in array
max(0..i)
max(0.0)
max(0.1)
max(1 * 0)
max(1 * 1.0)
max(1 * i)
max(1 ** 0)
max(1 ** 1.0)
max(1 + 0)
max(1 + 1)
max(1 + f64)
max(1 + i)
max(1 - 1)
max(1 - 1.0)
max(1 - f64)
max(1 - i)
max(1 .. 1)
max(1 / 1.0)
max(1 / f64)
max(1 / i)
max(1 ?? 1.0)
max(1 ?? f64)
max(1 ?? false)
max(1 ?? foo)
max(1 ?? list)
max(1 ?? list, array)
max(1 ?? ok)
max(1 ^ $env?.i)
max(1 ^ 0)
max(1 ^ 1.0)
max(1 ^ i)
max(1 | bitshr(1))
max(1 | max(1.0))
max(1) * i
max(1) ** f64
max(1) ** i
max(1) .. i
max(1) / i
max(1) < f64
max(1) < i
max(1) ?? $env.ok
max(1, 1.0) < f64
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)
max(1.0 ** 1.0)
max(1.0 ** f64)
max(1.0 ** i)
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)
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 / i)
max(1.0 ?? $env)
max(1.0 ?? 1.0)
max(1.0 ?? array)
max(1.0 ?? f64)
max(1.0 ?? false)
max(1.0 ?? false, i)
max(1.0 ?? foo)
max(1.0 ?? greet)
max(1.0 ?? i)
max(1.0 ?? nil)
max(1.0 ?? ok)
max(1.0 ^ 0)
max(1.0 ^ 1)
max(1.0 ^ 1.0)
max(1.0 ^ f64)
max(1.0 ^ i)
max(1.0)
max(1.0) ** i
max(1.0) - i
max(1.0) < i
max(1.0) <= $env.f64
max(1.0) <= i
max(1.0) > 1 - i
max(1.0) > f64
max(1.0) >= i
max(1.0) ?? i
max(1.0) ?? list
max(1.0) ?? ok
max(1.0) ^ f64
max(1.0) | min(array)
max(1.0, 1.0) ?? greet
max(1.0, array) >= floor(1.0)
max([0])
max([1.0])
max([1])
max([array, 1.0])
max([array])
max([f64, 1.0] ?? add)
max([f64])
max([i])
max(abs(0))
max(abs(1))
max(abs(1.0))
max(abs(f64))
max(abs(i))
max(add ?? $env)
max(add ?? f64)
max(add ?? i)
max(add(0, 0))
max(array ?? false)
max(array ?? greet)
max(array ?? i)
max(array | find(false))
max(array | findLast(ok))
max(array | findLast(true))
max(array | get(i))
max(array | map(1.0))
max(array | map(i))
max(array | reduce(#index))
max(array | reduce($env))
max(array | reduce($env, 0))
max(array | reduce(0))
max(array | reduce(1.0, foo))
max(array | reduce(i))
max(array | sortBy(#))
max(array | sortBy(0))
max(array | sortBy(1))
max(array | sortBy(1.0))
max(array | sortBy(f64))
max(array | sum(0))
max(array | sum(i))
max(array)
max(array) != array
max(array) != i
max(array) ** f64
max(array) ** i
max(array) - f64
max(array) / median(1)
max(array) == i
max(array) == str
max(array) > f64
max(array) ?? greet
max(array) ?? ok
max(array, abs(i))
max(array, array)
max(array, f64)
max(array, i)
max(array, int(0))
max(array?.[1])
max(array?.[i])
max(array[:])
max(bitnand(i, i))
max(bitnot(0))
max(bitnot(1))
max(bitnot(i))
max(bitor(1, 1))
max(bitushr(0, 1))
max(bitxor(0, 0))
max(bitxor(1, 0))
max(ceil(0))
max(ceil(1))
max(ceil(1.0))
max(ceil(f64))
max(ceil(i))
max(concat(array))
max(count(array, true))
max(count(list, false))
max(count(list, ok))
max(f64 * 1.0)
max(f64 * f64)
max(f64 * i)
max(f64 ** 0)
max(f64 ** 1)
max(f64 ** 1.0)
max(f64 ** i)
max(f64 + 0)
max(f64 + 1)
max(f64 + 1.0)
max(f64 - 1.0)
max(f64 - i)
max(f64 / 0)
max(f64 / 1)
max(f64 / 1.0)
max(f64 ?? $env)
max(f64 ?? 0)
max(f64 ?? 1.0)
max(f64 ?? foo)
max(f64 ?? greet)
max(f64 ?? i)
max(f64 ?? nil)
max(f64 ?? ok)
max(f64 ^ 1)
max(f64 ^ 1.0)
max(f64 ^ i)
max(f64)
max(f64) != f64
max(f64) ** f64
max(f64) / f64
max(f64) < i
max(f64) <= 0 * f64
max(f64) <= f64
max(f64) == f64
max(f64) >= f64
max(f64) ?? add
max(f64) ^ f64
max(f64) not in array
max(f64, $env?.array)
max(f64, 1.0 ** 1.0)
max(f64, array)
max(f64, array, array)
max(f64, f64)
max(f64, i)
max(f64, median(0))
max(f64, min(1, 1))
max(false ? foo : 0)
max(false ? nil : $env)
max(false ? nil : array)
max(false ? str : 0)
max(false ?: foo)
max(false ?? $env)
max(false ?? 1.0)
max(false ?? foo)
max(findLast($env, false))
max(findLastIndex($env, true))
max(findLastIndex(array, false))
max(findLastIndex(array, ok))
max(findLastIndex(array, true))
max(findLastIndex(list, false))
max(first($env))
max(first(array))
max(first(array), array)
max(flatten(array))
max(float(0))
max(float(1))
max(float(1.0))
max(float(f64))
max(float(i))
max(floor(1))
max(floor(1.0))
max(floor(i))
max(foo ?? $env)
max(foo ?? $env[foo:])
max(foo ?? 0)
max(foo ?? 1)
max(foo ?? 1.0)
max(foo ?? add)
max(foo ?? array)
max(foo ?? f64)
max(foo ?? false)
max(foo ?? greet)
max(foo ?? i)
max(foo ?? list)
max(foo ?? ok)
max(foo ?? true)
max(get($env, nil))
max(greet ?? $env)
max(greet ?? 0)
max(greet ?? 1)
max(greet ?? add)
max(greet ?? array)
max(greet ?? false)
max(greet ?? foo)
max(greet ?? list)
max(i % 1)
max(i % i)
max(i * 0)
max(i * 1)
max(i * 1.0)
max(i * i, i)
max(i ** 0)
max(i ** 1)
max(i ** 1.0)
max(i ** f64)
max(i ** i)
max(i + 0)
max(i + 1.0)
max(i + f64)
max(i - 1)
max(i - 1.0)
max(i - i)
max(i .. 0)
max(i .. 1)
max(i / 1)
max(i / 1.0)
max(i / i)
max(i ?? 0)
max(i ?? 1.0)
max(i ?? add)
max(i ?? list)
max(i ?? nil)
max(i ?? ok)
max(i ?? true)
max(i ^ 0)
max(i ^ i)
max(i | bitor(i))
max(i | bitshl(0))
max(i | max(1))
max(i | min(f64))
max(i)
max(i) + f64
max(i) - f64
max(i) < f64
max(i) <= f64
max(i) >= i
max(i) ?? str
max(i) not in array
max(i) | bitushr(i)
max(i) | bitxor(0)
max(i) | min(1.0)
max(i, array)
max(i, array, i)
max(i, f64)
max(i, i)
max(i, min(1.0))
max(i..i)
max(if false { 0 } else { nil })
max(if false { array } else { nil })
max(if false { ok } else { 1.0 })
max(if ok { $env } 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(int(sum(array, 1.0)))
max(last($env))
max(last($env)?.ok)
max(last(array))
max(len($env))
max(len(array))
max(len(list))
max(len(str))
max(let foobar = f64; foobar)
max(let tmp = $env; tmp)
max(list | count(ok))
max(list | count(true))
max(list | filter(false))
max(list | map(f64))
max(list | reduce($env))
max(list) startsWith str and false
max(map($env, #index))
max(map($env, 0))
max(map($env, 1.0))
max(map($env, array))
max(map(array, #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($env.array))
max(max($env?.Bar))
max(max(0))
max(max(1))
max(max(1.0))
max(max(array))
max(max(array?.[i]))
max(max(f64))
max(max(f64, 1))
max(max(i))
max(mean(0))
max(mean(0, f64))
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))
max(median(1.0))
max(median(1.0, array))
max(median(array))
max(median(array, 1))
max(median(f64))
max(median(i))
max(min($env))
max(min(0))
max(min(1))
max(min(1.0))
max(min(1.0, array))
max(min(1.0, f64, i))
max(min(array))
max(min(f64))
max(min(i))
max(nil ?? $env)
max(nil ?? 0)
max(nil ?? 1)
max(nil ?? 1.0)
max(nil ?? f64)
max(ok ? 1 : nil)
max(ok ? 1.0 : 1)
max(ok ? 1.0 : nil)
max(ok ? add : $env)
max(ok ? f64 : $env)
max(ok ?? 1.0)
max(ok ?? f64)
max(ok ?? foo)
max(ok ?? i)
max(reduce($env, i, foo))
max(reduce(array, #))
max(reduce(array, #acc))
max(reduce(array, $env))
max(reduce(array, $env).String)
max(reduce(array, 1.0))
max(reduce(list, 0))
max(reduce(list, 1.0))
max(reduce(list, f64))
max(reverse(array))
max(round(0))
max(round(1))
max(round(1.0))
max(round(f64))
max(round(i))
max(sort($env))
max(sort(array))
max(sortBy(array, #))
max(sortBy(array, 1))
max(str ?? 0)
max(str ?? 1.0)
max(str ?? array)
max(str ?? foo)
max(str ?? i)
max(str ?? list)
max(sum($env, 1))
max(sum($env, 1), i)
max(sum($env, 1.0))
max(sum($env, f64))
max(sum($env?.[str]))
max(sum(array))
max(sum(array, #))
max(sum(array, 1.0))
max(sum(list, f64))
max(sum(list, i))
max(true ? array : false)
max(true ?: list)
max(true ?? $env?.[str])
max(true ?? 1)
max(true ?? add)
max(true ?? foo)
max(uniq(array))
max({foo: $env}?.add)
max({foo: true, foo: str}?.list)
mean($env | count(ok))
mean($env | filter(false))
mean($env | map(0))
mean($env | map(1.0))
mean($env | reduce(1, 1.0))
mean($env | reduce(1.0, greet))
mean($env | reduce(array, foo))
mean($env | reduce(i, nil))
mean($env | sum(0))
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)
mean(-1)
mean(-1.0)
mean(-f64)
mean(-i)
mean(0 % 1)
mean(0 * 0)
mean(0 * 1)
mean(0 * 1.0)
mean(0 * i)
mean(0 ** 0)
mean(0 ** 1)
mean(0 ** f64)
mean(0 ** f64, i)
mean(0 + 0)
mean(0 + f64)
mean(0 + i)
mean(0 - 0)
mean(0 - 1.0)
mean(0 - f64)
mean(0 .. 0)
mean(0 / 0)
mean(0 / 1)
mean(0 / 1, i)
mean(0 / 1.0)
mean(0 / i)
mean(0 ?? $env)
mean(0 ?? 0)
mean(0 ?? 1)
mean(0 ?? add)
mean(0 ?? foo)
mean(0 ?? foo, $env?.array)
mean(0 ?? i)
mean(0 ^ 0)
mean(0 ^ f64)
mean(0 ^ i)
mean(0 | bitand(0))
mean(0) * f64
mean(0) .. i
mean(0) / f64
mean(0) <= i
mean(0) == f64
mean(0) | max(f64)
mean(0, 1.0) >= 1 == nil
mean(0..i)
mean(0.1)
mean(1 % 1)
mean(1 % i)
mean(1 * 0)
mean(1 * 1.0, i)
mean(1 * i)
mean(1 ** 0)
mean(1 + 1)
mean(1 + 1.0)
mean(1 + f64)
mean(1 + i)
mean(1 - i)
mean(1 .. 0)
mean(1 / 0)
mean(1 / 1)
mean(1 / 1.0)
mean(1 / i)
mean(1 ?? $env)
mean(1 ?? 0)
mean(1 ?? 1)
mean(1 ?? 1.0)
mean(1 ?? add)
mean(1 ?? f64)
mean(1 ?? false)
mean(1 ?? foo)
mean(1 ?? ok)
mean(1 ?? str)
mean(1 ?? true)
mean(1 ^ 1)
mean(1 ^ 1.0)
mean(1 ^ f64)
mean(1 ^ i)
mean(1) * 1.0 ?? add
mean(1) * i
mean(1) ** i
mean(1) <= f64
mean(1) == f64
mean(1) == i + 0 ^ f64
mean(1) ?? array
mean(1) ?? i
mean(1) ?? ok
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 * 1.0)
mean(1.0 * i)
mean(1.0 ** 0)
mean(1.0 ** 1)
mean(1.0 ** 1.0)
mean(1.0 ** f64)
mean(1.0 ** i)
mean(1.0 + 1)
mean(1.0 + 1.0)
mean(1.0 + f64)
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 / i)
mean(1.0 ?? $env)
mean(1.0 ?? 1.0)
mean(1.0 ?? add)
mean(1.0 ?? array)
mean(1.0 ?? false)
mean(1.0 ?? foo)
mean(1.0 ?? i)
mean(1.0 ?? list)
mean(1.0 ?? nil)
mean(1.0 ?? str)
mean(1.0 ^ 0)
mean(1.0 ^ 1)
mean(1.0 ^ 1.0)
mean(1.0 ^ f64)
mean(1.0 ^ i)
mean(1.0 | max(1.0))
mean(1.0 | median(array))
mean(1.0)
mean(1.0) * i
mean(1.0) + i
mean(1.0) / f64
mean(1.0) == $env or $env
mean(1.0) > f64
mean(1.0) >= i
mean(1.0) >= i || true
mean(1.0) ?? findIndex($env, $env)
mean(1.0) ?? greet
mean(1.0) ?? list
mean(1.0) ^ i
mean(1.0) | max(1.0)
mean(1.0) | max(array)
mean(1.0, 1.0) < f64
mean(1.0, 1.0) ?? i
mean(1.1)
mean([0, 1.0])
mean([0, array])
mean([0])
mean([1.0])
mean([1])
mean([array, 0])
mean([array])
mean([f64, i])
mean([f64])
mean([i, 1.0])
mean([i])
mean(abs(-f64))
mean(abs(0))
mean(abs(1))
mean(abs(1.0))
mean(abs(f64))
mean(abs(i))
mean(abs(i), f64)
mean(array ?? $env)
mean(array ?? f64)
mean(array ?? f64, array)
mean(array ?? foo)
mean(array ?? nil)
mean(array | count(false))
mean(array | count(true))
mean(array | filter(ok))
mean(array | findLastIndex(ok))
mean(array | map(#index))
mean(array | map(array))
mean(array | map(i))
mean(array | max(0))
mean(array | max(1.0))
mean(array | mean(array))
mean(array | sortBy(#))
mean(array | sortBy(1))
mean(array | sum(#))
mean(array | sum(1.0))
mean(array)
mean(array) != add
mean(array) * f64
mean(array) .. i
mean(array) < f64
mean(array) <= f64
mean(array) == list
mean(array) >= f64
mean(array) >= f64 or ok
mean(array) ?? i
mean(array) not in array
mean(array) | median(array)
mean(array, -1.0)
mean(array, array)
mean(array, f64)
mean(array, f64, i)
mean(array, i)
mean(array, int(1.0))
mean(array?.[0])
mean(array?.[1])
mean(array?.[i])
mean(array?.[i], i)
mean(array[:0])
mean(array[i:0])
mean(bitand(0, i))
mean(bitnot(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(abs(f64)))
mean(ceil(f64))
mean(ceil(i))
mean(concat(array))
mean(f64 * 0)
mean(f64 * 1)
mean(f64 * 1.0)
mean(f64 * i)
mean(f64 ** 0)
mean(f64 ** 1.0)
mean(f64 ** i)
mean(f64 + 1.0)
mean(f64 + f64)
mean(f64 - 1.0)
mean(f64 - i)
mean(f64 / 1.0)
mean(f64 / f64)
mean(f64 / i)
mean(f64 ?? $env)
mean(f64 ?? 1.0)
mean(f64 ?? greet)
mean(f64 ?? list)
mean(f64 ^ 0)
mean(f64 ^ 1.0)
mean(f64 | min(1.0))
mean(f64)
mean(f64) * i
mean(f64) ** f64
mean(f64) - f64
mean(f64) > f64
mean(f64) > i
mean(f64) in $env?.array
mean(f64, 0) | median(1)
mean(f64, 1) <= f64
mean(f64, array)
mean(f64, f64)
mean(f64, i)
mean(f64, reduce(array, 1.0, nil))
mean(f64, round(i))
mean(f64, sum(array))
mean(false ? add : 1.0)
mean(false ? i : f64)
mean(false ?: 1)
mean(filter($env, false))
mean(filter(array, ok))
mean(find(array, ok))
mean(findIndex($env, true))
mean(findIndex(array, true))
mean(findLastIndex($env, ok))
mean(findLastIndex($env, true))
mean(findLastIndex(array, true))
mean(findLastIndex(list, ok))
mean(first(array))
mean(first(array), i * i)
mean(flatten(array))
mean(float(0))
mean(float(1))
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)
mean(i * 1.0)
mean(i ** 0)
mean(i ** 1.0)
mean(i ** f64)
mean(i ** i)
mean(i + 0)
mean(i + 1)
mean(i + 1.0)
mean(i + i)
mean(i - 1.0)
mean(i - f64)
mean(i .. $env?.i)
mean(i .. 1)
mean(i .. i)
mean(i / 1)
mean(i / f64)
mean(i / i)
mean(i ?? $env)
mean(i ?? 1.0)
mean(i ?? array)
mean(i ?? f64, i)
mean(i ?? foo)
mean(i ?? greet)
mean(i ?? list)
mean(i ?? nil)
mean(i ?? str)
mean(i ?? true)
mean(i ^ 1.0)
mean(i | bitxor(i))
mean(i | max(1, 1.0))
mean(i | mean(1.0))
mean(i)
mean(i) / 1.0 ^ 1.0
mean(i) <= f64
mean(i) >= i
mean(i) ?? $env?.[String]
mean(i) ^ $env?.i
mean(i) ^ f64
mean(i) in array
mean(i, $env.f64)
mean(i, -1.0)
mean(i, 0) + f64
mean(i, 1 ** f64)
mean(i, array)
mean(i, f64)
mean(i, float(f64))
mean(i, i)
mean(i, int(0))
mean(if false { 1 } else { 0 })
mean(if ok { 0 } else { foo })
mean(if ok { 0 } else { nil })
mean(if ok { f64 } else { 1.0 })
mean(if true { 1.0 } else { foo })
mean(if true { f64 } else { false })
mean(int(0))
mean(int(1))
mean(int(1.0))
mean(int(f64))
mean(int(i))
mean(last(array))
mean(lastIndexOf(str, str))
mean(len($env))
mean(len(array))
mean(len(list))
mean(let z = f64; 1.0 + z)
mean(let z = f64; z)
mean(list | filter(false))
mean(list | map(1.0))
mean(list | reduce(1))
mean(list | reduce(array))
mean(list | reduce(f64))
mean(list | sum(1))
mean(map($env, 1))
mean(map($env, 1.0))
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(1.0, f64, i))
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, 1.0))
mean(median(1.0))
mean(median(1.0, f64))
mean(median(array))
mean(median(array, 0))
mean(median(array, 1))
mean(median(array, f64))
mean(median(f64))
mean(median(i))
mean(min(0))
mean(min(1))
mean(min(1, 1.0))
mean(min(1.0))
mean(min(1.0, array))
mean(min(array))
mean(min(f64))
mean(min(f64, array))
mean(min(i))
mean(nil ?? 0)
mean(nil ?? 1)
mean(nil ?? 1.0)
mean(nil ?? array)
mean(nil ?? f64)
mean(reduce($env, 1.0, 1.0))
mean(reduce($env, i, greet))
mean(reduce(array, #))
mean(reduce(array, 1.0))
mean(reduce(array, array))
mean(reduce(array, f64, array))
mean(reduce(list, 1))
mean(reduce(list, array))
mean(reverse(array))
mean(round(0))
mean(round(1))
mean(round(1.0))
mean(round(f64))
mean(round(i))
mean(sort($env))
mean(sort(array))
mean(sortBy(array, #))
mean(sortBy(array, 0))
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, 0))
mean(sum(array, 1.0))
mean(true ? 0 : ok)
mean(true ? 0 : str)
mean(true ? 1.0 : 1)
mean(uniq(array ?? 1.0))
mean(uniq(array))
median($env | count(false))
median($env | findIndex(true))
median($env | findLastIndex(ok))
median($env | map(1))
median($env | map(1.0))
median($env | map(i))
median($env | reduce(f64, greet))
median($env | sum(0))
median($env | sum(1.0))
median($env.array)
median($env.array, f64)
median($env.f64)
median($env.f64, i)
median($env.i)
median($env.i, i)
median($env?.array)
median($env?.array, array)
median($env?.f64)
median($env?.i)
median($env?.i, $env.i)
median(-0)
median(-1)
median(-1.0 ?? true)
median(-1.0)
median(-f64)
median(-i ?? {foo: foo})
median(-i)
median(0 % 1)
median(0 % i)
median(0 * 0)
median(0 * 1)
median(0 * 1.0)
median(0 * f64)
median(0 * i)
median(0 ** 0)
median(0 ** 1.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)
median(0 .. i)
median(0 / 0)
median(0 / 1.0)
median(0 / i)
median(0 ?? $env)
median(0 ?? f64)
median(0 ?? false)
median(0 ?? foo)
median(0 ?? greet)
median(0 ?? list)
median(0 ?? nil)
median(0 ^ $env.i)
median(0 ^ 1)
median(0 ^ 1.0)
median(0 | max(1))
median(0) * i
median(0) - f64
median(0) / f64
median(0) == f64
median(0) >= f64
median(0) >= i
median(0) ?? trim($env)
median(0) not in [nil]
median(0, 0) ?? i
median(0.0)
median(0.1)
median(1 % 1)
median(1 * 0)
median(1 * 1)
median(1 * 1.0)
median(1 * i)
median(1 ** 0)
median(1 ** 1)
median(1 ** 1.0)
median(1 ** i)
median(1 + 0)
median(1 + 1)
median(1 + 1.0)
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 / f64)
median(1 / i)
median(1 ?? $env)
median(1 ?? array)
median(1 ?? f64)
median(1 ?? false)
median(1 ?? foo)
median(1 ?? greet)
median(1 ?? str)
median(1 ^ 0)
median(1 ^ 0, f64)
median(1 ^ 1.0)
median(1 ^ f64)
median(1 ^ i)
median(1 | max(array), i)
median(1 | min(array))
median(1) != 1.0 && ok
median(1) != f64
median(1) ^ $env?.f64
median(1.0 * 0)
median(1.0 * 1)
median(1.0 * 1.0)
median(1.0 * f64)
median(1.0 * f64, array | sortBy(1))
median(1.0 * i)
median(1.0 ** 0)
median(1.0 ** 1.0)
median(1.0 ** f64)
median(1.0 ** i)
median(1.0 + 0)
median(1.0 + 1)
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 - f64)
median(1.0 - i)
median(1.0 / 0)
median(1.0 / 1)
median(1.0 / 1.0)
median(1.0 / f64)
median(1.0 / i)
median(1.0 ?? $env)
median(1.0 ?? 0, 1.0)
median(1.0 ?? 1)
median(1.0 ?? 1.0)
median(1.0 ?? add)
median(1.0 ?? false)
median(1.0 ?? foo)
median(1.0 ?? greet)
median(1.0 ?? nil)
median(1.0 ?? str)
median(1.0 ^ 1)
median(1.0 ^ f64)
median(1.0 ^ i)
median(1.0 | mean(i))
median(1.0) * 0 ?? nil
median(1.0) * 1 + 1
median(1.0) * f64
median(1.0) ** f64
median(1.0) + 1.0 != f64
median(1.0) + i
median(1.0) - f64
median(1.0) / f64
median(1.0) / i
median(1.0) <= f64
median(1.0) <= i
median(1.0) <= i / 0
median(1.0) == $env == false
median(1.0) > 1.0 ? greet : list
median(1.0) >= f64
median(1.0) ?? $env.ok
median(1.0) ?? 1 ?? true
median(1.0) ?? add
median(1.0) ?? foo
median(1.0) ?? greet
median(1.0) ?? str
median(1.0) in array
median(1.0) not in array
median(1.0) | max(f64)
median(1.0) | max(i)
median(1.0, 0) ** f64
median(1.0, 0) ** i
median(1.0, 1.0) | mean(i, 0)
median(1.1)
median([0])
median([1 % i])
median([1, 1.0])
median([1.0])
median([1])
median([1], $env.f64)
median([array])
median([f64])
median([i, 1.0])
median([i])
median(abs(0))
median(abs(1))
median(abs(1.0))
median(abs(f64))
median(abs(i))
median(add(1, 0))
median(array ?? add)
median(array ?? array)
median(array ?? f64)
median(array ?? false)
median(array ?? foo)
median(array ?? nil)
median(array ?? str)
median(array | find(ok))
median(array | findLast(true))
median(array | map(#))
median(array | map(1.0))
median(array | reduce(1.0))
median(array | reduce(i, 1.0))
median(array | reduce(i, foo))
median(array | sortBy(#))
median(array | sortBy(i))
median(array | sum(#))
median(array)
median(array) != add
median(array) != ok
median(array) ** f64
median(array) ** i
median(array) + i
median(array) - 1.0 + i
median(array) / f64
median(array) < 0 >= 1.0
median(array) < i
median(array) >= i
median(array) ?? f64
median(array) ?? not ok
median(array) ?? ok
median(array) ^ f64
median(array) | get(nil)
median(array, $env?.i)
median(array, -0)
median(array, -i)
median(array, 1 ^ 1)
median(array, array)
median(array, array) not endsWith $env?.[Bar]
median(array, f64)
median(array, i % i)
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(bitxor(0, 0))
median(ceil($env.i))
median(ceil(0))
median(ceil(1.0))
median(ceil(f64))
median(ceil(i))
median(concat(array))
median(count($env, false))
median(count(array, ok))
median(count(array[0:0]))
median(count(list, ok))
median(f64 * $env?.f64)
median(f64 * 1.0)
median(f64 * f64)
median(f64 ** $env?.i)
median(f64 ** 0)
median(f64 ** 1)
median(f64 ** 1.0)
median(f64 + 0)
median(f64 + 1.0)
median(f64 + f64)
median(f64 + i)
median(f64 - 0)
median(f64 - 1)
median(f64 - 1.0)
median(f64 - i)
median(f64 / 0)
median(f64 / 1.0)
median(f64 / f64)
median(f64 / i)
median(f64 ?? 1)
median(f64 ?? 1.0)
median(f64 ?? array)
median(f64 ?? date(foo))
median(f64 ?? false)
median(f64 ?? i)
median(f64 ?? str)
median(f64 ^ 0)
median(f64 ^ 1)
median(f64 ^ 1.0)
median(f64 ^ f64)
median(f64 ^ i)
median(f64 | min(1.0))
median(f64)
median(f64) + i
median(f64) < f64
median(f64) == 1.0 and ok
median(f64) > i
median(f64) ?? array
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(f64, min(f64))
median(filter(list, false))
median(find(array, ok))
median(findIndex($env, true))
median(findLastIndex($env, ok))
median(findLastIndex($env, true))
median(findLastIndex(list, 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 * f64)
median(i * i)
median(i ** 0)
median(i ** 1.0)
median(i ** i)
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 ?? $env?.ok)
median(i ?? 0)
median(i ?? 1.0)
median(i ?? foo?.Bar)
median(i ?? i)
median(i ?? ok)
median(i ?? str)
median(i ^ 0)
median(i ^ 1.0)
median(i ^ f64)
median(i ^ i)
median(i | bitnand(i))
median(i | bitshr(1))
median(i | min(f64))
median(i)
median(i) * i
median(i) ?? f64
median(i) ?? list
median(i) ^ i
median(i) in $env?.array
median(i) | mean(array)
median(i) | median(array)
median(i) | min(f64)
median(i, $env.i)
median(i, -i)
median(i, 1.0) < i
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(if false { str } 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(len(list))
median(len(str))
median(let bar = 1.0; let foobar = 0; bar)
median(let bar = 1; bar)
median(let foobar = 0; foobar)
median(let z = 1; z)
median(list | count(ok))
median(list | map(#index))
median(list | map(array))
median(list | reduce(i))
median(list | sum(0))
median(map($env, 0))
median(map($env, 1))
median(map($env, 1.0))
median(map($env, f64))
median(map(array, 1))
median(map(list, 0))
median(map(list, 1.0))
median(max(0))
median(max(1))
median(max(1.0))
median(max(1.0, i))
median(max(array))
median(max(i))
median(max(i), array)
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))
median(median(1, 1.0))
median(median(1.0))
median(median(array))
median(median(f64))
median(median(f64, i))
median(median(i))
median(min(0 * 1))
median(min(0))
median(min(1))
median(min(1.0, array, 1))
median(min(array))
median(min(f64))
median(min(f64, 1.0))
median(min(i))
median(nil ?? 0)
median(nil ?? 1)
median(nil ?? 1.0)
median(nil ?? f64)
median(ok ? 1.0 : greet)
median(reduce(array, #))
median(reduce(array, #index))
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(sortBy(array, 1))
median(sortBy(array, f64))
median(sum($env, 0))
median(sum($env, 1.0))
median(sum($env, f64))
median(sum($env, i))
median(sum(array))
median(sum(array), f64)
median(sum(array), i)
median(sum(array, #))
median(sum(array, 1.0))
median(sum(list, i))
median(true ? 0 : 1.0, f64)
median(true ? 0 : ok)
median(true ? i : foo)
median(uniq(array))
median({foo: 1.0}?.foo)
min($env ?? 0)
min($env ?? 1)?.ok
min($env ?? add)
min($env ?? f64)
min($env ?? false)
min($env ?? foo)
min($env ?? greet)
min($env ?? i)
min($env ?? ok)
min($env ?? true)
min($env | filter(false))
min($env | findIndex(false))
min($env | findIndex(true))
min($env | findLast(false))
min($env | get(str))
min($env | map(0))
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 | sum(i))
min($env) != array
min($env) == greet
min($env) == i
min($env) == ok
min($env) ?? uniq($env)
min($env) matches $env?.foobar
min($env) not contains $env || true
min($env) not in list
min($env) | all(false)
min($env) | any(false)
min($env) | count(ok)
min($env) | map(1)
min($env) | map(add)
min($env) | map(f64)
min($env) | map(false)
min($env) | map(foo)
min($env) | map(ok)
min($env) | reduce(0, 1)
min($env) | reduce(1.0, $env)
min($env) | sum(0)
min($env) | sum(1.0)
min($env).Bar
min($env).Bar?.greet()
min($env).String
min($env).String?.[greet]
min($env).add
min($env).array
min($env).f64
min($env).false?.add
min($env).false?.f64
min($env).foo
min($env).foobar
min($env).foobar?.i(foobar, foobar)
min($env).foobar?.ok
min($env).greet
min($env).i
min($env).i && false
min($env).list
min($env).nil?.foobar
min($env).ok
min($env).str
min($env)?.$env?.Bar()
min($env)?.Bar
min($env)?.Bar?.foobar.foo().list
min($env)?.String
min($env)?.String?.foo
min($env)?.[str]
min($env)?.[str] not startsWith str
min($env)?.add
min($env)?.array
min($env)?.f64
min($env)?.foo
min($env)?.foobar
min($env)?.foobar?.String()
min($env)?.foobar?.foo.i
min($env)?.foobar?.list
min($env)?.foobar?.str
min($env)?.greet
min($env)?.greet(foobar)
min($env)?.i
min($env)?.list
min($env)?.not
min($env)?.ok
min($env)?.str
min($env)?.true?.f64(foobar)
min($env.array)
min($env.array, sum(array))
min($env.f64)
min($env.i)
min($env.i, i)
min($env?.$env)
min($env?.Bar)
min($env?.Bar?.array())
min($env?.Bar?.foo)
min($env?.Bar?.greet())
min($env?.String)
min($env?.String)?.[i]
min($env?.String?.list)
min($env?.[Bar])
min($env?.[Bar])?.add()
min($env?.[Bar]?.Bar)
min($env?.[Bar]?.[greet])
min($env?.[Bar]?.i())
min($env?.[String])
min($env?.[String])?.f64
min($env?.[foobar])
min($env?.[foobar])?.[str]
min($env?.[nil])
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)
min(-1)
min(-1.0 ** 1)
min(-1.0 + i)
min(-1.0)
min(-f64)
min(-i)
min(0 % 1)
min(0 % i)
min(0 * 0)
min(0 * 1)
min(0 * 1.0)
min(0 * f64)
min(0 * i)
min(0 ** 0)
min(0 ** 1.0)
min(0 ** i)
min(0 + 1)
min(0 + 1.0)
min(0 + f64)
min(0 - 1)
min(0 - 1.0)
min(0 - f64)
min(0 - i)
min(0 .. 0)
min(0 .. 1)
min(0 .. i)
min(0 / 0)
min(0 / 1)
min(0 ?? 1.0)
min(0 ?? false)
min(0 ?? foo)
min(0 ?? true)
min(0 ^ 0)
min(0 ^ 1)
min(0 | bitshl(1))
min(0 | median(1))
min(0) != $env?.i
min(0) * 0 < f64
min(0) * f64
min(0) ** f64
min(0) + i
min(0) - ceil(i)
min(0) / f64
min(0) ^ f64
min(0) in array
min(0) | max(0)
min(0, array) != str
min(0.0)
min(1 % 1)
min(1 * 1)
min(1 * 1.0)
min(1 ** 0)
min(1 ** 1)
min(1 ** 1.0)
min(1 ** f64)
min(1 ** i)
min(1 + 0)
min(1 + 1.0)
min(1 - 1)
min(1 - f64)
min(1 .. i)
min(1 / 0)
min(1 / 1)
min(1 / 1.0)
min(1 / i)
min(1 ?? 0)
min(1 ?? 1.0)
min(1 ?? add)
min(1 ?? foo)
min(1 ?? greet)
min(1 ?? nil)
min(1 ?? ok)
min(1 ^ 0)
min(1 ^ 1.0)
min(1 ^ i)
min(1 | min(1.0))
min(1) % i
min(1) + f64
min(1) - i
min(1) < f64
min(1) < i
min(1) <= i
min(1) ?? i
min(1) not in array
min(1) | median(array)
min(1, 1) - i
min(1, 1.0) in array
min(1, array) | get(ok)
min(1..i)
min(1.0 * 0)
min(1.0 * 1)
min(1.0 * 1.0)
min(1.0 * f64)
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 + 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 ?? $env?.[greet])
min(1.0 ?? 0)
min(1.0 ?? 1)
min(1.0 ?? add)
min(1.0 ?? array)
min(1.0 ?? f64)
min(1.0 ?? foo)
min(1.0 ?? list)
min(1.0 ?? nil)
min(1.0 ?? ok)
min(1.0 ?? ok, array)
min(1.0 ?? str)
min(1.0 ?? true)
min(1.0 ^ 0)
min(1.0 ^ 1)
min(1.0 ^ 1.0)
min(1.0 ^ f64)
min(1.0 ^ i)
min(1.0 | max(0))
min(1.0 | max(1))
min(1.0 | max(array))
min(1.0 | mean(1.0))
min(1.0 | min(1.0))
min(1.0) * bitand(i, i)
min(1.0) * f64
min(1.0) ** f64
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) ?? add
min(1.0) ?? f64
min(1.0) ?? greet
min(1.0) ?? list
min(1.0) ?? str
min(1.0) ^ i
min(1.0) not in array
min(1.0) | max(array, 1.0)
min(1.0) | median(array)
min(1.0, 0) + i
min(1.0, 0) ?? ok
min(1.0, 1) - f64
min(1.0, 1.0) ** f64 ?? true
min(1.0, 1.0) + i
min(1.0, 1.0) - 0 < 1.0
min(1.0, 1.0) ^ f64
min(1.1)
min([$env] | reduce(.f64))
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(abs(i))
min(add ?? 1.0)
min(add ?? array)
min(add ?? f64)
min(add ?? foo)
min(add(0, 0))
min(add(1, 1))
min(array ?? $env?.[greet(f64)])
min(array ?? 0)
min(array ?? nil)
min(array | count(true))
min(array | filter(true))
min(array | find(ok))
min(array | findIndex(false))
min(array | findIndex(ok))
min(array | map(#))
min(array | map(i))
min(array | max(1.0, 0))
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 | sum(f64))
min(array)
min(array) + f64
min(array) - i
min(array) .. i
min(array) / i
min(array) < 1.0 - i
min(array) == i
min(array) ?? f64
min(array) ?? ok
min(array) | bitushr(0)
min(array) | get(0)
min(array) | get(str)
min(array) | median(0)
min(array, 1 - 0)
min(array, 1.0 ?? 0)
min(array, array)
min(array, array, 1) == f64
min(array, ceil(0))
min(array, f64 * i)
min(array, f64)
min(array, float(1.0))
min(array, i ?? 1.0)
min(array, i)
min(array, int(0))
min(array, sortBy(array, #))
min(array?.[0])
min(array?.[1])
min(array?.[i])
min(array[0:])
min(array[:0])?.[greet]
min(array[min(1):])
min(bitnot(0))
min(bitnot(1))
min(bitnot(i))
min(ceil(0))
min(ceil(1))
min(ceil(1.0))
min(ceil(f64))
min(ceil(i))
min(ceil(sum(array)), i)
min(count($env, false))
min(count($env, ok))
min(count([true]))
min(count(array, false))
min(f64 * 0)
min(f64 * 1)
min(f64 * f64)
min(f64 * i)
min(f64 ** 1)
min(f64 ** 1.0)
min(f64 ** f64)
min(f64 ** i)
min(f64 + 0)
min(f64 + 1.0)
min(f64 + f64)
min(f64 - 0)
min(f64 - 1.0)
min(f64 - i)
min(f64 / 0)
min(f64 / 1)
min(f64 / 1.0)
min(f64 ?? $env)
min(f64 ?? 1)
min(f64 ?? 1.0)
min(f64 ?? add, i)
min(f64 ?? array)
min(f64 ?? false)
min(f64 ?? foo)
min(f64 ?? ok)
min(f64 ?? true)
min(f64 ^ 0)
min(f64 ^ 1)
min(f64 ^ 1.0)
min(f64 ^ f64)
min(f64 ^ i)
min(f64 | min(0))
min(f64)
min(f64) * i
min(f64) / f64
min(f64) < i
min(f64) <= $env.i
min(f64) >= i
min(f64) ?? greet
min(f64) not in array
min(f64) | median(1.0)
min(f64, $env.array)
min(f64, $env.f64)
min(f64, -1)
min(f64, 0) == f64
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 ? 1 : 1.0)
min(false ? array : nil)
min(false ? foo : $env).i
min(false ? greet : foo)
min(false ?: 0)
min(false ?? 1.0)
min(false ?? add)
min(false ?? array)
min(false ?? list)
min(findIndex($env, false))
min(findIndex($env, true))
min(findIndex(array, true))
min(findIndex(list, false))
min(findLast(array, false))
min(findLast(array, true))
min(findLastIndex($env, false))
min(findLastIndex($env, true))
min(first($env))
min(first(array))
min(first(str ?? add))
min(flatten(array))
min(flatten(array), f64)
min(float(0))
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(foo ?? $env)
min(foo ?? 0)
min(foo ?? 1)
min(foo ?? add)
min(foo ?? f64)
min(foo ?? false)
min(foo ?? greet)
min(foo ?? list)
min(foo ?? ok)
min(foo ?? str)
min(foo ?? true)
min(greet ?? 1.0)
min(greet ?? add)
min(greet ?? f64)
min(greet ?? foo)
min(groupBy(array, #)?.array)
min(i % 1)
min(i % i)
min(i * 0)
min(i * f64)
min(i * i)
min(i + 1.0)
min(i + f64)
min(i + i)
min(i - 0)
min(i - 1.0)
min(i - f64)
min(i - i)
min(i .. 0)
min(i / 1.0)
min(i ?? $env)
min(i ?? f64)
min(i ?? false)
min(i ?? foo)
min(i ?? ok)
min(i ?? str)
min(i ?? true)
min(i ^ 1.0)
min(i ^ i)
min(i | bitor(0))
min(i | bitshr(1))
min(i | min(0))
min(i)
min(i) != $env?.i
min(i) != f64
min(i) % i
min(i) < f64
min(i) < i
min(i) <= f64
min(i) == f64
min(i) ?? [0]
min(i) ?? foo
min(i) ?? foo.Bar
min(i) ?? foo?.Bar
min(i, $env.i)
min(i, 1 ?? 0)
min(i, [1])
min(i, array)
min(i, array) .. i
min(i, array) ^ i <= 1.0
min(i, f64 ** 1)
min(i, f64 / 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(f64))
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 | map(1))
min(list | map(1.0))
min(list | map(i))
min(list | reduce($env))
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, 1.0))
min(map($env, array))
min(map(array, #))
min(map(array, #index))
min(map(array, 1.0))
min(map(list, #index))
min(map(list, f64))
min(max($env))
min(max(0))
min(max(0, 1))
min(max(0, 1.0, 0))
min(max(0, i))
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(1.0, 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(median(i))
min(min($env))
min(min(0))
min(min(1))
min(min(1.0))
min(min(1.0, 1))
min(min(f64))
min(min(f64, 1.0))
min(min(f64, 1.0, 1.0))
min(min(i))
min(nil ?? $env)
min(nil ?? f64)
min(nil ?? i)
min(ok ? array : true)
min(ok ?: 1.0)
min(ok ?? 1)
min(ok ?? i)
min(ok ?? toJSON(list))
min(reduce(array, #))
min(reduce(array, $env))?.str
min(reduce(array, 1.0))
min(reduce(array, i))
min(reduce(list, 1.0))
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(round(i))
min(sort($env))
min(sort(array))
min(sortBy(array, #))
min(sortBy(array, 1))
min(sortBy(array, f64))
min(sortBy(array, str), i)
min(sortBy(array, toJSON(foo)))
min(str ?? $env)
min(str ?? 1.0)
min(str ?? false)
min(str ?? foo)
min(str ?? i)
min(str ?? list)
min(sum($env, 1))
min(sum($env, 1.0))
min(sum($env?.array))
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 ? 0 : foo)
min(true ? 1.0 : str)
min(true ? nil : $env)
min(true ? nil : i)
min(true ?: add)
min(true ?: foo)
min(true ?? 1)
min(true ?? foo)
min(true ?? list)
min(true ?? str)
min(uniq(array))
min({foo: 0}.foo)
min({foo: 1.0}.array)
min({foo: add}.i)
min({foo: i}?.i)
min({foo: nil}?.i)
min({foo: str}?.list)
min({foo: sum(array)}.array)
nil != $env ?? add
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?.Bar?.[i]
nil != $env?.Bar?.list()
nil != $env?.Bar?.str()
nil != $env?.String
nil != $env?.String?.[i]
nil != $env?.[1.0 | first(nil)]
nil != $env?.[Bar]
nil != $env?.[Bar]?.Bar
nil != $env?.[String]
nil != $env?.[String]?.foo
nil != $env?.[foobar]
nil != $env?.[greet(foobar)]
nil != $env?.[str]
nil != $env?.add
nil != $env?.array
nil != $env?.array && true
nil != $env?.f64
nil != $env?.false?.[str]
nil != $env?.foo
nil != $env?.foobar
nil != $env?.foobar?.greet(1.0)
nil != $env?.greet
nil != $env?.i
nil != $env?.list
nil != $env?.ok
nil != $env?.str
nil != 0 && ok
nil != 0 ** i
nil != 0 - i
nil != 0 / f64
nil != 0 ?: array
nil != 0 ^ $env?.i
nil != 1 % i
nil != 1 + f64
nil != 1 + i
nil != 1 ?? foo
nil != 1 ^ i
nil != 1.0 && ok
nil != 1.0 + f64
nil != 1.0 - f64
nil != 1.0 ?: reduce($env, #.String, true)
nil != 1.0 ?? ok
nil != 1.0 ^ f64
nil != 1.0 and ok
nil != 1.0 or 1.0 == 1
nil != add ?? ok
nil != add and ok
nil != array ?: i ^ 1.0
nil != array ?? i
nil != array?.[i]
nil != f64 + i
nil != f64 - f64 == nil
nil != f64 / f64 && ok
nil != f64 ?? -1
nil != f64 ?? foo
nil != f64 not in $env?.String
nil != f64 or i == i
nil != false == ok
nil != false ?? add
nil != false ?? foo
nil != false || $env > $env
nil != foo == ok
nil != foo ?: greet
nil != foo ?: list
nil != foo ?? foo
nil != foo or $env?.[add]
nil != foo || 1 == $env?.[ok]
nil != foo || i == f64
nil != foo.Bar
nil != foo.String
nil != foo.String()
nil != foo?.Bar
nil != foo?.String
nil != foo?.String()
nil != greet && false != nil
nil != greet == ok
nil != greet ?: i
nil != greet ?? add
nil != i && f64 < 1.0
nil != i + i
nil != i .. $env?.i
nil != i ?? greet
nil != list or one($env, #.f64)
nil != list?.[-i]
nil != list?.[i]
nil != list?.[i]?.Bar
nil != list?.[i]?.String
nil != list[:]
nil != nil && $env?.[array]
nil != nil && ok
nil != nil ?? array
nil != nil ?? i
nil != nil ?? str
nil != ok || abs($env)
nil != str && get($env, nil)
nil != str ?? foo
nil != str or $env * i
nil != str[:]
nil != true ?? i
nil != true || $env == 1.0
nil == $env ?? add
nil == $env ?? array
nil == $env ?? ok
nil == $env ?? str == false
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?.String?.ok
nil == $env?.[Bar]
nil == $env?.[String]
nil == $env?.[foo.Bar]
nil == $env?.[foobar?.[i]]
nil == $env?.[foobar?.array]
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?.foobar?.i
nil == $env?.greet
nil == $env?.i
nil == $env?.list
nil == $env?.nil?.[foo]
nil == $env?.ok
nil == $env?.str
nil == 0 != foo ?? greet
nil == 0 ** 1.0 ? nil : nil
nil == 0 ?? $env?.add
nil == 0 || ok
nil == 1 * i
nil == 1 + f64
nil == 1 / i
nil == 1 and find($env, #.add)?.[i]
nil == 1 || 0 > i
nil == 1..i
nil == 1.0 ** f64
nil == 1.0 + f64
nil == 1.0 ?: i
nil == 1.0 ?: str
nil == 1.0 ?? string(nil)
nil == 1.0 ^ f64
nil == 1.0 and ok
nil == add ?: i
nil == add and ok
nil == add or foo ?? f64
nil == array ?? add
nil == array?.[i]
nil == f64 * f64
nil == f64 + f64
nil == f64 - f64
nil == f64 ?: ok
nil == f64 ?? greet
nil == false && list != $env
nil == false ?? array
nil == foo != foo ?? greet
nil == foo != ok
nil == foo ?: i
nil == foo ?? 1.0 ?? true
nil == foo ?? add
nil == foo ?? greet($env)
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 ?? map($env, #.f64)
nil == greet and $env?.[list]
nil == greet or ok
nil == i != ok
nil == i + i
nil == i and ok
nil == i in $env?.[String]
nil == list ?? list
nil == list?.[i]
nil == list[:]
nil == nil != $env?.[String]
nil == nil != nil || false
nil == nil and ok
nil == ok != ok
nil == str != false || true
nil == str ?? add
nil == true ?? ok
nil ?? $env ?? $env?.[array][foobar:]
nil ?? $env ?? str
nil ?? $env | findLastIndex(true)
nil ?? $env | map(0)
nil ?? $env | map(1)
nil ?? $env | map(1.0)
nil ?? $env | map(add)
nil ?? $env | map(list)
nil ?? $env | one(ok)
nil ?? $env | sum(f64)
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?.[Bar]
nil ?? $env?.[String]
nil ?? $env?.[foobar]
nil ?? $env?.[str]
nil ?? $env?.add
nil ?? $env?.array
nil ?? $env?.f64
nil ?? $env?.foo
nil ?? $env?.foobar
nil ?? $env?.foobar?.i
nil ?? $env?.greet
nil ?? $env?.i
nil ?? $env?.list
nil ?? $env?.ok
nil ?? $env?.str
nil ?? 0 | min(1.0)
nil ?? 1 ?? array
nil ?? 1.0 ?? trimSuffix(str)
nil ?? array ?? str
nil ?? array | groupBy(1.0)
nil ?? array | map(#)
nil ?? array | map(true)
nil ?? array | one(ok)
nil ?? array | reduce(#, false)
nil ?? array | reduce(greet, $env)
nil ?? array | reduce(list)
nil ?? array | sortBy(1.0)
nil ?? array | sum(i)
nil ?? array?.[i]
nil ?? f64 ?? i
nil ?? foo ?? $env.list
nil ?? foo.Bar
nil ?? foo.String
nil ?? foo.String()
nil ?? foo?.Bar
nil ?? foo?.String
nil ?? foo?.String()
nil ?? greet ?? add
nil ?? i | median(f64)
nil ?? list ?? add
nil ?? list ?? {foo: foo}
nil ?? list | groupBy(#)
nil ?? list | groupBy(ok)
nil ?? list | groupBy(true)
nil ?? list | map(f64)
nil ?? list | map(str)
nil ?? list | reduce(#acc)
nil ?? list | reduce(1.0, $env)
nil ?? list | sortBy(.Bar)
nil ?? list | sum(0)
nil ?? list?.[i]
nil ?? nil ?? foo
nil ?? ok ?? ok
nil ?? str ?? str
nil ?? str | repeat(0)
nil in $env != ok
nil in $env ?? str
nil in $env or ok
nil in $env.array
nil in $env.list
nil in $env?.Bar
nil in $env?.Bar?.[greet]
nil in $env?.String
nil in $env?.[Bar]
nil in $env?.[Bar]?.[array]
nil in $env?.[String]
nil in $env?.[String]?.list
nil in $env?.[foobar?.f64]
nil in $env?.[foobar]
nil in $env?.array
nil in $env?.foobar?.i(false)
nil in $env?.list
nil in array ?? greet
nil in array ?? toJSON(str)
nil in list && ok
nil in list and $env == foo
nil in list and ok
nil in list or ok
nil not in $env ?: str
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 != ok
nil not in array ?: i
nil not in list[i:]
nil; $env.greet
nil; $env.ok
nil; array | reduce(1.0, 1.0)
none($env | map($env), .f64 != foo)
none($env, false) != ok
none($env, false) && ok == true
none($env.array, # == 1.0)
none($env.array, str not in $env)
none($env.list, 1.0 <= 1.0)
none($env?.[str], 1 > f64)
none($env?.[str], ok)
none($env?.list, f64 == $env)
none($env?.list, ok)
none(1 .. 0, $env < $env)
none(1 .. 0, $env | all(ok))
none(1 .. i, !false)
none([$env, foo], false != #)
none([$env], .f64 in #.String)
none([1.0], ok)
none([array, false], true and ok)
none([f64, nil], ok)
none([false], #)
none([greet, 1.0], ok)
none([nil, foo], ok)
none(array | map(0), ok)
none(array, !true)
none(array, # != #)
none(array, # != 0)
none(array, # != nil)
none(array, # < #)
none(array, # < 1)
none(array, # <= #)
none(array, # == 0)
none(array, # == nil)
none(array, # > #)
none(array, # >= #)
none(array, # >= f64)
none(array, # >= i)
none(array, $env == foo)
none(array, $env || true)
none(array, $env.ok)
none(array, 0 <= 0)
none(array, 1 == #)
none(array, 1.0 != 1.0)
none(array, 1.0 < #)
none(array, 1.0 <= #)
none(array, 1.0 == $env)
none(array, add == add)
none(array, f64 == #)
none(array, false ?? add)
none(array, foo != nil)
none(array, i != #)
none(array, i != nil)
none(array, i < #)
none(array, i >= #)
none(array, nil != 1)
none(array, nil == add)
none(array, nil == false)
none(array, nil == i)
none(array, not false)
none(array, ok && false)
none(array, ok ?? i)
none(array, ok)
none(concat(array), f64 >= #)
none(flatten(array), ok)
none(if true { list } else { greet }, list != list)
none(list ?? ok, 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, $env?.ok)
none(list, .Bar not in #)
none(list, .Bar startsWith str)
none(list, 1 == f64)
none(list, 1.0 > 1.0)
none(list, array == $env)
none(list, f64 != $env)
none(list, f64 == 1.0)
none(list, false != true)
none(list, false ?? #)
none(list, false and false)
none(list, foo != #)
none(list, foo != foo)
none(list, foo == #)
none(list, foo == foo)
none(list, i == 1)
none(list, nil == list)
none(list, not true)
none(list, ok == $env)
none(list, ok)
none(list, ok) || ok
none(list, str < .Bar)
none(list, true == $env)
none(list, true || true) ?? i
none(list, true) != ok
none(map($env, 1.0), ok)
none(map(list, $env), ok)
none(reverse(array), not false)
none(sort($env), #.add?.greet(foo))
none(sort($env), #.f64 != 1.0)
none(sort($env), #.ok not in #)
none(sort($env), not #.f64)
none(sort($env), sortBy(.Bar, #.greet))
none(str ?? $env, ok)
none(str ?? ok, f64 >= #)
none(toPairs($env), # in #)
not !$env.ok
not !false
not !ok
not !true
not !true or true
not $env && false
not $env and false
not $env or true
not $env || true
not $env.ok
not $env?.ok
not all($env, false)
not all($env, ok)
not all($env, true)
not all(array, false)
not all(array, true)
not all(list, ok)
not all(list, true)
not any($env, false)
not any($env, ok)
not any($env, true)
not any(array, ok)
not any(array, true)
not any(list, ok)
not false != $env
not false != false
not false != nil
not false != ok
not false != true
not false && $env
not false && false
not false && ok
not false && true
not false == $env
not false == false
not false == nil
not false == true
not false ? 0 / 1 : ok
not false ? 1.0 : foo
not false ? add : foo
not false ? foo : foo
not false ? greet : nil
not false ? list : 1.0
not false ? nil : 1.0
not false ? ok : i
not false ? ok : nil
not false ?: 1.0
not false ?: add
not false ?: nil
not false ?: ok
not false ?? $env
not false ?? 0
not false ?? 1
not false ?? 1.0
not false ?? add
not false ?? array
not false ?? f64
not false ?? false
not false ?? findLastIndex($env, #.foo)
not false ?? foo
not false ?? greet
not false ?? i
not false ?? list
not false ?? nil
not false ?? not $env
not false ?? ok
not false ?? one(list, ok)
not false ?? str
not false ?? true
not false and $env
not false and false
not false and ok
not false not in $env or true
not false not in $env?.Bar
not false or $env
not false or false
not false or false != $env
not false or not true
not false or ok
not false or true
not false || $env
not false || false
not false || last($env)
not false || ok
not false || true
not max($env).ok
not nil ?? false
not nil ?? ok
not nil ?? true
not none($env, false)
not none($env, ok)
not none($env, true)
not none(array, false)
not none(array, ok)
not none(array, true)
not none(list, false)
not none(list, ok)
not not !false
not not $env.ok
not not $env?.ok
not not false
not not not false
not not ok
not not ok != false
not not true
not not true and ok
not ok
not ok != $env
not ok != 1.0 ?? i
not ok != false
not ok != nil
not ok != ok
not ok != true
not ok && $env
not ok && $env?.[list]
not ok && 1.0 ?? split($env, str)
not ok && false
not ok && ok
not ok && true
not ok == $env
not ok == false
not ok == false != $env
not ok == foo ?? $env
not ok == nil
not ok == ok
not ok == true
not ok ? $env : str
not ok ? 1 : $env
not ok ? 1.0 : 1.0
not ok ? 1.0 : add
not ok ? 1.0 : foo
not ok ? 1.0 : ok
not ok ? f64 : 1.0
not ok ? f64 : foo
not ok ? foo : nil
not ok ? i : 1.0
not ok ? list : 1
not ok ? nil : 0
not ok ? nil : array
not ok ? nil : foo
not ok ? ok : $env
not ok ? ok : $env?.add
not ok ? ok : foo
not ok ? true : $env
not ok ? true : 0
not ok ?: $env
not ok ?: 1.0
not ok ?: array
not ok ?: foo
not ok ?: list
not ok ?? $env.f64
not ok ?? $env?.[foo]
not ok ?? 0
not ok ?? 0 == $env
not ok ?? 1
not ok ?? 1.0
not ok ?? [$env, list]
not ok ?? add
not ok ?? array
not ok ?? f64
not ok ?? f64 ?: greet
not ok ?? false
not ok ?? foo
not ok ?? foo.String
not ok ?? greet
not ok ?? i
not ok ?? list
not ok ?? nil
not ok ?? nil || ok
not ok ?? ok
not ok ?? str
not ok ?? true
not ok and $env
not ok and false
not ok and foo in list
not ok and ok
not ok and true
not ok not in $env?.[String]
not ok or $env
not ok or $env?.[str]
not ok or false
not ok or ok
not ok or true
not ok || $env
not ok || false
not ok || ok
not ok || true
not ok; nil
not one($env, false)
not one($env, ok)
not one($env, true)
not one(array, false)
not one(array, true)
not one(list, false)
not one(list, ok)
not one(list, true)
not reduce(array, false)
not reduce(array, ok)
not reduce(array, true)
not reduce(list, true)
not true != $env
not true != false
not true != nil
not true != nil or $env
not true != ok
not true != true
not true && $env
not true && $env == $env
not true && 0 * $env
not true && false
not true && not true
not true && ok
not true && true
not true == $env
not true == false
not true == nil
not true == ok
not true == true
not true ? 0 : foo
not true ? 1.0 : $env
not true ? 1.0 : nil
not true ? f64 : 1
not true ? greet : list
not true ? str : array
not true ?: $env
not true ?: 0
not true ?: 1
not true ?: 1.0
not true ?: add
not true ?: greet
not true ?: nil
not true ?: ok
not true ?? $env
not true ?? $env.add
not true ?? $env.list
not true ?? $env?.[Bar]
not true ?? $env?.ok
not true ?? $env[:$env | now(greet)]
not true ?? $env[:foobar].i
not true ?? 0
not true ?? 1
not true ?? 1.0
not true ?? add
not true ?? array
not true ?? f64
not true ?? false
not true ?? floor($env)
not true ?? foo
not true ?? greet
not true ?? i
not true ?? list
not true ?? nil
not true ?? ok
not true ?? str
not true ?? str && true
not true ?? true
not true and $env
not true and false
not true and ok
not true and true
not true in $env?.[foobar]
not true or $env
not true or $env?.String
not true or $env?.[Bar]
not true or false
not true or ok
not true or true
not true || $env
not true || $env?.String
not true || $env?.[String]
not true || false
not true || ok
not true || true
ok
ok != !false
ok != !ok
ok != !true
ok != $env != $env
ok != $env != ok
ok != $env && $env
ok != $env == ok
ok != $env ?? foo
ok != $env ?? ok
ok != $env and $env
ok != $env or nil not in $env
ok != $env.ok
ok != $env?.Bar
ok != $env?.String
ok != $env?.String?.[i]
ok != $env?.[Bar]
ok != $env?.[String]
ok != $env?.[foobar]
ok != $env?.[nil]
ok != $env?.[str]
ok != $env?.foobar
ok != $env?.foobar?.greet
ok != $env?.ok
ok != any($env, ok)
ok != any(array, false)
ok != array ?? f64
ok != false && $env
ok != false ? 1.0 : foo
ok != false ? list : 0
ok != false ?? findLastIndex($env, #)
ok != false or false
ok != false or true
ok != false; false
ok != greet ?? foo
ok != i ?? sum($env, #)
ok != nil && ok
ok != nil == ok
ok != nil == ok and ok
ok != nil ? f64 : 1
ok != nil ?? false
ok != nil ?? true
ok != nil and $env
ok != nil and 1 <= 1
ok != nil or false
ok != not false
ok != not true
ok != ok
ok != ok != nil
ok != ok == nil
ok != ok ? str : str
ok != reduce(list, ok)
ok != str ?? f64
ok != str ?? i
ok != sum($env?.[str])
ok != true != nil
ok != true != true
ok != true && $env
ok != true && ok
ok != true == $env
ok != true ? 1.0 : $env
ok != true ?? foo
ok != true and $env?.Bar
ok && !true
ok && $env != $env
ok && $env != array
ok && $env != nil
ok && $env != str
ok && $env == foo
ok && $env == greet
ok && $env ?? greet
ok && $env ?? ok
ok && $env not in $env?.array
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]?.[array]
ok && $env?.[Bar]?.add
ok && $env?.[String]
ok && $env?.[String]?.foo
ok && $env?.[foobar?.Bar]
ok && $env?.[foobar]
ok && $env?.[str]
ok && $env?.foobar
ok && $env?.ok
ok && 0 < 0
ok && 0 < 1
ok && 0 == 0
ok && 0 >= f64
ok && 0 ?? add
ok && 1 != i
ok && 1 <= 1.0
ok && 1 == 1
ok && 1 == f64
ok && 1 ?? foo
ok && 1.0 != $env
ok && 1.0 != 1.0
ok && 1.0 != f64
ok && 1.0 < f64
ok && 1.0 == f64
ok && 1.0 > 1
ok && 1.0 >= f64
ok && 1.0 ?? 0
ok && 1.0 ?? foo
ok && 1.0 ?? list
ok && add != $env
ok && add != $env?.String
ok && add == nil
ok && add ?? list
ok && add ?? true
ok && all(list, false)
ok && array == array
ok && array ?? !$env
ok && array ?? f64
ok && array ?? false
ok && array ?? greet
ok && f64 != nil
ok && f64 > 1 or $env
ok && f64 > 1.0
ok && foo != foo
ok && foo != nil
ok && foo == $env
ok && foo ?? $env
ok && foo ?? i
ok && foo ?? ok
ok && greet == nil
ok && i < 1
ok && i <= f64
ok && i == i
ok && i >= 1
ok && i not in array
ok && list == $env
ok && list ?? greet
ok && max($env)
ok && max(array)
ok && mean(array)
ok && median(array)
ok && min(array)
ok && nil != $env
ok && nil != add
ok && nil == i
ok && nil == nil
ok && nil == true
ok && nil ?? $env
ok && nil in array
ok && not $env?.ok
ok && not true
ok && ok
ok && ok && $env?.[str]
ok && ok == $env
ok && ok == ok
ok && ok == true
ok && ok ?? 1.0
ok && ok and $env
ok && ok or false
ok && ok || false
ok && one(list, false)
ok && str == nil
ok && str endsWith str
ok && str not in $env
ok && str not startsWith str
ok && str startsWith str
ok && true != ok
ok && true ?? 0
ok && true ?? foo
ok && true ?? max(i, 1.0)
ok && true ?? true
ok && true or false
ok && true || $env?.String
ok == !true
ok == $env && $env
ok == $env && ok
ok == $env ? nil : foo
ok == $env ?? 0
ok == $env ?? 1
ok == $env ?? 1.0 == false
ok == $env ?? ok
ok == $env and ok
ok == $env and true
ok == $env || false
ok == $env || ok
ok == $env.ok
ok == $env?.Bar
ok == $env?.Bar?.[str]
ok == $env?.String
ok == $env?.String?.[greet]
ok == $env?.[Bar]
ok == $env?.[Bar]?.[array]
ok == $env?.[String]
ok == $env?.[foobar]
ok == $env?.[str]
ok == $env?.false
ok == $env?.foobar
ok == $env?.nil
ok == $env?.ok
ok == 1.0 ?? $env
ok == 1.0 ?? array
ok == any($env, false)
ok == array ?? $env
ok == array ?? 0
ok == f64 ?? array
ok == f64 ?? i
ok == false != nil
ok == first($env)
ok == foo ?? i
ok == foo ?? ok
ok == i ?? f64
ok == i ?? min($env)
ok == list ?? greet
ok == list ?? ok
ok == max(array)
ok == mean(array)
ok == min($env)
ok == nil != false
ok == nil != ok
ok == nil != true
ok == nil == nil
ok == nil ? 1.0 : $env
ok == not false
ok == not ok
ok == not true
ok == ok
ok == ok != $env
ok == ok ? nil : $env
ok == ok || true
ok == str ?? true
ok == true != ok
ok == true && $env
ok == true == $env
ok == true ?? false
ok == true and ok
ok == true in find($env, false)
ok ? $env : $env * $env | map(i)
ok ? $env : $env >= 1.0 | date(ok, true)
ok ? $env : $env | find(.f64)
ok ? $env : $env | map(1.0)
ok ? $env : $env?.Bar
ok ? $env : $env?.String()
ok ? $env : $env?.[Bar]
ok ? $env : $env?.[String]
ok ? $env : $env?.[add]
ok ? $env : $env?.[str]
ok ? $env : $env?.array
ok ? $env : $env?.ok
ok ? $env : 0 not in array
ok ? $env : foo.Bar
ok ? $env : foo?.Bar
ok ? $env?.String : str
ok ? $env?.[String] : add
ok ? 0 : $env.list
ok ? 0 : $env?.f64
ok ? 0 : $env?.foo
ok ? 0 : $env?.ok
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.add
ok ? 1.0 : $env.array
ok ? 1.0 : $env.list
ok ? 1.0 : $env?.Bar
ok ? 1.0 : $env?.[array]
ok ? 1.0 : $env?.array
ok ? 1.0 : $env?.greet
ok ? 1.0 : $env?.i
ok ? 1.0 : $env?.list
ok ? 1.0 : 1.0 * f64
ok ? 1.0 : f64 ?? 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?.Bar()
ok ? add : $env?.[String]
ok ? add : $env?.[greet]
ok ? add : $env?.ok
ok ? add : add
ok ? add : array | reduce(1.0)
ok ? add : f64
ok ? add : foo.Bar
ok ? add : foo?.String
ok ? add : greet
ok ? add : i
ok ? add : list | find($env?.Bar)
ok ? add : list | reduce(#)
ok ? add : nil in -$env
ok ? add : nil in array
ok ? add : str
ok ? array : $env | sum(#)
ok ? array : $env?.add
ok ? array : add
ok ? array : foo
ok ? array : list | min(i)
ok ? array : ok
ok ? array : sum(array)
ok ? f64 - 0 : $env not contains $env
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 : foo?.String()
ok ? f64 : keys($env)
ok ? f64 : list ?? str
ok ? f64 : str
ok ? f64 : uniq($env)
ok ? false : $env.foo
ok ? false : $env?.[Bar]
ok ? false : $env?.[add]
ok ? false : $env?.[i]
ok ? false : $env?.list
ok ? false : foo.Bar
ok ? false : list?.[i]
ok ? foo : $env endsWith str
ok ? foo : $env not endsWith $env?.true
ok ? foo : $env | groupBy(.list)
ok ? foo : $env | groupBy(i)
ok ? foo : $env | sum(#.foo)
ok ? foo : $env.add
ok ? foo : $env.greet
ok ? foo : $env.i
ok ? foo : $env?.Bar()
ok ? foo : $env?.String
ok ? foo : $env?.[f64]
ok ? foo : $env?.[find(foobar, .f64)]
ok ? foo : $env?.[foo]
ok ? foo : $env?.add
ok ? foo : $env?.array
ok ? foo : $env?.foobar?.String()
ok ? foo : $env?.greet
ok ? foo : add
ok ? foo : array
ok ? foo : array | reduce(false)
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 ? foo.String : str
ok ? greet : $env.str
ok ? greet : $env?.f64
ok ? greet : array
ok ? greet : f64
ok ? greet : foo
ok ? greet : foo?.String()
ok ? greet : groupBy($env, greet)?.[i]
ok ? greet : i
ok ? greet : list | mean(nil)
ok ? greet : sortBy($env, 1)
ok ? greet : str
ok ? greet : string($env)
ok ? greet : {foo: true}
ok ? i : $env?.[greet]
ok ? i : $env?.i
ok ? i : foo
ok ? i : foo.Bar
ok ? i : list
ok ? i : list?.[i]
ok ? i : str
ok ? list : $env.i
ok ? list : $env[fromBase64(foo, foo):]
ok ? list : add
ok ? list : f64
ok ? list : foo
ok ? list : foo.String
ok ? list : i
ok ? list : nil ?? list
ok ? list : ok
ok ? list : str
ok ? nil != $env : str
ok ? nil : $env not matches $env?.[i]
ok ? nil : $env | mean($env)
ok ? nil : $env.foo
ok ? nil : $env.ok
ok ? nil : $env?.String
ok ? nil : $env?.[String]
ok ? nil : $env?.[f64]
ok ? nil : $env?.[greet]
ok ? nil : $env?.[list]
ok ? nil : $env?.[ok]
ok ? nil : $env?.greet
ok ? nil : $env?.i
ok ? nil : $env?.ok
ok ? nil : $env?.str
ok ? nil : foo.Bar
ok ? nil : foo.String
ok ? ok != $env : 1 < 1.0
ok ? ok : $env | filter(one(array, ok))
ok ? ok : $env.list
ok ? ok : $env?.[array]
ok ? ok : $env?.greet
ok ? ok : false and ok
ok ? ok : foo
ok ? ok : foo | date(list)
ok ? ok : foo?.String
ok ? ok : i
ok ? ok : list?.[i]
ok ? ok : ok
ok ? reduce($env, $env, true) : foo?.Bar
ok ? str : $env | findLastIndex(#)
ok ? str : $env?.String(i)?.ok
ok ? str : $env?.[Bar]
ok ? str : $env?.foo
ok ? str : $env?.ok
ok ? str : add
ok ? str : f64
ok ? str : foo
ok ? str : ok
ok ? true : $env | groupBy(sortBy(#, 1))
ok ? true : array?.[i]
ok ? true : foo?.String
ok ? true : foo?.String()
ok ? true ?: 0 : str
ok ?: $env ?? $env
ok ?: $env not endsWith str
ok ?: $env not matches $env
ok ?: $env | any(.Bar)
ok ?: $env | filter(.Bar)
ok ?: $env | find(#.str)
ok ?: $env | map(#.Bar)
ok ?: $env | max(add)
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]
ok ?: $env?.[Bar]?.str
ok ?: $env?.[String]
ok ?: $env?.[add]
ok ?: $env?.[array]
ok ?: $env?.[f64]
ok ?: $env?.[foo]
ok ?: $env?.[greet]
ok ?: $env?.[i]
ok ?: $env?.[ok]
ok ?: $env?.[str]
ok ?: $env?.add
ok ?: $env?.array
ok ?: $env?.f64
ok ?: $env?.foo
ok ?: $env?.greet
ok ?: $env?.i
ok ?: $env?.list
ok ?: $env?.str
ok ?: $env[foobar not in list:]
ok ?: $env[foobar:]
ok ?: 1 % 1
ok ?: 1.0 | date($env)
ok ?: 1.0 | date(1)
ok ?: add
ok ?: all($env, .f64)
ok ?: array
ok ?: array | sum(greet)
ok ?: array?.[i]
ok ?: ceil(f64)
ok ?: count($env)
ok ?: count(array)
ok ?: count(list)
ok ?: date(array)
ok ?: date(false)
ok ?: date(list)
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 ?: list | none(true)
ok ?: max(list)
ok ?: nil != str
ok ?: nil in $env
ok ?: ok
ok ?: ok | date(add, f64)
ok ?: str
ok ?: str matches findLast($env, #)
ok ?: str startsWith $env
ok ?: sum($env)
ok ?: sum(array, 0)
ok ?: {foo: list}
ok ?? !$env
ok ?? !false
ok ?? !ok
ok ?? !true
ok ?? $env ?: list | min(add, add)
ok ?? $env ?? f64
ok ?? $env ?? true
ok ?? $env | get(f64)
ok ?? $env.add
ok ?? $env.array
ok ?? $env.f64
ok ?? $env.foo
ok ?? $env.greet
ok ?? $env.i
ok ?? $env.list
ok ?? $env.ok
ok ?? $env.str
ok ?? $env?.Bar
ok ?? $env?.Bar()
ok ?? $env?.String
ok ?? $env?.String($env)
ok ?? $env?.String(str)
ok ?? $env?.String.Bar
ok ?? $env?.String.add
ok ?? $env?.String?.[ok]
ok ?? $env?.String?.list()
ok ?? $env?.[0 + foo]
ok ?? $env?.[1 ** foobar]
ok ?? $env?.[1.0 < list]
ok ?? $env?.[Bar]
ok ?? $env?.[Bar]?.array
ok ?? $env?.[String]
ok ?? $env?.[String].f64
ok ?? $env?.[String].ok
ok ?? $env?.[String]?.ok
ok ?? $env?.[add]
ok ?? $env?.[array]
ok ?? $env?.[array]?.f64
ok ?? $env?.[f64]
ok ?? $env?.[foo and i]
ok ?? $env?.[foo]
ok ?? $env?.[foo]?.[i]
ok ?? $env?.[foobar?.[greet]]
ok ?? $env?.[foobar?.array()]
ok ?? $env?.[greet]
ok ?? $env?.[i]
ok ?? $env?.[list]
ok ?? $env?.[list]?.ok
ok ?? $env?.[ok]
ok ?? $env?.[ok]?.[i]
ok ?? $env?.[str]
ok ?? $env?.[true ** 0]
ok ?? $env?.add
ok ?? $env?.all(foobar, nil, list)
ok ?? $env?.array
ok ?? $env?.f64
ok ?? $env?.foo
ok ?? $env?.greet
ok ?? $env?.i
ok ?? $env?.list
ok ?? $env?.ok
ok ?? $env?.str
ok ?? $env[:f64]
ok ?? $env[array not matches foobar:]
ok ?? $env[array.list:foo(String)]
ok ?? $env[foobar not matches false:foobar]
ok ?? $env[foobar.ok:]
ok ?? $env[greet:foobar?.[greet]]
ok ?? $env[i:]
ok ?? $env[nil:Bar]
ok ?? $env[str():]
ok ?? $env[str(foobar):]
ok ?? -$env
ok ?? -$env?.[ok]
ok ?? -0
ok ?? -1
ok ?? -1.0
ok ?? -f64
ok ?? -i
ok ?? 0 ?? $env
ok ?? 0 ?? foo
ok ?? 1 ?: f64
ok ?? 1 ?? $env
ok ?? 1.0 ?? $env.add
ok ?? 1.0 ?? ok
ok ?? 1.0 | get($env)
ok ?? [1.0]
ok ?? add
ok ?? add ?? i
ok ?? add(i, 1)
ok ?? all($env, #.str)
ok ?? all($env, .Bar)
ok ?? any($env, .str)
ok ?? array
ok ?? array ?? str
ok ?? bitnot($env)
ok ?? bitnot(i)
ok ?? ceil(1.0)
ok ?? concat($env)
ok ?? count($env)
ok ?? count($env, #.add)
ok ?? count(array)
ok ?? count(list)
ok ?? date(1.0)
ok ?? date(ok)
ok ?? f64
ok ?? f64 ?? false
ok ?? f64 ?? i
ok ?? false ? $env : f64
ok ?? find($env, #.foo)
ok ?? find($env, .ok)
ok ?? find(array, ok)
ok ?? findIndex($env, .array)
ok ?? findLastIndex($env, #)
ok ?? findLastIndex($env, #.list)
ok ?? findLastIndex($env, .list)
ok ?? first($env)
ok ?? flatten($env)
ok ?? float(0)
ok ?? float(1.0)
ok ?? float(str)
ok ?? foo
ok ?? foo ?? $env?.Bar()
ok ?? foo ?? array
ok ?? foo ?? list
ok ?? foo ?? lower($env)
ok ?? foo.Bar
ok ?? foo.String
ok ?? foo.String()
ok ?? foo?.Bar
ok ?? foo?.String
ok ?? foo?.String()
ok ?? greet
ok ?? greet ? greet : greet
ok ?? greet ?? nil
ok ?? greet ?? str
ok ?? greet($env)
ok ?? greet(str)
ok ?? groupBy($env, $env)?.i
ok ?? groupBy($env, .foo)
ok ?? groupBy($env, .greet)
ok ?? groupBy($env, .list)
ok ?? groupBy($env, i)
ok ?? groupBy(array, #)
ok ?? groupBy(array, foo)
ok ?? i
ok ?? i ?? ok
ok ?? i ?? str
ok ?? int(i)
ok ?? len(list)
ok ?? list
ok ?? list ? ok : 1.0
ok ?? list?.[i]
ok ?? max(0, $env)?.[add]
ok ?? min(array)
ok ?? nil ? false : foo
ok ?? nil ?? 1
ok ?? nil ?? add
ok ?? nil ?? array
ok ?? none($env, #)
ok ?? none(list, $env)
ok ?? not $env
ok ?? not 1.0 ?? foo
ok ?? not false
ok ?? not ok
ok ?? not true
ok ?? ok
ok ?? round($env)
ok ?? sort($env)
ok ?? sortBy($env, #)
ok ?? sortBy(array, #)
ok ?? str
ok ?? str ?? array
ok ?? str ?? f64
ok ?? str ?? ok
ok ?? str | get(false)
ok ?? string(add)
ok ?? string(ok)
ok ?? sum($env)
ok ?? sum($env, #)
ok ?? sum($env, #.f64)?.[add]
ok ?? sum(array)
ok ?? sum(list)
ok ?? sum(uniq($env))
ok ?? timezone($env)
ok ?? toBase64($env)
ok ?? toJSON(0)
ok ?? toJSON(1.0)
ok ?? toJSON(foo)
ok ?? toJSON(true)
ok ?? toPairs($env)
ok ?? trimPrefix($env)
ok ?? true ?? list
ok ?? type($env)
ok ?? type(f64)
ok ?? type(greet)
ok ?? type(ok)
ok ?? {foo: 1}
ok ?? {foo: i}
ok ?? {foo: nil}
ok ?? {foo: ok}
ok and !true
ok and $env != 0
ok and $env != 1.0
ok and $env != false
ok and $env != list
ok and $env == f64
ok and $env == list
ok and $env ?? f64
ok and $env in array
ok and $env || false
ok and $env.ok
ok and $env?.Bar
ok and $env?.Bar?.f64
ok and $env?.Bar?.foobar
ok and $env?.String
ok and $env?.[Bar]
ok and $env?.[Bar]?.[foo]
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?.foobar?.[foo]
ok and $env?.nil?.f64
ok and $env?.ok
ok and 0 != nil
ok and 0 < i
ok and 0 <= f64
ok and 1 < 1.0
ok and 1 < i
ok and 1 <= f64
ok and 1.0 != f64
ok and 1.0 != i
ok and 1.0 <= i
ok and 1.0 ?? $env
ok and 1.0 ?? $env.foo
ok and 1.0 not in array
ok and add == $env
ok and array != array
ok and array ?? f64
ok and f64 not in array
ok and false && $env
ok and false == $env
ok and false ? $env : $env
ok and false ?? 1.0
ok and first($env)
ok and foo != foo
ok and foo == nil
ok and foo ?? $env.ok
ok and foo ?? $env?.String()
ok and foo ?? true
ok and greet == nil
ok and greet not in $env?.[Bar]
ok and i < i
ok and i == f64
ok and i >= 1.0
ok and i ?? add
ok and i ^ 1 != 1.0
ok and last($env)
ok and list ?? [i]
ok and list ?? foo
ok and nil != false
ok and nil != foo
ok and nil != ok
ok and nil == $env
ok and nil == add
ok and nil == f64
ok and nil == true
ok and nil not in array
ok and not ok
ok and not true
ok and ok
ok and ok ? add : i
ok and ok ?? $env
ok and one(list, ok)
ok and str == string(foo)
ok and str matches toJSON(1.0)
ok and str not endsWith str
ok and str not startsWith str
ok and true != false
ok and true && $env
ok and true ?? add
ok and true ?? str
ok and true and $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 $env?.foobar?.[add]
ok in [$env, 1]
ok in [false]
ok in [ok]
ok in concat(array)
ok in first($env)
ok in flatten(array)
ok in last($env)
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?.String?.greet
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 $env?.foobar?.[array]
ok not in $env?.foobar?.[list]
ok not in $env?.true || false
ok not in [0, nil]
ok not in [false]
ok not in [ok]
ok not in [true]
ok not in array ?? greet
ok not in groupBy(list, i)
ok not in last($env)
ok not in list ?? add
ok not in list ?? greet
ok not in map($env, false)
ok not in values($env)
ok or !false
ok or !ok
ok or !true
ok or $env != 1
ok or $env != nil
ok or $env * 1.0
ok or $env * f64
ok or $env + $env?.str
ok or $env - $env
ok or $env - 1
ok or $env - 1.0
ok or $env < i
ok or $env <= $env.f64
ok or $env <= $env?.[f64]
ok or $env == $env
ok or $env == $env?.foo
ok or $env == 1
ok or $env == array
ok or $env == list
ok or $env == ok
ok or $env > str
ok or $env >= i
ok or $env >= str
ok or $env ?: ok
ok or $env and $env?.String
ok or $env and 1 != $env
ok or $env endsWith str
ok or $env in $env
ok or $env in list
ok or $env not in foo
ok or $env not in str
ok or $env not startsWith str
ok or $env or $env
ok or $env or ok
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()
ok or $env?.String(1, f64)
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?.[1]
ok or $env?.[Bar]
ok or $env?.[Bar].array
ok or $env?.[Bar]?.[list]
ok or $env?.[Bar]?.greet
ok or $env?.[String]
ok or $env?.[String].list
ok or $env?.[add]
ok or $env?.[add]?.array
ok or $env?.[add]?.ok
ok or $env?.[array($env)]
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 or 1]
ok or $env?.[foobar]
ok or $env?.[foobar]?.add
ok or $env?.[greet()]
ok or $env?.[greet]
ok or $env?.[greet] < str
ok or $env?.[i]
ok or $env?.[i].String
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?.[ok]?.add
ok or $env?.[sortBy(foobar, $env)]
ok or $env?.[str]
ok or $env?.[str]?.[f64]
ok or $env?.[str]?.list
ok or $env?.ok
ok or $env?.upper(1.0, 0, foo)
ok or $env[$env:foobar]?.[foo]?.[foo]
ok or $env[:1.0 ^ false].str
ok or $env[:foo?.list]
ok or $env[:foo]
ok or $env[:greet?.f64]
ok or $env[:indexOf(greet)]
ok or $env[:nil .. add]
ok or $env[:str]
ok or $env[add.Bar():]
ok or $env[foo:]
ok or $env[foobar.foo(nil):f64?.[foo]]
ok or $env[foobar:]
ok or $env[list:]
ok or $env[nil matches i:foobar not startsWith foobar]
ok or $env[not foobar:ok]
ok or $env[ok():]
ok or $env[ok:]
ok or -$env
ok or -i ?? add
ok or 0 < $env
ok or 0 == nil
ok or 0 == nil ? 0 : array
ok or 0 >= $env?.[array]
ok or 0 >= 1.0
ok or 1 + $env?.[i]
ok or 1 <= 1.0
ok or 1 <= i
ok or 1 > $env?.[String]
ok or 1 > 0
ok or 1 >= 1.0
ok or 1 ?? ok
ok or 1.0 != $env
ok or 1.0 != nil
ok or 1.0 < 0
ok or 1.0 < 1.0
ok or 1.0 < f64
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 ?? 1
ok or 1.0 ?? list
ok or 1.0 in $env
ok or abs($env)
ok or add == $env.add
ok or add ?? array
ok or array != nil
ok or array ?? 0
ok or f64 < 1
ok or f64 <= i
ok or f64 == nil
ok or f64 > $env
ok or f64 > $env?.[array]
ok or f64 > 1
ok or f64 > f64
ok or f64 >= 0
ok or f64 ?? $env
ok or false && ok
ok or false ? foo : foo
ok or false ?: foo
ok or false ?? 1.0
ok or false or ok
ok or false || false
ok or find($env, #)
ok or find($env, .greet)
ok or find($env, .str)
ok or foo != $env.foo
ok or foo != foo
ok or foo == foo
ok or foo ?? $env
ok or foo ?? list
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 fromJSON(str)
ok or greet != $env
ok or greet == $env
ok or greet not in $env
ok or i != nil
ok or i < i
ok or i == nil
ok or i ?? foo
ok or last($env)
ok or list ?? true
ok or mean(array)
ok or nil != $env
ok or nil != add
ok or nil != foo
ok or nil != i
ok or nil != str
ok or nil == add
ok or nil == array
ok or nil == str
ok or nil in array
ok or nil not in $env?.[Bar]
ok or none($env, #)
ok or not $env
ok or not $env?.Bar()?.String
ok or not $env?.[str]
ok or not ok
ok or ok
ok or ok != true
ok or ok == false
ok or ok ?? nil
ok or ok ?? not ok
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 == $env?.[str]?.String
ok or str not endsWith $env
ok or str not in foo
ok or sum($env)
ok or true && false
ok or true == $env?.[String]
ok or true == nil
ok or true ?? $env
ok or true ?? list
ok or true ?? true
ok or true or $env?.String(i)
ok or true || ok
ok or {foo: nil}?.i
ok || !$env
ok || !false
ok || !ok
ok || !true
ok || $env != f64
ok || $env != false
ok || $env != i
ok || $env != nil ? foo : array
ok || $env && $env
ok || $env + 1.0
ok || $env + i
ok || $env < $env
ok || $env < -1.0
ok || $env < false ?? 1.0
ok || $env <= 0
ok || $env <= i
ok || $env == $env
ok || $env == 1.0
ok || $env == list
ok || $env >= $env.f64
ok || $env >= str
ok || $env contains $env?.[Bar].Bar
ok || $env contains str
ok || $env endsWith $env?.[list]
ok || $env matches $env
ok || $env matches str
ok || $env not contains str
ok || $env not in str
ok || $env not matches $env
ok || $env or false
ok || $env || $env
ok || $env || ok
ok || $env.ok
ok || $env?.$env
ok || $env?.$env.str
ok || $env?.Bar
ok || $env?.Bar()
ok || $env?.String
ok || $env?.String()
ok || $env?.String()[:ok]?.foo
ok || $env?.String(all(foobar, #.list))
ok || $env?.String(first(foobar))
ok || $env?.String(foo())
ok || $env?.String.greet
ok || $env?.String?.ok()?.array
ok || $env?.[Bar]
ok || $env?.[String?.Bar]
ok || $env?.[String]
ok || $env?.[String]?.Bar
ok || $env?.[add]
ok || $env?.[add]?.[i]
ok || $env?.[add]?.i
ok || $env?.[all(foobar, foobar)]
ok || $env?.[array]
ok || $env?.[array].list
ok || $env?.[f64]
ok || $env?.[f64].str(list?.[ok])
ok || $env?.[findLastIndex(i, .String)]
ok || $env?.[foo]
ok || $env?.[foo].f64
ok || $env?.[foo]?.str
ok || $env?.[foobar startsWith foobar]
ok || $env?.[foobar | take(foobar)]
ok || $env?.[foobar?.i]
ok || $env?.[foobar]
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?.[list].add
ok || $env?.[list]?.[greet]
ok || $env?.[nil endsWith list]
ok || $env?.[ok]
ok || $env?.[str()]
ok || $env?.[str]
ok || $env?.[str].list
ok || $env?.foobar
ok || $env?.foobar.String
ok || $env?.ok
ok || $env?.sortBy(nil)
ok || $env?.toPairs(add, true)
ok || $env[$env:Bar]
ok || $env[1.0:]
ok || $env[:String()]
ok || $env[:add()]
ok || $env[:array | none(false)]
ok || $env[:foo]
ok || $env[:foobar]
ok || $env[Bar(foo):add and foobar]
ok || $env[Bar?.[str]:date($env)]
ok || $env[add():]
ok || $env[add:foobar]
ok || $env[f64.ok:array(foobar, foobar, String)]
ok || $env[f64:ok(true)]
ok || $env[false .. String:]
ok || $env[foo:foobar]
ok || $env[foobar:]
ok || $env[foobar?.list:]
ok || $env[greet:$env?.Bar]
ok || $env[i(foobar):Bar .. foo]
ok || $env[map(foo, foobar):]
ok || $env[str?.add:groupBy(i, foobar)]
ok || 0 - $env
ok || 0 == $env
ok || 0 == 1
ok || 0 == 1.0
ok || 0 > 1.0
ok || 0 ?? $env[:String()]
ok || 0 ?? ok
ok || 1 < findLast($env, #.ok)
ok || 1 > 1
ok || 1 >= $env?.[foo]
ok || 1.0 != 1.0
ok || 1.0 != f64
ok || 1.0 * $env
ok || 1.0 - $env?.[ok]
ok || 1.0 <= 0
ok || 1.0 <= 1
ok || 1.0 <= i
ok || 1.0 == 1
ok || 1.0 == 1.0
ok || 1.0 ?? add
ok || 1.0 ?? array
ok || 1.0 ?? i
ok || 1.0 in $env
ok || 1.0 in $env?.String
ok || add == $env?.[foo]
ok || add ?? str
ok || add not in $env
ok || any($env, #)
ok || any($env, .list)
ok || any($env, false)
ok || array != nil
ok || array ?? 1.0
ok || f64 != $env
ok || f64 != f64
ok || f64 + $env
ok || f64 < $env
ok || f64 < 1.0
ok || f64 < i
ok || f64 <= 1
ok || f64 == f64
ok || f64 > $env
ok || f64 > 1
ok || false ?: foo
ok || false and false
ok || false not in sum(list, $env)
ok || findLast($env, #.String)
ok || findLast($env, $env)
ok || foo != nil
ok || foo == $env
ok || foo == $env[:false]
ok || foo == foo
ok || foo == nil
ok || foo ?? array
ok || foo ?? list
ok || foo ?? not true
ok || foo not in list
ok || fromJSON($env)
ok || greet != nil
ok || greet == $env
ok || greet ?? array
ok || greet ?? i
ok || i * $env
ok || i + $env
ok || i < f64
ok || i == 1
ok || i > i
ok || i >= $env
ok || i >= 1.0
ok || last($env)
ok || list != list
ok || list ?? i
ok || list ?? str
ok || max(i, list)
ok || max(list, greet)
ok || mean(list | sortBy(greet))
ok || mean(list)
ok || median($env)?.greet
ok || median(array)
ok || median(array, 1)
ok || median(array, str)
ok || min($env)
ok || nil != -1.0
ok || nil != 1
ok || nil != add
ok || nil != greet
ok || nil != i
ok || nil != nil
ok || nil != true
ok || nil == $env.array
ok || nil == 1.0
ok || nil == false
ok || nil == nil ?? 1
ok || nil ?? $env?.[f64]
ok || nil in $env?.String
ok || nil in array
ok || nil not in array
ok || none(array, $env)
ok || not $env
ok || not ok
ok || ok
ok || ok == nil
ok || ok == ok
ok || ok ?: foo
ok || ok ?? [nil]
ok || ok || $env
ok || one($env, .add)
ok || reduce($env, .foo)
ok || sortBy($env, array).str
ok || sortBy($env, i, str)
ok || str != $env
ok || str != nil
ok || str != str
ok || str + $env
ok || str <= str
ok || str ?? array
ok || str contains $env
ok || str contains str
ok || str endsWith $env
ok || str endsWith str
ok || str in $env
ok || str matches $env
ok || str not in foo
ok || sum($env)
ok || sum($env, .list)
ok || true != nil
ok || true && $env
ok || true ?? add
ok || true and $env
ok || true and true
ok || true || $env?.[greet]
ok || {foo: nil}?.add
ok; 0 ?? 1
ok; add
ok; f64
ok; foo
ok; foo.String
ok; foo?.String; groupBy(list, #)
ok; greet
ok; list
ok; list | sortBy(i)
ok; list?.[i]
ok; ok
ok; str
ok; true != $env
one($env ?? nil, false == $env)
one($env | map(true), ok)
one($env, true) ?: greet
one($env, true) || $env?.Bar
one($env.array, nil != true)
one($env?.[str], # in list)
one($env?.[str], list == #)
one($env?.[str], ok)
one($env?.array, $env == #)
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([true, foo], ok)
one(array ?? nil, ok)
one(array, !ok)
one(array, # != #)
one(array, # < #)
one(array, # <= 0)
one(array, # <= 1)
one(array, # == 1)
one(array, # > #)
one(array, # > 0)
one(array, # >= #)
one(array, # not in array)
one(array, $env != #)
one(array, $env != ok)
one(array, $env && false)
one(array, $env == list)
one(array, $env.ok)
one(array, $env?.ok)
one(array, 0 == 0)
one(array, 0 >= 0)
one(array, 1 == 1.0)
one(array, 1 >= #)
one(array, 1.0 < #)
one(array, 1.0 <= #)
one(array, 1.0 > #)
one(array, 1.0 >= #)
one(array, f64 != nil)
one(array, f64 == i)
one(array, false and $env?.[ok])
one(array, false) != $env?.ok
one(array, false) != ok
one(array, foo == foo)
one(array, greet == nil)
one(array, i != $env)
one(array, i <= f64)
one(array, list != $env)
one(array, nil != #)
one(array, nil != add)
one(array, nil in $env)
one(array, nil not in list)
one(array, ok)
one(array, ok) and $env[greet:]
one(array, ok) or ok
one(array, str == str)
one(array, str > str)
one(array, true ?? i)
one(array, true and true)
one(array, true or $env)
one(array, true) == ok
one(if ok { $env } else { add }, ok)
one(list ?? ok, ok)
one(list, # != $env)
one(list, # != foo)
one(list, # == #)
one(list, # == $env)
one(list, # == foo)
one(list, $env != .String)
one(list, $env != i)
one(list, $env == foo)
one(list, $env == nil)
one(list, $env.ok)
one(list, $env?.ok)
one(list, .Bar in foo)
one(list, 1 <= f64)
one(list, 1 > 1.0)
one(list, 1.0 != i)
one(list, 1.0 < i)
one(list, 1.0 == $env)
one(list, 1.0 >= 0)
one(list, any(list, ok))
one(list, f64 == 1)
one(list, f64 > 1.0)
one(list, false and ok)
one(list, foo != #)
one(list, greet == nil)
one(list, i == 0)
one(list, list != $env)
one(list, nil != 1.0)
one(list, nil == #)
one(list, nil == list)
one(list, nil not in $env)
one(list, none(list, false))
one(list, not ok)
one(list, ok)
one(list, ok) and ok
one(list, str < #.Bar)
one(list, str >= str)
one(list, true != $env)
one(list, true ?? foo)
one(min($env), ok)
one(sort($env), $env == nil)
one(sort($env), .String.list(nil))
one(sort($env), .greet[:.i])
one(sort($env), .list?.array(foobar))
one(sort($env), 1.0 != $env)
one(sort($env), i >= .f64)
one(sort($env), ok)
one(uniq(array), ok)
reduce($env | map($env), #.foo)
reduce($env | map(0), str)
reduce($env | map(1.0), str)
reduce($env | map(f64), #)
reduce($env | map(foo), greet)
reduce($env | map(str), str)
reduce($env, #.list) == 1 && false
reduce($env, $env, $env).foo
reduce($env, $env, $env).greet
reduce($env, $env, $env)?.add
reduce($env, $env, $env)?.f64
reduce($env, $env, $env)?.greet
reduce($env, $env, $env)?.ok
reduce($env, $env, 1)?.f64
reduce($env, $env, 1.0)?.add
reduce($env, $env, 1.0)?.greet
reduce($env, $env, 1.0)?.list
reduce($env, $env, add).ok
reduce($env, $env, array)?.i
reduce($env, $env, false).str
reduce($env, $env, foo)?.Bar
reduce($env, $env, foo)?.str
reduce($env, $env, greet).String
reduce($env, $env, greet).greet
reduce($env, $env, greet)?.String
reduce($env, $env, greet)?.greet
reduce($env, $env, i)?.[str]
reduce($env, $env, i)?.f64
reduce($env, $env, list).foo
reduce($env, $env, list).ok
reduce($env, $env, list)?.add
reduce($env, $env, nil).Bar
reduce($env, $env, nil)?.str
reduce($env, $env, true)?.list
reduce($env, 1.0, false) ?? array
reduce($env, array, $env) | reduce(str)
reduce($env, array, 1.0) | all(false)
reduce($env, array, false)?.[i]
reduce($env, foo, 1).Bar
reduce($env, foo, add)?.Bar
reduce($env, foo, false).Bar
reduce($env, foo, nil)?.Bar
reduce($env, foo, ok).String
reduce($env, foo, ok)?.String()
reduce($env, i, 1.0) ?? add
reduce($env, list, 1.0)?.[i]
reduce($env, str, false) ?? array
reduce($env.array, #)
reduce($env.array, #index / #)
reduce($env.array, add)
reduce($env.array, f64)
reduce($env.array, greet)
reduce($env.array, i)
reduce($env.array, last($env))
reduce($env.array, list)
reduce($env.array, mean(f64, #))
reduce($env.array, ok)
reduce($env.array, str)
reduce($env.list, #)
reduce($env.list, #.Bar)
reduce($env.list, #?.Bar)
reduce($env.list, #acc)
reduce($env.list, 1.0 + 1.0)
reduce($env.list, [#, 1])
reduce($env.list, [nil])
reduce($env.list, add)
reduce($env.list, array)
reduce($env.list, f64 ^ 1)
reduce($env.list, greet ?? $env, str ?? add)
reduce($env.list, greet)
reduce($env.list, list)
reduce($env.list, ok)
reduce($env.list, ok, {foo: nil})
reduce($env.list, str)
reduce($env?.[str], # != foo)
reduce($env?.[str], #)
reduce($env?.[str], #acc)
reduce($env?.[str], #index != #)
reduce($env?.[str], #index == #)
reduce($env?.[str], -0)
reduce($env?.[str], 1 <= 1)
reduce($env?.[str], f64)
reduce($env?.[str], foo)
reduce($env?.[str], greet)
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, $env.greet)
reduce($env?.array, add)
reduce($env?.array, array)
reduce($env?.array, f64)
reduce($env?.array, foo)
reduce($env?.array, greet)
reduce($env?.array, i != #)
reduce($env?.array, i)
reduce($env?.array, list | groupBy(foo))
reduce($env?.array, list)
reduce($env?.array, ok)
reduce($env?.array, str)
reduce($env?.list, #)
reduce($env?.list, #.String)
reduce($env?.list, #.String, array)
reduce($env?.list, #acc)
reduce($env?.list, .Bar in #)
reduce($env?.list, .Bar)
reduce($env?.list, add)
reduce($env?.list, f64)
reduce($env?.list, false != ok)
reduce($env?.list, foo)
reduce($env?.list, foo, $env?.i)
reduce($env?.list, foo?.Bar)
reduce($env?.list, greet)
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], #)
reduce([$env], #.Bar)
reduce([$env], #.String != $env)
reduce([$env], #.add < #.greet)
reduce([$env], #.foo?.[list])
reduce([$env], #acc)
reduce([$env], .Bar)
reduce([$env], .str)
reduce([$env], add)
reduce([$env], f64 <= #.f64)
reduce([$env], foo)
reduce([$env], greet)
reduce([$env], i)
reduce([$env], if true { .greet } else { foo })
reduce([$env], round($env))
reduce([$env], upper(.foo))
reduce([0, $env], array)
reduce([0], #)
reduce([0], array)
reduce([1, greet], add)
reduce([1.0, 1], # - #)
reduce([1.0, foo], #)
reduce([1.0], # - 1)
reduce([1.0], #)
reduce([1.0], $env[:#])
reduce([1.0], list)
reduce([1], add)
reduce([1], foo)
reduce([add], $env[foobar:])
reduce([f64, add], #)
reduce([f64], i)
reduce([false, add], i)
reduce([false], #acc)
reduce([false], foo)
reduce([foo, add], #)
reduce([foo], #)
reduce([foo], #.Bar + #acc)
reduce([foo], #index)
reduce([foo], $env?.[f64])
reduce([foo], foo).String
reduce([foo], greet)
reduce([foo], ok)
reduce([greet, greet], str)
reduce([greet], f64)
reduce([i, 1.0], # != #)
reduce([i, i], foo)
reduce([i], list)
reduce([list], #)
reduce([list], add)
reduce([list], greet)
reduce([nil != true], list)
reduce([nil, add], foo)
reduce([nil, foo], # ?? .add)
reduce([nil], array)
reduce([nil], i)
reduce([ok], #)
reduce([ok], add)
reduce([ok], foo)
reduce([str, 1.0], $env.i)
reduce([str], i)
reduce([true, greet], #)
reduce([true], foo.Bar)
reduce(array ?? add, str)
reduce(array ?? str, #index)
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, # % i)
reduce(array, # * #)
reduce(array, # + #)
reduce(array, # + 0)
reduce(array, # - #acc)
reduce(array, # .. #)
reduce(array, # / #)
reduce(array, # / 0)
reduce(array, # < #)
reduce(array, # <= #)
reduce(array, # <= 1)
reduce(array, # == #)
reduce(array, # == 0)
reduce(array, # > i)
reduce(array, # >= #)
reduce(array, # >= 0)
reduce(array, # ?? foo)
reduce(array, # ^ #)
reduce(array, # in array)
reduce(array, #)
reduce(array, #) * f64
reduce(array, #, add)
reduce(array, #, array)
reduce(array, #, greet)
reduce(array, #, i)
reduce(array, #, i) | mean(array)
reduce(array, #, ok)
reduce(array, #..i)
reduce(array, #acc)
reduce(array, #acc, nil)?.[greet]
reduce(array, #acc, nil)?.i
reduce(array, #acc, nil)?.list
reduce(array, #index != f64)
reduce(array, #index ** 1.0)
reduce(array, #index ** f64)
reduce(array, #index == 1.0)
reduce(array, #index ?? foo)
reduce(array, #index ^ #)
reduce(array, #index)
reduce(array, #index, foo)
reduce(array, $env != foo)
reduce(array, $env != ok)
reduce(array, $env == #)
reduce(array, $env == ok)
reduce(array, $env ?? ok)
reduce(array, $env and true)
reduce(array, $env) == ok
reduce(array, $env) | count(false)
reduce(array, $env) | find(false)
reduce(array, $env) | map(false)
reduce(array, $env).Bar
reduce(array, $env).String
reduce(array, $env).add
reduce(array, $env).array
reduce(array, $env).f64
reduce(array, $env).foo
reduce(array, $env).foobar
reduce(array, $env).greet
reduce(array, $env).greet(foobar)
reduce(array, $env).i
reduce(array, $env).list
reduce(array, $env).str
reduce(array, $env)?.Bar
reduce(array, $env)?.String
reduce(array, $env)?.String?.str
reduce(array, $env)?.[str]
reduce(array, $env)?.add
reduce(array, $env)?.array
reduce(array, $env)?.f64
reduce(array, $env)?.false?.foo
reduce(array, $env)?.foo
reduce(array, $env)?.foobar
reduce(array, $env)?.greet
reduce(array, $env)?.i
reduce(array, $env)?.list
reduce(array, $env)?.ok
reduce(array, $env)?.str
reduce(array, $env, $env) | sum(1)
reduce(array, $env, $env)?.str
reduce(array, $env, 0)?.String
reduce(array, $env, 1.0).Bar
reduce(array, $env, f64)?.[str]
reduce(array, $env, f64)?.list
reduce(array, $env, foo)?.ok
reduce(array, $env, ok)?.Bar
reduce(array, $env, str)?.greet
reduce(array, $env, true).array
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?.add)
reduce(array, $env?.array)
reduce(array, $env?.f64)
reduce(array, $env?.foo)
reduce(array, $env?.foo.Bar)
reduce(array, $env?.greet)
reduce(array, $env?.i)
reduce(array, $env?.list, greet)
reduce(array, $env?.str)
reduce(array, -#)
reduce(array, -0)
reduce(array, -1)
reduce(array, 0 * 1)
reduce(array, 0) ^ i
reduce(array, 0) | min(1.0)
reduce(array, 1 != $env)
reduce(array, 1 != nil)
reduce(array, 1 | max(#acc))
reduce(array, 1) ** f64
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 - f64)
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 >= f64)
reduce(array, 1.0 ?? #)
reduce(array, 1.0 ?? $env)
reduce(array, 1.0 ^ #)
reduce(array, 1.0) / $env?.i
reduce(array, 1.0) == $env?.[str]
reduce(array, 1.0) ^ $env?.f64
reduce(array, [#])
reduce(array, [1.0])
reduce(array, [add])
reduce(array, [flatten(list)])
reduce(array, [foo])
reduce(array, abs(#))
reduce(array, add == nil)
reduce(array, add)
reduce(array, add, f64)
reduce(array, array | reduce($env))
reduce(array, array)
reduce(array, array) | mean(1, i)
reduce(array, array)?.[i]
reduce(array, array, foo)
reduce(array, array, i)
reduce(array, array?.[i])
reduce(array, array[1:])
reduce(array, bitnand(1, #acc))
reduce(array, bitnot(#))
reduce(array, bitnot(#)) % i
reduce(array, bitnot(i))
reduce(array, bitor(i, #))
reduce(array, ceil(#))
reduce(array, concat(list))
reduce(array, f64 + #)
reduce(array, f64)
reduce(array, f64) ?? f64
reduce(array, false ?? #)
reduce(array, false) == $env?.String
reduce(array, false) and ok
reduce(array, float(#))
reduce(array, float(i))
reduce(array, foo == $env)
reduce(array, foo ?? $env)
reduce(array, foo)
reduce(array, foo).Bar
reduce(array, foo).String
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, array)
reduce(array, foo, foo).String
reduce(array, foo, greet)?.String()
reduce(array, foo, i).Bar
reduce(array, foo, list).Bar
reduce(array, foo, str)
reduce(array, foo, str).Bar
reduce(array, foo.Bar)
reduce(array, foo.String())
reduce(array, foo.String)
reduce(array, foo?.Bar)
reduce(array, foo?.String())
reduce(array, foo?.String)
reduce(array, greet(str))
reduce(array, greet)
reduce(array, greet, [array])
reduce(array, greet, foo)
reduce(array, i ** #acc)
reduce(array, i .. #, greet)
reduce(array, i <= #)
reduce(array, i ^ #acc)
reduce(array, i)
reduce(array, i) != i
reduce(array, i, array) % i
reduce(array, i, f64) not in $env?.array
reduce(array, i, list)
reduce(array, keys($env))
reduce(array, list ?? #, i)
reduce(array, list ?? str)
reduce(array, list)
reduce(array, list)?.[i]
reduce(array, list, {foo: nil})
reduce(array, list[:#])
reduce(array, mean(#))
reduce(array, median(#))
reduce(array, median(0))
reduce(array, ok ? ok : #index)
reduce(array, ok)
reduce(array, ok, $env.ok)
reduce(array, ok, 1.0) == ok
reduce(array, reduce(array, #))
reduce(array, reduce(array, #, i))
reduce(array, round(#))
reduce(array, round(1))
reduce(array, str ?? 1.0)
reduce(array, str not in foo)
reduce(array, str)
reduce(array, str) + str
reduce(array, str) | greet()
reduce(array, str, $env.f64)
reduce(array, str, array) not in foo
reduce(array, str, f64)
reduce(array, string(#))
reduce(array, string(i))
reduce(array, sum(array, 1.0))
reduce(array, toJSON(#))
reduce(array, toJSON(1.0))
reduce(array, true and ok)
reduce(array, true or $env)
reduce(array, true) ?? add
reduce(array, type(#))
reduce(array, type(true))
reduce(array, uniq(list))
reduce(array[0:], list)
reduce(concat(list), #)
reduce(flatten(array), array)
reduce(flatten(array), foo)
reduce(flatten(list), #)
reduce(keys($env), #acc)
reduce(keys($env), $env?.[String])
reduce(keys($env), abs(0))
reduce(keys($env), greet)
reduce(keys($env), max(#))
reduce(keys($env), sum(#))
reduce(let foobar = array; foobar, #)
reduce(list ?? 1.0, foo)
reduce(list ?? array, #)
reduce(list | map(1), $env?.f64)
reduce(list | map(1.0), array)
reduce(list | map(false), true != #)
reduce(list | reduce(array), #)
reduce(list | sortBy(1.0), greet)
reduce(list, # == #)
reduce(list, # == $env)
reduce(list, # ?? false)
reduce(list, # ?? foo)
reduce(list, # in list)
reduce(list, #)
reduce(list, #) ?? foo
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, #, 1.0)?.String
reduce(list, #, add)
reduce(list, #, array)?.String
reduce(list, #, f64).String
reduce(list, #, nil).String
reduce(list, #, ok)?.Bar
reduce(list, #.Bar != nil)
reduce(list, #.Bar >= .Bar)
reduce(list, #.Bar)
reduce(list, #.String())
reduce(list, #.String)
reduce(list, #?.Bar)
reduce(list, #?.String())
reduce(list, #?.String)
reduce(list, #acc == 0)
reduce(list, #acc ?? $env)
reduce(list, #acc ?? 1)
reduce(list, #acc)
reduce(list, #acc).Bar
reduce(list, #acc)?.Bar
reduce(list, #acc, foo).String
reduce(list, #index)
reduce(list, $env && true)
reduce(list, $env == ok)
reduce(list, $env ?? array)
reduce(list, $env and true)
reduce(list, $env | map(add))
reduce(list, $env) | map(i)
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)?.foo
reduce(list, $env)?.foobar
reduce(list, $env)?.foobar?.i
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, array)?.greet
reduce(list, $env, false).f64
reduce(list, $env, false).ok
reduce(list, $env, foo).ok
reduce(list, $env, greet)?.Bar?.str
reduce(list, $env, i).ok
reduce(list, $env, nil)?.greet
reduce(list, $env.add)
reduce(list, $env.f64)
reduce(list, $env.list)
reduce(list, $env.str)
reduce(list, $env?.[#.Bar])
reduce(list, $env?.[String])
reduce(list, $env?.[foobar])
reduce(list, $env?.add)
reduce(list, $env?.f64)
reduce(list, $env?.foo)
reduce(list, $env?.list)
reduce(list, $env?.nil?.[greet])
reduce(list, $env?.ok)
reduce(list, $env?.str)
reduce(list, -i)
reduce(list, .Bar not contains str)
reduce(list, .Bar not in foo, {foo: str})
reduce(list, .Bar)
reduce(list, .String ?? foo)
reduce(list, .String)
reduce(list, .String, greet)
reduce(list, 0 .. 0)
reduce(list, 0 == 1)
reduce(list, 0) != i
reduce(list, 0) | mean(1.0)
reduce(list, 1 <= 1)
reduce(list, 1) * i
reduce(list, 1) / i
reduce(list, 1.0 * f64)
reduce(list, 1.0 * i)
reduce(list, 1.0 + 1)
reduce(list, 1.0 <= 1.0)
reduce(list, 1.0) * i
reduce(list, 1.0) == i
reduce(list, 1.0, array) <= i
reduce(list, [$env, 0])
reduce(list, [f64, false])
reduce(list, [foo])
reduce(list, [nil, #])
reduce(list, [str])
reduce(list, abs(#index))
reduce(list, add == $env)
reduce(list, add)
reduce(list, add, foo)
reduce(list, add, ok)
reduce(list, array != array)
reduce(list, array | one(ok))
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 * #index)
reduce(list, f64 * f64)
reduce(list, f64 / f64)
reduce(list, f64 >= 1)
reduce(list, f64)
reduce(list, f64, f64)
reduce(list, f64, str)
reduce(list, false == ok)
reduce(list, false ?: foo)
reduce(list, false) ? f64 : [false]
reduce(list, false) in uniq(list)
reduce(list, first(#acc))
reduce(list, foo != foo)
reduce(list, foo ?? f64)
reduce(list, foo ?? nil)
reduce(list, foo)
reduce(list, foo).Bar
reduce(list, foo).String
reduce(list, foo).String()
reduce(list, foo)?.Bar
reduce(list, foo)?.String
reduce(list, foo)?.String()
reduce(list, foo, $env) not in list
reduce(list, foo, array).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 == #acc)
reduce(list, greet ?? $env)
reduce(list, greet(#.Bar))
reduce(list, greet(.Bar))
reduce(list, greet)
reduce(list, greet) ?? greet
reduce(list, greet, greet)
reduce(list, i / 1.0)
reduce(list, i ^ 0)
reduce(list, i)
reduce(list, i, $env?.list[:])
reduce(list, i, 1.0) == i
reduce(list, i, list)
reduce(list, i, ok)
reduce(list, int(#index))
reduce(list, int(0))
reduce(list, len($env))
reduce(list, list | any(ok))
reduce(list, list | map($env))
reduce(list, list)
reduce(list, list)?.[i]
reduce(list, list, f64) | map(array)
reduce(list, list, i)
reduce(list, list?.[i])
reduce(list, max(f64))
reduce(list, mean(1.0))
reduce(list, median(i))
reduce(list, nil != $env)
reduce(list, nil != 0)
reduce(list, nil == $env)
reduce(list, ok == false)
reduce(list, ok ?? #)
reduce(list, ok ?? #acc)
reduce(list, ok ?? $env)
reduce(list, ok)
reduce(list, ok) || $env?.[greet]
reduce(list, ok, $env.foo)
reduce(list, ok, 1 * i)
reduce(list, ok, f64)
reduce(list, reduce(array, greet, foo))
reduce(list, sort($env), ok)
reduce(list, str > #.Bar)
reduce(list, str ?? f64)
reduce(list, str)
reduce(list, str) == str
reduce(list, string(ok))
reduce(list, sum(list, 1.0))
reduce(list, toBase64(#.Bar))
reduce(list, trimSuffix(#.Bar))
reduce(list, trimSuffix(.Bar))
reduce(list, true != $env)
reduce(list, true != ok)
reduce(list, true ? # : false)
reduce(list, true || false)
reduce(list, true || true)
reduce(list, true) and ok
reduce(list, type($env))
reduce(list, type(i))
reduce(list, type(list))
reduce(list[:1], [$env])
reduce(list[:1], str)
reduce(list[:], greet)
reduce(map($env, 1.0), #)
reduce(map($env, false), i)
reduce(map($env, foo), str)
reduce(map($env, greet), #)
reduce(map($env, greet), i)
reduce(map($env, list), $env.str)
reduce(map(array, foo), foo?.Bar)
reduce(map(array, list), list)
reduce(map(array, ok), greet)
reduce(map(list, #), #)
reduce(map(list, #), $env?.add)
reduce(map(list, .Bar), list)
reduce(map(list, i), #)
reduce(max($env).array, ok)
reduce(nil ?? list, add)
reduce(reduce(array, list), #index)
reduce(reduce(list, array), i)
reduce(reverse(array), $env.ok)
reduce(reverse(array), $env?.ok)
reduce(reverse(list), str)
reduce(sort(array), str)
reduce(sortBy(array, #), #)
reduce(sortBy(array, #), array)
reduce(sortBy(array, 1.0), ok)
reduce(sortBy(list, 1.0), i)
reduce(str ?? $env, #)
reduce(uniq(array), greet)
reduce(values($env), # == $env)
reduce(values($env), #)
repeat(nil ?? str, i)
repeat(str, 0 ?? false)
repeat(str, i)
repeat(str, i) not startsWith str
repeat(str, max(1.0, array))
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(foo))
reverse($env | map(ok))
reverse($env | map(true))
reverse($env.array)
reverse($env.list)
reverse($env?.array)
reverse($env?.list)
reverse(0 .. 1)
reverse(0 .. i)
reverse(1 .. 0)
reverse(1 .. 1)
reverse(1 .. i)
reverse([$env, 0])
reverse([$env, f64])
reverse([$env, ok])
reverse([$env])
reverse([0, $env, foo])
reverse([0, foo])
reverse([0, nil])
reverse([0])
reverse([1 .. 1])
reverse([1, true])
reverse([1.0, list])
reverse([1.0])
reverse([1])
reverse([add, list])
reverse([add])
reverse([array, array])
reverse([array, greet])
reverse([array])
reverse([f64, nil])
reverse([f64])
reverse([false, true])
reverse([false])
reverse([foo, 1.0])
reverse([foo, array])
reverse([foo, f64])
reverse([foo, list])
reverse([foo, str])
reverse([foo])
reverse([greet])
reverse([i, 1])
reverse([i])
reverse([list])
reverse([nil, 1])
reverse([nil, i])
reverse([nil, list])
reverse([nil, nil])
reverse([nil, true])
reverse([nil])
reverse([ok])
reverse([str, ok])
reverse([str])
reverse([true])
reverse(array ?? 1)
reverse(array ?? 1.0)
reverse(array ?? add)
reverse(array ?? f64)
reverse(array ?? foo)
reverse(array | map(#))
reverse(array | map($env))
reverse(array | map(1.0))
reverse(array | map(ok))
reverse(array | map(str))
reverse(array | reduce(array, foo))
reverse(array | sortBy(1))
reverse(array)
reverse(array) ?? list
reverse(array) not in sort(array)
reverse(array) | findIndex(ok)
reverse(array) | findLastIndex(false)
reverse(array) | groupBy(#)
reverse(array) | groupBy(0)
reverse(array) | groupBy(i)
reverse(array) | map(#)
reverse(array) | map($env)
reverse(array) | one(ok)
reverse(array) | reduce(#)
reverse(array) | reduce(#, greet)
reverse(array) | reduce($env)
reverse(array) | reduce(array)
reverse(array) | reduce(foo)
reverse(array) | reduce(str)
reverse(array) | sortBy(1)
reverse(array) | sortBy(i)
reverse(array) | sum(#)
reverse(array) | sum(f64)
reverse(array)?.[i]
reverse(array[i:1])
reverse(concat(array))
reverse(concat(list))
reverse(false ? array : list)
reverse(filter($env, false))
reverse(filter(list, ok))
reverse(flatten(array))
reverse(flatten(list))
reverse(i .. i)
reverse(if false { $env } else { array })
reverse(if false { 1.0 } else { list })
reverse(keys($env))
reverse(let foobar = array; foobar)
reverse(let foobar = list; foobar)
reverse(list ?? 1.0)
reverse(list ?? add)
reverse(list ?? f64)
reverse(list ?? false)
reverse(list ?? foo)
reverse(list ?? ok)
reverse(list ?? str)
reverse(list ?? true)
reverse(list | filter(true))
reverse(list | map(#))
reverse(list | map(1.0))
reverse(list | map(array))
reverse(list | map(foo))
reverse(list | map(i))
reverse(list | map(ok))
reverse(list | map(str))
reverse(list | map(true))
reverse(list | sortBy(0))
reverse(list | sortBy(1.0))
reverse(list | sortBy(str))
reverse(list)
reverse(list) != list
reverse(list) == array
reverse(list) ?? list
reverse(list) | any(true)
reverse(list) | count(true)
reverse(list) | find(false)
reverse(list) | findIndex(false)
reverse(list) | groupBy(#)
reverse(list) | groupBy(foo)
reverse(list) | groupBy(true)
reverse(list) | map(#index)
reverse(list) | map(list)
reverse(list) | one(false)
reverse(list) | reduce(#, false)
reverse(list) | reduce(0)
reverse(list) | reduce(1.0)
reverse(list) | reduce(f64)
reverse(list) | reduce(foo)
reverse(list) | reduce(greet)
reverse(list) | reduce(ok)
reverse(list) | reduce(true)
reverse(list) | sum(f64)
reverse(list)?.[i]
reverse(list[:i])
reverse(map($env, $env))
reverse(map($env, 0))
reverse(map($env, 1.0))
reverse(map($env, add))
reverse(map($env, array))
reverse(map($env, f64))
reverse(map($env, foo))
reverse(map($env, list))
reverse(map($env, str))
reverse(map($env, true))
reverse(map(array, #))
reverse(map(array, #index))
reverse(map(array, 1.0))
reverse(map(array, foo))
reverse(map(array, i))
reverse(map(list, #))
reverse(map(list, #.Bar))
reverse(map(list, $env))
reverse(reduce(array, list))
reverse(reduce(list, list, ok))
reverse(reverse(array))
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(sortBy(list, i))
reverse(toPairs($env))
reverse(uniq(array))
reverse(uniq(list))
reverse(values($env))
round($env | count(ok))
round($env | findIndex(true))
round($env | reduce(0, foo))
round($env | reduce(1.0, f64))
round($env | sum(1.0))
round($env | sum(f64))
round($env.f64)
round($env.f64) != i
round($env.i)
round($env?.f64)
round($env?.f64) - f64
round($env?.i)
round(-0)
round(-1)
round(-1.0)
round(-f64)
round(-i)
round(0 * 0)
round(0 * 1.0)
round(0 * f64)
round(0 ** 0)
round(0 ** 1)
round(0 ** 1.0)
round(0 ** f64)
round(0 ** i)
round(0 + 0)
round(0 + 1)
round(0 + 1.0)
round(0 + i)
round(0 - 0)
round(0 - 1)
round(0 - f64)
round(0 / 0)
round(0 / 1.0)
round(0 / f64)
round(0 / i)
round(0 ?? f64)
round(0 ?? false)
round(0 ?? true)
round(0 ^ 1.0)
round(0 ^ f64)
round(0 | max(array))
round(0) != i
round(0) - i
round(0) / f64
round(0) < i
round(0) == max($env)
round(0) ?? foo
round(0) ^ f64
round(0) ^ i
round(0.1)
round(1 % i)
round(1 * 0)
round(1 * 1)
round(1 ** 0)
round(1 ** 1)
round(1 ** 1.0)
round(1 ** i)
round(1 + 0)
round(1 + 1)
round(1 + 1.0)
round(1 + i)
round(1 - 0)
round(1 - 1)
round(1 - 1.0)
round(1 - i)
round(1 / 1)
round(1 / f64)
round(1 / i)
round(1 ?? 0)
round(1 ?? 1.0)
round(1 ?? array)
round(1 ?? f64)
round(1 ?? foo)
round(1 ?? i)
round(1 ?? nil)
round(1 ^ 0)
round(1 ^ 1)
round(1 ^ 1.0)
round(1 ^ f64)
round(1 ^ i)
round(1 | bitnand(0))
round(1) * f64
round(1) * i
round(1) / f64
round(1) ?? array ?? foo
round(1) ?? greet
round(1) ?? ok
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)
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 + f64)
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 / 0)
round(1.0 / 1)
round(1.0 / 1.0)
round(1.0 / f64)
round(1.0 / i)
round(1.0 ?? $env)
round(1.0 ?? 0)
round(1.0 ?? 1)
round(1.0 ?? add)
round(1.0 ?? f64)
round(1.0 ?? false)
round(1.0 ?? foo)
round(1.0 ?? i)
round(1.0 ?? list)
round(1.0 ?? nil)
round(1.0 ?? ok)
round(1.0 ?? str)
round(1.0 ^ $env.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 | max(i))
round(1.0 | mean(0))
round(1.0)
round(1.0) != f64
round(1.0) * $env and false
round(1.0) * f64
round(1.0) ** 1.0 != 1
round(1.0) ** 1.0 / f64
round(1.0) ** f64
round(1.0) + f64
round(1.0) + mean(1.0, f64)
round(1.0) + min(1.0)
round(1.0) - f64
round(1.0) / i
round(1.0) / int(1.0)
round(1.0) <= i
round(1.0) == 1 / i
round(1.0) == i
round(1.0) > i
round(1.0) >= f64
round(1.0) >= i
round(1.0) ?? f64
round(1.0) ?? foo
round(1.0) ^ f64
round(1.0) ^ i
round(1.0) ^ sum($env, 1)
round(1.0) in $env.array
round(1.0) | median(array)
round(1.0) | median(f64)
round(1.1)
round(abs(-1.0))
round(abs(1.0))
round(abs(f64))
round(abs(i))
round(array | max(array))
round(array | median(1.0))
round(array | reduce(#))
round(array | sum(#))
round(array | sum(0))
round(array | sum(1))
round(array | sum(f64))
round(array?.[0])
round(array?.[i])
round(bitand(0, i))
round(bitnand(1, 1))
round(bitnand(i, 1))
round(bitnot(0))
round(bitnot(1))
round(bitnot(i))
round(ceil(0))
round(ceil(1))
round(ceil(1.0))
round(ceil(f64))
round(ceil(i))
round(count($env, ok))
round(count($env, true))
round(f64 * 0)
round(f64 * 1)
round(f64 * 1.0)
round(f64 * i)
round(f64 ** $env.f64)
round(f64 ** 0)
round(f64 + 0)
round(f64 + 1.0)
round(f64 - 0)
round(f64 - 1.0)
round(f64 - f64)
round(f64 - i)
round(f64 / 0)
round(f64 / 1.0)
round(f64 / f64)
round(f64 ?? $env)
round(f64 ?? 0)
round(f64 ?? add)
round(f64 ?? array)
round(f64 ?? foo)
round(f64 ?? greet)
round(f64 ?? list)
round(f64 ?? nil)
round(f64 ?? ok)
round(f64 ^ 1)
round(f64 ^ 1.0)
round(f64 ^ f64)
round(f64 ^ i)
round(f64 | median(0))
round(f64)
round(f64) != $env?.f64
round(f64) != f64
round(f64) + f64
round(f64) + f64 < 0
round(f64) < i
round(f64) <= i
round(f64) >= i
round(false ? 0 : 1.0)
round(false ?: 1)
round(find(array, true))
round(findIndex(array, true))
round(findIndex(list, ok))
round(findLast(array, ok))
round(findLastIndex($env, true))
round(findLastIndex(array, ok))
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)
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 - 0)
round(i - 1)
round(i - 1.0)
round(i - f64)
round(i / 1)
round(i / 1.0)
round(i / f64)
round(i / i)
round(i ?? $env)
round(i ?? 1.0)
round(i ?? add)
round(i ?? false)
round(i ?? list)
round(i ?? nil)
round(i ^ 0)
round(i ^ 1)
round(i ^ 1.0)
round(i ^ f64)
round(i)
round(i) ** i
round(i) + i
round(i) / i
round(i) < 1.0 != $env
round(i) <= 1.0 ? foo : add
round(i) == i
round(i) > $env?.i
round(i) > f64
round(i) ?? add
round(i) ?? f64
round(i) ?? foo
round(i) ?? str
round(i) ^ i
round(i) | median(f64)
round(if false { foo } else { 0 })
round(if true { 0 } else { greet })
round(int(0))
round(int(1))
round(int(1.0))
round(int(f64))
round(int(i))
round(int(string(1.0)))
round(last(array))
round(len($env))
round(len(array))
round(len(list))
round(len(str))
round(list | count(ok))
round(list | reduce(1))
round(list | reduce(1.0, $env))
round(list | reduce(1.0, 1.0))
round(list | reduce(f64))
round(map(list, 1.0) | max(1))
round(max(0))
round(max(1))
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(array, i, array))
round(mean(f64))
round(mean(f64, f64))
round(mean(i))
round(median($env.array))
round(median(0))
round(median(1))
round(median(1.0))
round(median(array))
round(median(array, 1.0))
round(median(f64))
round(median(f64, i))
round(median(i))
round(min(0))
round(min(1))
round(min(1.0))
round(min(1.0, 1.0))
round(min(array))
round(min(array, 0))
round(min(array, array, array))
round(min(f64))
round(min(i))
round(nil ?? 1)
round(nil ?? 1.0)
round(nil ?? f64)
round(ok ? i : 0)
round(reduce(array, #))
round(reduce(array, #, nil))
round(reduce(array, 1.0))
round(reduce(array, i))
round(reduce(list, #index, nil))
round(round(0))
round(round(1))
round(round(1.0))
round(sum($env, 0))
round(sum($env, 1))
round(sum($env, f64))
round(sum($env, i))
round(sum(array))
sort($env ?? $env)
sort($env ?? add)
sort($env ?? array)
sort($env ?? f64)
sort($env ?? false)
sort($env ?? foo)
sort($env ?? greet)
sort($env ?? list)
sort($env ?? nil)
sort($env ?? ok)
sort($env | filter(false))
sort($env | find(false))
sort($env | map(#index))
sort($env | map(0))
sort($env) != $env?.String
sort($env) != array
sort($env) ?? $env?.array
sort($env) ?? greet
sort($env) ?? type(list)
sort($env) | all(#)
sort($env) | all(#.Bar)
sort($env) | all(#.String)
sort($env) | all(#.add)
sort($env) | all(#.array)
sort($env) | all(#.foo?.Bar)
sort($env) | all(#.ok)
sort($env) | all($env)
sort($env) | all(.foo?.[array])
sort($env) | all(.str)
sort($env) | all(true)
sort($env) | any(#)
sort($env) | any(#.f64)
sort($env) | any(#.i)
sort($env) | any(.String)
sort($env) | any(.array)
sort($env) | concat(list)
sort($env) | count(#)
sort($env) | count(#.Bar)
sort($env) | count(#.foo)
sort($env) | count(#.i == 0)
sort($env) | count($env)
sort($env) | count(.f64)
sort($env) | count(false)
sort($env) | filter(#)
sort($env) | filter(#.String)
sort($env) | filter(#.i)
sort($env) | filter(#.list)
sort($env) | find(#)
sort($env) | find(#.Bar)
sort($env) | find(#.list)
sort($env) | find($env)
sort($env) | find(.String[#.array:true])
sort($env) | find(.array)
sort($env) | find(.i)
sort($env) | find(false)
sort($env) | findIndex(#)
sort($env) | findIndex(#.add)
sort($env) | findIndex(#.array)
sort($env) | findIndex(.String)
sort($env) | findIndex(.array)
sort($env) | findIndex(.foo)
sort($env) | findIndex(.ok)
sort($env) | findIndex(false)
sort($env) | findIndex(ok)
sort($env) | findLast(#)
sort($env) | findLast(#.array)
sort($env) | findLast(#.list?.foo(#))
sort($env) | findLast(#.str)
sort($env) | findLast(false)
sort($env) | findLastIndex(#)
sort($env) | findLastIndex(#.add)
sort($env) | findLastIndex(#.list)
sort($env) | findLastIndex($env)
sort($env) | findLastIndex(.Bar)
sort($env) | findLastIndex(.foo)
sort($env) | groupBy(#)
sort($env) | groupBy(#.Bar)
sort($env) | groupBy(#.add)
sort($env) | groupBy(#.greet / #)
sort($env) | groupBy(#.greet)
sort($env) | groupBy(#?.foo(i))
sort($env) | groupBy(.array)
sort($env) | groupBy(.greet)
sort($env) | groupBy(0)
sort($env) | groupBy(1.0)
sort($env) | groupBy(add)
sort($env) | groupBy(f64)
sort($env) | groupBy(i)
sort($env) | groupBy(list)
sort($env) | groupBy(ok)
sort($env) | map(#)
sort($env) | map(#.Bar)
sort($env) | map(#.f64)
sort($env) | map($env)
sort($env) | map(.array)
sort($env) | map(.foo)
sort($env) | map(.list)
sort($env) | map(1)
sort($env) | map(1.0)
sort($env) | map(f64 ?? 0)
sort($env) | map(foo)
sort($env) | map(i)
sort($env) | map(true)
sort($env) | mean(1.0)
sort($env) | none(#)
sort($env) | none(#.add[foobar:])
sort($env) | none(#.list)
sort($env) | none(#.ok)
sort($env) | none($env)
sort($env) | none(.String)
sort($env) | none(.add)
sort($env) | none(.array)
sort($env) | none(.foo)
sort($env) | none(.list)
sort($env) | one(#.add)
sort($env) | one(#.f64)
sort($env) | one(#.greet)
sort($env) | one(#.list)
sort($env) | one(#.ok)
sort($env) | one(#.ok.nil)
sort($env) | one(#.str)
sort($env) | one($env)
sort($env) | one(.Bar)
sort($env) | one(.f64)
sort($env) | one(.f64?.[.greet])
sort($env) | one(.list)
sort($env) | one(false)
sort($env) | one(ok)
sort($env) | reduce(#.String, nil)
sort($env) | reduce(#.greet, str)
sort($env) | reduce(false, 0)
sort($env) | reduce(foo, foo)
sort($env) | sortBy(#)
sort($env) | sortBy(#.String)
sort($env) | sortBy(.add)
sort($env) | sortBy(.f64)
sort($env) | sortBy(1.0)
sort($env) | sortBy(foo)
sort($env) | sortBy(i)
sort($env) | sortBy(str)
sort($env) | sum(#.foo)
sort($env) | sum(#.greet)
sort($env) | sum(#.str?.String)
sort($env) | sum($env)
sort($env) | sum(.array)
sort($env) | sum(1.0)
sort($env) | sum(array)
sort($env) | sum(false)
sort($env) | sum(foo)
sort($env) | sum(not #.array)
sort($env)?.[i]
sort($env)?.[i].add()
sort($env)?.[i]?.[array]
sort($env)[:]
sort($env.array)
sort($env?.$env)
sort($env?.Bar)
sort($env?.Bar?.[ok])
sort($env?.Bar?.greet)
sort($env?.String)
sort($env?.String) | one(.str.add(foobar))
sort($env?.[Bar])
sort($env?.[Bar]) ?? array
sort($env?.[Bar]?.[array])
sort($env?.[Bar]?.foo())
sort($env?.[String])
sort($env?.[foobar])
sort($env?.[foobar]?.[add])
sort($env?.[nil])
sort($env?.[nil]?.String().array)
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(0 .. i)
sort(0 ?? 1.0)
sort(0 ?? foo)
sort(0 ?? foo.Bar)
sort(0 ?? ok)
sort(1 .. 1)
sort(1 ?? 1.0)
sort(1 ?? array)
sort(1 ?? false)
sort(1 ?? foo)
sort(1 ?? greet)
sort(1 ?? ok)
sort(1..i)
sort(1.0 ?? $env)
sort(1.0 ?? 0)
sort(1.0 ?? false)
sort(1.0 ?? foo)
sort(1.0 ?? greet)
sort(1.0 ?? i)
sort(1.0 ?? ok)
sort(1.0 ?? str)
sort(1.0 ?? true)
sort([$env])
sort([0 .. 0])
sort([0])
sort([1 ?? 0])
sort([1.0])
sort([1])
sort([add])
sort([array])
sort([f64])
sort([false])
sort([foo])
sort([greet])
sort([i])
sort([list])
sort([nil])
sort([ok])
sort([str])
sort([true])
sort(add ?? $env)
sort(add ?? 0)
sort(add ?? 1.0)
sort(add ?? array)
sort(add ?? greet)
sort(add ?? i)
sort(add ?? ok)
sort(array ?? 0)
sort(array ?? array)
sort(array ?? foo)
sort(array ?? nil)
sort(array ?? true)
sort(array | filter(ok))
sort(array | map(#))
sort(array | map(1))
sort(array | mean(1))
sort(array | median(1, i))
sort(array | sortBy(#))
sort(array | sortBy(f64))
sort(array | sortBy(str))
sort(array | sum(#)..i)
sort(array)
sort(array) != list
sort(array) == list
sort(array) ?? mean(f64)
sort(array) ?? not ok
sort(array) | filter(true)
sort(array) | find(true)
sort(array) | findIndex($env?.ok)
sort(array) | findLast(ok)
sort(array) | findLastIndex(false)
sort(array) | get(i)
sort(array) | groupBy(#)
sort(array) | groupBy(foo)
sort(array) | groupBy(str)
sort(array) | map(#)
sort(array) | map(0)
sort(array) | map(1.0)
sort(array) | map(foo)
sort(array) | map(list)
sort(array) | map(ok)
sort(array) | one(false)
sort(array) | reduce(#)
sort(array) | reduce(#index)
sort(array) | reduce($env)
sort(array) | reduce(foo)
sort(array) | reduce(list, greet)
sort(array) | reduce(true, 1.0)
sort(array) | sortBy(#)
sort(array) | sortBy(1)
sort(array)?.[i]
sort(array[0:])
sort(array[:0])
sort(concat(array))
sort(f64 ?? $env)
sort(f64 ?? foo)
sort(false ? true : 0)
sort(false ?: $env)
sort(false ?: 1.0)
sort(false ?: i)
sort(false ?: list)
sort(false ?? $env)
sort(false ?? add)
sort(false ?? array)
sort(false ?? foo)
sort(false ?? greet)
sort(false ?? list)
sort(filter($env, false))
sort(filter(list, false))
sort(first($env))
sort(flatten(array))
sort(foo ?? $env)
sort(foo ?? 0)
sort(foo ?? 1)
sort(foo ?? 1.0)
sort(foo ?? add)
sort(foo ?? array)
sort(foo ?? f64)
sort(foo ?? false)
sort(foo ?? i)
sort(foo ?? ok)
sort(foo ?? true)
sort(greet ?? $env)
sort(greet ?? foo)
sort(i .. 0)
sort(i .. 1)
sort(i ?? $env)
sort(i ?? 1.0)
sort(i ?? f64)
sort(i ?? list)
sort(if false { 1 } else { 1.0 })
sort(if false { 1.0 } else { 1 })
sort(if false { false } else { f64 })
sort(if false { foo } else { 1.0 })
sort(if false { nil } else { $env })
sort(if ok { ok } else { 1.0 })
sort(if true { add } else { str })
sort(if true { array } else { i })
sort(if true { f64 } else { $env })
sort(if true { foo } else { 1.0 })
sort(if true { greet } else { 1 })
sort(keys($env))
sort(last($env))
sort(list ?? 1)
sort(list ?? 1.0)
sort(list ?? add)
sort(list ?? str)
sort(list ?? true)
sort(list | map(#.Bar))
sort(list | reduce(array))
sort(map($env, #index))
sort(map($env, i))
sort(map(array, #))
sort(map(array, 0))
sort(map(array, 1.0))
sort(map(list, #.Bar))
sort(map(list, 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(nil ?? $env)
sort(ok ? 1.0 : $env)
sort(ok ? list : str)
sort(ok ?: 1.0)
sort(ok ?: list)
sort(ok ?? 0)
sort(ok ?? add)
sort(ok ?? f64)
sort(ok ?? foo)
sort(ok ?? list)
sort(reduce(array, $env))
sort(reduce(array, array))
sort(reduce(list, $env))
sort(reverse(array))
sort(sort($env))
sort(sort([str]))
sort(sort(array))
sort(sortBy(array, 1.0))
sort(str ?? $env)
sort(str ?? $env.list)
sort(str ?? 0)
sort(str ?? 1.0)
sort(str ?? foo)
sort(str ?? greet)
sort(str ?? true)
sort(toPairs($env))
sort(true ? 0 : $env)
sort(true ? i : 1.0)
sort(true ? list : 1)
sort(true ?? 1.0)
sort(true ?? f64)
sort(true ?? foo)
sort(true ?? greet)
sort(true ?? str)
sort({foo: 1.0}.add)
sort({foo: foo, foo: add}.Bar)
sort({foo: nil, foo: foo}.add)
sort({foo: nil}.i)
sort({foo: str}.greet)
sort({foo: true}.Bar)
sortBy($env, #) == $env || true
sortBy($env.array, #)
sortBy($env.array, f64)
sortBy($env.array, str)
sortBy($env.list, #.Bar)
sortBy($env.list, f64)
sortBy($env.list, i)
sortBy($env.list, str)
sortBy($env?.[str], #)
sortBy($env?.[str], $env?.i)
sortBy($env?.[str], f64)
sortBy($env?.[str], str)
sortBy($env?.array, #)
sortBy($env?.array, str)
sortBy($env?.list, .Bar)
sortBy($env?.list, f64)
sortBy($env?.list, i)
sortBy(0 .. 0, #)
sortBy(0 .. 0, str)
sortBy(0 .. 1, #)
sortBy(0 .. i, # ^ i)
sortBy([$env], #)
sortBy([$env], #.String?.[foo])
sortBy([$env], #?.add)
sortBy([$env], .list)
sortBy([$env], f64 ?? .array)
sortBy([$env], greet)
sortBy([$env], str)
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], # + #)
sortBy([f64], add)
sortBy([f64], array)
sortBy([f64], f64)
sortBy([f64], i)
sortBy([false], list)
sortBy([foo], #)
sortBy([foo], #?.Bar)
sortBy([foo], add)
sortBy([foo], array)
sortBy([foo], foo)
sortBy([greet], #)
sortBy([groupBy(array, #)], #)
sortBy([i], array)
sortBy([list], #)
sortBy([nil], add)
sortBy([nil], array)
sortBy([ok], add)
sortBy([str], #)
sortBy([str], findIndex(list, ok))
sortBy([true], f64)
sortBy([true], i)
sortBy(array ?? 1.0, #)
sortBy(array ?? f64, f64)
sortBy(array | sortBy(#), #)
sortBy(array, # * #)
sortBy(array, # ** #)
sortBy(array, # + #)
sortBy(array, # - 1)
sortBy(array, # / #)
sortBy(array, # / f64)
sortBy(array, # ?? #)
sortBy(array, # ?? foo)
sortBy(array, # ?? str)
sortBy(array, # ^ #)
sortBy(array, # ^ 1)
sortBy(array, # | bitshl(#))
sortBy(array, # | mean(#, #))
sortBy(array, #)
sortBy(array, #) | any(ok)
sortBy(array, #) | findIndex(false)
sortBy(array, #) | groupBy(true)
sortBy(array, #) | map(#)
sortBy(array, #) | map($env)
sortBy(array, #) | map(0)
sortBy(array, #) | map(foo)
sortBy(array, #) | min(array, 1)
sortBy(array, #) | reduce(#)
sortBy(array, #) | reduce(#, 1)
sortBy(array, #) | reduce($env)
sortBy(array, #) | reduce(1.0, nil)
sortBy(array, #) | reduce(true, 1.0)
sortBy(array, #)?.[i]
sortBy(array, $env.f64)
sortBy(array, $env.i)
sortBy(array, $env.str)
sortBy(array, $env?.[str])
sortBy(array, $env?.i)
sortBy(array, -#)
sortBy(array, -0)
sortBy(array, -1.0)
sortBy(array, 0 * #)
sortBy(array, 0 ** #)
sortBy(array, 0 - 1)
sortBy(array, 0) | map(#)
sortBy(array, 0) | sortBy(#)
sortBy(array, 0)?.[i]
sortBy(array, 1 ** f64)
sortBy(array, 1 + #)
sortBy(array, 1 / #)
sortBy(array, 1 ?? false)
sortBy(array, 1 ^ #)
sortBy(array, 1) | all(ok)
sortBy(array, 1) | groupBy(#)
sortBy(array, 1) | reduce($env)
sortBy(array, 1) | reduce(foo)
sortBy(array, 1)?.[i]
sortBy(array, 1.0 ^ #)
sortBy(array, 1.0) | findLast(false)
sortBy(array, 1.0) | max(1.0)
sortBy(array, 1.0)?.[i]
sortBy(array, abs(#))
sortBy(array, bitnand(#, #))
sortBy(array, bitnot(#))
sortBy(array, f64 ** #)
sortBy(array, f64)
sortBy(array, f64) | groupBy(1.0)
sortBy(array, f64) | reduce(#, 1.0)
sortBy(array, f64)?.[i]
sortBy(array, findLast(array, ok))
sortBy(array, findLastIndex($env, ok))
sortBy(array, float(1))
sortBy(array, foo.Bar)
sortBy(array, foo?.Bar)
sortBy(array, i ** #)
sortBy(array, i + 1)
sortBy(array, i - #)
sortBy(array, i)
sortBy(array, i) | find(false)
sortBy(array, i) | map(list)
sortBy(array, i)?.[i]
sortBy(array, max(#))
sortBy(array, mean(#))
sortBy(array, median(1.0))
sortBy(array, min(#))
sortBy(array, round(#))
sortBy(array, round(i))
sortBy(array, str)
sortBy(array, str) | groupBy(1.0)
sortBy(array, str) | map(list)
sortBy(array, str) | none(ok)
sortBy(array, str) | reduce(#)
sortBy(array, str) | reduce(ok)
sortBy(array, str) | sortBy(0)
sortBy(array, str)?.[i]
sortBy(array, string(1.0))
sortBy(array, toJSON(f64))
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(filter($env, false), .add)
sortBy(filter($env, false), findLast($env, #.greet))
sortBy(flatten(array), #)
sortBy(flatten(list), f64)
sortBy(flatten(list), str)
sortBy(let foobar = array; foobar, # * 1.0)
sortBy(list | map(i), # ^ #)
sortBy(list, #.Bar)
sortBy(list, #.Bar) | map(#)
sortBy(list, #.Bar)?.[i]
sortBy(list, #.String())
sortBy(list, #?.Bar)
sortBy(list, $env.f64)
sortBy(list, $env.i)
sortBy(list, $env.str)
sortBy(list, $env?.[str])
sortBy(list, $env?.i)
sortBy(list, -0)
sortBy(list, -1.0)
sortBy(list, -f64)
sortBy(list, .Bar)
sortBy(list, .Bar) != list
sortBy(list, .Bar) | sum(f64)
sortBy(list, 0 ^ 0)
sortBy(list, 0) ?? greet
sortBy(list, 0)?.[i]
sortBy(list, 1 ?? #)
sortBy(list, 1 ?? greet)
sortBy(list, 1)?.[i]
sortBy(list, 1.0 ** f64)
sortBy(list, 1.0 + i)
sortBy(list, 1.0) | groupBy(true)
sortBy(list, 1.0) | map(list)
sortBy(list, 1.0) | reduce(greet)
sortBy(list, 1.0) | sortBy(i)
sortBy(list, 1.0)?.[$env?.i]
sortBy(list, 1.0)?.[i]
sortBy(list, abs(0))
sortBy(list, abs(f64))
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, foo.String())
sortBy(list, foo?.Bar)
sortBy(list, greet(#.Bar))
sortBy(list, greet(.Bar))
sortBy(list, greet(str))
sortBy(list, i ?? #)
sortBy(list, i ?? $env)
sortBy(list, i)
sortBy(list, i) == list
sortBy(list, i) | one(false)
sortBy(list, i) | reduce($env)
sortBy(list, i) | reduce(add)
sortBy(list, i)?.[i]
sortBy(list, len(#.Bar))
sortBy(list, len(list))
sortBy(list, reduce(array, i))
sortBy(list, round(1))
sortBy(list, round(1.0))
sortBy(list, str)
sortBy(list, str) | map(0)
sortBy(list, str) | map(array)
sortBy(list, str) | reduce(true)
sortBy(list, str)?.[i]
sortBy(list, string(#.Bar))
sortBy(list, string(1.0))
sortBy(list, string(greet))
sortBy(list, string(ok))
sortBy(list, sum(array))
sortBy(list, toBase64(#.Bar))
sortBy(list, toBase64(str))
sortBy(list, toJSON(#.Bar))
sortBy(list, toJSON(i))
sortBy(list, trimPrefix(str))
sortBy(list, type(1.0))
sortBy(list, type(add))
sortBy(list, type(false))
sortBy(list, type(list))
sortBy(map($env, greet), type(f64))
sortBy(map(array, #), #)
sortBy(map(array, add), bitnot(1))
sortBy(sort($env), #)
sortBy(sort($env), #.array .. .f64)
sortBy(sort($env), f64)
sortBy(sort($env), map(#.list, array))
sortBy(sort($env), ok)
sortBy(sortBy(array, i), #)
sortBy(take(list, 1), #)
sortBy(uniq(array), #)
split($env.str, str)
split(str, $env?.[str])
split(str, $env?.str)
split(str, str)
split(str, str)?.[i]
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 ?? $env
str != $env ?? 1.0
str != $env ?? i
str != $env and false
str != $env and ok
str != $env or $env
str != $env or false
str != $env.str
str != $env?.Bar
str != $env?.String
str != $env?.[Bar]
str != $env?.[String]
str != $env?.[foobar]
str != $env?.[nil]
str != $env?.[str]
str != $env?.foobar
str != $env?.foobar?.[greet]
str != $env?.str
str != 0 ?? array
str != 1 ?? f64
str != 1 ?? foo
str != 1.0 ?? 1
str != 1.0 ?? concat($env, $env)
str != 1.0 ?? list
str != add ?? foo
str != array ?? $env?.[String]
str != f64 ?? array
str != first($env)
str != foo ?? $env?.greet
str != foo ?? 1.0
str != foo ?? array
str != foo ?? f64
str != foo ?? false
str != foo ?? greet
str != foo ?? greet and $env
str != foo.Bar
str != foo.String()
str != foo?.Bar
str != foo?.String()
str != greet ?? $env?.[String]
str != greet ?? array
str != greet ?? ok
str != greet(str)
str != i ?? array
str != list ?? 1
str != list ?? false
str != list ?? true
str != lower(str)
str != median(array)
str != min(array, array)
str != nil != nil
str != nil && $env
str != nil == true
str != nil ? foo : f64
str != nil ?? $env
str != nil or $env
str != nil or $env?.[Bar]
str != nil or ok
str != nil || $env
str != nil || false
str != nil || ok
str != ok ?? 1
str != reduce(array, #acc, foo)
str != reduce(list, .Bar, false)
str != str
str != str != false
str != str && $env?.String.i()
str != str && true
str != str ? 0 : 1.0
str != str ? foo : true
str != str ?? 1.0
str != str ?? i
str != str ?? ok
str != str and $env
str != str || $env
str != str || false
str != string(1.0)
str != string(f64)
str != string(false)
str != string(list)
str != toJSON(1.0)
str != toJSON(false)
str != toJSON(foo)
str != trim(str)
str != true ?? f64
str != true ?? str
str != type($env)
str != type(false)
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 + repeat(str, 1)
str + str
str + str != $env
str + str ?? foo
str + str in max($env)
str + str not in $env
str + string($env)
str + string(add)
str + string(f64)
str + string(list)
str + string(nil)
str + string(str)
str + toBase64(str)
str + toJSON(1.0)
str + toJSON(false)
str + toJSON(i)
str + toJSON(list)
str + toJSON(nil)
str + toJSON(ok)
str + toJSON(str)
str + type($env)
str + type(foo)
str < $env && false
str < $env.str
str < $env?.[str]
str < $env?.str
str < -$env or true
str < foo.Bar
str < foo.String()
str < foo?.Bar
str < foo?.String()
str < greet(str)
str < nil ?? str
str < str
str < str && false
str < str and ok
str < str || ok
str < string($env)
str < string(add)
str < string(foo)
str < string(greet)
str < string(str)
str < toJSON(foo)
str < type(array)
str < type(nil)
str < type(str)
str < type(true)
str <= $env or 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 != $env
str <= str != nil
str <= str ?: str
str <= str ?? f64
str <= str[:i]
str <= string($env)
str <= string(0)
str <= string(i)
str <= string(list)
str <= string(nil)
str <= string(true)
str <= toJSON(1.0)
str <= toJSON(f64)
str <= toJSON(foo)
str <= toJSON(nil)
str <= toJSON(ok)
str <= type(1.0)
str <= type(add)
str <= type(foo)
str <= type(list)
str <= type(str)
str <= type(true)
str == $env != nil
str == $env && ok
str == $env ?? 1
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?.[Bar]?.[list]
str == $env?.[String]
str == $env?.[String]?.add
str == $env?.[String]?.array
str == $env?.[foobar]
str == $env?.[str]
str == $env?.foo.Bar
str == $env?.foobar
str == $env?.foobar?.String
str == $env?.not
str == $env?.str
str == $env?.true
str == 0 ?? 1.0
str == 1 ?? add
str == 1.0 ?? foo
str == add ?? list
str == f64 ?? 0
str == false ?? str
str == first($env)
str == foo ?? add
str == foo ?? str
str == foo.Bar
str == foo.String()
str == foo?.Bar
str == foo?.String()
str == greet(str)
str == i ?? array
str == list ?? foo
str == max($env)
str == nil == ok
str == nil ?: list
str == nil or true || $env
str == reduce(array, str)
str == str
str == str || $env[true:]
str == str || true
str == string(add)
str == string(foo)
str == string(ok)
str == toBase64(str | repeat(0))
str == toJSON(0)
str == toJSON(1.0)
str == toJSON(f64)
str == toJSON(nil)
str == trim(str)
str == true ?? foo
str == type(add)
str == type(foo)
str == type(greet)
str == upper(str)
str == {foo: 1}.array
str > $env or true
str > $env || true
str > $env.str
str > $env?.[str]
str > $env?.foo?.String()
str > $env?.str
str > foo.Bar
str > foo.Bar < foo.Bar
str > foo.String()
str > foo?.Bar
str > foo?.String()
str > str
str > str + $env.str
str > str + str
str > str < $env?.str
str > str > $env?.Bar
str > str > $env?.[list]
str > str ?: 1
str > str ?: str
str > str and true
str > str[1:]
str > str[int(0):]
str > string($env)
str > string(nil)
str > string(true)
str > toJSON(1.0)
str > toJSON(foo)
str > toJSON(ok)
str > trimSuffix(str)
str > type(1)
str > type(1.0)
str > type(add)
str > type(false)
str > type(nil)
str > upper(toJSON(false))
str >= $env && false
str >= $env or true
str >= $env.str
str >= $env?.[str]
str >= $env?.[str] ?? list
str >= $env?.foo.Bar
str >= $env?.str
str >= foo.Bar
str >= foo.String()
str >= foo?.Bar
str >= foo?.String()
str >= greet(str)
str >= str
str >= str != $env
str >= str ?? nil
str >= string(1)
str >= string(1.0)
str >= string(add)
str >= string(str)
str >= toJSON(false)
str >= toJSON(str)
str >= type(1)
str >= type(list)
str ?? !$env
str ?? !ok
str ?? $env ?? f64
str ?? $env ?? foo
str ?? $env ?? foo?.String
str ?? $env ?? list
str ?? $env ?? ok
str ?? $env ?? str
str ?? $env | any(false)
str ?? $env | greet()
str ?? $env | groupBy(#)
str ?? $env | map(#)
str ?? $env | reduce(#)
str ?? $env | reduce($env, false)
str ?? $env | reduce(0)
str ?? $env | reduce(foo, foo)
str ?? $env | reduce(true, 1.0)
str ?? $env | sum(#)
str ?? $env.add
str ?? $env.array
str ?? $env.f64
str ?? $env.foo
str ?? $env.greet
str ?? $env.i
str ?? $env.list
str ?? $env.ok
str ?? $env.str
str ?? $env?.Bar
str ?? $env?.Bar()
str ?? $env?.Bar(foo)
str ?? $env?.Bar(list)
str ?? $env?.String
str ?? $env?.String()
str ?? $env?.String(foo contains foobar)
str ?? $env?.[1.0]
str ?? $env?.[Bar | any(1)]
str ?? $env?.[Bar()]
str ?? $env?.[Bar]
str ?? $env?.[Bar].String()
str ?? $env?.[String]
str ?? $env?.[String].list
str ?? $env?.[[foo]]
str ?? $env?.[add]
str ?? $env?.[add].greet
str ?? $env?.[add]?.[f64]
str ?? $env?.[array]
str ?? $env?.[array].f64()
str ?? $env?.[f64]
str ?? $env?.[f64].f64
str ?? $env?.[foo]
str ?? $env?.[foobar]
str ?? $env?.[greet]
str ?? $env?.[i]
str ?? $env?.[i]?.foo
str ?? $env?.[list]
str ?? $env?.[list]?.add?.[array]
str ?? $env?.[list]?.i
str ?? $env?.[nil]
str ?? $env?.[ok]
str ?? $env?.[ok]?.Bar
str ?? $env?.[str]
str ?? $env?.add
str ?? $env?.array
str ?? $env?.f64
str ?? $env?.foo
str ?? $env?.foobar
str ?? $env?.greet
str ?? $env?.i
str ?? $env?.list
str ?? $env?.nil
str ?? $env?.ok
str ?? $env?.str
str ?? $env[:foobar]
str ?? $env[:list?.f64()]
str ?? $env[f64:]
str ?? $env[ok:]
str ?? -$env
str ?? -0
str ?? -1
str ?? -1.0
str ?? -i
str ?? 0 | all(false)
str ?? 0 | groupBy(foo)
str ?? 0 | map(greet)
str ?? 0 | map(ok)
str ?? 0 | sum(f64)
str ?? 1 ?? foo
str ?? 1 | greet()
str ?? 1 | map(foo)
str ?? 1 | map(i)
str ?? 1.0 ?? foo
str ?? 1.0 | findLast(true)
str ?? 1.0 | findLastIndex(ok)
str ?? 1.0 | groupBy(#)
str ?? 1.0 | groupBy(0)
str ?? 1.0 | map(#)
str ?? 1.0 | map(1)
str ?? 1.0 | map(1.0)
str ?? 1.0 | reduce(#)
str ?? 1.0 | reduce(false == #)
str ?? 1.0 | sum(#)
str ?? [0, i]
str ?? [1.0]
str ?? [f64]
str ?? [foo]
str ?? [nil]
str ?? [true]
str ?? add
str ?? add ?? $env
str ?? add | count(true)
str ?? add | map(add)
str ?? add | reduce(foo)
str ?? add | reduce(greet)
str ?? all($env, #)
str ?? all(list, $env)
str ?? array
str ?? array | findIndex(true)
str ?? array | map(array)
str ?? array | none(true)
str ?? array?.[i]
str ?? concat(array)
str ?? count($env)
str ?? date(array)
str ?? date(greet)
str ?? date(ok, foo)
str ?? duration(str)
str ?? f64
str ?? f64 | groupBy(#)
str ?? false | count(false)
str ?? false | findLastIndex(# not in list)
str ?? false | groupBy(#)
str ?? false | map(0)
str ?? false | map(foo)
str ?? false | reduce(#)
str ?? findIndex($env, #)
str ?? first($env)
str ?? float(1.0)
str ?? floor(1)
str ?? foo
str ?? foo ?? $env
str ?? foo ?? 1.0
str ?? foo ?? f64
str ?? foo ?? list
str ?? foo ?? nil
str ?? foo ?? ok
str ?? foo ?? str
str ?? foo | any(ok)
str ?? foo | count(ok)
str ?? foo | findLastIndex(false)
str ?? foo | findLastIndex(ok)
str ?? foo | groupBy(1.0)
str ?? foo | map(#)
str ?? foo | map(ok)
str ?? foo | none(ok)
str ?? foo | none(true)
str ?? foo | one(false)
str ?? foo | reduce(#, 1)
str ?? foo | reduce(add)
str ?? foo | reduce(greet, foo)
str ?? foo | reduce(i, nil)
str ?? foo | sortBy(0)
str ?? foo | sum(#)
str ?? foo.Bar
str ?? foo.String
str ?? foo.String()
str ?? foo?.Bar
str ?? foo?.String
str ?? fromJSON($env)
str ?? greet
str ?? greet | greet()
str ?? greet | groupBy(1.0)
str ?? greet | groupBy(i)
str ?? greet | groupBy(ok)
str ?? greet | none(true)
str ?? greet | reduce(#)
str ?? greet | reduce(str)
str ?? greet($env)
str ?? greet(str)
str ?? groupBy($env, 1.0)
str ?? i
str ?? i ?? 1
str ?? i ?? ok
str ?? i | map(true)
str ?? i | reduce(#)
str ?? i | reduce($env)
str ?? i | reduce($env, greet)
str ?? i | reduce(false)
str ?? i | sortBy(#)
str ?? i | sum(#)
str ?? indexOf($env, str)
str ?? len(list)
str ?? list
str ?? list ?? $env | reduce(#)
str ?? list ?? true
str ?? list | any(ok)
str ?? list | map(list)
str ?? list | map(str)
str ?? list | sortBy(f64)
str ?? list?.[i]
str ?? map($env, add)
str ?? map(array, 1)
str ?? max($env)
str ?? max(0, 1)
str ?? max(1.0)
str ?? mean(array).i()
str ?? min(1.0)
str ?? min(list)
str ?? nil ?? list
str ?? nil | greet()
str ?? not $env
str ?? not false
str ?? not true
str ?? ok
str ?? ok ?? array
str ?? ok ?? toJSON(1)
str ?? ok | all(ok)
str ?? ok | find(ok)
str ?? ok | findIndex(false)
str ?? ok | groupBy(foo)
str ?? ok | map(#)
str ?? ok | map($env)
str ?? ok | map(list)
str ?? one($env, .greet)
str ?? reduce($env, #)
str ?? round(0)
str ?? sortBy(array, f64)
str ?? str
str ?? str ?? str
str ?? str[:sum(array)]
str ?? string(1)
str ?? string(array)
str ?? string(true)
str ?? sum($env)
str ?? sum($env, #.f64)
str ?? sum($env, .String)
str ?? sum(array, foo)
str ?? toJSON(0)
str ?? toJSON(foo)
str ?? toJSON(nil)
str ?? toJSON(str)
str ?? toPairs($env)
str ?? toPairs($env?.String)
str ?? trim($env)
str ?? trimSuffix($env)
str ?? true ?? greet
str ?? true | all(true)
str ?? true | find(false)
str ?? true | greet()
str ?? true | reduce(#)
str ?? true | reduce($env)
str ?? true | sum(1.0)
str ?? type(1)
str ?? type(1.0)
str ?? type(nil)
str ?? {foo: 1.0}
str ?? {foo: 1}
str ?? {foo: array}
str ?? {foo: nil}
str ?? {foo: true}
str contains $env.str
str contains $env?.Bar
str contains $env?.String
str contains $env?.String?.[i]
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 last($env)
str contains str
str contains str && ok
str contains str == ok
str contains str ?? $env
str contains str ?? list
str contains str ?? str
str contains str or $env?.[foo]
str contains str[:i]
str contains string(greet)
str contains string(ok)
str contains string(str)
str contains toJSON(f64)
str contains toJSON(foo)
str contains toJSON(nil)
str contains toJSON(ok)
str contains trimSuffix(str)
str contains type(foo)
str contains type(nil)
str contains type(ok)
str endsWith $env.str
str endsWith $env?.Bar
str endsWith $env?.Bar?.foo(foo)
str endsWith $env?.String
str endsWith $env?.[Bar]
str endsWith $env?.[Bar]?.add
str endsWith $env?.[String]
str endsWith $env?.[String]?.[add]
str endsWith $env?.[foobar]
str endsWith $env?.[str]
str endsWith $env?.foobar
str endsWith $env?.str
str endsWith first($env)
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 str == nil
str endsWith str ?? foo
str endsWith str ?? ok
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(nil)
str endsWith toJSON(str)
str endsWith toJSON(true)
str endsWith trimPrefix($env.str)
str endsWith trimSuffix(str)
str endsWith type($env)
str endsWith type(add)
str endsWith type(i)
str endsWith type(list)
str endsWith type(str)
str endsWith {foo: f64}.f64
str endsWith {foo: nil, foo: $env}?.f64
str in $env != $env
str in $env && $env
str in $env == ok
str in $env ?? $env?.[i]
str in $env ?? str
str in $env and $env
str in $env and false
str in $env and ok
str in $env || $env
str in $env || ok
str in $env.foo
str in $env?.Bar
str in $env?.String
str in $env?.String?.[f64]
str in $env?.[Bar]
str in $env?.[Bar]?.[ok]
str in $env?.[Bar]?.[str]
str in $env?.[String]
str in $env?.[String]?.str()
str in $env?.[foobar?.[str]]
str in $env?.[foobar]
str in $env?.foo
str in $env?.foobar
str in $env?.foobar?.greet
str in [$env, nil]
str in [nil]
str in array ?? foo
str in concat(array)
str in find($env, false)
str in find(list, true)
str in foo
str in foo != false
str in foo ?? greet
str in foo and array != array
str in foo and false
str in foo || $env
str in list?.[i]
str in min($env)
str in sort(array)
str in {foo: $env?.[Bar]}
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
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 last($env)
str matches lower(str)
str matches str
str matches str == nil
str matches str ?? 1.0
str matches str ?? foo
str matches str ?? i
str matches str || $env
str matches string($env)
str matches string($env?.[String])
str matches string(1)
str matches string(1.0)
str matches string(add)
str matches toBase64(str)
str matches toJSON(1.0)
str matches toJSON(nil)
str matches toJSON(ok)
str matches trimSuffix(str)
str matches type(0)
str matches type(1)
str matches type(f64)
str matches type(foo)
str matches type(greet)
str matches type(i)
str matches type(str)
str matches type(true)
str matches {foo: i}?.foobar
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?.[nil]
str not contains $env?.[str]
str not contains $env?.foobar
str not contains $env?.nil
str not contains $env?.str
str not contains $env?.true?.[greet]
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)
str not contains last($env)?.add
str not contains lower(str)
str not contains str
str not contains str && $env
str not contains str + str
str not contains str[:1]
str not contains string($env)
str not contains string(add)
str not contains string(nil)
str not contains string(str)
str not contains toJSON(0)
str not contains toJSON(array)
str not contains trim(str)
str not contains trimPrefix(str)
str not contains trimSuffix(str)
str not contains type(0)
str not contains type(foo)
str not contains type(greet)
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 and false
str not endsWith $env.str
str not endsWith $env?.Bar
str not endsWith $env?.Bar?.[list]
str not endsWith $env?.String
str not endsWith $env?.[Bar]
str not endsWith $env?.[Bar]?.String
str not endsWith $env?.[String]
str not endsWith $env?.[String]?.String
str not endsWith $env?.[String]?.[add]?.[add]
str not endsWith $env?.[String]?.[greet]
str not endsWith $env?.[foobar?.foo($env)]
str not endsWith $env?.[str]
str not endsWith $env?.false
str not endsWith $env?.foobar
str not endsWith $env?.greet(str)
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 ?? array
str not endsWith str ?? nil
str not endsWith str || $env.ok
str not endsWith str || true
str not endsWith string(1)
str not endsWith toBase64(str)
str not endsWith toJSON(foo)
str not endsWith trimSuffix(str)
str not endsWith type(i)
str not endsWith type(list)
str not endsWith upper(foo?.String())
str not endsWith {foo: foo}.i
str not in $env && $env
str not in $env == $env
str not in $env ? $env : $env
str not in $env ? 1.0 : false
str not in $env ?? list
str not in $env and false
str not in $env.foo
str not in $env?.Bar
str not in $env?.Bar?.add
str not in $env?.String
str not in $env?.String?.[ok]
str not in $env?.[Bar]
str not in $env?.[Bar]?.String
str not in $env?.[Bar]?.list
str not in $env?.[String]
str not in $env?.[String]?.[array]
str not in $env?.[String]?.add()
str not in $env?.[foobar]
str not in $env?.[foobar]?.[ok]
str not in $env?.[foobar]?.ok
str not in $env?.[nil]
str not in $env?.foo
str not in $env?.foobar
str not in $env?.foobar?.[ok]
str not in [greet, $env]
str not in [nil, add]
str not in [nil, greet]
str not in [nil]
str not in array ?? 1
str not in foo
str not in foo != false
str not in foo && $env
str not in foo && $env || true
str not in foo && false
str not in foo ? 1.0 : i
str not in foo ?? $env
str not in foo ?? f64
str not in foo ?? foo
str not in foo and false
str not in foo and ok
str not in foo or $env?.[f64]
str not in foo || $env
str not in foo || ok
str not in foo || true
str not in groupBy(array, 1)
str not in groupBy(list, #)
str not in list ?? foo
str not in list?.[i]
str not in map(list, #.Bar)
str not in nil ?? $env
str not in reduce($env, $env, list)
str not in reverse(array)
str not in reverse(list)
str not in toPairs($env)
str not in {foo: $env}
str not in {foo: 0, foo: add}
str not in {foo: 1.0}
str not in {foo: add}
str not in {foo: array}
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?.foobar?.[str]
str not matches $env?.nil
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 greet(str)
str not matches lower(str)
str not matches str
str not matches str == $env
str not matches str ?: {foo: $env}
str not matches str || ok
str not matches string(1)
str not matches string(foo)
str not matches toJSON(1.0)
str not matches toJSON(f64)
str not matches toJSON(foo)
str not matches toJSON(i)
str not matches toJSON(nil)
str not matches toJSON(ok)
str not matches trimSuffix(str)
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?.[Bar]?.i
str not startsWith $env?.[String]
str not startsWith $env?.[String]?.list
str not startsWith $env?.[foobar]?.[str]
str not startsWith $env?.[nil]
str not startsWith $env?.[str]
str not startsWith $env?.false?.[add]
str not startsWith $env?.nil
str not startsWith $env?.str
str not startsWith findLast($env, false)
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 last($env)
str not startsWith lower(str)
str not startsWith str
str not startsWith str ?: 1.0
str not startsWith str ?: ok
str not startsWith str and $env
str not startsWith string(false)
str not startsWith string(foo)
str not startsWith string(i)
str not startsWith string(nil)
str not startsWith string(ok)
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(i)
str not startsWith type(ok)
str not startsWith {foo: i}?.greet
str startsWith $env.str
str startsWith $env?.Bar
str startsWith $env?.String
str startsWith $env?.String?.[greet]
str startsWith $env?.String?.array
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 foo?.String()
str startsWith greet(str)
str startsWith lower(type(array))
str startsWith str
str startsWith str && ok
str startsWith str ?? nil
str startsWith str[1:]
str startsWith string($env)
str startsWith string(1.0)
str startsWith string(add)
str startsWith toBase64(str)
str startsWith toJSON(1.0)
str startsWith toJSON(foo)
str startsWith toJSON(list)
str startsWith toJSON(true)
str startsWith type($env)
str startsWith type(add)
str startsWith type(foo)
str startsWith type(i)
str startsWith type(true)
str | date(str)
str | greet()
str | greet() != $env?.$env
str | greet() < str
str | greet() not in foo
str | hasPrefix($env?.[str])
str | hasPrefix(str)
str | hasSuffix(str)
str | indexOf(str)
str | indexOf(toJSON(foo))
str | lastIndexOf(str)
str | repeat(0)
str | repeat(1)
str | repeat(i)
str | split(str)
str | split(str, i)
str | splitAfter($env?.[str])
str | splitAfter($env?.str)
str | splitAfter(foo?.Bar)
str | splitAfter(str)
str | splitAfter(str, 1)
str | trim(nil ?? str)
str | trim(str)
str | trim(type(1.0))
str | trimPrefix(str)
str | trimPrefix(toJSON(ok))
str | trimPrefix(type(i))
str | trimSuffix(str)
str; $env | count(false)
str; $env?.[Bar]
str; $env?.add
str; $env?.ok
str; add
str; array
str; f64
str; foo
str; greet
str; i
str; ok
str; str
str; uniq(array)
str[$env?.i:]
str[-0:]
str[-1:]
str[0:] + str ?? i
str[1 ?? add:]
str[1.0 ?? foo:]
str[1:] endsWith str
str[1:] not contains str
str[1:] | greet()
str[:$env.i]
str[:$env?.i]
str[:-1]
str[:-i]
str[:0 % i]
str[:0] matches str
str[:]
str[:] <= str
str[:array | reduce(#)]
str[:array?.[i]]
str[:i]
str[:int(i)]
str[:last(array)]
str[:median(1, 1.0)]
str[:min(0)]
str[:nil ?? 0]
str[:sum(array)]
str[f64 ?? str:]
str[first(array):]
str[i:]
str[i:] endsWith str
str[i:] not endsWith str
str[i:i]
str[len(str):]
str[nil ?? 0:]
str[sum(array):]
string(!false)
string(!ok)
string(!true)
string($env != 0)
string($env != 1)
string($env != 1.0)
string($env != add)
string($env != f64)
string($env != false)
string($env != foo)
string($env != foo?.String())
string($env != greet)
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 == 1.0)
string($env == array)
string($env == f64)
string($env == false)
string($env == foo)
string($env == greet)
string($env == nil)
string($env == str)
string($env ?? $env)
string($env ?? 1)
string($env ?? 1.0)
string($env ?? add)
string($env ?? f64)
string($env ?? false)
string($env ?? foo)
string($env ?? list)
string($env ?? nil)
string($env ?? ok)
string($env ?? true)
string($env and true)
string($env in $env?.[Bar])
string($env in array)
string($env in list)
string($env not in array)
string($env or true)
string($env | all(false))
string($env | all(ok))
string($env | count(false))
string($env | count(ok))
string($env | count(true))
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 | map(true))
string($env | none(ok))
string($env | one(ok))
string($env | one(true))
string($env | reduce($env, ok))
string($env | reduce(1, array))
string($env | reduce(f64, 1.0))
string($env | sum(0))
string($env | sum(1))
string($env | sum(1.0))
string($env | sum(f64))
string($env || false)
string($env || true)
string($env) ?? f64
string($env) ?? i
string($env) matches str
string($env) not in foo
string($env) not matches $env?.Bar
string($env) not matches str
string($env) not startsWith str
string($env) | greet()
string($env) | trimPrefix(str)
string($env)[:]
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?.[list])
string($env?.Bar?.[str])
string($env?.Bar?.greet)
string($env?.String)
string($env?.String?.Bar)
string($env?.String?.String)
string($env?.String?.list)
string($env?.[Bar])
string($env?.[Bar]?.Bar)
string($env?.[Bar]?.[i])
string($env?.[Bar]?.foobar)
string($env?.[String])
string($env?.[String]?.array)
string($env?.[String]?.str)
string($env?.[foobar])
string($env?.[nil])
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?.nil)
string($env?.ok)
string($env?.str)
string($env?.str[:])
string($env?.true)
string(-0)
string(-1 == nil)
string(-1)
string(-1.0)
string(-f64)
string(-i)
string(0 != 0)
string(0 != 1.0)
string(0 != i)
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 ** i)
string(0 + 0)
string(0 + 1.0)
string(0 - 1)
string(0 - i)
string(0 .. 0)
string(0 .. i)
string(0 / $env.f64)
string(0 / 1)
string(0 < 0)
string(0 < 1)
string(0 < 1.0)
string(0 < f64)
string(0 <= 0)
string(0 <= 1.0)
string(0 <= f64)
string(0 <= i)
string(0 == $env)
string(0 == 1)
string(0 == f64)
string(0 == i)
string(0 == nil)
string(0 > 1)
string(0 > f64)
string(0 > i)
string(0 >= 1)
string(0 >= 1.0)
string(0 >= f64)
string(0 >= i)
string(0 ?? 1)
string(0 ?? 1.0)
string(0 ?? array)
string(0 ?? f64)
string(0 ?? foo)
string(0 ?? i)
string(0 ?? list)
string(0 ?? str)
string(0 ?? true)
string(0 ^ i)
string(0 | mean(f64))
string(0) >= str
string(0) ?? $env?.list
string(0) ?? 0 | find(true)
string(0) contains string(str)
string(0) not startsWith str
string(0) | greet()
string(0)[:]
string(0)[i:]
string(0..i)
string(1 != 1)
string(1 != 1.0)
string(1 != f64)
string(1 != nil)
string(1 % 1)
string(1 * 0)
string(1 * 0) ?? add
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 + i)
string(1 - 0)
string(1 - 1)
string(1 - 1.0)
string(1 - f64)
string(1 .. 0)
string(1 .. 1)
string(1 .. i)
string(1 / 0)
string(1 / 1)
string(1 / 1.0)
string(1 / f64)
string(1 < 0)
string(1 < 1.0)
string(1 < i)
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)
string(1 >= 1.0)
string(1 >= f64)
string(1 >= i)
string(1 ?? $env)
string(1 ?? 0)
string(1 ?? 1.0)
string(1 ?? array)
string(1 ?? f64)
string(1 ?? false)
string(1 ?? foo)
string(1 ?? i)
string(1 ?? nil)
string(1 ?? str)
string(1 ^ 1)
string(1 ^ 1.0)
string(1 ^ i)
string(1 not in array)
string(1 | min(1.0))
string(1) != str
string(1) + str
string(1) < foo?.Bar
string(1) == $env?.[Bar]
string(1) > foo?.Bar
string(1) ?? i
string(1) ?? list
string(1) ?? str
string(1) matches toJSON(false)
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 != f64)
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 + 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 / 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 <= 0)
string(1.0 <= 1)
string(1.0 <= 1.0)
string(1.0 <= i)
string(1.0 == $env)
string(1.0 == 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 > 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 ?? $env)
string(1.0 ?? 0)
string(1.0 ?? 1.0)
string(1.0 ?? array)
string(1.0 ?? false)
string(1.0 ?? foo)
string(1.0 ?? foo) not endsWith str
string(1.0 ?? list)
string(1.0 ?? nil)
string(1.0 ?? ok)
string(1.0 ?? true)
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 not in array)
string(1.0 | median(array))
string(1.0)
string(1.0) != str
string(1.0) >= str
string(1.0) >= string(i)
string(1.0) ?? add
string(1.0) endsWith str
string(1.0) in first($env)
string(1.0) not startsWith toJSON(false)
string(1.0) startsWith str
string(1.0) startsWith type(foo)
string(1.0) | greet()
string([$env, 0])
string([$env, foo])
string([$env, ok])
string([$env])
string([0, nil])
string([0])
string([1, true])
string([1.0, $env])
string([1.0])
string([1])
string([add, 1.0])
string([add])
string([array, i])
string([array])
string([f64, f64])
string([f64])
string([false, 1])
string([false])
string([foo])
string([greet, i])
string([greet])
string([i])
string([list, false])
string([list, list])
string([list])
string([nil, list])
string([nil])
string([ok, 1])
string([ok, list])
string([ok, nil])
string([ok])
string([str])
string([true, greet])
string([true, list])
string([true])
string(abs(0))
string(abs(1))
string(abs(1.0))
string(abs(f64))
string(abs(i))
string(add != $env)
string(add == add)
string(add == nil)
string(add ?? 1.0)
string(add ?? add)
string(add ?? f64)
string(add ?? foo)
string(add(1, 0))
string(add(1, 1))
string(add(1, i))
string(add)
string(add) ?? ok
string(add) in foo
string(add) matches str
string(add) | greet()
string(any($env, false))
string(any($env, ok))
string(any(array, false))
string(any(array, ok))
string(array != $env)
string(array != array)
string(array != list)
string(array != nil)
string(array == $env)
string(array == array)
string(array == list)
string(array == nil)
string(array ?? $env)
string(array ?? 1.0)
string(array ?? add)
string(array ?? f64)
string(array ?? foo)
string(array ?? i)
string(array | any(ok))
string(array | count(false))
string(array | findIndex(false))
string(array | findLast(false))
string(array | groupBy(i))
string(array | map(#))
string(array | map($env))
string(array | map(f64))
string(array | one(true))
string(array | reduce(#))
string(array | reduce(#acc))
string(array | reduce(add))
string(array | reduce(foo))
string(array | reduce(i))
string(array | reduce(list))
string(array | sortBy(#))
string(array | sortBy(i))
string(array | sum(#))
string(array | sum(1))
string(array | sum(f64))
string(array)
string(array) > str
string(array) >= foo.Bar
string(array) in map(array, $env)
string(array) matches str
string(array) not in foo
string(array) not startsWith str
string(array) startsWith str
string(array) | greet()
string(array)[:i]
string(array?.[i])
string(array[0:])
string(array[1:])
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(ceil(i))
string(concat(array))
string(concat(list))
string(count($env, false))
string(count($env, ok))
string(count(list, ok))
string(f64 != $env)
string(f64 != f64)
string(f64 != nil)
string(f64 * 1)
string(f64 * 1.0)
string(f64 * f64)
string(f64 * i)
string(f64 ** 0)
string(f64 ** 1.0)
string(f64 ** i)
string(f64 + 1)
string(f64 + 1.0)
string(f64 + f64)
string(f64 + i)
string(f64 - 1)
string(f64 - i)
string(f64 / 0)
string(f64 / 1.0)
string(f64 < 1)
string(f64 < 1.0)
string(f64 < f64)
string(f64 <= f64)
string(f64 == $env)
string(f64 == 0)
string(f64 == 1)
string(f64 == 1.0)
string(f64 == nil)
string(f64 > 0)
string(f64 > 1)
string(f64 > 1.0)
string(f64 > f64)
string(f64 > i)
string(f64 >= 0)
string(f64 >= 1)
string(f64 >= 1.0)
string(f64 >= i)
string(f64 ?? $env)
string(f64 ?? add)
string(f64 ?? array)
string(f64 ?? f64)
string(f64 ?? false)
string(f64 ?? foo)
string(f64 ?? i)
string(f64 ?? nil)
string(f64 ^ 1.0)
string(f64 ^ i)
string(f64 not in array)
string(f64)
string(f64) + str
string(f64) < str
string(f64) <= str
string(f64) >= str
string(f64) ?? $env.ok
string(f64) ?? [foo]
string(false != $env)
string(false != false)
string(false != nil)
string(false != true)
string(false && $env)
string(false && ok)
string(false == $env)
string(false == false)
string(false == nil)
string(false == true)
string(false ? foo : 1)
string(false ?: i)
string(false ?? $env)
string(false ?? 1.0)
string(false ?? f64)
string(false ?? foo)
string(false ?? nil)
string(false and $env)
string(false and false)
string(false or $env)
string(false or false)
string(false or ok)
string(false || $env)
string(false) + foo?.Bar
string(false) < str
string(false) == foo.Bar
string(false) in $env?.[String]
string(false) not contains str
string(false) startsWith str
string(false) | greet()
string(find(array, false))
string(find(list, ok))
string(find(list, true))
string(findIndex($env, true))
string(findIndex(list, false))
string(findLast(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(first(list)?.Bar)
string(flatten(array))
string(flatten(list))
string(float(0))
string(float(1))
string(float(1.0))
string(float(f64 * 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 ?? $env)
string(foo ?? 0)
string(foo ?? 1.0)
string(foo ?? add)
string(foo ?? array)
string(foo ?? f64)
string(foo ?? false)
string(foo ?? foo)
string(foo ?? foo) ?? list
string(foo ?? greet)
string(foo ?? i)
string(foo ?? list)
string(foo ?? ok)
string(foo ?? true)
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) > str
string(foo) >= str
string(foo) ?? array
string(foo) ?? i
string(foo) ?? list
string(foo) ?? ok
string(foo) contains str
string(foo) contains toJSON(foo)
string(foo) in list?.[i]
string(foo) matches str
string(foo) not endsWith type(str)
string(foo) not in foo
string(foo) not matches greet(str)
string(foo) startsWith str
string(foo) | greet()
string(foo)[:]
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(get(list, 1))
string(greet != $env)
string(greet != greet)
string(greet != nil)
string(greet == greet)
string(greet ?? 0)
string(greet ?? 1.0)
string(greet ?? add)
string(greet ?? f64)
string(greet ?? foo)
string(greet ?? greet)
string(greet(str))
string(greet)
string(greet) + str
string(greet) ?? {foo: 0}
string(greet) not in foo
string(greet) not matches str
string(greet) startsWith $env?.[str]
string(greet) | greet()
string(groupBy(array, #))
string(groupBy(array, 0))
string(groupBy(list, 1.0))
string(groupBy(list, false))
string(groupBy(list, ok)?.greet)
string(groupBy(list, str))
string(i != $env)
string(i != 0)
string(i != 1)
string(i != 1.0)
string(i != nil)
string(i % 1)
string(i * 0)
string(i * 1.0)
string(i ** 0)
string(i ** 1.0)
string(i ** f64)
string(i ** i)
string(i + 0)
string(i + 1)
string(i + 1.0)
string(i + f64)
string(i + i)
string(i - 1)
string(i - 1.0)
string(i - f64)
string(i - i)
string(i .. 0)
string(i .. 1)
string(i / 0)
string(i / f64)
string(i / i)
string(i < 0)
string(i <= f64)
string(i == $env)
string(i == 1)
string(i == 1.0)
string(i == f64)
string(i == nil)
string(i > 0)
string(i > 1)
string(i > f64)
string(i >= 1.0)
string(i >= i)
string(i ?? $env)
string(i ?? f64)
string(i ?? false)
string(i ?? foo)
string(i ?? i)
string(i ?? list)
string(i ?? ok)
string(i ?? true)
string(i ^ 1)
string(i ^ 1.0)
string(i ^ f64)
string(i ^ i)
string(i in array)
string(i not in array)
string(i | bitshr(i))
string(i | min(1.0, 1.0))
string(i)
string(i) ?? i
string(i) ?? toJSON(array)
string(i) not endsWith str
string(i) not in foo
string(i) | greet()
string(i) | indexOf(str)
string(i)[:]
string(if false ?? list { $env?.f64 } else { f64 })
string(if false { foo } else { false })
string(if false { ok } else { i })
string(if ok { 0 } else { str })
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(if true { str } else { 1.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(let foobar = 1.0; foobar + foobar)
string(let x = foo; x)
string(let z = 0; let x = foo; z)
string(list != $env)
string(list != array)
string(list != list)
string(list != nil)
string(list == $env)
string(list == array)
string(list == list)
string(list == nil)
string(list ?? $env)
string(list ?? 1.0)
string(list ?? false)
string(list ?? foo)
string(list ?? greet)
string(list ?? i)
string(list ?? list)
string(list ?? nil)
string(list ?? true)
string(list | concat(array))
string(list | count(true))
string(list | findIndex(ok))
string(list | groupBy(#))
string(list | groupBy(0))
string(list | groupBy(1))
string(list | groupBy(1.0))
string(list | groupBy(ok))
string(list | map(.Bar))
string(list | map(.String))
string(list | map(greet))
string(list | map(i))
string(list | one(false))
string(list | reduce(#))
string(list | reduce(#.String))
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) != str ?? true
string(list) > str
string(list) ?? add
string(list) not contains str
string(list) not contains str ?? add
string(list) not startsWith str
string(list) startsWith str
string(list) | greet()
string(list) | split(str)
string(list?.[0])
string(list?.[i])
string(list?.[i]?.String)
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, #index))
string(map(array, add))
string(map(array, f64))
string(map(array, greet))
string(map(array, str))
string(map(list, $env))
string(map(list, greet))
string(map(list, list))
string(map(list, true))
string(max($env))
string(max(0))
string(max(1))
string(max(1.0))
string(max(array))
string(max(f64))
string(max(f64, 0))
string(max(i))
string(mean(0))
string(mean(1))
string(mean(1.0))
string(mean(array))
string(mean(f64))
string(mean(i))
string(median(0))
string(median(1))
string(median(1.0))
string(median(1.0, 0))
string(median(array))
string(median(f64))
string(median(i))
string(median(i, 0))
string(median(round(i)))
string(min($env))
string(min(0))
string(min(0, 1.0))
string(min(1))
string(min(1, f64))
string(min(1.0))
string(min(1.0, 0))
string(min(1.0, array))
string(min(array))
string(min(f64))
string(min(i))
string(min(i, 1.0))
string(nil != $env)
string(nil != 0)
string(nil != 1.0)
string(nil != foo)
string(nil != list)
string(nil != nil)
string(nil != ok)
string(nil != str)
string(nil == $env)
string(nil == 0)
string(nil == 1.0)
string(nil == add)
string(nil == array)
string(nil == f64)
string(nil == foo)
string(nil == greet)
string(nil == i)
string(nil == list)
string(nil == nil)
string(nil == nil) <= str
string(nil == ok)
string(nil == true)
string(nil ?? 0)
string(nil ?? 1.0)
string(nil ?? add)
string(nil ?? array)
string(nil ?? foo)
string(nil ?? i)
string(nil ?? nil)
string(nil ?? true)
string(nil in $env)
string(nil in array)
string(nil in list)
string(nil not in $env)
string(nil not in $env?.array)
string(nil not in array)
string(nil not in list)
string(nil) != $env?.[String]
string(nil) != str
string(nil) == toJSON(nil)
string(nil) > str
string(nil) >= str
string(nil) ?? f64
string(nil) ?? greet
string(nil) ?? list
string(nil) contains str
string(nil) in foo
string(nil) not matches greet(str)
string(nil) not matches str
string(nil) not startsWith str
string(nil) | greet()
string(nil) | trimSuffix(str)
string(nil)[:i]
string(nil)[i:]
string(none($env, ok))
string(none(list, true))
string(not false)
string(not ok)
string(not true)
string(ok != $env)
string(ok != ok)
string(ok && $env)
string(ok && ok)
string(ok && true)
string(ok == $env)
string(ok == false)
string(ok == nil)
string(ok == ok)
string(ok ? $env : $env)
string(ok ? $env : str)
string(ok ? foo : nil)
string(ok ? foo : ok)
string(ok ? true : $env)
string(ok ?: add)
string(ok ?: f64)
string(ok ?: foo)
string(ok ?: list)
string(ok ?? $env)
string(ok ?? $env?.[i])
string(ok ?? foo)
string(ok ?? i)
string(ok and $env)
string(ok and $env?.[Bar])
string(ok and ok)
string(ok and true)
string(ok or $env)
string(ok or ok)
string(ok or true)
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) matches trimPrefix(str)
string(ok) | greet()
string(ok) | indexOf(str)
string(ok); ok
string(ok)[1.0 ?? 1:]
string(ok)[:]
string(one($env, false))
string(reduce(array, #))
string(reduce(array, 1.0))
string(reduce(array, add))
string(reduce(array, foo))
string(reduce(array, greet))
string(reduce(array, i))
string(reduce(array, list))
string(reduce(list, #))
string(reduce(list, .Bar))
string(reduce(list, foo))
string(reduce(list, greet))
string(reduce(list, ok, 1.0))
string(reverse(array))
string(round(0))
string(round(1))
string(round(1.0))
string(round(f64))
string(round(i))
string(sort($env))
string(sort(array))
string(sort(ok ? foo : 1.0))
string(sortBy(array, #))
string(sortBy(list, .Bar))
string(sortBy(list, f64))
string(str != $env)
string(str < str)
string(str <= str)
string(str == $env)
string(str == $env?.[Bar])
string(str == nil)
string(str == str)
string(str > foo.Bar)
string(str ?? add)
string(str ?? ok)
string(str ?? true)
string(str contains str)
string(str in $env)
string(str in $env?.Bar)
string(str in foo)
string(str not contains $env?.[str])
string(str not in $env)
string(str not in foo)
string(str not matches str)
string(str | greet())
string(str)
string(str) != str
string(str) + str
string(str) contains str
string(str) in foo
string(str) matches str
string(str) not contains str
string(str) | greet()
string(str)[:]
string(str[:0])
string(str[:1])
string(str[:i])
string(string($env))
string(string(0))
string(string(1))
string(string(1.0))
string(string(add))
string(string(array))
string(string(f64))
string(string(false))
string(string(foo))
string(string(greet))
string(string(i))
string(string(list))
string(string(nil))
string(string(ok))
string(string(str))
string(string(true))
string(sum($env, 0))
string(sum($env, 1.0))
string(sum(array))
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(list))
string(toJSON(nil))
string(toJSON(ok))
string(toJSON(str))
string(toJSON(true))
string(toPairs($env))
string(trim(str))
string(trimPrefix(str))
string(trimSuffix(str))
string(true != $env)
string(true != false)
string(true != nil)
string(true != ok)
string(true != true)
string(true && $env)
string(true && false)
string(true == $env)
string(true == false)
string(true == nil)
string(true == true)
string(true ? $env : f64)
string(true ? add : nil)
string(true ? false : greet)
string(true ? false : i)
string(true ? foo : $env)
string(true ? str : add)
string(true ?: $env)
string(true ?: nil)
string(true ?: ok)
string(true ?? 0)
string(true ?? array)
string(true ?? foo)
string(true ?? i)
string(true ?? list)
string(true and $env)
string(true and false)
string(true and ok)
string(true or false)
string(true or ok)
string(true || $env)
string(true || ok)
string(true || true)
string(true) + str
string(true) ?? array | groupBy(foo)
string(type($env))
string(type(0))
string(type(1))
string(type(1.0))
string(type(add))
string(type(array))
string(type(f64))
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(uniq(list))
string(upper(str))
string(values($env))
string({foo: $env, foo: $env}?.f64)
string({foo: $env, foo: nil})
string({foo: $env})
string({foo: 0})
string({foo: 1.0, foo: list})
string({foo: 1.0})
string({foo: 1})
string({foo: add ?? $env})
string({foo: add, foo: 1.0})
string({foo: add})
string({foo: array, foo: 1.0, foo: list})
string({foo: array})
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: 1})
string({foo: foo, foo: array})
string({foo: foo, foo: list})
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: $env})
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: false, foo: list})
string({foo: ok, foo: ok, foo: array})
string({foo: ok, foo: str})
string({foo: ok})
string({foo: str})
string({foo: true})
string({foo: true}?.array)
sum($env ?? greet, f64)
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(f64))
sum($env | map(i))
sum($env | map(str), f64)
sum($env | reduce(#acc, str))
sum($env | reduce(array, 0))
sum($env) or true ? foo : array
sum($env, 0) in array
sum($env, 0) | max(i)
sum($env, 0) | median(1.0)
sum($env, 1) != f64
sum($env, 1) >= 1.0 >= 1.0
sum($env, 1) >= i
sum($env, 1.0) ** 1 ^ 1
sum($env, 1.0) / -0
sum($env, 1.0) >= f64
sum($env, 1.0) ?? add
sum($env, 1.0) ?? str
sum($env, f64) != sum(array)
sum($env, f64) ** f64 + f64
sum($env, f64) ?? add
sum($env, f64) | max(i)
sum($env, i) <= abs(1.0)
sum($env, i) ^ i
sum($env, ok) or not false
sum($env.array | sortBy(#))
sum($env.array | sortBy(i))
sum($env.array)
sum($env.array, # ** #)
sum($env.array, #)
sum($env.array, f64)
sum($env.array, i)
sum($env.list, abs(1.0))
sum($env.list, f64)
sum($env.list, i)
sum($env?.[str])
sum($env?.[str]) != ok
sum($env?.[str], #)
sum($env?.[str], f64)
sum($env?.[str], i)
sum($env?.array)
sum($env?.array) ?? add
sum($env?.array, #)
sum($env?.array, i)
sum($env?.array, i) <= i
sum($env?.list, f64 + 1.0)
sum(0 .. 0)
sum(0 .. 1)
sum(0 .. i)
sum(0..i)
sum(1 .. 0)
sum(1 .. 0, #)
sum(1 .. 1)
sum(1 .. i)
sum(1..i)
sum(1..i, # + #)
sum(1..i, f64)
sum([$env, add], f64)
sum([-1])
sum([0, 0])
sum([0])
sum([1, 0])
sum([1, 1.0])
sum([1.0, 0])
sum([1.0, 1.0])
sum([1.0, 1.0], #)
sum([1.0, 1])
sum([1.0, 1], f64)
sum([1.0, f64])
sum([1.0])
sum([1.0], #)
sum([1.0], i)
sum([1])
sum([1], 1 / #)
sum([f64, 0])
sum([f64, 1.0])
sum([f64])
sum([f64], i)
sum([foo], f64)
sum([i])
sum([nil], 1.0 + i)
sum([ok], f64)
sum([ok], i)
sum([str, str])
sum([true], i)
sum(array ?? 0, min(1))
sum(array ?? 1)
sum(array ?? 1.0)
sum(array ?? add)
sum(array ?? add, #)
sum(array ?? array)
sum(array ?? f64)
sum(array ?? false)
sum(array ?? foo)
sum(array ?? greet)
sum(array ?? i)
sum(array ?? list)
sum(array ?? nil)
sum(array ?? str)
sum(array ?? true)
sum(array | filter(false))
sum(array | filter(ok))
sum(array | filter(true))
sum(array | map(#))
sum(array | map(#index))
sum(array | map(0))
sum(array | map(1))
sum(array | map(1.0))
sum(array | map(f64))
sum(array | map(i))
sum(array | map(i), i)
sum(array | sortBy(#))
sum(array | sortBy(0))
sum(array | sortBy(1))
sum(array | sortBy(1.0))
sum(array | sortBy(i))
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) * f64
sum(array) * i
sum(array) ** f64
sum(array) ** i
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
sum(array) <= i || $env
sum(array) <= max(array)
sum(array) == f64
sum(array) == i
sum(array) > f64
sum(array) > reduce(array, i)
sum(array) >= f64 != true
sum(array) >= i
sum(array) ?? all($env, #)
sum(array) ?? f64
sum(array) ?? foo
sum(array) ?? list
sum(array) ?? ok
sum(array) ?? str
sum(array) ?? {foo: true}
sum(array) ^ f64
sum(array) ^ i
sum(array) ^ round(1)
sum(array) not in $env.array
sum(array) not in array
sum(array) | bitnand(i)
sum(array) | bitor(i)
sum(array) | bitushr(0)
sum(array) | bitxor(0)
sum(array) | max(array)
sum(array) | mean(1)
sum(array) | mean(1.0)
sum(array) | min(i)
sum(array)..i
sum(array); f64
sum(array, # % #)
sum(array, # ** #)
sum(array, # ** i)
sum(array, # + #)
sum(array, # - 0)
sum(array, # / f64)
sum(array, #)
sum(array, #) * i
sum(array, #) ** f64
sum(array, #) <= i
sum(array, #) <= i ?? 1.0
sum(array, #) ?? foo
sum(array, #) not in array
sum(array, $env.f64)
sum(array, $env.i)
sum(array, $env?.f64)
sum(array, $env?.i)
sum(array, -#)
sum(array, -0)
sum(array, -1)
sum(array, -1.0)
sum(array, 0 ** f64)
sum(array, 1 - #)
sum(array, 1 ?? i)
sum(array, 1) != i
sum(array, 1) .. array?.[i]
sum(array, 1) ?? i
sum(array, 1) ^ i
sum(array, 1.0 ** #)
sum(array, 1.0 / #)
sum(array, 1.0 ?? foo)
sum(array, 1.0) * mean(i, 0)
sum(array, 1.0) - f64
sum(array, 1.0) == f64
sum(array, abs(#))
sum(array, array | reduce(f64))
sum(array, array?.[i])
sum(array, bitnot(#))
sum(array, bitshr(#, #))
sum(array, bitushr(#, #))
sum(array, ceil(f64))
sum(array, f64)
sum(array, f64) + int(i)
sum(array, f64) == i
sum(array, f64) > i
sum(array, f64) ^ i
sum(array, float(# | bitxor(#)))
sum(array, float(#))
sum(array, float(1.0))
sum(array, floor(0))
sum(array, floor(f64))
sum(array, i + 1.0)
sum(array, i)
sum(array, int(i))
sum(array, max(#, #))
sum(array, mean(array))
sum(array, nil ?? #)
sum(array, round(#))
sum(array, round(1.0))
sum(array, sum($env, 1))
sum(array, sum(array, #))
sum(array, true ? 0 : 0)
sum(array[0:])
sum(array[1:])
sum(array[:0])
sum(array[:1])
sum(array[:i])
sum(array[i:])
sum(concat(array))
sum(concat(array), #)
sum(concat(array, 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(filter(list, false))
sum(flatten(array))
sum(flatten(array), max(#))
sum(flatten(sort(str ?? 1)))
sum(get($env, str))
sum(i .. 0)
sum(i .. 1)
sum(i .. i)
sum(i..i)
sum(if false { 1 } else { array })
sum(if false { array } else { array })
sum(if false { foo } else { str })
sum(if ok { array } else { 1 })
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(let y = array; y)
sum(list | filter(false))
sum(list | map(#index))
sum(list | map(0))
sum(list | map(1))
sum(list | map(1.0))
sum(list | map(f64))
sum(list | map(greet), i)
sum(list | map(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, -1.0)
sum(list, 0 * 1.0)
sum(list, 0 ?? #)
sum(list, 0 ?? str)
sum(list, 0) ** f64
sum(list, 0) ?? array
sum(list, 1 ^ 0)
sum(list, 1) | bitxor(0)
sum(list, 1.0 ** i)
sum(list, 1.0 / 1.0)
sum(list, 1.0 ?? str)
sum(list, f64 * 0)
sum(list, f64 ** 0)
sum(list, f64 - 1.0)
sum(list, f64 - f64)
sum(list, f64)
sum(list, f64) ?? 1.0 ?? list
sum(list, f64) | mean(f64)
sum(list, i + 0)
sum(list, i / 0)
sum(list, i ?? true)
sum(list, i)
sum(list, i) ** i
sum(list, int(i))
sum(list, len($env))
sum(list, len(str))
sum(list, list | sum(1.0))
sum(list, max(0))
sum(list, mean(i))
sum(list, round(1.0))
sum(list[i:0])
sum(list[i:i])
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, #index))
sum(map(list, 0))
sum(map(list, 1))
sum(map(list, 1.0))
sum(map(list, f64))
sum(map(list, i))
sum(max($env).array)
sum(max($env?.[str]))
sum(min($env), f64)
sum(nil ?? array)
sum(ok ? array : false)
sum(ok ? array : foo)
sum(reduce($env, array, $env))
sum(reduce($env, array, nil))
sum(reduce(array, array))
sum(reduce(array, array, false))
sum(reduce(list, array))
sum(reverse(array))
sum(sort($env))
sum(sort($env), #.Bar)
sum(sort($env), #.add % 1)
sum(sort($env), #.add not in #.add)
sum(sort($env), $env == #)
sum(sort($env), .array?.foobar)
sum(sort($env), .list)
sum(sort($env), 1.0 ?? #.greet)
sum(sort($env), any(#, #.String))
sum(sort($env?.String))
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(str ?? $env)
sum(str ?? 0)
sum(str ?? 1)
sum(str ?? 1, #)
sum(str ?? 1.0)
sum(str ?? add)
sum(str ?? array)
sum(str ?? f64)
sum(str ?? false)
sum(str ?? false, #)
sum(str ?? false, f64)
sum(str ?? foo)
sum(str ?? greet)
sum(str ?? i)
sum(str ?? list)
sum(str ?? ok)
sum(str ?? true)
sum(string($env) ?? array)
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, $env?.i)
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 ?? foo)
toBase64(foo?.Bar)
toBase64(foo?.Bar)[:]
toBase64(foo?.String())
toBase64(greet(str))
toBase64(lower(str))
toBase64(reduce(list, str))
toBase64(str + str)
toBase64(str ?? $env)
toBase64(str ?? 1)
toBase64(str ?? array)
toBase64(str ?? i)
toBase64(str ?? nil)
toBase64(str ?? ok)
toBase64(str | greet())
toBase64(str)
toBase64(str) < str
toBase64(str) > str
toBase64(str) >= str
toBase64(str) ?? array
toBase64(str) endsWith first($env)
toBase64(str) in foo ?? 0
toBase64(str) not contains $env?.str
toBase64(str) not matches $env?.Bar
toBase64(str) not startsWith str
toBase64(str) | greet()
toBase64(str) | repeat(i)
toBase64(str)[i:]
toBase64(str[:0])
toBase64(str[:1])
toBase64(str[:i])
toBase64(str[i:])
toBase64(string($env))
toBase64(string(0))
toBase64(string(1))
toBase64(string(1.0))
toBase64(string(add))
toBase64(string(array))
toBase64(string(f64))
toBase64(string(false))
toBase64(string(foo))
toBase64(string(foo?.Bar))
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(trim(str))
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(str))
toBase64(type(true))
toBase64(upper(str))
toJSON(!false)
toJSON(!ok)
toJSON(!true)
toJSON($env != 0)
toJSON($env != 1)
toJSON($env != 1.0)
toJSON($env != add)
toJSON($env != array)
toJSON($env != f64)
toJSON($env != false)
toJSON($env != foo)
toJSON($env != greet)
toJSON($env != i)
toJSON($env != list)
toJSON($env != nil)
toJSON($env != str)
toJSON($env != true)
toJSON($env && false)
toJSON($env == $env)
toJSON($env == 0)
toJSON($env == 1)
toJSON($env == array)
toJSON($env == f64)
toJSON($env == false)
toJSON($env == foo)
toJSON($env == i)
toJSON($env == list)
toJSON($env == nil)
toJSON($env == str)
toJSON($env == true)
toJSON($env in list)
toJSON($env not in array)
toJSON($env not in list)
toJSON($env or true)
toJSON($env | all(false))
toJSON($env | any(false))
toJSON($env | any(true))
toJSON($env | count(false))
toJSON($env | findIndex(ok))
toJSON($env | findLastIndex(ok))
toJSON($env | get(nil))
toJSON($env | map(array))
toJSON($env | map(f64))
toJSON($env | map(list))
toJSON($env | map(str))
toJSON($env | map(true))
toJSON($env | none(false))
toJSON($env | reduce(#index, $env))
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?.Bar())
toJSON($env?.Bar?.[greet])
toJSON($env?.Bar?.[list])
toJSON($env?.Bar?.f64)
toJSON($env?.String)
toJSON($env?.[Bar])
toJSON($env?.[String])
toJSON($env?.[foobar])
toJSON($env?.[foobar]?.i())
toJSON($env?.[foobar]?.list)
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($env?.true)
toJSON(-$env?.i)
toJSON(-0 < 1.0)
toJSON(-0)
toJSON(-1)
toJSON(-1.0)
toJSON(-f64)
toJSON(-i)
toJSON(0 != $env)
toJSON(0 != 1)
toJSON(0 != 1.0)
toJSON(0 != i)
toJSON(0 != nil)
toJSON(0 % 1)
toJSON(0 % i)
toJSON(0 * 1.0)
toJSON(0 ** 1)
toJSON(0 ** 1.0)
toJSON(0 ** f64)
toJSON(0 + 0)
toJSON(0 + 1)
toJSON(0 + 1.0)
toJSON(0 + f64)
toJSON(0 - 1)
toJSON(0 - 1.0)
toJSON(0 - f64)
toJSON(0 - i)
toJSON(0 .. 1)
toJSON(0 .. i)
toJSON(0 / 1.0)
toJSON(0 / f64)
toJSON(0 / i)
toJSON(0 < 0)
toJSON(0 < 1.0)
toJSON(0 <= 0)
toJSON(0 <= 1)
toJSON(0 <= 1.0)
toJSON(0 <= f64)
toJSON(0 <= i)
toJSON(0 == $env?.[foobar])
toJSON(0 == 1)
toJSON(0 == 1.0)
toJSON(0 == f64)
toJSON(0 == nil)
toJSON(0 > 1)
toJSON(0 > 1.0)
toJSON(0 > i)
toJSON(0 >= 0)
toJSON(0 >= 1)
toJSON(0 >= 1.0)
toJSON(0 ?? 1.0)
toJSON(0 ?? f64)
toJSON(0 ?? greet)
toJSON(0 ?? list)
toJSON(0 ?? nil)
toJSON(0 ^ 1.0)
toJSON(0 ^ f64)
toJSON(0 ^ i)
toJSON(0 in array)
toJSON(0 not in array)
toJSON(0 | bitor(i))
toJSON(0 | bitshl(0))
toJSON(0 | bitshr(0))
toJSON(0 | min(1.0))
toJSON(0) != greet(str)
toJSON(0) + str
toJSON(0) > str
toJSON(0) >= str
toJSON(0) ?? array
toJSON(0) ?? not true
toJSON(0) contains $env?.[String]
toJSON(0) in foo
toJSON(0) | greet()
toJSON(0..i)
toJSON(0.0)
toJSON(0.1)
toJSON(1 != $env)
toJSON(1 != 0)
toJSON(1 != 1.0)
toJSON(1 != i)
toJSON(1 != nil)
toJSON(1 % i)
toJSON(1 * 1.0)
toJSON(1 * i)
toJSON(1 ** 0)
toJSON(1 ** 1)
toJSON(1 ** i)
toJSON(1 + 0)
toJSON(1 + 1)
toJSON(1 + 1.0)
toJSON(1 + f64)
toJSON(1 - 1.0)
toJSON(1 - f64)
toJSON(1 - i)
toJSON(1 .. 0)
toJSON(1 .. 1)
toJSON(1 .. i)
toJSON(1 / 1)
toJSON(1 / f64)
toJSON(1 / i)
toJSON(1 < 0)
toJSON(1 < 1.0)
toJSON(1 <= 0)
toJSON(1 <= 1)
toJSON(1 <= f64)
toJSON(1 <= i)
toJSON(1 == $env)
toJSON(1 == 0)
toJSON(1 == 1.0)
toJSON(1 == nil)
toJSON(1 > 0)
toJSON(1 > 1)
toJSON(1 > 1.0)
toJSON(1 > i)
toJSON(1 >= 0)
toJSON(1 >= 1)
toJSON(1 >= 1.0)
toJSON(1 >= f64)
toJSON(1 >= i)
toJSON(1 ?? $env?.[foo])
toJSON(1 ?? 1)
toJSON(1 ?? false)
toJSON(1 ?? foo)
toJSON(1 ?? nil)
toJSON(1 ^ 1.0)
toJSON(1 not in array)
toJSON(1 | min(f64))
toJSON(1) != str
toJSON(1) > str
toJSON(1) ?? $env.ok
toJSON(1) ?? array
toJSON(1) endsWith str
toJSON(1) not contains str
toJSON(1) not endsWith 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 * 0)
toJSON(1.0 * 1)
toJSON(1.0 * 1.0)
toJSON(1.0 * f64)
toJSON(1.0 * i)
toJSON(1.0 ** 0)
toJSON(1.0 ** 1)
toJSON(1.0 ** 1.0)
toJSON(1.0 ** f64)
toJSON(1.0 ** i)
toJSON(1.0 + 0)
toJSON(1.0 + 1)
toJSON(1.0 + 1.0)
toJSON(1.0 + f64)
toJSON(1.0 + i)
toJSON(1.0 - 0)
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.0)
toJSON(1.0 < f64)
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 == i)
toJSON(1.0 > 0)
toJSON(1.0 > 1.0)
toJSON(1.0 > f64)
toJSON(1.0 > i)
toJSON(1.0 >= 0)
toJSON(1.0 >= 1)
toJSON(1.0 >= 1.0)
toJSON(1.0 >= f64)
toJSON(1.0 >= i)
toJSON(1.0 ?? $env)
toJSON(1.0 ?? 1)
toJSON(1.0 ?? add)
toJSON(1.0 ?? array)
toJSON(1.0 ?? f64)
toJSON(1.0 ?? foo)
toJSON(1.0 ?? greet)
toJSON(1.0 ?? i)
toJSON(1.0 ?? nil)
toJSON(1.0 ^ 0)
toJSON(1.0 ^ 1)
toJSON(1.0 ^ 1.0)
toJSON(1.0 ^ f64)
toJSON(1.0 ^ f64) + str
toJSON(1.0 ^ i)
toJSON(1.0 in $env?.[String])
toJSON(1.0 in array)
toJSON(1.0 not in array)
toJSON(1.0 | median(array))
toJSON(1.0)
toJSON(1.0) + str
toJSON(1.0) <= str
toJSON(1.0) ?? add
toJSON(1.0) ?? foo
toJSON(1.0) contains str
toJSON(1.0) matches str
toJSON(1.0) not endsWith str
toJSON(1.0) not in foo
toJSON(1.0) startsWith str
toJSON(1.0) | greet()
toJSON(1.0) | indexOf(str)
toJSON([0])
toJSON([1, 1])
toJSON([1, foo])
toJSON([1, i])
toJSON([1, str])
toJSON([1.0])
toJSON([1])
toJSON([array, 0])
toJSON([array])
toJSON([f64, nil])
toJSON([f64])
toJSON([false])
toJSON([foo, list])
toJSON([foo])
toJSON([i])
toJSON([nil])
toJSON([not true])
toJSON([ok])
toJSON([str, 1.0])
toJSON([str])
toJSON([true])
toJSON(abs(0))
toJSON(abs(1))
toJSON(abs(1.0))
toJSON(abs(f64 / 1.0))
toJSON(abs(f64))
toJSON(abs(i))
toJSON(add != $env)
toJSON(add != add)
toJSON(add == $env)
toJSON(add == add)
toJSON(add == nil)
toJSON(add(i, 0))
toJSON(all(list, false))
toJSON(all(list, true))
toJSON(any(array, false))
toJSON(any(array, true))
toJSON(any(list, ok))
toJSON(array != $env)
toJSON(array != array)
toJSON(array != list)
toJSON(array != nil)
toJSON(array == array)
toJSON(array == list)
toJSON(array == nil)
toJSON(array ?? 0)
toJSON(array ?? 1)
toJSON(array ?? 1.0)
toJSON(array ?? array)
toJSON(array ?? f64)
toJSON(array ?? list)
toJSON(array ?? str)
toJSON(array | count(false))
toJSON(array | count(ok))
toJSON(array | count(true))
toJSON(array | filter(ok))
toJSON(array | find(true))
toJSON(array | findLast(true))
toJSON(array | map(#))
toJSON(array | map(array))
toJSON(array | max(i))
toJSON(array | min(i))
toJSON(array | none(false))
toJSON(array | one(ok))
toJSON(array | reduce(1))
toJSON(array | reduce(ok))
toJSON(array | sortBy(#))
toJSON(array | sortBy(0))
toJSON(array | sum(#))
toJSON(array | sum(1.0))
toJSON(array | sum(i))
toJSON(array)
toJSON(array) != $env?.[Bar]
toJSON(array) != str
toJSON(array) + str
toJSON(array) < str
toJSON(array) == greet(str)
toJSON(array) endsWith str
toJSON(array) matches 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(bitnand(1, 1))
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, false))
toJSON(count(array, ok))
toJSON(count(array, true))
toJSON(count(list, false))
toJSON(count(list, true))
toJSON(f64 != 0)
toJSON(f64 != 1)
toJSON(f64 != 1.0)
toJSON(f64 != f64)
toJSON(f64 != nil)
toJSON(f64 * 0)
toJSON(f64 * 1.0)
toJSON(f64 * f64)
toJSON(f64 ** 1)
toJSON(f64 ** f64)
toJSON(f64 + 1.0)
toJSON(f64 - 1.0)
toJSON(f64 / 1)
toJSON(f64 / 1.0)
toJSON(f64 / i)
toJSON(f64 < 0)
toJSON(f64 < 1)
toJSON(f64 < 1.0)
toJSON(f64 <= 0)
toJSON(f64 <= 1)
toJSON(f64 <= 1.0)
toJSON(f64 <= i)
toJSON(f64 == $env)
toJSON(f64 == 0)
toJSON(f64 == 1.0)
toJSON(f64 == nil)
toJSON(f64 > 0)
toJSON(f64 > 1.0)
toJSON(f64 >= 1.0)
toJSON(f64 >= i)
toJSON(f64 ?? $env)
toJSON(f64 ?? 1.0)
toJSON(f64 ?? add)
toJSON(f64 ?? array)
toJSON(f64 ?? i)
toJSON(f64 ?? nil)
toJSON(f64 ?? ok)
toJSON(f64 ^ 0)
toJSON(f64 ^ 1.0)
toJSON(f64 ^ f64)
toJSON(f64 ^ i)
toJSON(f64 in array)
toJSON(f64 not in array)
toJSON(f64 | mean(1.0))
toJSON(f64 | median(i))
toJSON(f64)
toJSON(f64) > str
toJSON(f64) ?? add
toJSON(f64) in reduce(array, $env, array)
toJSON(f64) not contains str ?? 0
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 && ok)
toJSON(false == $env)
toJSON(false == nil)
toJSON(false == ok)
toJSON(false == true)
toJSON(false ? ok : true)
toJSON(false ?: f64)
toJSON(false ?? 1.0)
toJSON(false ?? add)
toJSON(false ?? f64)
toJSON(false ?? foo)
toJSON(false ?? greet)
toJSON(false ?? i)
toJSON(false ?? nil)
toJSON(false ?? ok)
toJSON(false and $env)
toJSON(false not in $env?.[String])
toJSON(false or false)
toJSON(false || false)
toJSON(false || ok)
toJSON(false) <= $env.str
toJSON(false) <= str
toJSON(false) ?? f64
toJSON(false) ?? len(array)
toJSON(false) not endsWith str
toJSON(false) startsWith first($env)
toJSON(false) | lastIndexOf(str)
toJSON(find(array, true))
toJSON(find(list, false))
toJSON(find(list, ok))
toJSON(findIndex($env, false))
toJSON(findIndex($env, true))
toJSON(findIndex(list, false))
toJSON(findLastIndex($env, false))
toJSON(findLastIndex($env, ok))
toJSON(first($env))
toJSON(first(array))
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))
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 ?? $env)
toJSON(foo ?? $env?.[f64 >= foobar])
toJSON(foo ?? 0)
toJSON(foo ?? 1)
toJSON(foo ?? add)
toJSON(foo ?? f64)
toJSON(foo ?? foo)
toJSON(foo ?? list)
toJSON(foo ?? ok)
toJSON(foo ?? str)
toJSON(foo ?? true)
toJSON(foo in list)
toJSON(foo not in list)
toJSON(foo)
toJSON(foo) + str
toJSON(foo) < str
toJSON(foo) > str
toJSON(foo) > toJSON(1.0)
toJSON(foo) >= string(nil)
toJSON(foo) ?? $env?.greet
toJSON(foo) ?? i
toJSON(foo) ?? ok
toJSON(foo) not in $env?.String
toJSON(foo) not matches $env?.[foobar]
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 == nil)
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 * i)
toJSON(i ** 1.0) | greet()
toJSON(i ** f64)
toJSON(i + 1 .. 0)
toJSON(i + 1.0)
toJSON(i - 1)
toJSON(i - i)
toJSON(i .. 1)
toJSON(i / 1.0)
toJSON(i / f64)
toJSON(i / i)
toJSON(i < 1)
toJSON(i < 1.0)
toJSON(i <= 1)
toJSON(i == 0)
toJSON(i == 1)
toJSON(i == 1.0)
toJSON(i == nil)
toJSON(i == nil) <= str
toJSON(i > 1)
toJSON(i > f64)
toJSON(i > i)
toJSON(i >= 0)
toJSON(i >= 1.0)
toJSON(i >= f64)
toJSON(i >= i)
toJSON(i ?? $env)
toJSON(i ?? 0)
toJSON(i ?? 1.0)
toJSON(i ?? add)
toJSON(i ?? array)
toJSON(i ?? foo)
toJSON(i ?? greet)
toJSON(i ?? list?.[i])
toJSON(i ?? nil)
toJSON(i ?? str)
toJSON(i ?? true)
toJSON(i ^ 0)
toJSON(i ^ 1.0)
toJSON(i ^ f64)
toJSON(i in array)
toJSON(i not in array)
toJSON(i | bitand(0))
toJSON(i)
toJSON(i) + str
toJSON(i) < foo.String()
toJSON(i) <= str
toJSON(i) ?? array
toJSON(i) ?? i
toJSON(i) not contains string(0)
toJSON(i) not in foo ? 1.0 : foo
toJSON(i) | greet()
toJSON(if false { $env } else { nil })
toJSON(if false { add } else { ok })
toJSON(if false { nil } else { list })
toJSON(if false { str } else { str })
toJSON(if ok { foo } else { 1.0 })
toJSON(if true { foo } else { 1 })
toJSON(if true { ok } else { f64 })
toJSON(if true { true } else { i })
toJSON(int(0))
toJSON(int(1))
toJSON(int(1.0))
toJSON(int(f64))
toJSON(keys($env))
toJSON(last($env))
toJSON(last($env?.[foobar]))
toJSON(last(array))
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 ?? 0)
toJSON(list ?? 1.0)
toJSON(list ?? add)
toJSON(list ?? array)
toJSON(list ?? false)
toJSON(list ?? foo)
toJSON(list ?? nil)
toJSON(list ?? ok)
toJSON(list ?? true)
toJSON(list | all(false))
toJSON(list | find(false))
toJSON(list | find(ok))
toJSON(list | findIndex(true))
toJSON(list | findLast(ok))
toJSON(list | map(#))
toJSON(list | map(#.Bar))
toJSON(list | map(0))
toJSON(list | map(1))
toJSON(list | map(foo))
toJSON(list | map(true))
toJSON(list | none(true))
toJSON(list | reduce(#))
toJSON(list | reduce(0))
toJSON(list | reduce(foo))
toJSON(list | sortBy(f64))
toJSON(list | sortBy(i))
toJSON(list | sum(1.0))
toJSON(list | sum(i))
toJSON(list)
toJSON(list) + str
toJSON(list) <= str
toJSON(list) == str
toJSON(list) > str
toJSON(list) > string($env)
toJSON(list) not in foo
toJSON(list) startsWith str
toJSON(list) | greet()
toJSON(list?.[0])
toJSON(list?.[i])
toJSON(list[0:])
toJSON(list[:1])
toJSON(lower(str))
toJSON(map($env, 0))
toJSON(map($env, array))
toJSON(map($env, false))
toJSON(map($env, foo))
toJSON(map($env, i))
toJSON(map($env, list))
toJSON(map(array, #))
toJSON(map(array, 0))
toJSON(map(array, list))
toJSON(map(array, ok))
toJSON(map(array, str))
toJSON(map(list, #))
toJSON(map(list, #index))
toJSON(map(list, .Bar))
toJSON(map(list, array))
toJSON(map(list, f64))
toJSON(map(list, list))
toJSON(max(0))
toJSON(max(1))
toJSON(max(1.0))
toJSON(max(1.0, 0))
toJSON(max(1.0, 1))
toJSON(max(1.0, array))
toJSON(max(array))
toJSON(max(f64))
toJSON(max(i))
toJSON(mean(0))
toJSON(mean(1))
toJSON(mean(1.0))
toJSON(mean(array))
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(f64, i))
toJSON(median(i))
toJSON(min($env)?.list)
toJSON(min(0))
toJSON(min(1))
toJSON(min(1, f64))
toJSON(min(1.0))
toJSON(min(array))
toJSON(min(f64))
toJSON(min(i))
toJSON(nil != $env)
toJSON(nil != 0)
toJSON(nil != 1)
toJSON(nil != 1.0)
toJSON(nil != add)
toJSON(nil != array)
toJSON(nil != f64)
toJSON(nil != false)
toJSON(nil != foo)
toJSON(nil != greet)
toJSON(nil != i)
toJSON(nil != list)
toJSON(nil != nil)
toJSON(nil != ok)
toJSON(nil != str)
toJSON(nil != true or ok)
toJSON(nil != true)
toJSON(nil == $env)
toJSON(nil == 0)
toJSON(nil == 1)
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 ?? 0)
toJSON(nil ?? 1)
toJSON(nil ?? array)
toJSON(nil ?? f64)
toJSON(nil ?? foo)
toJSON(nil ?? i)
toJSON(nil ?? list)
toJSON(nil ?? nil)
toJSON(nil ?? true)
toJSON(nil in $env)
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) > toJSON(true)
toJSON(nil) >= str
toJSON(nil) ?? str
toJSON(nil) in $env?.String
toJSON(nil) in foo
toJSON(nil) matches str
toJSON(nil) not contains $env?.[str]
toJSON(nil) not in foo
toJSON(nil) not matches foo?.Bar
toJSON(nil) not startsWith str
toJSON(nil) | greet()
toJSON(nil)[:i]
toJSON(none($env, false))
toJSON(none($env, true))
toJSON(none(list, false))
toJSON(none(list, ok))
toJSON(not false)
toJSON(not ok)
toJSON(not true)
toJSON(ok != false)
toJSON(ok != nil)
toJSON(ok != ok)
toJSON(ok && false)
toJSON(ok && ok)
toJSON(ok && true)
toJSON(ok == $env)
toJSON(ok == false)
toJSON(ok == nil)
toJSON(ok == nil) < foo?.String()
toJSON(ok == true)
toJSON(ok ? 1.0 : 0)
toJSON(ok ? foo : ok)
toJSON(ok ?: foo)
toJSON(ok ?? $env)
toJSON(ok ?? 1)
toJSON(ok ?? 1.0)
toJSON(ok ?? array)
toJSON(ok ?? f64)
toJSON(ok ?? false)
toJSON(ok ?? foo)
toJSON(ok ?? ok)
toJSON(ok and true)
toJSON(ok or false)
toJSON(ok or true)
toJSON(ok || false)
toJSON(ok)
toJSON(ok) != string(true)
toJSON(ok) == trimSuffix(str)
toJSON(ok) ?? i
toJSON(ok) matches foo.Bar
toJSON(ok) not startsWith str
toJSON(ok) | greet()
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, 1))
toJSON(reduce(array, f64))
toJSON(reduce(array, foo))
toJSON(reduce(array, str))
toJSON(reduce(list, #))
toJSON(reduce(list, #.Bar))
toJSON(reduce(list, 0))
toJSON(reduce(list, 1.0))
toJSON(reduce(list, f64))
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, 0))
toJSON(sortBy(array, 1))
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 >= str)
toJSON(str ?? $env)
toJSON(str ?? 0)
toJSON(str ?? array)
toJSON(str ?? false)
toJSON(str ?? foo)
toJSON(str ?? list)
toJSON(str ?? ok)
toJSON(str contains str)
toJSON(str endsWith str)
toJSON(str in $env)
toJSON(str in foo)
toJSON(str in list?.[i])
toJSON(str matches str)
toJSON(str not contains str)
toJSON(str not endsWith str)
toJSON(str not in $env)
toJSON(str not in [add, array, foo])
toJSON(str not in foo)
toJSON(str startsWith str)
toJSON(str)
toJSON(str) ?? array
toJSON(str) endsWith str
toJSON(str) matches str
toJSON(str) matches str || ok
toJSON(str) | greet()
toJSON(str[0:])
toJSON(str[:0])
toJSON(str[:])
toJSON(string($env | one(true)))
toJSON(string($env))
toJSON(string($env?.[str]))
toJSON(string(0))
toJSON(string(1))
toJSON(string(1.0 - 1))
toJSON(string(1.0))
toJSON(string(add))
toJSON(string(array))
toJSON(string(f64))
toJSON(string(false))
toJSON(string(foo))
toJSON(string(greet))
toJSON(string(i))
toJSON(string(list))
toJSON(string(nil))
toJSON(string(ok))
toJSON(string(str))
toJSON(string(true))
toJSON(string(values($env)))
toJSON(sum($env, 1.0))
toJSON(sum(array))
toJSON(sum(array, #))
toJSON(sum(array, i))
toJSON(sum(i .. i))
toJSON(sum(list, i))
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(greet(str)))
toJSON(trim(str))
toJSON(trimPrefix($env?.[str]))
toJSON(trimPrefix(str))
toJSON(trimSuffix($env?.str))
toJSON(trimSuffix(str))
toJSON(true != $env)
toJSON(true != false)
toJSON(true != nil)
toJSON(true != ok)
toJSON(true != true)
toJSON(true && false)
toJSON(true && ok)
toJSON(true && true)
toJSON(true == $env)
toJSON(true == true)
toJSON(true ? foo : 1.0)
toJSON(true ? foo : f64)
toJSON(true ? nil : false)
toJSON(true ?: greet)
toJSON(true ?: nil)
toJSON(true ?? $env)
toJSON(true ?? foo)
toJSON(true ?? nil)
toJSON(true ?? str)
toJSON(true and ok)
toJSON(true and true)
toJSON(true or $env)
toJSON(true or false)
toJSON(true or ok)
toJSON(true or true)
toJSON(true || $env)
toJSON(true || ok)
toJSON(true || true)
toJSON(true) + str | trimPrefix(str)
toJSON(true) < str
toJSON(true) > str
toJSON(true) ?? $env.greet
toJSON(true) ?? 1 | groupBy(true)
toJSON(true) ?? f64
toJSON(true) ?? foo | filter(true)
toJSON(true) in foo
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 + 1.0))
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(type(true))
toJSON(uniq(array))
toJSON(uniq(list))
toJSON(upper(str))
toJSON({foo: $env}?.list)
toJSON({foo: 0, foo: f64}.i)
toJSON({foo: 0})
toJSON({foo: 1, foo: 1.0, foo: $env})
toJSON({foo: 1, foo: true})
toJSON({foo: 1.0})
toJSON({foo: 1.0}.f64)
toJSON({foo: 1})
toJSON({foo: array})
toJSON({foo: f64})
toJSON({foo: false})
toJSON({foo: foo, foo: array})
toJSON({foo: foo, foo: f64})
toJSON({foo: foo, foo: str})
toJSON({foo: foo, foo: true})
toJSON({foo: foo})
toJSON({foo: foo}.Bar)
toJSON({foo: foo}?.array)
toJSON({foo: i, foo: foo})
toJSON({foo: i})
toJSON({foo: list})
toJSON({foo: nil != 1.0})
toJSON({foo: nil, foo: $env, foo: 0})
toJSON({foo: nil, foo: 1.0})
toJSON({foo: nil, foo: i})
toJSON({foo: nil})
toJSON({foo: ok})
toJSON({foo: str, foo: 0})
toJSON({foo: str})
toJSON({foo: true})
toPairs($env ?? $env)
toPairs($env ?? 0)
toPairs($env ?? 1)
toPairs($env ?? 1.0)
toPairs($env ?? add)
toPairs($env ?? array)
toPairs($env ?? foo)
toPairs($env ?? i)
toPairs($env ?? ok)
toPairs($env ?? str)
toPairs($env ?? true)
toPairs($env) != array
toPairs($env) != list
toPairs($env) == array
toPairs($env) == list
toPairs($env) ?? array
toPairs($env) ?? foo
toPairs($env) ?? greet
toPairs($env) ?? list
toPairs($env) ?? str
toPairs($env) not in $env?.Bar
toPairs($env) | concat(array)
toPairs($env) | count(false)
toPairs($env) | count(ok)
toPairs($env) | findIndex(false)
toPairs($env) | findLast(ok)
toPairs($env) | findLastIndex(true)
toPairs($env) | groupBy(1.0)
toPairs($env) | groupBy(false)
toPairs($env) | groupBy(foo)
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(#, foo)
toPairs($env) | reduce($env)
toPairs($env) | reduce(1.0)
toPairs($env) | reduce(add)
toPairs($env) | reduce(false)
toPairs($env) | reduce(foo)
toPairs($env) | reduce(greet)
toPairs($env) | reduce(i)
toPairs($env) | sortBy(0)
toPairs($env) | sortBy(i)
toPairs($env)?.[i]
toPairs(array | groupBy(1.0))
toPairs(array | groupBy(f64))
toPairs(array | groupBy(ok))
toPairs(false ? $env : $env)
toPairs(groupBy(array, 1.0))
toPairs(groupBy(array, str))
toPairs(groupBy(array, true))
toPairs(groupBy(list, #))
toPairs(groupBy(list, 1.0))
toPairs(list | groupBy(#))
toPairs(list | groupBy(false))
toPairs(list | groupBy(foo))
toPairs(list | groupBy(i))
toPairs(max($env))
toPairs(min($env))
toPairs(nil ?? $env)
toPairs(reduce(array, $env))
toPairs({foo: $env, foo: true})
toPairs({foo: $env})
toPairs({foo: 0, foo: $env})
toPairs({foo: 0})
toPairs({foo: 1, foo: $env})
toPairs({foo: 1, foo: foo})
toPairs({foo: 1.0 - 1.0})
toPairs({foo: 1.0, foo: $env})
toPairs({foo: 1.0, foo: 1})
toPairs({foo: 1.0})
toPairs({foo: 1})
toPairs({foo: add, foo: add})
toPairs({foo: add})
toPairs({foo: array, foo: f64})
toPairs({foo: array})
toPairs({foo: f64})
toPairs({foo: false})
toPairs({foo: foo, foo: greet})
toPairs({foo: foo, foo: list})
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.Bar, str)
trim(foo.String())
trim(foo?.Bar)
trim(foo?.String())
trim(greet(foo?.Bar))
trim(greet(str))
trim(last(list).Bar)
trim(list | reduce(.Bar))
trim(lower(str))
trim(nil ?? str)
trim(reduce($env, str, greet))
trim(reduce(array, str))
trim(str + str)
trim(str ?? 1.0)
trim(str ?? add)
trim(str ?? list)
trim(str | greet())
trim(str)
trim(str) == str
trim(str) >= str
trim(str) ?? array
trim(str) in foo
trim(str) matches str
trim(str) not endsWith $env?.[str]
trim(str) not in list?.[i]
trim(str) not matches foo.String()
trim(str) not matches str
trim(str) | greet()
trim(str)[:]
trim(str, foo.Bar)
trim(str, str)
trim(str, toJSON(ok))
trim(str[0:])
trim(str[:0])
trim(str[:1])
trim(str[:i])
trim(string($env))
trim(string($env.ok))
trim(string($env?.Bar))
trim(string(0))
trim(string(1))
trim(string(1.0))
trim(string(add))
trim(string(array))
trim(string(f64))
trim(string(false))
trim(string(foo))
trim(string(greet))
trim(string(i))
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($env?.foo))
trim(toJSON(0))
trim(toJSON(1))
trim(toJSON(1.0))
trim(toJSON(array))
trim(toJSON(f64))
trim(toJSON(false))
trim(toJSON(foo != foo))
trim(toJSON(foo))
trim(toJSON(i))
trim(toJSON(list))
trim(toJSON(nil))
trim(toJSON(ok))
trim(toJSON(str))
trim(toJSON(true))
trim(trim(str))
trim(trimPrefix(str))
trim(trimSuffix(str))
trim(type($env))
trim(type(0))
trim(type(1))
trim(type(1.0))
trim(type(add))
trim(type(array))
trim(type(f64))
trim(type(false))
trim(type(foo))
trim(type(greet))
trim(type(i))
trim(type(list))
trim(type(nil))
trim(type(ok))
trim(type(str))
trim(type(true))
trim(upper(str))
trimPrefix($env) == nil || true
trimPrefix($env.str)
trimPrefix($env?.[str])
trimPrefix($env?.str)
trimPrefix($env?.str, str)
trimPrefix(array | reduce(str, add))
trimPrefix(false ? greet : str)
trimPrefix(foo.Bar)
trimPrefix(foo.String())
trimPrefix(foo?.Bar)
trimPrefix(foo?.String())
trimPrefix(greet(foo?.String()))
trimPrefix(greet(str))
trimPrefix(greet(toJSON(false)))
trimPrefix(lower(str))
trimPrefix(nil ?? str)
trimPrefix(reduce(array, str))
trimPrefix(reduce(list, str))
trimPrefix(str + foo?.Bar)
trimPrefix(str ?? $env)
trimPrefix(str ?? 0)
trimPrefix(str ?? array)
trimPrefix(str ?? false)
trimPrefix(str ?? foo)
trimPrefix(str ?? greet)
trimPrefix(str ?? i)
trimPrefix(str ?? str)
trimPrefix(str | greet())
trimPrefix(str)
trimPrefix(str) < type(nil)
trimPrefix(str) <= str
trimPrefix(str) == str
trimPrefix(str) > str
trimPrefix(str) ?? f64
trimPrefix(str) endsWith str
trimPrefix(str) not contains str
trimPrefix(str) not startsWith str
trimPrefix(str) startsWith str
trimPrefix(str, false ? i : str)
trimPrefix(str, foo?.Bar)
trimPrefix(str, str)
trimPrefix(str, string(foo))
trimPrefix(str, toJSON(nil))
trimPrefix(str, type(false))
trimPrefix(str, type(true))
trimPrefix(str[0:])
trimPrefix(str[1:])
trimPrefix(str[:i])
trimPrefix(string($env))
trimPrefix(string(0))
trimPrefix(string(1))
trimPrefix(string(1.0))
trimPrefix(string(add))
trimPrefix(string(array))
trimPrefix(string(f64))
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))
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(trimPrefix(type($env)))
trimPrefix(trimSuffix(str))
trimPrefix(type($env))
trimPrefix(type($env.ok))
trimPrefix(type(0))
trimPrefix(type(1))
trimPrefix(type(1.0))
trimPrefix(type(add))
trimPrefix(type(array))
trimPrefix(type(f64))
trimPrefix(type(false))
trimPrefix(type(foo))
trimPrefix(type(greet))
trimPrefix(type(i))
trimPrefix(type(list))
trimPrefix(type(nil))
trimPrefix(type(ok))
trimPrefix(type(str))
trimPrefix(type(true))
trimPrefix(upper(foo?.String()))
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(list | reduce(#.Bar))
trimSuffix(lower(str))
trimSuffix(str ?? $env)
trimSuffix(str ?? foo)
trimSuffix(str ?? list)
trimSuffix(str | greet())
trimSuffix(str)
trimSuffix(str) != str
trimSuffix(str) + str
trimSuffix(str) <= greet(str)
trimSuffix(str) ?? add
trimSuffix(str) ?? foo
trimSuffix(str) ?? ok
trimSuffix(str) | greet()
trimSuffix(str, $env?.[str])
trimSuffix(str, str)
trimSuffix(string($env))
trimSuffix(string($env), str)
trimSuffix(string(0))
trimSuffix(string(1))
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(string(str))
trimSuffix(string(sum($env, 0)))
trimSuffix(string(true))
trimSuffix(toBase64($env?.[str]))
trimSuffix(toBase64($env?.str))
trimSuffix(toBase64(str))
trimSuffix(toJSON(0))
trimSuffix(toJSON(1.0))
trimSuffix(toJSON(array))
trimSuffix(toJSON(f64))
trimSuffix(toJSON(false))
trimSuffix(toJSON(foo))
trimSuffix(toJSON(i))
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(f64))
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(type(true))
trimSuffix(upper(str))
true != $env != 1 ?? foo
true != $env || $env >= 1.0
true != $env || ok
true != $env.ok
true != $env?.Bar
true != $env?.String
true != $env?.String?.String
true != $env?.String?.[str]
true != $env?.[Bar]
true != $env?.[String]
true != $env?.[String]?.Bar
true != $env?.[foobar?.[greet]]
true != $env?.[foobar]
true != $env?.[str]
true != $env?.ok
true != f64 - 0 ?? $env
true != false == ok
true != false ?? i
true != i ?? f64
true != list ?? array
true != list ?? not ok
true != nil and foo ?? ok
true != nil and ok
true != ok != $env?.String
true != ok ?? array
true != str ?? add
true != str ?? greet
true != str ?? i
true != true ?: foo
true != true ?? array
true != true ?? greet
true && $env != list
true && $env == list?.[i]
true && $env == str
true && $env ?? $env[:foo]
true && $env ?? foo
true && $env ?? groupBy(list, foo)?.f64
true && $env ?? not $env
true && $env ?? ok
true && $env.ok
true && $env?.Bar
true && $env?.String
true && $env?.[Bar]
true && $env?.[Bar]?.[str]
true && $env?.[Bar]?.str
true && $env?.[String]
true && $env?.[foobar]
true && $env?.[str]
true && $env?.foobar
true && $env?.i != f64
true && $env?.ok
true && 0 * i < 1
true && 0 ?? add
true && 1 < len($env)
true && 1.0 == f64
true && 1.0 > 0 and true
true && 1.0 >= f64
true && add ?? list
true && false != false || true
true && false && ok
true && greet == greet
true && nil != foo
true && nil == ok
true && nil == str
true && ok ?: str
true && str != str
true && str ?? $env?.[ok]
true && str ?? f64
true && str ?? i
true && str startsWith $env?.String
true && true ?? ok
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?.foobar
true == $env?.ok
true == 1.0 ?? foo || ok
true == f64 ?? greet
true == false and ok
true == foo ?? f64
true == nil && false != nil
true == nil && foo in $env
true == nil == ok
true == ok && ok
true == true ?: add
true == true or !true
true ? $env : $env.f64
true ? $env : $env.foo
true ? $env : $env.str
true ? $env : $env?.Bar
true ? $env : $env?.String
true ? $env : $env?.[array]
true ? $env : $env?.[list]
true ? $env : $env?.[ok]
true ? $env : $env?.greet
true ? $env : foo.String
true ? $env : i | date(i)
true ? 0 : $env.i
true ? 0 : $env?.Bar
true ? 0 : $env?.Bar?.greet
true ? 0 : $env?.String
true ? 0 : $env?.[Bar]
true ? 0 : $env?.[add]?.[f64]
true ? 0 : $env?.[sortBy(1, foobar)]
true ? 0 : $env?.foobar
true ? 0 : $env[:list(foobar)]
true ? 0 : 1 < 1.0 ** 1.0
true ? 0 : foo.String()
true ? 0 : i > f64
true ? 1 : $env | max(0, f64)
true ? 1 : $env.f64
true ? 1 : $env?.[ok]
true ? 1 : $env?.i
true ? 1 : 1.0 / 1 == f64
true ? 1 : list | sortBy(add)
true ? 1.0 : $env | sortBy(add)
true ? 1.0 : $env.foo
true ? 1.0 : $env.greet
true ? 1.0 : $env.ok
true ? 1.0 : $env.str
true ? 1.0 : $env?.[Bar]
true ? 1.0 : $env?.[i]
true ? 1.0 : $env?.[str]
true ? 1.0 : $env?.list
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 ? add : $env?.[add]
true ? add : $env?.[ok]
true ? add : foo.String
true ? add : i != i
true ? array : $env.array
true ? array : $env?.[str]
true ? array : $env?.foo
true ? array : foo.String
true ? f64 : $env.add
true ? f64 : $env?.[f64]
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.list
true ? false : $env?.[array]
true ? false : $env?.[i]
true ? false : $env?.f64
true ? false : $env[:Bar not matches $env]
true ? false : array != array
true ? foo : $env | greet()
true ? foo : $env | one(ok)
true ? foo : $env | sortBy(1.0)
true ? foo : $env.array
true ? foo : $env.foo
true ? foo : $env?.[String]
true ? foo : $env?.[foo]?.greet
true ? foo : $env?.[str]
true ? foo : $env?.array
true ? foo : $env?.i
true ? foo : $env?.str
true ? foo : 1.0 + i
true ? foo : array | sortBy(f64)
true ? foo : foo ?? list
true ? foo : foo.Bar
true ? foo : foo.String
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 : foo?.Bar
true ? greet : nil != none($env, #)
true ? i : $env?.[Bar]
true ? i : array | map(i)
true ? list : $env | all(#.foo)
true ? list : $env?.String
true ? list : $env?.[f64]
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 | bitxor(0)
true ? nil : $env.str
true ? nil : $env?.[f64]
true ? nil : $env?.foo
true ? nil : $env?.str
true ? nil : $env[str(1.0):] | all(.list?.i(foobar))
true ? nil : foo.Bar
true ? nil : nil != greet
true ? ok : $env.foo
true ? ok : $env?.[str]
true ? ok : $env?.array
true ? ok : foo.String
true ? str : $env?.array
true ? str : $env?.f64
true ? str : array | max(i)
true ? str : foo.Bar
true ? str : foo?.Bar
true ? str : i + i
true ? true : $env?.String.str
true ? true : $env?.[array]
true ? true : $env?.[array].greet
true ? true : $env?.greet
true ? true : $env?.str
true ? true : 1.0 == $env?.Bar
true ? true : array | date(false, foo)
true ? true : foo?.Bar
true ? true : list | sum(#)
true ? true : str != str
true ?: $env != 0 ^ $env
true ?: $env % i
true ?: $env or ok
true ?: $env | any(.i)
true ?: $env | count(.list)
true ?: $env | find(#)
true ?: $env | groupBy(.foo)
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.i ?? $env
true ?: $env.list
true ?: $env.ok
true ?: $env.str
true ?: $env?.Bar
true ?: $env?.String
true ?: $env?.[Bar]
true ?: $env?.[String()]
true ?: $env?.[array]
true ?: $env?.[f64]
true ?: $env?.[foo]
true ?: $env?.[i]
true ?: $env?.[list]
true ?: $env?.add
true ?: $env?.array
true ?: $env?.f64
true ?: $env?.foo
true ?: $env?.greet
true ?: $env?.i
true ?: $env?.ok
true ?: $env?.str
true ?: $env[:foobar]
true ?: 0 != 0 ? true : false
true ?: 1.0 - f64
true ?: 1.0 == f64
true ?: 1.0 >= f64
true ?: 1.0 | max($env)
true ?: array | map(1.0)
true ?: array?.[$env?.String()]
true ?: foo ?? f64
true ?: foo.Bar
true ?: foo.String
true ?: foo?.Bar
true ?: foo?.String
true ?: nil != f64
true ?: nil == $env?.str
true ?? $env.add
true ?? $env.array
true ?? $env.f64
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?.String()
true ?? $env?.String?.f64
true ?? $env?.[1.0 not endsWith foobar]
true ?? $env?.[Bar]
true ?? $env?.[Bar]?.[str]
true ?? $env?.[String]
true ?? $env?.[abs(foobar)]
true ?? $env?.[add]
true ?? $env?.[array]
true ?? $env?.[f64]
true ?? $env?.[foo?.greet]
true ?? $env?.[foo]
true ?? $env?.[foo].array
true ?? $env?.[foobar | one(#)]
true ?? $env?.[foobar.f64(1, foobar, ok)]
true ?? $env?.[greet]
true ?? $env?.[i]
true ?? $env?.[list]
true ?? $env?.[ok]
true ?? $env?.[ok]?.[greet]
true ?? $env?.[str]
true ?? $env?.add
true ?? $env?.array
true ?? $env?.f64
true ?? $env?.foo
true ?? $env?.foobar
true ?? $env?.foobar.String
true ?? $env?.greet
true ?? $env?.i
true ?? $env?.list
true ?? $env?.ok
true ?? $env?.str
true ?? $env[$env?.[str]:]
true ?? $env[:String.greet].greet
true ?? $env[:array[:f64]]
true ?? $env[f64():]
true ?? $env[false == str:]
true ?? $env[foobar ^ foobar:findIndex($env, #index)]
true ?? $env[foobar:foobar]
true ?? 0 ?? greet
true ?? 1 ?? groupBy($env, .str)
true ?? 1.0 ?? i
true ?? array?.[i]
true ?? foo ?? i
true ?? foo.Bar
true ?? foo.String
true ?? foo?.Bar
true ?? foo?.String
true ?? foo?.String()
true ?? i | get(false)
true ?? list?.[i]
true ?? nil ?? greet
true and $env != greet
true and $env == f64
true and $env == last(array)
true and $env ?? $env ?? add
true and $env ?? count($env, #)
true and $env ?? str
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?.Bar
true and $env?.String?.[array]
true and $env?.String?.ok
true and $env?.[Bar]
true and $env?.[Bar]?.i
true and $env?.[String]
true and $env?.[str]
true and $env?.foobar
true and $env?.foobar?.array()
true and $env?.ok
true and 0 != f64
true and 0 < i
true and 1 > f64
true and 1 > i
true and 1 >= i
true and 1 in sort($env)
true and 1.0 > f64
true and 1.0 in array
true and add ?? array
true and array != list
true and f64 < f64
true and f64 <= f64
true and f64 ?? foo
true and false ?? ok
true and false || ok
true and foo != foo
true and foo == foo
true and i == i
true and nil != greet
true and nil != list
true and nil == greet
true and str != str
true and str ?? greet
true and true || $env >= $env
true in $env?.Bar
true in $env?.Bar?.foo
true in $env?.String
true in $env?.[Bar]
true in $env?.[String]
true in $env?.[first(foobar)]
true in $env?.[foobar | last(nil)]
true in $env?.[foobar]
true not in $env?.Bar
true not in $env?.String
true not in $env?.String?.Bar(foo)
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 not in array ?? add
true not in array ?? foo
true not in list ?? i
true or $env != array
true or $env != ok
true or $env && ok
true or $env * findIndex(list, true)
true or $env - f64
true or $env - list ?? false
true or $env ?? $env?.[Bar]
true or $env ?? foo
true or $env endsWith $env?.greet($env)
true or $env in str
true or $env not in [i]
true or $env startsWith str
true or $env.ok
true or $env?.Bar
true or $env?.Bar()
true or $env?.Bar(add not matches foobar)
true or $env?.Bar(f64?.String() in count(greet))
true or $env?.Bar?.array
true or $env?.String
true or $env?.String()
true or $env?.String(add())
true or $env?.String(true | findLastIndex(1))
true or $env?.String?.ok
true or $env?.[0 | one(1.0)]
true or $env?.[Bar]
true or $env?.[Bar].ok
true or $env?.[String]
true or $env?.[add]
true or $env?.[add]?.[add]
true or $env?.[add]?.str
true or $env?.[array(ok, foobar)]
true or $env?.[array]
true or $env?.[array]?.greet?.Bar
true or $env?.[array]?.str()
true or $env?.[f64]
true or $env?.[float(array, foobar)]
true or $env?.[foo | findLastIndex(#)]
true or $env?.[foo]
true or $env?.[foobar != foo]
true or $env?.[foobar | concat(true)]
true or $env?.[greet]
true or $env?.[greet]?.[add]
true or $env?.[i.f64]
true or $env?.[i]
true or $env?.[i] == ok
true or $env?.[list(foobar, foobar)]?.foo
true or $env?.[list]
true or $env?.[list]?.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[:i]
true or $env[:nil | filter(false)]
true or $env[:str]
true or $env[:true || foobar]
true or $env[foobar:]
true or $env[foobar?.[array]:]
true or $env[none($env, .String):]
true or $env[ok:]
true or $env[trimSuffix(foobar, nil, 1.0, array):]
true or 0 < f64
true or 0 < f64 ** 1
true or 0 <= $env?.[f64]?.[foo]
true or 0 <= i
true or 0 ?? foo?.Bar
true or 1 > f64
true or 1 >= $env in $env
true or 1.0 != i
true or 1.0 <= $env ^ i
true or 1.0 > i
true or 1.0 >= f64
true or array == list
true or f64 + $env?.[add]
true or f64 ?? foo
true or f64 ?? i
true or f64 ?? list
true or false ?: sum($env, .Bar)
true or false or ok
true or foo != foo && true
true or greet == greet
true or i > $env[:foobar]
true or i not in $env * f64
true or list != list
true or nil == add
true or nil == str in $env
true or nil not in $env?.[String]
true or nil not in list
true or ok && ok
true or ok and foo == $env?.[String]
true or ok in sum($env)
true or str == toJSON(f64)
true or str contains $env?.str
true or str in $env[list:]
true or str not in foo
true || $env != 1.0 - $env
true || $env != i
true || $env <= foo?.Bar
true || $env == greet
true || $env > f64
true || $env >= f64 - 0
true || $env ?? add
true || $env ?? array
true || $env ?? f64
true || $env ?? foo
true || $env ?? ok
true || $env contains str
true || $env in str
true || $env not contains $env?.[foo]
true || $env not contains str
true || $env or ok
true || $env.ok
true || $env?.Bar
true || $env?.Bar()
true || $env?.Bar?.i()
true || $env?.String
true || $env?.String($env | bitshl(str)).str
true || $env?.String()
true || $env?.String(false > foobar, array(foobar))
true || $env?.String(foobar?.greet(foobar))
true || $env?.String(map(foobar | findIndex(#.str), .greet))
true || $env?.String(reduce(foobar, #.list).i)
true || $env?.String?.list
true || $env?.[$env > list]
true || $env?.[Bar(nil, 0)]
true || $env?.[Bar]
true || $env?.[String]
true || $env?.[add(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.i]
true || $env?.[foo]
true || $env?.[foobar | findIndex(add)]
true || $env?.[foobar | findLastIndex(.ok)]
true || $env?.[foobar]
true || $env?.[greet]
true || $env?.[i]
true || $env?.[i]?.[ok]
true || $env?.[list]
true || $env?.[list]?.String
true || $env?.[ok not startsWith 1.0]
true || $env?.[ok]
true || $env?.[ok]?.[ok]
true || $env?.[str]
true || $env?.[{foo: nil}]
true || $env?.any($env)
true || $env?.foobar
true || $env?.ok
true || $env?.reduce($env)
true || $env[:String == foo]
true || $env[:array($env)]
true || $env[:foobar]
true || $env[:ok ? false : add]
true || $env[:str]
true || $env[Bar | map(1):foobar]
true || $env[String.Bar(foobar):add()]
true || $env[duration(String):]
true || $env[false | bitand(str):]
true || $env[foo(foobar):f64 contains list]
true || $env[foobar:]
true || $env[foobar?.[str]:str()]
true || $env[list endsWith str:foobar]
true || $env[list:]
true || $env[ok + foobar:]
true || $env[ok not in foobar:]
true || 0 != $env?.f64
true || 0 != f64
true || 0 <= $env?.String(str)
true || 0 > 1.0 != true
true || 0 >= median(0, $env)
true || 1 > f64
true || 1.0 ** f64 >= f64
true || 1.0 + 1.0 > 1.0
true || 1.0 < $env?.[str]
true || 1.0 < find($env, #)
true || 1.0 <= i
true || 1.0 > f64
true || 1.0 > f64 == true
true || 1.0 >= f64
true || 1.0 >= i
true || 1.0 in $env?.[add]
true || add != add
true || add ?? f64
true || array != list
true || array ?? !true
true || array not in $env?.[f64]
true || false == $env?.[add]
true || false ?: f64
true || false ?: foo ?? f64
true || false ?? $env?.[array]
true || foo == $env || ok
true || foo ?? array
true || foo ?? ok
true || i == $env?.[f64]
true || i > f64
true || i >= $env ?? $env
true || i in array
true || nil != f64
true || nil != greet ?? $env
true || nil != i
true || nil == foo
true || nil == ok
true || ok ?? greet
true || true && f64 != 1.0
true || true and ok
true; $env?.[str]
true; foo?.String
type(!false)
type(!ok)
type(!true)
type($env != $env)
type($env != 0)
type($env != 1.0)
type($env != add)
type($env != f64)
type($env != foo)
type($env != greet)
type($env != list)
type($env != nil)
type($env != str)
type($env != true)
type($env && true)
type($env == $env)
type($env == 1)
type($env == 1.0)
type($env == add)
type($env == array)
type($env == f64)
type($env == false)
type($env == foo)
type($env == greet)
type($env == nil)
type($env == ok)
type($env == str)
type($env ?? $env)
type($env ?? 1)
type($env ?? 1.0)
type($env ?? array)
type($env ?? false)
type($env ?? foo)
type($env ?? greet)
type($env ?? i)
type($env ?? list)
type($env ?? nil)
type($env and false)
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 false)
type($env or true)
type($env | all(true))
type($env | any(false))
type($env | any(ok))
type($env | any(true))
type($env | count(false))
type($env | count(ok))
type($env | count(true))
type($env | find(false))
type($env | findIndex(true))
type($env | findLastIndex(ok))
type($env | map(#index))
type($env | map($env))
type($env | map(1.0))
type($env | map(false))
type($env | map(foo))
type($env | map(ok))
type($env | map(str))
type($env | none(true))
type($env | one(false))
type($env | sum(0))
type($env | sum(1.0))
type($env || false)
type($env || true)
type($env) != foo?.Bar
type($env) != str
type($env) <= str
type($env) contains str
type($env) endsWith str
type($env) in foo
type($env) not contains toJSON(true)
type($env) not in foo
type($env) not matches str
type($env) startsWith type($env)
type($env) | greet()
type($env) | indexOf(str)
type($env.add)
type($env.array)
type($env.f64)
type($env.foo)
type($env.foo?.Bar)
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?.String?.greet)
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?.false)
type($env?.foo)
type($env?.foo?.String)
type($env?.foobar)
type($env?.greet)
type($env?.i)
type($env?.list ?? foo)
type($env?.list)
type($env?.nil)
type($env?.ok)
type($env?.str)
type($env?.true)
type(-0)
type(-1)
type(-1.0)
type(-f64)
type(-i)
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 * 1)
type(0 ** 0)
type(0 + 0)
type(0 + 1)
type(0 + i)
type(0 - 0)
type(0 - 1)
type(0 - f64)
type(0 - i)
type(0 .. 0)
type(0 .. 1)
type(0 .. i)
type(0 / 1)
type(0 / 1.0)
type(0 / i)
type(0 < 0)
type(0 < 1)
type(0 < 1.0)
type(0 < f64)
type(0 <= 1)
type(0 <= 1.0)
type(0 <= i)
type(0 == $env)
type(0 == 1)
type(0 == 1.0)
type(0 == i)
type(0 == nil)
type(0 > 0)
type(0 > 1.0)
type(0 > i)
type(0 >= 1.0)
type(0 ?? $env)
type(0 ?? $env?.ok)
type(0 ?? 1)
type(0 ?? 1.0)
type(0 ?? foo)
type(0 ?? greet)
type(0 ?? list)
type(0 ?? nil)
type(0 ?? ok)
type(0 ?? str)
type(0 ^ 1)
type(0 ^ 1.0)
type(0 ^ f64)
type(0 ^ i)
type(0 | bitshr(0))
type(0 | bitxor(1))
type(0 | median(1, 1.0))
type(0 | min(0))
type(0 | min(i))
type(0) != str
type(0) ?? array
type(0) ?? i
type(0) ?? ok
type(0) in foo
type(0) not startsWith str
type(0) | greet()
type(0) | splitAfter(str)
type(0) | trim(str)
type(0)[i:]
type(0..i)
type(0.0)
type(0.1)
type(1 != $env)
type(1 != 1.0)
type(1 != f64)
type(1 != nil)
type(1 % 1)
type(1 * 0)
type(1 * 1)
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 + i)
type(1 - 1.0)
type(1 .. 0)
type(1 .. 1)
type(1 / 0)
type(1 / 1)
type(1 / 1.0)
type(1 / f64)
type(1 / i)
type(1 < 1.0)
type(1 <= 0)
type(1 <= 1)
type(1 <= 1.0)
type(1 <= i)
type(1 == $env)
type(1 == 1.0)
type(1 == f64)
type(1 == i)
type(1 == nil)
type(1 > 0)
type(1 > 1)
type(1 > 1.0)
type(1 > f64)
type(1 > i)
type(1 >= 0)
type(1 >= 1.0)
type(1 >= f64)
type(1 >= i)
type(1 ?? $env)
type(1 ?? 0)
type(1 ?? add)
type(1 ?? foo)
type(1 ?? ok)
type(1 ?? str)
type(1 ^ 0)
type(1 ^ 1)
type(1 ^ 1.0)
type(1 in array)
type(1 not in array)
type(1) != str
type(1) < str
type(1) <= str
type(1) >= type(ok)
type(1) in $env?.Bar
type(1) not in foo
type(1) not matches str
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 * i) | greet()
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 + f64)
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 / i)
type(1.0 < 0)
type(1.0 < 1)
type(1.0 < 1.0)
type(1.0 < f64)
type(1.0 < i)
type(1.0 <= 0)
type(1.0 <= 1)
type(1.0 <= 1.0)
type(1.0 <= i)
type(1.0 == $env)
type(1.0 == 0)
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 > f64)
type(1.0 > i)
type(1.0 >= 0)
type(1.0 >= 1)
type(1.0 >= 1.0)
type(1.0 >= f64)
type(1.0 >= i)
type(1.0 ?? $env)
type(1.0 ?? 0)
type(1.0 ?? add)
type(1.0 ?? f64)
type(1.0 ?? foo)
type(1.0 ?? greet)
type(1.0 ?? i)
type(1.0 ?? nil)
type(1.0 ?? ok)
type(1.0 ?? str)
type(1.0 ^ 0)
type(1.0 ^ 1.0)
type(1.0 ^ f64)
type(1.0 ^ i)
type(1.0 in array)
type(1.0 | max(0))
type(1.0 | mean(1.0))
type(1.0)
type(1.0) + foo.Bar
type(1.0) + str
type(1.0) < str
type(1.0) >= str
type(1.0) ?? array
type(1.0) ?? f64
type(1.0) ?? greet($env)
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) not startsWith foo?.Bar
type(1.0) startsWith str
type(1.0) | greet()
type(1.0)[:i]
type([$env, $env])
type([$env, 0])
type([$env, f64])
type([$env])
type([0])
type([1.0, 0])
type([1.0, foo])
type([1.0])
type([1])
type([add])
type([array])
type([f64])
type([false, $env])
type([false])
type([foo, foo])
type([foo, i])
type([foo, nil])
type([foo])
type([greet])
type([i, array])
type([i, foo, nil])
type([i])
type([list, 1.0, true])
type([list, ok])
type([list])
type([nil, foo])
type([nil])
type([ok, f64])
type([ok, nil])
type([ok])
type([str])
type([true, foo])
type([true])
type(abs(0))
type(abs(1))
type(abs(1.0))
type(abs(f64))
type(abs(i))
type(add != $env)
type(add != add)
type(add == nil)
type(add ?? $env)
type(add ?? $env?.[i])
type(add ?? 0)
type(add ?? foo)
type(add ?? i)
type(add ?? list)
type(add ?? ok)
type(add ?? true)
type(add(1, 0))
type(add(i, 0))
type(add)
type(add) != str
type(add) == foo.Bar
type(add) > str
type(add) ?? max(array)
type(add) matches str
type(add) not matches str
type(add) | greet()
type(add)[:]
type(all($env, true))
type(all(array, false))
type(all(array, true))
type(all(list, true))
type(any($env, false))
type(any($env, ok))
type(any(array, 1 > #))
type(any(array, false))
type(any(array, ok))
type(any(list, false))
type(array != nil)
type(array == $env)
type(array == array)
type(array == nil)
type(array ?? $env)
type(array ?? 1.0)
type(array ?? add)
type(array ?? array)
type(array ?? f64)
type(array ?? false)
type(array ?? i)
type(array ?? nil)
type(array ?? str)
type(array ?? true)
type(array | find(false))
type(array | findIndex(false))
type(array | findIndex(ok))
type(array | groupBy(#))
type(array | groupBy(foo))
type(array | groupBy(ok))
type(array | map(#))
type(array | map(1))
type(array | map(greet))
type(array | min(array))
type(array | none(false))
type(array | none(ok))
type(array | reduce(#))
type(array | reduce(#, foo))
type(array | reduce(#index))
type(array | reduce(1.0, list))
type(array | reduce(1.0, ok))
type(array | reduce(false))
type(array | reduce(false, add))
type(array | reduce(foo))
type(array | reduce(true))
type(array | sortBy(#))
type(array | sum(#))
type(array | sum(1))
type(array | sum(1.0))
type(array | sum(i))
type(array)
type(array) != false ?? i
type(array) + str
type(array) < str
type(array) == str
type(array) ?? f64
type(array) ?? greet
type(array) ?? str
type(array) endsWith $env?.[Bar]?.[str]
type(array) in foo
type(array) not in foo
type(array) | repeat(1)
type(array?.[0])
type(array?.[i])
type(array[1:])
type(array[:0])
type(array[:])
type(array[:i])
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 - f64))
type(ceil(1))
type(ceil(1.0))
type(ceil(f64))
type(ceil(floor(i)))
type(ceil(i))
type(concat(array))
type(concat(list))
type(count($env, ok))
type(count($env, true))
type(count([true]))
type(f64 != 0)
type(f64 != 1)
type(f64 != 1.0)
type(f64 != nil)
type(f64 * 0)
type(f64 * 1.0)
type(f64 * f64)
type(f64 * i)
type(f64 ** 0)
type(f64 ** 1.0)
type(f64 ** i)
type(f64 + 1)
type(f64 + 1.0)
type(f64 + f64)
type(f64 + i)
type(f64 - 0)
type(f64 - 1.0)
type(f64 / 0)
type(f64 / 1.0)
type(f64 / i)
type(f64 < 1)
type(f64 < 1.0)
type(f64 <= 1)
type(f64 <= 1.0)
type(f64 <= i)
type(f64 == 0)
type(f64 == 1)
type(f64 == f64)
type(f64 == nil)
type(f64 > 0 != $env)
type(f64 > 1)
type(f64 > 1.0)
type(f64 > f64)
type(f64 > i)
type(f64 >= 1)
type(f64 >= 1.0)
type(f64 >= f64)
type(f64 ?? $env?.[nil == nil])
type(f64 ?? array)
type(f64 ?? false)
type(f64 ?? foo)
type(f64 ?? str)
type(f64 ?? true)
type(f64 ^ 1)
type(f64 ^ 1.0)
type(f64 ^ f64)
type(f64 ^ i)
type(f64 not in array)
type(f64)
type(f64) == str
type(f64) > str
type(f64) >= str
type(f64) matches toJSON(1.0)
type(f64) not startsWith str
type(f64) startsWith str
type(f64) | greet()
type(false != false)
type(false != nil)
type(false != ok)
type(false != true)
type(false && $env)
type(false && ok)
type(false == $env)
type(false == false)
type(false == ok)
type(false ? f64 : 1)
type(false ? foo : add)
type(false ? foo : list)
type(false ? list : foo)
type(false ?? $env)
type(false ?? 1.0)
type(false ?? add)
type(false ?? f64)
type(false ?? i)
type(false ?? list)
type(false ?? nil)
type(false ?? ok)
type(false ?? str)
type(false ?? true)
type(false and $env)
type(false and true)
type(false or $env)
type(false or ok)
type(false or true)
type(false || $env)
type(false || false)
type(false || ok)
type(false || true)
type(false) == str
type(false) > str
type(false) ?? $env?.[i]
type(false) ?? greet
type(false) | greet()
type(false) | splitAfter(str)
type(filter($env, false))
type(find(array, false))
type(find(array, true))
type(findIndex($env, ok))
type(findIndex(list, ok))
type(findLast($env, false))
type(findLast(array, ok))
type(findLast(list, false))
type(findLast(list, ok))
type(findLastIndex(array, ok))
type(first($env))
type(first(array))
type(first(list))
type(flatten(array))
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))
type(floor(1.0))
type(floor(f64))
type(floor(i))
type(foo != $env)
type(foo != $env?.foo)
type(foo != foo)
type(foo != nil)
type(foo == $env)
type(foo == foo)
type(foo == nil)
type(foo ?? $env)
type(foo ?? 0)
type(foo ?? 1)
type(foo ?? 1.0)
type(foo ?? add)
type(foo ?? array)
type(foo ?? f64)
type(foo ?? false)
type(foo ?? foo)
type(foo ?? greet)
type(foo ?? i)
type(foo ?? list)
type(foo ?? nil)
type(foo ?? ok)
type(foo ?? true)
type(foo in list)
type(foo not in list)
type(foo)
type(foo) != $env?.foobar
type(foo) <= str
type(foo) > str
type(foo) ?? add
type(foo) ?? array
type(foo) contains $env?.Bar?.[add]
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 matches str
type(foo) not startsWith str
type(foo) startsWith $env?.[Bar]
type(foo) | greet()
type(foo)[:]
type(foo.Bar)
type(foo.Bar) matches str
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 ?? $env)
type(greet ?? 1)
type(greet ?? 1.0)
type(greet ?? add)
type(greet ?? array)
type(greet ?? f64)
type(greet ?? false)
type(greet ?? greet)
type(greet ?? list)
type(greet ?? nil)
type(greet ?? str)
type(greet(str))
type(greet(toJSON(false)))
type(greet)
type(greet) ?? foo
type(greet) contains foo.Bar
type(greet) startsWith str
type(greet) | greet()
type(groupBy(array, #))
type(groupBy(array, 0))
type(groupBy(array, 1.0))
type(groupBy(array, false))
type(groupBy(array, foo))
type(groupBy(array, ok))
type(groupBy(list, #))
type(groupBy(list, .Bar))
type(groupBy(list, 0))
type(groupBy(list, 1.0))
type(groupBy(list, false))
type(i != $env)
type(i != 1.0)
type(i != array?.[i])
type(i != f64)
type(i != i)
type(i != nil)
type(i * 0)
type(i * 1)
type(i * 1.0)
type(i * f64)
type(i ** 0)
type(i ** 1.0)
type(i ** f64)
type(i + 0)
type(i + 1)
type(i + 1.0)
type(i + f64)
type(i + i)
type(i - 0)
type(i - 1)
type(i - 1.0)
type(i - f64)
type(i .. 0)
type(i .. i)
type(i / 1.0)
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)
type(i == 1.0)
type(i == nil)
type(i > 1.0)
type(i > f64)
type(i >= 1.0)
type(i >= f64)
type(i >= i)
type(i ?? $env)
type(i ?? 1.0)
type(i ?? add)
type(i ?? false)
type(i ?? foo)
type(i ?? list)
type(i ?? nil)
type(i ^ 0)
type(i ^ 1)
type(i ^ i)
type(i | bitushr(i))
type(i)
type(i) <= str
type(i) ?? foo
type(i) ?? greet
type(i) matches string(ok)
type(i) not in foo
type(i) not startsWith str
type(i) | greet()
type(i) | splitAfter(str)
type(if false { $env } else { $env })
type(if false { f64 } else { 0 })
type(if false { nil } else { foo })
type(if false { nil } else { nil })
type(if false { nil } else { ok })
type(if false { str } else { add })
type(if false { true } else { array })
type(if ok { 1 } else { false })
type(if ok { array } else { ok })
type(if ok { foo } else { foo })
type(if ok { nil } else { str })
type(if true { i } else { 0 })
type(int(0))
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)?.[i])
type(last($env?.Bar))
type(last(array))
type(last(list))
type(len($env))
type(len(array))
type(len(list))
type(len(str))
type(let bar = $env; bar)
type(let bar = true; bar)
type(let foobar = 1; foobar)
type(let y = list; let bar = i; y)
type(list != $env)
type(list != array)
type(list != list)
type(list != nil)
type(list == $env)
type(list == nil)
type(list ?? $env)
type(list ?? 0)
type(list ?? 1.0)
type(list ?? add)
type(list ?? foo)
type(list ?? greet)
type(list | any(ok))
type(list | count(true))
type(list | filter(true))
type(list | find(false))
type(list | findLast(ok))
type(list | groupBy(#))
type(list | groupBy(0))
type(list | groupBy(1.0))
type(list | map(#))
type(list | map(#index))
type(list | map(0))
type(list | map(1.0))
type(list | map(foo))
type(list | map(greet))
type(list | one(false))
type(list | one(ok))
type(list | reduce(#))
type(list | reduce(#, 0))
type(list | reduce(#, nil))
type(list | reduce(#.Bar))
type(list | reduce(#acc))
type(list | reduce($env))
type(list | reduce(i))
type(list | reduce(ok, add))
type(list | sortBy(#.Bar))
type(list)
type(list) == str
type(list) >= string(0)
type(list) ?? foo | reduce(foo, 1.0)
type(list) ?? greet
type(list) contains toBase64(str)
type(list) | hasSuffix(str)
type(list?.[i])
type(list?.[i].Bar)
type(list[0:])
type(list[:i])
type(lower($env?.[str]))
type(lower(str))
type(map($env, #index))
type(map($env, $env))
type(map($env, 1))
type(map($env, 1.0))
type(map($env, add))
type(map($env, f64))
type(map($env, foo))
type(map($env, greet))
type(map($env, i))
type(map(array, # == i))
type(map(array, #))
type(map(array, 0))
type(map(array, 1))
type(map(array, false))
type(map(list, #))
type(map(list, 1.0))
type(map(list, false))
type(map(list, foo))
type(max($env))
type(max(0))
type(max(0, array))
type(max(0, f64))
type(max(1))
type(max(1.0))
type(max(array))
type(max(f64))
type(max(i))
type(mean(0))
type(mean(1))
type(mean(1.0))
type(mean(array))
type(mean(array, 1.0))
type(mean(f64))
type(mean(i))
type(median($env.i))
type(median(0))
type(median(0, 1))
type(median(1.0))
type(median(array))
type(median(f64))
type(median(f64, 1.0))
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(f64, 1.0))
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 == greet)
type(nil == i)
type(nil == list)
type(nil == nil)
type(nil == ok)
type(nil == str)
type(nil ?? $env)
type(nil ?? 0)
type(nil ?? 1.0)
type(nil ?? add)
type(nil ?? array)
type(nil ?? foo)
type(nil ?? i)
type(nil ?? nil)
type(nil ?? ok)
type(nil ?? str)
type(nil ?? true)
type(nil in $env)
type(nil in array)
type(nil in list)
type(nil not in $env)
type(nil not in array)
type(nil not in list)
type(nil) < str
type(nil) <= str
type(nil) >= str
type(nil) ?? toJSON($env)
type(nil) matches str
type(nil) matches string(foo)
type(nil) not endsWith str
type(nil) not in foo
type(nil) not in {foo: false}
type(nil) startsWith str
type(nil) | greet()
type(nil)[:]
type(none(array, false))
type(none(array, ok))
type(none(list, false))
type(none(list, ok))
type(not !false)
type(not false)
type(not ok)
type(not true)
type(ok != $env)
type(ok != nil)
type(ok && true)
type(ok == $env)
type(ok == false)
type(ok == nil)
type(ok == true)
type(ok ? 1 : 1.0)
type(ok ? 1 : foo)
type(ok ? list : foo)
type(ok ?: array)
type(ok ?: greet)
type(ok ?? 0)
type(ok ?? 1)
type(ok ?? 1.0)
type(ok ?? add)
type(ok ?? f64)
type(ok ?? foo)
type(ok ?? i)
type(ok ?? list)
type(ok ?? ok)
type(ok ?? str)
type(ok ?? true)
type(ok and $env)
type(ok and false)
type(ok and ok)
type(ok and true)
type(ok or $env)
type(ok or false)
type(ok or true)
type(ok || $env)
type(ok || false)
type(ok || ok)
type(ok || true)
type(ok)
type(ok) <= str
type(ok) ?? array
type(ok) ?? f64
type(ok) ?? foo
type(ok) contains str
type(ok) in foo
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, 0))
type(reduce(array, add))
type(reduce(array, array))
type(reduce(array, f64))
type(reduce(array, foo))
type(reduce(array, greet, false))
type(reduce(array, ok))
type(reduce(list, #))
type(reduce(list, #.String))
type(reduce(list, #index))
type(reduce(list, $env))
type(reduce(list, 0))
type(reduce(list, add))
type(reduce(list, false))
type(reduce(list, ok))
type(reverse([ok]))
type(reverse(array))
type(reverse(list))
type(round(0))
type(round(1))
type(round(1.0))
type(round(f64))
type(round(i))
type(sort($env))
type(sort(array))
type(sortBy(array, #))
type(sortBy(array, 0))
type(sortBy(array, 1.0))
type(sortBy(list, 0))
type(sortBy(list, i))
type(str != $env)
type(str != str)
type(str <= str)
type(str == $env)
type(str == str)
type(str > str)
type(str >= str)
type(str ?? $env)
type(str ?? 1.0)
type(str ?? f64)
type(str ?? foo)
type(str ?? i)
type(str ?? list)
type(str ?? nil)
type(str ?? ok)
type(str ?? str)
type(str contains 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) ?? -f64
type(str) ?? foo
type(str) contains $env?.String
type(str) matches str
type(str) not endsWith str
type(str) not in list?.[i]
type(str)[:]
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(nil))
type(string(ok))
type(string(str))
type(string(true))
type(sum($env, f64))
type(sum(array))
type(sum(array, #))
type(sum(array, 1))
type(sum(list, 1.0))
type(toBase64(str))
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(trim(str))
type(trimPrefix(str))
type(trimSuffix(str))
type(true != $env)
type(true != nil)
type(true != ok)
type(true && $env)
type(true && ok)
type(true && true)
type(true == $env)
type(true == false)
type(true == ok)
type(true == true)
type(true ? $env : add)
type(true ? foo : 1)
type(true ? greet : 1.0)
type(true ?: 1)
type(true ?? 0)
type(true ?? 1)
type(true ?? 1.0)
type(true ?? array)
type(true ?? foo)
type(true and false)
type(true or $env)
type(true or false)
type(true or ok)
type(true || $env)
type(true || false)
type(true || true)
type(true) < foo?.String()
type(true) <= str
type(true) in foo
type(true) not in [add, false]
type(true) | greet()
type(type($env))
type(type($env.foo))
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(nil))
type(type(ok))
type(type(str))
type(type(true))
type(uniq(array))
type(uniq(list))
type(upper(str))
type(values($env))
type({foo: $env})
type({foo: $env}?.ok)
type({foo: -0})
type({foo: 0, foo: 1.0})
type({foo: 0, foo: add})
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: $env})
type({foo: 1.0, foo: greet, foo: ok})
type({foo: 1.0, foo: greet})
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: $env})
type({foo: f64, foo: add})
type({foo: f64, foo: true})
type({foo: f64})
type({foo: false, foo: 1.0})
type({foo: false, foo: foo})
type({foo: false, foo: nil})
type({foo: false})
type({foo: foo, foo: $env})
type({foo: foo, foo: 1})
type({foo: foo, foo: foo})
type({foo: foo, foo: i})
type({foo: foo, foo: list})
type({foo: foo})
type({foo: foo}.Bar)
type({foo: greet, foo: i})
type({foo: greet})
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, foo: str})
type({foo: str})
type({foo: toJSON(foo)})
type({foo: true})
uniq($env | filter(false))
uniq($env | map(#index))
uniq($env | map(0))
uniq($env | map(1.0))
uniq($env | map(add))
uniq($env | map(f64))
uniq($env | map(foo))
uniq($env | map(ok))
uniq($env | map(str))
uniq($env | reduce(array, foo))
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, add])
uniq([$env])
uniq([0, 1.0])
uniq([0])
uniq([1 == nil])
uniq([1.0, $env, foo])
uniq([1.0, $env])
uniq([1.0, array])
uniq([1.0, ok])
uniq([1.0, str])
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([greet, $env])
uniq([greet])
uniq([i])
uniq([list])
uniq([nil, $env])
uniq([nil, nil])
uniq([nil])
uniq([ok])
uniq([str, 1.0])
uniq([str, true])
uniq([str])
uniq([true, $env])
uniq([true, true])
uniq([true])
uniq(array ?? 0)
uniq(array ?? 1)
uniq(array ?? 1.0)
uniq(array ?? add)
uniq(array ?? false)
uniq(array ?? i)
uniq(array ?? list)
uniq(array | filter(ok))
uniq(array | map(#))
uniq(array | map(1.0))
uniq(array | sortBy(#))
uniq(array | sortBy(1))
uniq(array)
uniq(array) != array
uniq(array) == array
uniq(array) | all(ok)
uniq(array) | count(false)
uniq(array) | filter(false)
uniq(array) | filter(true)
uniq(array) | groupBy(1)
uniq(array) | groupBy(1.0)
uniq(array) | groupBy(ok)
uniq(array) | map(1)
uniq(array) | map(add)
uniq(array) | map(true)
uniq(array) | min(i)
uniq(array) | one(false)
uniq(array) | reduce(#)
uniq(array) | reduce(1.0)
uniq(array) | reduce(false)
uniq(array) | reduce(foo)
uniq(array) | reduce(greet)
uniq(array) | reduce(i)
uniq(array) | sortBy(#)
uniq(array) | sortBy(1)
uniq(array) | sum(#)
uniq(array); str
uniq(array)?.[i]
uniq(array)[:]
uniq(array)[:i]
uniq(array)[i:]
uniq(array[1:i])
uniq(array[:1])
uniq(array[:])
uniq(array[:i])
uniq(concat(array))
uniq(concat(list))
uniq(false ? 0 : array)
uniq(filter(array, ok))
uniq(filter(array, true))
uniq(filter(list, false))
uniq(flatten(array))
uniq(flatten(list))
uniq(keys($env))
uniq(list ?? 1.0)
uniq(list ?? f64)
uniq(list ?? false)
uniq(list ?? foo | map(#))
uniq(list ?? foo)
uniq(list ?? str)
uniq(list ?? true)
uniq(list | map(#))
uniq(list | map(.String))
uniq(list | map(1.0))
uniq(list | map(add))
uniq(list | map(false))
uniq(list | map(foo))
uniq(list | map(greet))
uniq(list | reduce(list))
uniq(list | sortBy(#.Bar))
uniq(list | sortBy(1.0))
uniq(list)
uniq(list) != array
uniq(list) ?? ok
uniq(list) | all(false)
uniq(list) | all(true)
uniq(list) | find(false)
uniq(list) | findIndex(false)
uniq(list) | findLast(false)
uniq(list) | groupBy(#)
uniq(list) | groupBy(1.0)
uniq(list) | groupBy(i)
uniq(list) | groupBy(ok)
uniq(list) | map(#)
uniq(list) | map(.String)
uniq(list) | map(false)
uniq(list) | map(greet)
uniq(list) | one(true)
uniq(list) | reduce(#.String)
uniq(list) | reduce(foo, foo)
uniq(list) | reduce(ok)
uniq(list) | reduce(true, 1.0)
uniq(list) | sortBy(0)
uniq(list) | sortBy(1)
uniq(list) | sum(0)
uniq(list)?.[i]
uniq(list)[$env.i:]
uniq(list[1:])
uniq(list[:i])
uniq(list[i:])
uniq(map($env, 1.0))
uniq(map($env, array))
uniq(map($env, foo))
uniq(map($env, i))
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, array))
uniq(map(array, greet))
uniq(map(array, i))
uniq(map(array, ok))
uniq(map(list, #))
uniq(map(list, f64))
uniq(map(list, ok))
uniq(reduce(array, array))
uniq(reverse(array))
uniq(reverse(list))
uniq(sort($env))
uniq(sort(array))
uniq(sortBy(array, #))
uniq(sortBy(array, 0))
uniq(sortBy(list, #.Bar))
uniq(sortBy(list, 1))
uniq(sortBy(list, 1.0))
uniq(toPairs($env))
uniq(uniq(array))
uniq(uniq(list))
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.Bar) > str
upper(foo.Bar) ?? add
upper(foo.String())
upper(foo?.Bar)
upper(foo?.String())
upper(greet(str))
upper(list | reduce(#.Bar))
upper(list?.[i]?.Bar)
upper(lower(str))
upper(nil ?? $env?.str)
upper(reduce(array, str))
upper(str ?? 0)
upper(str ?? 1.0)
upper(str ?? array)
upper(str ?? greet)
upper(str ?? list)
upper(str | greet())
upper(str)
upper(str) <= string($env)
upper(str) ?? add
upper(str) in foo
upper(str) matches str
upper(str) not contains str
upper(str) not endsWith str
upper(str) not in foo
upper(str) | greet()
upper(str[1:])
upper(str[:0])
upper(str[i:])
upper(string($env))
upper(string(0))
upper(string(1))
upper(string(1.0))
upper(string(add))
upper(string(array))
upper(string(f64))
upper(string(foo))
upper(string(foo.Bar))
upper(string(greet))
upper(string(i))
upper(string(list))
upper(string(nil))
upper(string(ok))
upper(string(str))
upper(string(true))
upper(toBase64(str))
upper(toJSON(0))
upper(toJSON(1))
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(reduce(list, ok)))
upper(toJSON(str))
upper(toJSON(true))
upper(trim(str))
upper(trimPrefix(str))
upper(trimSuffix(str))
upper(type($env))
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(foo?.Bar))
upper(type(greet))
upper(type(i))
upper(type(list))
upper(type(nil))
upper(type(ok))
upper(type(str))
upper(type(true))
upper(upper(str))
values($env ?? $env)
values($env ?? 0)
values($env ?? 1)
values($env ?? 1.0)
values($env ?? false)
values($env ?? foo)
values($env ?? greet)
values($env ?? ok)
values($env ?? true)
values($env | reduce($env, 1))
values($env) ?? add
values($env) ?? foo
values($env) ?? i
values($env) | all(ok)
values($env) | find(false)
values($env) | findIndex(ok)
values($env) | findIndex(true)
values($env) | findLast(ok)
values($env) | findLastIndex(ok)
values($env) | groupBy(1)
values($env) | groupBy(f64)
values($env) | groupBy(foo)
values($env) | groupBy(str)
values($env) | map(#)
values($env) | map(1.0)
values($env) | map(add)
values($env) | map(f64)
values($env) | map(foo)
values($env) | map(greet)
values($env) | one(true)
values($env) | reduce(#)
values($env) | reduce(#index)
values($env) | reduce(1)
values($env) | reduce(1.0, 0)
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) | sum(1.0)
values($env)?.[i]
values(array | groupBy(#))
values(array | groupBy(0))
values(array | groupBy(1))
values(array | groupBy(false))
values(false ? add : $env)
values(groupBy(array, 0))
values(groupBy(array, 1.0))
values(groupBy(array, foo))
values(groupBy(array, ok))
values(groupBy(list, #))
values(groupBy(list, 1.0))
values(groupBy(list, f64))
values(groupBy(list, false))
values(groupBy(list, ok))
values(if ok { $env } else { str })
values(list | groupBy(#))
values(list | groupBy(.Bar))
values(list | groupBy(false))
values(max($env))
values(min($env))
values(nil ?? $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 * 0})
values({foo: 1.0, foo: 1.0})
values({foo: 1.0, foo: f64})
values({foo: 1.0})
values({foo: 1})
values({foo: add, foo: i})
values({foo: array, foo: foo})
values({foo: array, foo: nil, 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: 1.0, foo: false})
values({foo: greet, foo: foo})
values({foo: greet})
values({foo: i, foo: true})
values({foo: i})
values({foo: last($env)})
values({foo: list})
values({foo: nil, 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})
values({foo: true, foo: 1.0})
values({foo: true, foo: false})
values({foo: true})
{foo: !false}
{foo: !ok, foo: greet}
{foo: !ok}
{foo: !true, foo: greet}
{foo: !true}
{foo: $env != $env}
{foo: $env != $env}.f64
{foo: $env != 0}
{foo: $env != 1.0}
{foo: $env != 1}
{foo: $env != add}
{foo: $env != array}
{foo: $env != f64, foo: foo}
{foo: $env != false}
{foo: $env != foo}
{foo: $env != greet}
{foo: $env != greet}.Bar
{foo: $env != i}
{foo: $env != list}
{foo: $env != nil, foo: array}
{foo: $env != nil}
{foo: $env != ok}
{foo: $env != str}
{foo: $env && false}
{foo: $env && true}
{foo: $env == $env}
{foo: $env == 0}
{foo: $env == 0}.array
{foo: $env == 1.0}
{foo: $env == 1}
{foo: $env == 1}?.greet
{foo: $env == add}
{foo: $env == array}
{foo: $env == f64}
{foo: $env == false}
{foo: $env == foo}
{foo: $env == foo}.i
{foo: $env == greet}
{foo: $env == i}
{foo: $env == list}
{foo: $env == nil}
{foo: $env == ok}
{foo: $env == str}
{foo: $env == true}
{foo: $env ?? $env}
{foo: $env ?? 1, foo: list}
{foo: $env ?? 1.0}
{foo: $env ?? 1}
{foo: $env ?? array}
{foo: $env ?? f64}
{foo: $env ?? f64}.Bar
{foo: $env ?? foo}
{foo: $env ?? greet}
{foo: $env ?? i}
{foo: $env ?? list}
{foo: $env ?? nil}
{foo: $env ?? str}
{foo: $env and false}
{foo: $env and true}
{foo: $env in array}
{foo: $env in list}
{foo: $env not in list}
{foo: $env or false}
{foo: $env or true}
{foo: $env | all(ok)}
{foo: $env | any(ok)}
{foo: $env | any(true)}
{foo: $env | find(false)}
{foo: $env | map(#index)}
{foo: $env | map($env)}
{foo: $env | map(0)}
{foo: $env | map(1)}
{foo: $env | map(add), foo: i}
{foo: $env | map(add)}
{foo: $env | map(f64)}
{foo: $env | map(foo)}
{foo: $env | map(i)}
{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 | reduce(greet, i)}
{foo: $env | sum(0)}
{foo: $env | sum(1.0)}
{foo: $env || false}
{foo: $env || true}
{foo: $env, foo: $env, foo: true}?.add
{foo: $env, foo: $env}.Bar
{foo: $env, foo: $env}.String
{foo: $env, foo: $env}.add
{foo: $env, foo: $env}.array
{foo: $env, foo: $env}.f64
{foo: $env, foo: $env}.foo
{foo: $env, foo: $env}.greet
{foo: $env, foo: $env}.i
{foo: $env, foo: $env}.i?.[ok]
{foo: $env, foo: $env}.ok
{foo: $env, foo: $env}.str
{foo: $env, foo: $env}?.String
{foo: $env, foo: $env}?.[str]
{foo: $env, foo: $env}?.add
{foo: $env, foo: $env}?.array
{foo: $env, foo: $env}?.f64
{foo: $env, foo: $env}?.foo
{foo: $env, foo: $env}?.foobar
{foo: $env, foo: $env}?.greet
{foo: $env, foo: $env}?.i
{foo: $env, foo: $env}?.list
{foo: $env, foo: $env}?.ok
{foo: $env, foo: $env}?.str
{foo: $env, foo: 0}.Bar
{foo: $env, foo: 0}.add
{foo: $env, foo: 0}.foo
{foo: $env, foo: 0}.greet
{foo: $env, foo: 0}.list
{foo: $env, foo: 0}.ok
{foo: $env, foo: 0}?.Bar
{foo: $env, foo: 0}?.false?.ok
{foo: $env, foo: 0}?.i
{foo: $env, foo: 0}?.list
{foo: $env, foo: 1, foo: foo}?.foo
{foo: $env, foo: 1.0, foo: foo}.ok
{foo: $env, foo: 1.0, foo: greet}.str
{foo: $env, foo: 1.0}.Bar
{foo: $env, foo: 1.0}.String
{foo: $env, foo: 1.0}.add
{foo: $env, foo: 1.0}.f64
{foo: $env, foo: 1.0}.foo
{foo: $env, foo: 1.0}.greet
{foo: $env, foo: 1.0}.i
{foo: $env, foo: 1.0}.list
{foo: $env, foo: 1.0}.ok
{foo: $env, foo: 1.0}.str
{foo: $env, foo: 1.0}?.Bar
{foo: $env, foo: 1.0}?.array
{foo: $env, foo: 1.0}?.foo
{foo: $env, foo: 1.0}?.greet
{foo: $env, foo: 1.0}?.i
{foo: $env, foo: 1.0}?.ok
{foo: $env, foo: 1.0}?.str
{foo: $env, foo: 1}.Bar
{foo: $env, foo: 1}.String
{foo: $env, foo: 1}.add
{foo: $env, foo: 1}.f64
{foo: $env, foo: 1}.foo
{foo: $env, foo: 1}.list
{foo: $env, foo: 1}.ok
{foo: $env, foo: 1}?.String
{foo: $env, foo: 1}?.[str]
{foo: $env, foo: 1}?.array
{foo: $env, foo: 1}?.f64
{foo: $env, foo: 1}?.greet
{foo: $env, foo: 1}?.i
{foo: $env, foo: add, foo: $env}?.foo
{foo: $env, foo: add}.Bar
{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}.str?.array
{foo: $env, foo: add}?.Bar
{foo: $env, foo: add}?.add
{foo: $env, foo: add}?.foo
{foo: $env, foo: add}?.list
{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}?.Bar
{foo: $env, foo: array}?.array
{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}.add
{foo: $env, foo: f64}.f64
{foo: $env, foo: f64}?.foo
{foo: $env, foo: f64}?.i
{foo: $env, foo: false, foo: foo}?.str
{foo: $env, foo: false, foo: str}.array
{foo: $env, foo: false}.add
{foo: $env, foo: false}.array
{foo: $env, foo: false}.i
{foo: $env, foo: false}.list
{foo: $env, foo: false}.str
{foo: $env, foo: false}?.[str]
{foo: $env, foo: false}?.array
{foo: $env, foo: false}?.greet
{foo: $env, foo: false}?.i
{foo: $env, foo: foo, foo: $env}?.greet
{foo: $env, foo: foo, foo: foo}?.i
{foo: $env, foo: foo, foo: list}.String
{foo: $env, foo: foo, foo: nil}.ok
{foo: $env, foo: foo, foo: ok}?.ok
{foo: $env, foo: foo}.String
{foo: $env, foo: foo}.array
{foo: $env, foo: foo}.foo
{foo: $env, foo: foo}.foobar
{foo: $env, foo: foo}.greet
{foo: $env, foo: foo}.i
{foo: $env, foo: foo}.list
{foo: $env, foo: foo}.ok
{foo: $env, foo: foo}.str
{foo: $env, foo: foo}?.Bar
{foo: $env, foo: foo}?.String
{foo: $env, foo: foo}?.add
{foo: $env, foo: foo}?.array
{foo: $env, foo: foo}?.greet
{foo: $env, foo: foo}?.i?.[array]
{foo: $env, foo: foo}?.list
{foo: $env, foo: foo}?.ok
{foo: $env, foo: foo}?.str
{foo: $env, foo: greet, foo: 0}.greet
{foo: $env, foo: greet, foo: foo}.f64
{foo: $env, foo: greet, foo: nil}?.foo
{foo: $env, foo: greet}.Bar?.[list]?.greet
{foo: $env, foo: greet}.add
{foo: $env, foo: greet}.f64
{foo: $env, foo: greet}.foo
{foo: $env, foo: greet}.i
{foo: $env, foo: greet}.str
{foo: $env, foo: greet}?.Bar
{foo: $env, foo: greet}?.[str]
{foo: $env, foo: greet}?.add
{foo: $env, foo: greet}?.f64
{foo: $env, foo: greet}?.greet
{foo: $env, foo: greet}?.list
{foo: $env, foo: i, foo: nil}.greet
{foo: $env, foo: i}.greet
{foo: $env, foo: i}?.Bar
{foo: $env, foo: i}?.String
{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}.ok
{foo: $env, foo: list}?.Bar?.greet
{foo: $env, foo: list}?.[str]
{foo: $env, foo: list}?.add
{foo: $env, foo: list}?.array
{foo: $env, foo: list}?.greet
{foo: $env, foo: list}?.list
{foo: $env, foo: list}?.str
{foo: $env, foo: nil}.Bar
{foo: $env, foo: nil}.String
{foo: $env, foo: nil}.array
{foo: $env, foo: nil}.foo
{foo: $env, foo: nil}.foobar?.i
{foo: $env, foo: nil}.greet
{foo: $env, foo: nil}.ok
{foo: $env, foo: nil}.ok?.ok(ok)
{foo: $env, foo: nil}.str
{foo: $env, foo: nil}?.[str]
{foo: $env, foo: nil}?.add
{foo: $env, foo: nil}?.array
{foo: $env, foo: nil}?.f64
{foo: $env, foo: nil}?.foobar
{foo: $env, foo: nil}?.list
{foo: $env, foo: nil}?.ok
{foo: $env, foo: nil}?.str
{foo: $env, foo: ok}.Bar
{foo: $env, foo: ok}.String
{foo: $env, foo: ok}.array
{foo: $env, foo: ok}.f64
{foo: $env, foo: ok}.i
{foo: $env, foo: ok}?.greet
{foo: $env, foo: str, foo: f64}?.i
{foo: $env, foo: str, foo: nil}?.array
{foo: $env, foo: str}.array
{foo: $env, foo: str}.f64
{foo: $env, foo: str}.ok
{foo: $env, foo: str}?.Bar
{foo: $env, foo: str}?.[str]
{foo: $env, foo: str}?.f64
{foo: $env, foo: str}?.foo
{foo: $env, foo: str}?.greet
{foo: $env, foo: str}?.ok
{foo: $env, foo: true, foo: 1.0}?.list
{foo: $env, foo: true, foo: nil}?.greet
{foo: $env, foo: true}.Bar
{foo: $env, foo: true}.String?.list
{foo: $env, foo: true}.array
{foo: $env, foo: true}.foo
{foo: $env, foo: true}.foobar
{foo: $env, foo: true}.list
{foo: $env, foo: true}.ok
{foo: $env, foo: true}.str?.list
{foo: $env, foo: true}?.String
{foo: $env, foo: true}?.[str]
{foo: $env, foo: true}?.array
{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.add}?.[str]
{foo: $env.add}?.f64
{foo: $env.array, foo: $env != i}?.str
{foo: $env.array, foo: add}
{foo: $env.array, foo: greet}
{foo: $env.array, foo: {foo: array}}
{foo: $env.array}
{foo: $env.array}.i
{foo: $env.f64, foo: array}
{foo: $env.f64, foo: str}
{foo: $env.f64}
{foo: $env.f64}.foo
{foo: $env.f64}?.add
{foo: $env.f64}?.array
{foo: $env.foo, foo: f64}?.list
{foo: $env.foo}
{foo: $env.foo}.greet
{foo: $env.foo}?.String
{foo: $env.greet, foo: array}
{foo: $env.greet, foo: i}
{foo: $env.greet}
{foo: $env.greet}.array
{foo: $env.i, foo: add}
{foo: $env.i, foo: array}
{foo: $env.i, foo: ok != $env}
{foo: $env.i}
{foo: $env.i}?.str
{foo: $env.list != list}
{foo: $env.list, foo: 1.0 == 1.0}
{foo: $env.list, foo: array}
{foo: $env.list}
{foo: $env.list}.foo
{foo: $env.ok, foo: add}
{foo: $env.ok, foo: ok}
{foo: $env.ok}
{foo: $env.ok}.String
{foo: $env.ok}?.str
{foo: $env.str}
{foo: $env.str}.ok
{foo: $env?.$env}
{foo: $env?.Bar, foo: array}
{foo: $env?.Bar, foo: if false { foo } else { 0 }}
{foo: $env?.Bar, foo: ok}
{foo: $env?.Bar?.Bar()}
{foo: $env?.Bar?.Bar}
{foo: $env?.Bar?.[greet]}
{foo: $env?.Bar?.greet()}
{foo: $env?.Bar?.list}
{foo: $env?.Bar}
{foo: $env?.Bar}.Bar
{foo: $env?.Bar}.String
{foo: $env?.Bar}.list
{foo: $env?.Bar}?.list
{foo: $env?.Bar}?.ok
{foo: $env?.Bar}?.str
{foo: $env?.String, foo: ok}
{foo: $env?.String, foo: str}
{foo: $env?.String}
{foo: $env?.String}?.ok
{foo: $env?.[Bar], foo: f64}
{foo: $env?.[Bar], foo: i}
{foo: $env?.[Bar], foo: list}
{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: $env.greet}
{foo: $env?.[String], foo: ok}
{foo: $env?.[String]?.array}
{foo: $env?.[String]}
{foo: $env?.[String]}.f64
{foo: $env?.[String]}.greet
{foo: $env?.[foobar]?.add}
{foo: $env?.[foobar]?.list}
{foo: $env?.[foobar]}
{foo: $env?.[foobar]}?.add
{foo: $env?.[nil]}
{foo: $env?.[str]}
{foo: $env?.[str]}.str
{foo: $env?.[str]}?.add
{foo: $env?.add, foo: add}
{foo: $env?.add}
{foo: $env?.add}.greet
{foo: $env?.add}?.array
{foo: $env?.add}?.foo
{foo: $env?.add}?.str
{foo: $env?.array, foo: add}
{foo: $env?.array}
{foo: $env?.array}.ok
{foo: $env?.array}?.Bar
{foo: $env?.f64, foo: add}
{foo: $env?.f64}
{foo: $env?.f64}.ok?.add
{foo: $env?.f64}.str
{foo: $env?.f64}?.greet
{foo: $env?.false}
{foo: $env?.foo.String()}
{foo: $env?.foobar, foo: greet}
{foo: $env?.foobar}
{foo: $env?.foobar}?.list
{foo: $env?.foo}
{foo: $env?.foo}.f64
{foo: $env?.foo}.str
{foo: $env?.foo}?.ok
{foo: $env?.greet, foo: first(array)}
{foo: $env?.greet, foo: i}
{foo: $env?.greet}
{foo: $env?.greet}.foo
{foo: $env?.greet}?.add
{foo: $env?.greet}?.foo
{foo: $env?.i, foo: foo?.Bar}
{foo: $env?.i, foo: i}
{foo: $env?.i, foo: ok}
{foo: $env?.i, foo: string(i)}
{foo: $env?.i, foo: str}
{foo: $env?.i}
{foo: $env?.i}.String
{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: greet}
{foo: $env?.ok}
{foo: $env?.ok}.f64
{foo: $env?.ok}?.add
{foo: $env?.ok}?.foo
{foo: $env?.ok}?.list
{foo: $env?.str, foo: $env?.ok}
{foo: $env?.str, foo: array}
{foo: $env?.str, foo: f64}
{foo: $env?.str}
{foo: $env?.str}.f64
{foo: $env?.str}?.Bar
{foo: $env?.str}?.i
{foo: $env?.true}
{foo: $env} == nil or false
{foo: $env} ?? $env.array
{foo: $env} ?? add
{foo: $env} ?? list
{foo: $env}.Bar
{foo: $env}.Bar?.[str]
{foo: $env}.Bar?.add
{foo: $env}.String
{foo: $env}.String?.foo
{foo: $env}.add
{foo: $env}.add?.String
{foo: $env}.add?.[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?.Bar()
{foo: $env}.array?.i
{foo: $env}.array?.str
{foo: $env}.f64
{foo: $env}.f64?.[foo]
{foo: $env}.foo
{foo: $env}.foo.array
{foo: $env}.foo?.foo
{foo: $env}.foo?.i
{foo: $env}.foobar
{foo: $env}.foobar?.[f64]
{foo: $env}.foobar?.[list]
{foo: $env}.greet
{foo: $env}.greet?.Bar
{foo: $env}.greet?.[ok]
{foo: $env}.i
{foo: $env}.i?.add()
{foo: $env}.i?.greet()
{foo: $env}.list
{foo: $env}.list?.[f64]
{foo: $env}.list?.greet
{foo: $env}.ok
{foo: $env}.ok?.[greet]
{foo: $env}.ok?.[ok]
{foo: $env}.ok?.array
{foo: $env}.str
{foo: $env}.str?.Bar
{foo: $env}.str?.[f64]
{foo: $env}.str?.str
{foo: $env}?.$env?.Bar(1.0)
{foo: $env}?.$env?.add()
{foo: $env}?.Bar
{foo: $env}?.Bar?.[add]
{foo: $env}?.Bar?.foo
{foo: $env}?.Bar?.i
{foo: $env}?.String
{foo: $env}?.String != str
{foo: $env}?.String?.[add]
{foo: $env}?.String?.[f64]
{foo: $env}?.String?.list
{foo: $env}?.String?.str()
{foo: $env}?.[$env?.Bar]
{foo: $env}?.[str]
{foo: $env}?.add
{foo: $env}?.array
{foo: $env}?.array?.Bar(1.0)
{foo: $env}?.array?.[array]
{foo: $env}?.array?.[greet]
{foo: $env}?.array?.[ok]
{foo: $env}?.f64
{foo: $env}?.f64?.[f64]
{foo: $env}?.foo
{foo: $env}?.foo ?? ok
{foo: $env}?.foo.Bar
{foo: $env}?.foo.f64
{foo: $env}?.foo.ok
{foo: $env}?.foobar
{foo: $env}?.foobar?.[list]?.[list]
{foo: $env}?.foobar?.array
{foo: $env}?.foobar?.greet(nil)
{foo: $env}?.greet
{foo: $env}?.greet?.[f64]
{foo: $env}?.greet?.f64
{foo: $env}?.greet?.list()
{foo: $env}?.greet?.ok
{foo: $env}?.i
{foo: $env}?.i?.[array]
{foo: $env}?.i?.add
{foo: $env}?.list
{foo: $env}?.list?.[foo]
{foo: $env}?.list?.f64
{foo: $env}?.list?.greet?.[i]
{foo: $env}?.list?.i
{foo: $env}?.ok
{foo: $env}?.ok?.[array]?.ok
{foo: $env}?.ok?.[ok]
{foo: $env}?.ok?.[str]
{foo: $env}?.str
{foo: $env}?.str?.[ok]
{foo: $env}?.str?.array
{foo: $env}?.str?.foo
{foo: -$env?.f64}
{foo: -0}
{foo: -1.0 / i}
{foo: -1.0, foo: $env?.f64}
{foo: -1.0, foo: i}
{foo: -1.0}
{foo: -1}
{foo: -f64}
{foo: -i, foo: !ok}
{foo: -i, foo: add}
{foo: -i}
{foo: -i}.list
{foo: 0 != $env.i}
{foo: 0 != $env}
{foo: 0 != 0}
{foo: 0 != 1.0}
{foo: 0 != 1}
{foo: 0 != f64}
{foo: 0 != i}
{foo: 0 != nil}
{foo: 0 % i}
{foo: 0 * 0}
{foo: 0 * 1.0}
{foo: 0 * 1}
{foo: 0 * i}
{foo: 0 * i}.add
{foo: 0 ** 0}
{foo: 0 ** 1}
{foo: 0 ** f64}
{foo: 0 ** i}
{foo: 0 + 0}
{foo: 0 + 1.0}
{foo: 0 + f64}
{foo: 0 - 0}
{foo: 0 - 1.0, foo: array}
{foo: 0 - 1.0}
{foo: 0 - 1}
{foo: 0 - f64}
{foo: 0 - i}
{foo: 0 .. 0}
{foo: 0 .. 1}
{foo: 0 .. i}
{foo: 0 / 0}
{foo: 0 / 1.0}
{foo: 0 < $env.i}
{foo: 0 < 0, foo: i}
{foo: 0 < 0}
{foo: 0 < 1.0}
{foo: 0 < 1.0}?.f64
{foo: 0 < 1}
{foo: 0 < f64}
{foo: 0 <= 0}
{foo: 0 <= 1.0}
{foo: 0 <= f64}
{foo: 0 == 0}
{foo: 0 == 1.0}
{foo: 0 == f64}
{foo: 0 == i}
{foo: 0 == nil}
{foo: 0 > 0, foo: ok}
{foo: 0 > 1.0}
{foo: 0 > 1}
{foo: 0 > i}
{foo: 0 >= 0}
{foo: 0 >= 1}
{foo: 0 >= i}
{foo: 0 ?? $env?.[ok]}
{foo: 0 ?? $env}
{foo: 0 ?? array}
{foo: 0 ?? foo}
{foo: 0 ?? i}
{foo: 0 ?? str}
{foo: 0 ?? true}
{foo: 0 ^ 0}
{foo: 0 ^ 1.0}
{foo: 0 ^ i}
{foo: 0 in array}
{foo: 0 | add(i)}
{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}.i
{foo: 0, foo: $env}.list
{foo: 0, foo: $env}.str
{foo: 0, foo: $env}?.String
{foo: 0, foo: $env}?.[str]
{foo: 0, foo: $env}?.add
{foo: 0, foo: $env}?.array
{foo: 0, foo: $env}?.f64
{foo: 0, foo: $env}?.greet
{foo: 0, foo: $env}?.ok
{foo: 0, foo: $env}?.str
{foo: 0, foo: 0, foo: false}?.list
{foo: 0, foo: 0}.String
{foo: 0, foo: 0}.add
{foo: 0, foo: 0}.array
{foo: 0, foo: 0}.foobar
{foo: 0, foo: 0}?.f64
{foo: 0, foo: 0}?.ok
{foo: 0, foo: 1, foo: 0} ?? i
{foo: 0, foo: 1.0, foo: array}?.i
{foo: 0, foo: 1.0, foo: ok}.str
{foo: 0, foo: 1.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}.str
{foo: 0, foo: 1.0}?.[str]
{foo: 0, foo: 1.0}?.f64
{foo: 0, foo: 1.0}?.foo
{foo: 0, foo: 1.0}?.i
{foo: 0, foo: 1.0}?.list
{foo: 0, foo: 1.0}?.str
{foo: 0, foo: 1.0}?.str?.max(foo)?.ok
{foo: 0, foo: 1}.Bar
{foo: 0, foo: 1}.add
{foo: 0, foo: 1}.array
{foo: 0, foo: 1}.foo
{foo: 0, foo: 1}.greet
{foo: 0, foo: 1}?.add
{foo: 0, foo: 1}?.i
{foo: 0, foo: 1}?.ok
{foo: 0, foo: add}.String?.[greet]
{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}.f64
{foo: 0, foo: array}.greet
{foo: 0, foo: array}.list
{foo: 0, foo: array}?.foo
{foo: 0, foo: array}?.i
{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: false}?.list
{foo: 0, foo: false}?.list?.foo
{foo: 0, foo: foo, foo: 1}?.String
{foo: 0, foo: foo, foo: add}.array
{foo: 0, foo: foo, foo: false}?.greet
{foo: 0, foo: foo}.Bar
{foo: 0, foo: foo}.String
{foo: 0, foo: foo}.add
{foo: 0, foo: foo}.foo
{foo: 0, foo: foo}.foobar
{foo: 0, foo: foo}.greet?.add
{foo: 0, foo: foo}.i
{foo: 0, foo: foo}.str
{foo: 0, foo: foo}?.add
{foo: 0, foo: foo}?.array
{foo: 0, foo: foo}?.f64
{foo: 0, foo: foo}?.foo
{foo: 0, foo: foo}?.ok
{foo: 0, foo: greet, foo: i}?.array
{foo: 0, foo: greet}.f64
{foo: 0, foo: greet}.foobar
{foo: 0, foo: greet}.greet
{foo: 0, foo: greet}.ok
{foo: 0, foo: greet}?.add
{foo: 0, foo: greet}?.greet
{foo: 0, foo: greet}?.str
{foo: 0, foo: i}.add
{foo: 0, foo: i}.array
{foo: 0, foo: i}.f64
{foo: 0, foo: i}?.foobar
{foo: 0, foo: i}?.str
{foo: 0, foo: list}?.Bar
{foo: 0, foo: list}?.[str]
{foo: 0, foo: list}?.greet
{foo: 0, foo: nil, foo: foo}?.add
{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}.list
{foo: 0, foo: nil}.ok
{foo: 0, foo: nil}?.Bar
{foo: 0, foo: nil}?.String
{foo: 0, foo: ok}.add
{foo: 0, foo: ok}.array
{foo: 0, foo: ok}.f64
{foo: 0, foo: ok}.ok
{foo: 0, foo: ok}.str
{foo: 0, foo: ok}?.[str]
{foo: 0, foo: ok}?.add
{foo: 0, foo: ok}?.foo
{foo: 0, foo: ok}?.ok
{foo: 0, foo: str, foo: f64}.Bar
{foo: 0, foo: str}.Bar
{foo: 0, foo: str}?.f64
{foo: 0, foo: str}?.foo
{foo: 0, foo: str}?.greet
{foo: 0, foo: str}?.i
{foo: 0, foo: str}?.ok
{foo: 0, foo: true, foo: i}.list
{foo: 0, foo: true}?.ok
{foo: 0, foo: true}?.str
{foo: 0..i}
{foo: 0.0}
{foo: 0.1}
{foo: 0} ?? array
{foo: 0} ?? list
{foo: 0} ?? sum(array)
{foo: 0}.Bar
{foo: 0}.String
{foo: 0}.String?.[f64]
{foo: 0}.String?.[i]
{foo: 0}.String?.ok()
{foo: 0}.add
{foo: 0}.array
{foo: 0}.array?.ok
{foo: 0}.f64
{foo: 0}.foo
{foo: 0}.greet
{foo: 0}.greet?.String
{foo: 0}.greet?.[list]
{foo: 0}.i
{foo: 0}.i?.foo(nil)
{foo: 0}.list
{foo: 0}.list?.[add]
{foo: 0}.list?.[foo].String
{foo: 0}.nil?.[add]
{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}.str?.[add]?.[add]
{foo: 0}?.Bar
{foo: 0}?.Bar?.foo
{foo: 0}?.String
{foo: 0}?.[str]
{foo: 0}?.add
{foo: 0}?.add?.ok
{foo: 0}?.array
{foo: 0}?.array?.[i]
{foo: 0}?.f64
{foo: 0}?.foo
{foo: 0}?.foobar
{foo: 0}?.foobar == foo
{foo: 0}?.foobar?.[array]
{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 != 0}
{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}
{foo: 1 ** 1.0}.f64
{foo: 1 ** 1.0}.i
{foo: 1 ** 1.0}?.[str]
{foo: 1 ** 1}
{foo: 1 ** f64}
{foo: 1 ** i}
{foo: 1 + 0}
{foo: 1 + 1.0}
{foo: 1 + 1}
{foo: 1 + f64}
{foo: 1 + i}
{foo: 1 - 0}
{foo: 1 - 1.0}
{foo: 1 - 1}
{foo: 1 - f64}
{foo: 1 - i}
{foo: 1 .. 0}
{foo: 1 .. i}
{foo: 1 / 0}?.String
{foo: 1 / 1.0}
{foo: 1 / 1}
{foo: 1 / f64}
{foo: 1 / i}
{foo: 1 < 1.0}
{foo: 1 < 1}
{foo: 1 < f64}
{foo: 1 < i}
{foo: 1 <= 0}
{foo: 1 <= 1.0}
{foo: 1 <= 1}
{foo: 1 <= f64, foo: array}
{foo: 1 == $env}
{foo: 1 == 0}
{foo: 1 == 1.0}
{foo: 1 == 1}
{foo: 1 == f64}
{foo: 1 == nil}
{foo: 1 > 0}
{foo: 1 > 1.0}
{foo: 1 > 1}
{foo: 1 > i}
{foo: 1 >= 1.0}
{foo: 1 >= 1}
{foo: 1 >= f64}
{foo: 1 >= i}
{foo: 1 ?? $env, foo: str}
{foo: 1 ?? $env}
{foo: 1 ?? 1}
{foo: 1 ?? greet}
{foo: 1 ?? list}
{foo: 1 ?? nil}
{foo: 1 ?? ok}
{foo: 1 ?? str}
{foo: 1 ^ 0}
{foo: 1 ^ 1.0}
{foo: 1 ^ f64}
{foo: 1 in array}
{foo: 1 not in $env?.array}
{foo: 1 | bitand(i)}
{foo: 1, foo: $env, foo: add}?.ok
{foo: 1, foo: $env}.Bar
{foo: 1, foo: $env}.String
{foo: 1, foo: $env}.array
{foo: 1, foo: $env}.greet
{foo: 1, foo: $env}.i
{foo: 1, foo: $env}.list
{foo: 1, foo: $env}.str
{foo: 1, foo: $env}?.f64
{foo: 1, foo: $env}?.greet
{foo: 1, foo: $env}?.str
{foo: 1, foo: 0, foo: add}?.array
{foo: 1, foo: 0} ?? foo?.Bar
{foo: 1, foo: 0}.add
{foo: 1, foo: 0}.f64
{foo: 1, foo: 0}.foo
{foo: 1, foo: 0}.greet
{foo: 1, foo: 0}.list
{foo: 1, foo: 0}?.list
{foo: 1, foo: 0}?.ok
{foo: 1, foo: 1.0}.String
{foo: 1, foo: 1.0}.f64
{foo: 1, foo: 1.0}.i
{foo: 1, foo: 1.0}?.Bar
{foo: 1, foo: 1.0}?.add
{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: 1}?.ok
{foo: 1, foo: add, foo: 1.0}?.Bar
{foo: 1, foo: add}.Bar
{foo: 1, foo: add}.array
{foo: 1, foo: add}.greet
{foo: 1, foo: add}.i
{foo: 1, foo: add}?.Bar
{foo: 1, foo: add}?.i
{foo: 1, foo: add}?.list
{foo: 1, foo: array}?.String
{foo: 1, foo: array}?.add
{foo: 1, foo: array}?.i
{foo: 1, foo: array}?.ok
{foo: 1, foo: f64}.Bar
{foo: 1, foo: f64}.array
{foo: 1, foo: f64}.foo
{foo: 1, foo: f64}.greet
{foo: 1, foo: f64}?.f64
{foo: 1, foo: f64}?.i
{foo: 1, foo: false}.array
{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}?.f64
{foo: 1, foo: false}?.f64?.[f64]
{foo: 1, foo: false}?.ok
{foo: 1, foo: foo, foo: $env}?.[str]
{foo: 1, foo: foo, foo: 1.0}.list
{foo: 1, foo: foo, foo: nil}.foo
{foo: 1, foo: foo}.Bar
{foo: 1, foo: foo}.f64
{foo: 1, foo: foo}.foo
{foo: 1, foo: foo}?.[str]
{foo: 1, foo: foo}?.[str]?.greet
{foo: 1, foo: foo}?.f64
{foo: 1, foo: foo}?.foo
{foo: 1, foo: foo}?.foobar
{foo: 1, foo: foo}?.greet
{foo: 1, foo: foo}?.list
{foo: 1, foo: greet, foo: 0}?.add
{foo: 1, foo: greet, foo: i}.foobar
{foo: 1, foo: greet, foo: list}?.ok
{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}?.[str]
{foo: 1, foo: greet}?.add
{foo: 1, foo: greet}?.array
{foo: 1, foo: greet}?.greet
{foo: 1, foo: i, foo: list}?.[str]
{foo: 1, foo: i}.String
{foo: 1, foo: i}?.greet
{foo: 1, foo: list} ?? i
{foo: 1, foo: list}.f64
{foo: 1, foo: list}.foo
{foo: 1, foo: list}.list
{foo: 1, foo: list}.str
{foo: 1, foo: list}?.Bar
{foo: 1, foo: list}?.String
{foo: 1, foo: list}?.[str]
{foo: 1, foo: list}?.add
{foo: 1, foo: list}?.ok
{foo: 1, foo: nil, foo: 1}.add
{foo: 1, foo: nil, foo: greet}.foo
{foo: 1, foo: nil}.add
{foo: 1, foo: nil}.i
{foo: 1, foo: nil}.list
{foo: 1, foo: nil}.ok
{foo: 1, foo: nil}?.Bar
{foo: 1, foo: nil}?.String
{foo: 1, foo: nil}?.[str]
{foo: 1, foo: nil}?.add
{foo: 1, foo: nil}?.f64
{foo: 1, foo: nil}?.list
{foo: 1, foo: nil}?.str
{foo: 1, foo: ok}.foo
{foo: 1, foo: ok}.list
{foo: 1, foo: ok}?.Bar
{foo: 1, foo: ok}?.String
{foo: 1, foo: ok}?.[str]
{foo: 1, foo: ok}?.array
{foo: 1, foo: ok}?.ok
{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}?.i
{foo: 1, foo: str}?.str
{foo: 1, foo: true}.String
{foo: 1, foo: true}.array
{foo: 1, foo: true}.ok
{foo: 1.0 != $env?.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 * 1.0}
{foo: 1.0 * 1}
{foo: 1.0 * f64}
{foo: 1.0 * i}
{foo: 1.0 * i}?.f64
{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}
{foo: 1.0 + f64}
{foo: 1.0 + f64}?.f64
{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 / 0}
{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.0}.String
{foo: 1.0 < 1}
{foo: 1.0 < f64}
{foo: 1.0 < i}
{foo: 1.0 <= 0}
{foo: 1.0 <= 1.0, foo: str}
{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: 1.0 == f64}.foo
{foo: 1.0 == i}
{foo: 1.0 == nil}
{foo: 1.0 == nil}?.String
{foo: 1.0 > 0}
{foo: 1.0 > 0}.list
{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 ?? $env}
{foo: 1.0 ?? 0}
{foo: 1.0 ?? 1.0, foo: i}
{foo: 1.0 ?? 1.0, foo: str}
{foo: 1.0 ?? 1.0}
{foo: 1.0 ?? 1}
{foo: 1.0 ?? f64}
{foo: 1.0 ?? foo}
{foo: 1.0 ?? i}
{foo: 1.0 ?? list}
{foo: 1.0 ?? nil}
{foo: 1.0 ?? ok}
{foo: 1.0 ?? str}
{foo: 1.0 ^ 0}
{foo: 1.0 ^ 1.0}
{foo: 1.0 ^ 1}
{foo: 1.0 ^ i}
{foo: 1.0 in array, foo: i}
{foo: 1.0 in array}
{foo: 1.0 not in array}
{foo: 1.0 | max(1.0)}
{foo: 1.0 | median(f64)}
{foo: 1.0 | min(1)}
{foo: 1.0, foo: $env, foo: foo}.f64
{foo: 1.0, foo: $env, foo: foo}.greet
{foo: 1.0, foo: $env, foo: str}?.i?.[add]
{foo: 1.0, foo: $env}.add
{foo: 1.0, foo: $env}.array
{foo: 1.0, foo: $env}.f64
{foo: 1.0, foo: $env}.foo
{foo: 1.0, foo: $env}.foobar
{foo: 1.0, foo: $env}.greet
{foo: 1.0, foo: $env}.i
{foo: 1.0, foo: $env}.ok
{foo: 1.0, foo: $env}?.Bar
{foo: 1.0, foo: $env}?.String
{foo: 1.0, foo: $env}?.add
{foo: 1.0, foo: $env}?.array
{foo: 1.0, foo: $env}?.f64
{foo: 1.0, foo: $env}?.greet
{foo: 1.0, foo: $env}?.list
{foo: 1.0, foo: $env}?.ok
{foo: 1.0, foo: 0, foo: $env}?.i
{foo: 1.0, foo: 0, foo: 0}?.array
{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}?.[str]
{foo: 1.0, foo: 0}?.f64
{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}.f64
{foo: 1.0, foo: 1.0}.foo
{foo: 1.0, foo: 1.0}.greet
{foo: 1.0, foo: 1.0}.i
{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}?.[str]
{foo: 1.0, foo: 1.0}?.add
{foo: 1.0, foo: 1.0}?.array
{foo: 1.0, foo: 1.0}?.f64
{foo: 1.0, foo: 1.0}?.greet
{foo: 1.0, foo: 1.0}?.i
{foo: 1.0, foo: 1.0}?.ok
{foo: 1.0, foo: 1}.add
{foo: 1.0, foo: 1}.array
{foo: 1.0, foo: 1}.foo
{foo: 1.0, foo: 1}.list
{foo: 1.0, foo: 1}?.Bar
{foo: 1.0, foo: 1}?.String
{foo: 1.0, foo: 1}?.[str]
{foo: 1.0, foo: 1}?.add
{foo: 1.0, foo: 1}?.foo
{foo: 1.0, foo: 1}?.greet
{foo: 1.0, foo: 1}?.i
{foo: 1.0, foo: 1}?.list
{foo: 1.0, foo: 1}?.ok
{foo: 1.0, foo: add}.Bar
{foo: 1.0, foo: add}.add
{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: add}?.ok
{foo: 1.0, foo: add}?.str
{foo: 1.0, foo: array}.foo
{foo: 1.0, foo: array}.greet
{foo: 1.0, foo: array}.list
{foo: 1.0, foo: array}.str
{foo: 1.0, foo: array}?.Bar
{foo: 1.0, foo: array}?.[str]
{foo: 1.0, foo: array}?.add
{foo: 1.0, foo: array}?.f64
{foo: 1.0, foo: array}?.list
{foo: 1.0, foo: f64}.add
{foo: 1.0, foo: f64}.foobar
{foo: 1.0, foo: f64}.greet
{foo: 1.0, foo: f64}.i
{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: f64}?.greet
{foo: 1.0, foo: false, foo: $env}?.ok
{foo: 1.0, foo: false, foo: 1.0}?.greet
{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}?.[str]
{foo: 1.0, foo: false}?.array
{foo: 1.0, foo: false}?.list
{foo: 1.0, foo: foo, foo: 1}.add
{foo: 1.0, foo: foo, foo: foo}?.list
{foo: 1.0, foo: foo, foo: list}?.f64
{foo: 1.0, foo: foo, foo: true}.Bar
{foo: 1.0, foo: foo}.Bar
{foo: 1.0, foo: foo}.array
{foo: 1.0, foo: foo}.f64
{foo: 1.0, foo: foo}.f64?.[ok]
{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}?.i
{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}.f64
{foo: 1.0, foo: greet}.i
{foo: 1.0, foo: greet}.list
{foo: 1.0, foo: greet}.ok
{foo: 1.0, foo: greet}?.[str]
{foo: 1.0, foo: greet}?.array
{foo: 1.0, foo: greet}?.foo
{foo: 1.0, foo: greet}?.greet
{foo: 1.0, foo: greet}?.i?.[i]
{foo: 1.0, foo: greet}?.ok
{foo: 1.0, foo: greet}?.str
{foo: 1.0, foo: i} ?? f64
{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}.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: i}?.ok
{foo: 1.0, foo: list}.f64
{foo: 1.0, foo: list}.foobar
{foo: 1.0, foo: list}.i
{foo: 1.0, foo: list}.list
{foo: 1.0, foo: list}.ok
{foo: 1.0, foo: list}?.String
{foo: 1.0, foo: list}?.array
{foo: 1.0, foo: list}?.ok
{foo: 1.0, foo: nil}.Bar
{foo: 1.0, foo: nil}.String
{foo: 1.0, foo: nil}.add
{foo: 1.0, foo: nil}.array
{foo: 1.0, foo: nil}.foo
{foo: 1.0, foo: nil}.greet
{foo: 1.0, foo: nil}.i
{foo: 1.0, foo: nil}.ok
{foo: 1.0, foo: nil}?.Bar
{foo: 1.0, foo: nil}?.Bar?.list
{foo: 1.0, foo: nil}?.String
{foo: 1.0, foo: nil}?.[str]
{foo: 1.0, foo: nil}?.add
{foo: 1.0, foo: nil}?.array
{foo: 1.0, foo: nil}?.f64
{foo: 1.0, foo: nil}?.foo
{foo: 1.0, foo: nil}?.foobar
{foo: 1.0, foo: nil}?.greet
{foo: 1.0, foo: nil}?.str
{foo: 1.0, foo: ok, foo: str}.f64
{foo: 1.0, foo: ok}.String
{foo: 1.0, foo: ok}.add
{foo: 1.0, foo: ok}.f64
{foo: 1.0, foo: ok}.greet
{foo: 1.0, foo: ok}.i
{foo: 1.0, foo: ok}.str
{foo: 1.0, foo: ok}?.String
{foo: 1.0, foo: ok}?.[str]
{foo: 1.0, foo: ok}?.f64
{foo: 1.0, foo: ok}?.greet
{foo: 1.0, foo: ok}?.list
{foo: 1.0, foo: ok}?.list?.ok
{foo: 1.0, foo: ok}?.str
{foo: 1.0, foo: str, foo: 1} != true ?? add
{foo: 1.0, foo: str, foo: str}.list
{foo: 1.0, foo: str}.array
{foo: 1.0, foo: str}.str
{foo: 1.0, foo: str}?.String
{foo: 1.0, foo: str}?.f64
{foo: 1.0, foo: str}?.greet
{foo: 1.0, foo: str}?.i
{foo: 1.0, foo: str}?.str
{foo: 1.0, foo: true, foo: foo}?.Bar
{foo: 1.0, foo: true, foo: true}?.[str]
{foo: 1.0, foo: true}.String
{foo: 1.0, foo: true}.add
{foo: 1.0, foo: true}.greet
{foo: 1.0, foo: true}.i
{foo: 1.0, foo: true}?.Bar
{foo: 1.0, foo: true}?.String
{foo: 1.0, foo: true}?.[str]
{foo: 1.0, foo: true}?.add
{foo: 1.0, foo: true}?.array
{foo: 1.0, foo: true}?.f64
{foo: 1.0, foo: true}?.ok
{foo: 1.0}
{foo: 1.0} ?? foo
{foo: 1.0} not in $env?.[String]
{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?.array
{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}.add?.ok
{foo: 1.0}.array
{foo: 1.0}.array?.array()
{foo: 1.0}.f64
{foo: 1.0}.f64?.[add]
{foo: 1.0}.f64?.foo
{foo: 1.0}.f64?.greet()
{foo: 1.0}.foo
{foo: 1.0}.foobar
{foo: 1.0}.foobar == 1.0
{foo: 1.0}.foobar?.String
{foo: 1.0}.foobar?.i
{foo: 1.0}.greet
{foo: 1.0}.greet?.[ok]
{foo: 1.0}.greet?.foo
{foo: 1.0}.i
{foo: 1.0}.i == ok
{foo: 1.0}.i?.[str]
{foo: 1.0}.list
{foo: 1.0}.list?.[list]?.i
{foo: 1.0}.list?.i
{foo: 1.0}.ok
{foo: 1.0}.ok?.[foo]
{foo: 1.0}.ok?.ok()
{foo: 1.0}.str
{foo: 1.0}.str?.[f64]
{foo: 1.0}.str?.[list]?.foo
{foo: 1.0}.str?.str
{foo: 1.0}?.$env?.String()
{foo: 1.0}?.$env?.[add]
{foo: 1.0}?.$env?.f64
{foo: 1.0}?.Bar
{foo: 1.0}?.Bar?.[greet]
{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]
{foo: 1.0}?.String?.[f64].str
{foo: 1.0}?.[greet(str)]
{foo: 1.0}?.[str]
{foo: 1.0}?.add
{foo: 1.0}?.add?.[i]
{foo: 1.0}?.add?.list
{foo: 1.0}?.array
{foo: 1.0}?.array?.greet
{foo: 1.0}?.array?.ok
{foo: 1.0}?.array?.str(foobar)
{foo: 1.0}?.f64
{foo: 1.0}?.f64?.[list]
{foo: 1.0}?.f64?.foo
{foo: 1.0}?.false?.[list]
{foo: 1.0}?.foo
{foo: 1.0}?.foobar
{foo: 1.0}?.foobar?.String
{foo: 1.0}?.greet
{foo: 1.0}?.greet?.array()
{foo: 1.0}?.greet?.list
{foo: 1.0}?.i
{foo: 1.0}?.i?.[foo]
{foo: 1.0}?.list
{foo: 1.0}?.list?.[i]
{foo: 1.0}?.list?.[str]
{foo: 1.0}?.not
{foo: 1.0}?.ok
{foo: 1.0}?.ok?.[ok]
{foo: 1.0}?.str
{foo: 1} == $env?.[String]
{foo: 1} ?? array
{foo: 1} ?? ok
{foo: 1}.Bar
{foo: 1}.Bar?.Bar()
{foo: 1}.Bar?.foo?.i
{foo: 1}.String
{foo: 1}.String?.[array]
{foo: 1}.String?.[greet]
{foo: 1}.add
{foo: 1}.add?.array
{foo: 1}.add?.str()
{foo: 1}.array
{foo: 1}.array?.[list]
{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 != add
{foo: 1}.list?.foo
{foo: 1}.ok
{foo: 1}.ok?.add
{foo: 1}.ok?.greet
{foo: 1}.str
{foo: 1}.str?.[f64]
{foo: 1}?.Bar
{foo: 1}?.String
{foo: 1}?.String not startsWith $env
{foo: 1}?.String?.Bar
{foo: 1}?.String?.[f64]
{foo: 1}?.String?.add
{foo: 1}?.String?.greet
{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?.String
{foo: 1}?.f64?.[ok]
{foo: 1}?.foo
{foo: 1}?.foobar
{foo: 1}?.foobar?.foo.foobar?.[foo]
{foo: 1}?.foobar?.greet(add)
{foo: 1}?.foobar?.i.array
{foo: 1}?.greet
{foo: 1}?.i
{foo: 1}?.i?.[add]
{foo: 1}?.list
{foo: 1}?.list?.[ok]
{foo: 1}?.nil?.str(nil)
{foo: 1}?.ok
{foo: 1}?.ok?.str
{foo: 1}?.str
{foo: 1}?.str?.[i]
{foo: 1}?.str?.[ok]
{foo: [$env, 1.0]}
{foo: [$env, false], foo: f64}
{foo: [$env, nil]}
{foo: [$env, ok]}
{foo: [$env]}
{foo: [$env]}?.String
{foo: [0 + 0, list]}
{foo: [0, 1.0]}
{foo: [0]}
{foo: [1, 1.0]}
{foo: [1.0, $env]}
{foo: [1.0, greet, 1.0]}
{foo: [1.0], foo: greet}
{foo: [1.0]}
{foo: [1.0]}?.f64
{foo: [1], foo: foo?.String}
{foo: [1]}
{foo: [1]}.list
{foo: [add, $env]}
{foo: [add, 1]}
{foo: [add, str]}
{foo: [add]}
{foo: [array, 1]}
{foo: [array, list, foo]}
{foo: [array]}
{foo: [ceil(f64)]}
{foo: [f64]}
{foo: [f64]}.array
{foo: [false, f64]}
{foo: [false]}
{foo: [foo, $env]}
{foo: [foo, false]}
{foo: [foo, i]}
{foo: [foo, nil]}
{foo: [foo, ok]}
{foo: [foo]}
{foo: [foo]}?.Bar
{foo: [greet, array]}
{foo: [greet]}
{foo: [greet]}.Bar
{foo: [i, 1, array]}
{foo: [i, 1]}
{foo: [i, str]}
{foo: [i], foo: f64}
{foo: [i]}
{foo: [i]}?.[str]
{foo: [list]}
{foo: [nil, 1.0]}
{foo: [nil, array]}
{foo: [nil, nil]}
{foo: [nil, true]}
{foo: [nil]}
{foo: [ok, foo]}
{foo: [ok]}
{foo: [str, ok]}
{foo: [str, true]}
{foo: [str]}
{foo: [true, add], foo: foo}
{foo: [true, false]}
{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: $env.list}.greet
{foo: add != nil}
{foo: add == $env}
{foo: add == add}
{foo: add ?? $env}
{foo: add ?? 0}
{foo: add ?? 1.0}
{foo: add ?? add}
{foo: add ?? false}
{foo: add ?? foo}
{foo: add ?? foo}?.list
{foo: add ?? i}
{foo: add ?? nil}
{foo: add ?? str}
{foo: add ?? true}
{foo: add(1, 0)}
{foo: add(i, 0)}
{foo: add(i, i)}
{foo: add, foo: $env in array}
{foo: add, foo: $env.add}
{foo: add, foo: $env.f64}
{foo: add, foo: $env.i}
{foo: add, foo: $env?.foobar}
{foo: add, foo: $env?.list}
{foo: add, foo: $env}.$env == f64
{foo: add, foo: $env}.Bar
{foo: add, foo: $env}.array
{foo: add, foo: $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: $env}?.list
{foo: add, foo: $env}?.ok
{foo: add, foo: 0, foo: 0}.ok
{foo: add, foo: 0, foo: nil}.String
{foo: add, foo: 0}.f64
{foo: add, foo: 0}.list
{foo: add, foo: 0}?.Bar
{foo: add, foo: 0}?.f64
{foo: add, foo: 0}?.i
{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}.f64
{foo: add, foo: 1.0}.greet
{foo: add, foo: 1.0}.i
{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} ?? f64
{foo: add, foo: 1}.Bar
{foo: add, foo: 1}.String
{foo: add, foo: 1}.add
{foo: add, foo: 1}.foo
{foo: add, foo: 1}.list
{foo: add, foo: 1}?.foo
{foo: add, foo: add}
{foo: add, foo: add}.String
{foo: add, foo: add}.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}?.list
{foo: add, foo: add}?.ok
{foo: add, foo: add}?.str
{foo: add, foo: array}
{foo: add, foo: array}.String
{foo: add, foo: array}.i
{foo: add, foo: array}?.Bar
{foo: add, foo: array}?.array
{foo: add, foo: array}?.i?.Bar
{foo: add, foo: f64, foo: $env}.foo
{foo: add, foo: f64}
{foo: add, foo: f64}.array
{foo: add, foo: f64}.foo
{foo: add, foo: f64}.greet
{foo: add, foo: f64}.i
{foo: add, foo: f64}.nil?.f64(foobar)
{foo: add, foo: f64}?.Bar
{foo: add, foo: f64}?.[str]
{foo: add, foo: f64}?.greet?.[array]
{foo: add, foo: f64}?.list
{foo: add, foo: f64}?.ok
{foo: add, foo: false}.array
{foo: add, foo: false}.foo
{foo: add, foo: false}.i
{foo: add, foo: false}?.Bar
{foo: add, foo: false}?.String
{foo: add, foo: false}?.[str]
{foo: add, foo: false}?.f64
{foo: add, foo: false}?.list
{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}.foo
{foo: add, foo: foo}.greet
{foo: add, foo: foo}.ok
{foo: add, foo: foo}?.Bar
{foo: add, foo: foo}?.add
{foo: add, foo: foo}?.array
{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}.add
{foo: add, foo: greet}.array
{foo: add, foo: greet}.greet
{foo: add, foo: greet}?.Bar
{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}.f64
{foo: add, foo: i}.greet
{foo: add, foo: i}.str
{foo: add, foo: i}?.Bar
{foo: add, foo: i}?.f64
{foo: add, foo: i}?.str
{foo: add, foo: list?.[i]}
{foo: add, foo: list}
{foo: add, foo: list}.str
{foo: add, foo: list}?.Bar
{foo: add, foo: list}?.greet
{foo: add, foo: list}?.list
{foo: add, foo: mean(1.0)}
{foo: add, foo: nil, foo: nil}?.f64
{foo: add, foo: nil}.array
{foo: add, foo: nil}.foo
{foo: add, foo: nil}.greet
{foo: add, foo: nil}.str
{foo: add, foo: nil}?.Bar
{foo: add, foo: nil}?.[str]
{foo: add, foo: nil}?.[str]?.str
{foo: add, foo: nil}?.add
{foo: add, foo: nil}?.f64
{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}.add
{foo: add, foo: str}.foo
{foo: add, foo: str}.greet
{foo: add, foo: str}?.String
{foo: add, foo: str}?.foo
{foo: add, foo: str}?.ok
{foo: add, foo: str}?.str
{foo: add, foo: true}.foo
{foo: add, foo: true}.i
{foo: add, foo: true}.list
{foo: add, foo: true}?.f64
{foo: add, foo: true}?.foo
{foo: add, foo: true}?.i
{foo: add, foo: true}?.list
{foo: add}
{foo: add} ?? greet
{foo: add}.Bar
{foo: add}.String
{foo: add}.add
{foo: add}.array
{foo: add}.f64
{foo: add}.foo
{foo: add}.foobar
{foo: add}.greet
{foo: add}.greet?.i
{foo: add}.i
{foo: add}.i?.[foo]
{foo: add}.i?.[greet]
{foo: add}.i?.greet
{foo: add}.list
{foo: add}.list?.add()?.Bar
{foo: add}.nil?.[greet]
{foo: add}.ok
{foo: add}.ok?.Bar(ok)
{foo: add}.str
{foo: add}.str?.[ok]
{foo: add}.true?.[str]
{foo: add}?.$env?.array
{foo: add}?.Bar
{foo: add}?.Bar?.i(foobar)
{foo: add}?.Bar?.list
{foo: add}?.String
{foo: add}?.String?.String
{foo: add}?.String?.[str]
{foo: add}?.[str]
{foo: add}?.[str]?.[f64]
{foo: add}?.add
{foo: add}?.add?.String()
{foo: add}?.array
{foo: add}?.array?.[f64]
{foo: add}?.array?.[list]
{foo: add}?.array?.find(nil, true).String
{foo: add}?.f64
{foo: add}?.f64?.[add]
{foo: add}?.f64?.[greet]
{foo: add}?.f64?.[str]
{foo: add}?.f64?.i
{foo: add}?.foo
{foo: add}?.foobar
{foo: add}?.foobar?.[array]
{foo: add}?.foobar?.[ok]
{foo: add}?.greet
{foo: add}?.greet?.[f64]
{foo: add}?.greet?.[foo]
{foo: add}?.i
{foo: add}?.list
{foo: add}?.list?.[array].list
{foo: add}?.list?.[ok]
{foo: add}?.list?.add
{foo: add}?.list?.list
{foo: add}?.ok
{foo: add}?.ok?.i
{foo: add}?.str
{foo: all($env, true)}
{foo: all(array, ok)}.Bar
{foo: all(array, true)}
{foo: all(list, true)}
{foo: any($env, false)}
{foo: any($env, ok)}
{foo: any($env, true)}
{foo: any(array, false)}
{foo: any(array, ok)}
{foo: any(list, ok)}
{foo: array != $env}
{foo: array != list}
{foo: array != nil}
{foo: array == $env}
{foo: array == array}
{foo: array == list}
{foo: array == nil}
{foo: array ?? $env}
{foo: array ?? 0}
{foo: array ?? 1.0}
{foo: array ?? 1}
{foo: array ?? add}
{foo: array ?? array}
{foo: array ?? foo}
{foo: array ?? greet}
{foo: array ?? i}
{foo: array ?? list}
{foo: array ?? str}
{foo: array ?? true}
{foo: array | all(false)}
{foo: array | filter(true)}
{foo: array | find(true)}
{foo: array | findIndex(true)}
{foo: array | groupBy(0)}
{foo: array | groupBy(1.0)}
{foo: array | groupBy(foo)}
{foo: array | groupBy(str)}
{foo: array | map(#)}
{foo: array | map($env)}
{foo: array | map(1)}?.list
{foo: array | map(false)}
{foo: array | map(foo)}
{foo: array | map(greet)}
{foo: array | map(list)}
{foo: array | map(ok)}
{foo: array | map(str)}
{foo: array | mean(i)}
{foo: array | min(f64)}
{foo: array | none(false)}
{foo: array | one(ok)}
{foo: array | reduce(#)}
{foo: array | reduce($env, 1.0)}
{foo: array | reduce(0)}
{foo: array | reduce(1.0)}
{foo: array | reduce(foo)}
{foo: array | reduce(i)}
{foo: array | reduce(i, f64)}
{foo: array | sortBy(#)}
{foo: array | sum(#)}
{foo: array | sum(1.0)}
{foo: array | sum(i)}
{foo: array, foo: !false}?.greet
{foo: array, foo: $env, foo: nil}.i
{foo: array, foo: $env.add}
{foo: array, foo: $env?.nil}
{foo: array, foo: $env}.String
{foo: array, foo: $env}.array?.[add]
{foo: array, foo: $env}.foo
{foo: array, foo: $env}.greet
{foo: array, foo: $env}.list
{foo: array, foo: $env}?.Bar
{foo: array, foo: $env}?.[str]
{foo: array, foo: $env}?.array
{foo: array, foo: $env}?.f64
{foo: array, foo: $env}?.foo
{foo: array, foo: $env}?.greet
{foo: array, foo: $env}?.i
{foo: array, foo: $env}?.ok
{foo: array, foo: 0}.Bar
{foo: array, foo: 0}?.ok
{foo: array, foo: 0}?.str
{foo: array, foo: 1.0 <= 0}
{foo: array, foo: 1.0, foo: ok}?.String
{foo: array, foo: 1.0}.String
{foo: array, foo: 1.0}.add
{foo: array, foo: 1.0}.list
{foo: array, foo: 1.0}.str
{foo: array, foo: 1.0}?.Bar
{foo: array, foo: 1.0}?.[str]
{foo: array, foo: 1.0}?.array
{foo: array, foo: 1.0}?.f64
{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}.add
{foo: array, foo: 1}.f64
{foo: array, foo: 1}.i?.ok
{foo: array, foo: 1}.ok
{foo: array, foo: 1}?.String
{foo: array, foo: 1}?.[str]
{foo: array, foo: 1}?.array
{foo: array, foo: 1}?.str
{foo: array, foo: [$env, nil]}
{foo: array, foo: add}
{foo: array, foo: add}.ok
{foo: array, foo: add}?.foo
{foo: array, foo: add}?.list
{foo: array, foo: array, foo: $env}.ok
{foo: array, foo: array}
{foo: array, foo: array}.Bar
{foo: array, foo: array}.add?.list()
{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: array}?.str
{foo: array, foo: f64, foo: 1.0}?.f64
{foo: array, foo: f64}
{foo: array, foo: f64}.Bar
{foo: array, foo: f64}.String
{foo: array, foo: f64}.f64
{foo: array, foo: f64}.list
{foo: array, foo: f64}.str
{foo: array, foo: f64}?.foo
{foo: array, foo: false}.add
{foo: array, foo: false}.f64
{foo: array, foo: false}.foo
{foo: array, foo: false}?.f64
{foo: array, foo: false}?.list
{foo: array, foo: false}?.str
{foo: array, foo: float(0)}
{foo: array, foo: foo != foo}
{foo: array, foo: foo, foo: foo}.i
{foo: array, foo: foo.Bar}
{foo: array, foo: foo.String}
{foo: array, foo: foo}
{foo: array, foo: foo}.Bar
{foo: array, foo: foo}.String
{foo: array, foo: foo}.add
{foo: array, foo: foo}.array
{foo: array, foo: foo}.greet
{foo: array, foo: foo}.i
{foo: array, foo: foo}.list
{foo: array, foo: foo}.str
{foo: array, foo: foo}?.Bar
{foo: array, foo: foo}?.String
{foo: array, foo: foo}?.array
{foo: array, foo: foo}?.foobar?.array()
{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}.String
{foo: array, foo: greet}?.f64
{foo: array, foo: greet}?.foo
{foo: array, foo: greet}?.greet
{foo: array, foo: greet}?.str
{foo: array, foo: groupBy(list, false)}
{foo: array, foo: i, foo: 1.0}?.f64
{foo: array, foo: i}
{foo: array, foo: i}.String
{foo: array, foo: i}.array
{foo: array, foo: i}.i
{foo: array, foo: i}.list
{foo: array, foo: i}?.String
{foo: array, foo: i}?.add
{foo: array, foo: list}
{foo: array, foo: list}.String
{foo: array, foo: list}.array
{foo: array, foo: list}.false?.[i]
{foo: array, foo: list}.greet
{foo: array, foo: list}.list
{foo: array, foo: list}.ok
{foo: array, foo: list}?.Bar
{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}.add
{foo: array, foo: nil}.array
{foo: array, foo: nil}.greet
{foo: array, foo: nil}.list
{foo: array, foo: nil}.str
{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}?.ok
{foo: array, foo: nil}?.str
{foo: array, foo: ok, foo: 1.0}.ok
{foo: array, foo: ok, foo: false}?.String?.String()
{foo: array, foo: ok}
{foo: array, foo: ok}.ok
{foo: array, foo: ok}?.Bar
{foo: array, foo: ok}?.String
{foo: array, foo: ok}?.ok
{foo: array, foo: reduce(array, #)}?.ok
{foo: array, foo: str, foo: foo}?.array
{foo: array, foo: str}
{foo: array, foo: str}.Bar
{foo: array, foo: str}.f64
{foo: array, foo: str}.i
{foo: array, foo: str}.list
{foo: array, foo: str}.ok
{foo: array, foo: str}.str
{foo: array, foo: toJSON(1.0)}
{foo: array, foo: true}.greet
{foo: array, foo: true}.str
{foo: array, foo: true}?.Bar
{foo: array, foo: true}?.foo
{foo: array, foo: {foo: $env}}
{foo: array?.[1]}
{foo: array?.[i], foo: list}
{foo: array?.[i]}
{foo: array[0:]}
{foo: array[1:]}
{foo: array[:0]}
{foo: array[:1]}
{foo: array[:]}
{foo: array[:i]}?.list
{foo: array}
{foo: array} ?? add
{foo: array} ?? groupBy(list, 1)
{foo: array} ?? list
{foo: array}.Bar
{foo: array}.Bar?.String
{foo: array}.Bar?.[array]
{foo: array}.Bar?.[i]
{foo: array}.Bar?.[ok]
{foo: array}.String
{foo: array}.String?.[f64]
{foo: array}.String?.list
{foo: array}.add
{foo: array}.add?.[add]
{foo: array}.array
{foo: array}.array?.add
{foo: array}.array?.list
{foo: array}.f64
{foo: array}.f64?.[i]
{foo: array}.f64?.add
{foo: array}.f64?.f64()
{foo: array}.foo
{foo: array}.foobar
{foo: array}.greet
{foo: array}.greet?.greet
{foo: array}.i
{foo: array}.i?.[list]
{foo: array}.i?.[ok]
{foo: array}.i?.array
{foo: array}.i?.foo
{foo: array}.list
{foo: array}.list?.[f64]
{foo: array}.ok
{foo: array}.str
{foo: array}.str?.[greet]
{foo: array}.str?.add
{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}?.[str]?.[array]
{foo: array}?.[type(nil)]
{foo: array}?.add
{foo: array}?.array
{foo: array}?.array?.foobar
{foo: array}?.f64
{foo: array}?.f64?.add
{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}?.list?.f64
{foo: array}?.ok
{foo: array}?.ok?.ok()
{foo: array}?.str
{foo: array}?.str?.[f64]
{foo: array}?.str?.[greet]
{foo: bitnand(i, 1)}
{foo: bitnot(0)}
{foo: bitnot(1)}
{foo: bitnot(i)}
{foo: bitor(0, 0)}
{foo: bitor(i, i)}
{foo: bitshr(1, i)}
{foo: bitxor(0, i)}
{foo: bitxor(i, 1)}
{foo: ceil(0), foo: array}
{foo: ceil(0)}
{foo: ceil(1)}
{foo: ceil(1.0), foo: ok}
{foo: ceil(1.0)}
{foo: ceil(f64)}
{foo: ceil(f64)}.array
{foo: ceil(i)}
{foo: concat(array)}
{foo: concat(list)}
{foo: count($env, ok)}
{foo: count($env, true), foo: f64}
{foo: count($env, true)}
{foo: count(array, false)}
{foo: count(array, ok)}
{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 * 0}
{foo: f64 * 1.0}
{foo: f64 * f64}
{foo: f64 * i}
{foo: f64 * i}?.Bar
{foo: f64 ** 1.0}
{foo: f64 ** f64}
{foo: f64 ** i}
{foo: f64 + 1.0}
{foo: f64 + 1}
{foo: f64 + f64}
{foo: f64 + i}
{foo: f64 - 0}
{foo: f64 / 0}
{foo: f64 / f64}
{foo: f64 / i}
{foo: f64 < 0}
{foo: f64 < 0}.f64
{foo: f64 < i}
{foo: f64 <= 1.0}
{foo: f64 <= f64}
{foo: f64 <= i}
{foo: f64 == $env}
{foo: f64 == 0}
{foo: f64 == 1.0}
{foo: f64 == 1}
{foo: f64 == i}
{foo: f64 == nil}
{foo: f64 > 0, foo: floor(1.0)}
{foo: f64 > 0}
{foo: f64 > f64}
{foo: f64 >= 0}
{foo: f64 >= 1.0}
{foo: f64 >= 1}
{foo: f64 ?? $env}
{foo: f64 ?? 1.0}
{foo: f64 ?? f64}
{foo: f64 ?? foo}
{foo: f64 ?? list}
{foo: f64 ?? nil}
{foo: f64 ?? str}
{foo: f64 ^ 1.0}
{foo: f64 ^ i}
{foo: f64 in array}
{foo: f64 not in array}
{foo: f64 not in array}.f64
{foo: f64, foo: $env == array}
{foo: f64, foo: $env.foo}
{foo: f64, foo: $env?.[foobar]}
{foo: f64, foo: $env?.list}
{foo: f64, foo: $env?.ok}
{foo: f64, foo: $env}.String
{foo: f64, foo: $env}.greet
{foo: f64, foo: $env}.i
{foo: f64, foo: $env}.ok
{foo: f64, foo: $env}.str
{foo: f64, foo: $env}?.i
{foo: f64, foo: $env}?.list
{foo: f64, foo: $env}?.ok
{foo: f64, foo: 0, foo: 1.0}.f64
{foo: f64, foo: 0}.Bar
{foo: f64, foo: 0}.add
{foo: f64, foo: 0}.array
{foo: f64, foo: 0}.list
{foo: f64, foo: 0}.ok
{foo: f64, foo: 0}.str
{foo: f64, foo: 0}?.foo
{foo: f64, foo: 0}?.list
{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, foo: true}.foo
{foo: f64, foo: 1.0}.f64
{foo: f64, foo: 1.0}.i
{foo: f64, foo: 1.0}?.Bar
{foo: f64, foo: 1.0}?.[str]
{foo: f64, foo: 1.0}?.array
{foo: f64, foo: 1.0}?.f64
{foo: f64, foo: 1.0}?.greet
{foo: f64, foo: 1.0}?.i
{foo: f64, foo: 1.0}?.ok
{foo: f64, foo: 1.0}?.str
{foo: f64, foo: 1}.ok
{foo: f64, foo: 1}?.String
{foo: f64, foo: 1}?.[str]
{foo: f64, foo: 1}?.greet
{foo: f64, foo: 1}?.list
{foo: f64, foo: 1}?.str
{foo: f64, foo: add}
{foo: f64, foo: add}.Bar
{foo: f64, foo: add}.add
{foo: f64, foo: add}.foo
{foo: f64, foo: add}.greet
{foo: f64, foo: add}.str
{foo: f64, foo: add}?.String
{foo: f64, foo: add}?.f64
{foo: f64, foo: add}?.foo
{foo: f64, foo: add}?.greet
{foo: f64, foo: add}?.i
{foo: f64, foo: array}
{foo: f64, foo: array}.Bar
{foo: f64, foo: array}.add
{foo: f64, foo: array}?.Bar
{foo: f64, foo: array}?.foo
{foo: f64, foo: array}?.list
{foo: f64, foo: array}?.str
{foo: f64, foo: f64}
{foo: f64, foo: f64}.String
{foo: f64, foo: f64}.ok
{foo: f64, foo: f64}.str
{foo: f64, foo: f64}?.Bar
{foo: f64, foo: f64}?.f64
{foo: f64, foo: f64}?.foo
{foo: f64, foo: f64}?.str
{foo: f64, foo: false != nil}
{foo: f64, foo: false}.f64
{foo: f64, foo: false}.greet
{foo: f64, foo: false}.ok?.[array]
{foo: f64, foo: foo, foo: 0}.ok
{foo: f64, foo: foo, foo: foo}.Bar
{foo: f64, foo: foo, foo: foo}?.add
{foo: f64, foo: foo, foo: foo}?.greet
{foo: f64, foo: foo}
{foo: f64, foo: foo}.Bar
{foo: f64, foo: foo}.add
{foo: f64, foo: foo}.array
{foo: f64, foo: foo}.f64
{foo: f64, foo: foo}.foo
{foo: f64, foo: foo}.greet
{foo: f64, foo: foo}.i
{foo: f64, foo: foo}.list
{foo: f64, foo: foo}.ok
{foo: f64, foo: foo}?.String
{foo: f64, foo: foo}?.[str]
{foo: f64, foo: foo}?.add
{foo: f64, foo: foo}?.array
{foo: f64, foo: foo}?.foo
{foo: f64, foo: foo}?.greet
{foo: f64, foo: foo}?.i
{foo: f64, foo: foo}?.str
{foo: f64, foo: greet(str)}.str
{foo: f64, foo: greet, foo: i}?.str
{foo: f64, foo: greet}
{foo: f64, foo: greet}.add
{foo: f64, foo: greet}.array
{foo: f64, foo: greet}.i
{foo: f64, foo: greet}?.foo
{foo: f64, foo: greet}?.greet
{foo: f64, foo: greet}?.ok
{foo: f64, foo: i, foo: add}.ok
{foo: f64, foo: i, foo: foo}?.greet
{foo: f64, foo: if ok { foo } else { nil }}.foo
{foo: f64, foo: i}
{foo: f64, foo: i}.array
{foo: f64, foo: i}.greet
{foo: f64, foo: i}?.[str]
{foo: f64, foo: list}
{foo: f64, foo: list}.String
{foo: f64, foo: list}.add
{foo: f64, foo: list}.array
{foo: f64, foo: list}.foo
{foo: f64, foo: list}.list
{foo: f64, foo: list}?.Bar
{foo: f64, foo: list}?.String
{foo: f64, foo: list}?.i?.[i]
{foo: f64, foo: nil, foo: $env}?.f64
{foo: f64, foo: nil, foo: $env}?.ok
{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}.greet
{foo: f64, foo: nil}?.[str]
{foo: f64, foo: nil}?.add?.[f64]
{foo: f64, foo: nil}?.array
{foo: f64, foo: nil}?.f64
{foo: f64, foo: nil}?.foobar
{foo: f64, foo: nil}?.i
{foo: f64, foo: nil}?.str
{foo: f64, foo: ok ?? f64}
{foo: f64, foo: ok, foo: 1.0}?.str
{foo: f64, foo: ok}
{foo: f64, foo: ok}?.Bar
{foo: f64, foo: ok}?.String
{foo: f64, foo: ok}?.f64?.[i]
{foo: f64, foo: ok}?.ok
{foo: f64, foo: round(1)}
{foo: f64, foo: str, foo: 0}?.[str]
{foo: f64, foo: str}
{foo: f64, foo: str}.array
{foo: f64, foo: str}.f64
{foo: f64, foo: str}.i
{foo: f64, foo: str}?.[str]
{foo: f64, foo: str}?.add
{foo: f64, foo: str}?.f64
{foo: f64, foo: str}?.list
{foo: f64, foo: sum(array)}
{foo: f64, foo: toJSON(1)}
{foo: f64, foo: true != nil}
{foo: f64, foo: true}.add
{foo: f64, foo: true}?.foo
{foo: f64, foo: true}?.str
{foo: f64, foo: {foo: nil}}
{foo: f64}
{foo: f64} ?? abs(0)
{foo: f64} ?? add
{foo: f64} ?? greet
{foo: f64} not in first($env)
{foo: f64}.Bar
{foo: f64}.String
{foo: f64}.String?.foo
{foo: f64}.add
{foo: f64}.array
{foo: f64}.array?.foo?.[ok]
{foo: f64}.f64
{foo: f64}.f64 != array
{foo: f64}.f64?.greet
{foo: f64}.foo
{foo: f64}.foobar
{foo: f64}.foobar?.[add]
{foo: f64}.greet
{foo: f64}.i
{foo: f64}.i?.add(foo)
{foo: f64}.i?.array
{foo: f64}.list
{foo: f64}.list?.list()
{foo: f64}.ok
{foo: f64}.ok?.list
{foo: f64}.str
{foo: f64}.str?.array
{foo: f64}?.Bar
{foo: f64}?.String
{foo: f64}?.[str]
{foo: f64}?.[str]?.Bar?.f64.String
{foo: f64}?.[str]?.list
{foo: f64}?.[str]?.list()
{foo: f64}?.add
{foo: f64}?.add?.[array]
{foo: f64}?.add?.add
{foo: f64}?.array
{foo: f64}?.array?.Bar()
{foo: f64}?.f64
{foo: f64}?.f64?.[f64]
{foo: f64}?.f64?.[ok]
{foo: f64}?.f64?.array
{foo: f64}?.foo
{foo: f64}?.foobar
{foo: f64}?.greet
{foo: f64}?.i
{foo: f64}?.i?.[foo]
{foo: f64}?.i?.add
{foo: f64}?.list
{foo: f64}?.list?.[list]
{foo: f64}?.ok
{foo: f64}?.ok?.foo
{foo: f64}?.str
{foo: f64}?.str?.i
{foo: false != $env}
{foo: false != false}
{foo: false != nil}
{foo: false != ok}
{foo: false != true}
{foo: false && $env}
{foo: false == false}
{foo: false == nil}
{foo: false == ok}
{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 ?: greet}
{foo: false ?? $env}
{foo: false ?? 0}
{foo: false ?? 1.0}
{foo: false ?? 1}
{foo: false ?? array}
{foo: false ?? f64}.str
{foo: false ?? false}
{foo: false ?? foo}
{foo: false ?? i}
{foo: false ?? list}
{foo: false ?? nil, foo: array}
{foo: false ?? nil}
{foo: false and $env}
{foo: false and false}
{foo: false and ok}
{foo: false and true}
{foo: false or $env}
{foo: false or false}
{foo: false or ok}
{foo: false or true}
{foo: false || $env}
{foo: false || true}
{foo: false, foo: $env, foo: foo}?.str
{foo: false, foo: $env, foo: true}.foo
{foo: false, foo: $env}.Bar
{foo: false, foo: $env}.String
{foo: false, foo: $env}.f64
{foo: false, foo: $env}.foo
{foo: false, foo: $env}.greet
{foo: false, foo: $env}.list
{foo: false, foo: $env}.ok
{foo: false, foo: $env}?.Bar
{foo: false, foo: $env}?.String
{foo: false, foo: $env}?.[str]
{foo: false, foo: $env}?.greet
{foo: false, foo: $env}?.list
{foo: false, foo: $env}?.str
{foo: false, foo: 0, foo: $env}?.list
{foo: false, foo: 0, foo: 0}.str
{foo: false, foo: 0}.f64
{foo: false, foo: 0}.greet
{foo: false, foo: 0}?.array
{foo: false, foo: 0}?.list
{foo: false, foo: 1.0, foo: $env}.add
{foo: false, foo: 1.0}.Bar
{foo: false, foo: 1.0}.String
{foo: false, foo: 1.0}.array
{foo: false, foo: 1.0}.foo
{foo: false, foo: 1.0}.greet
{foo: false, foo: 1.0}.str
{foo: false, foo: 1.0}?.String
{foo: false, foo: 1.0}?.[str]
{foo: false, foo: 1.0}?.ok
{foo: false, foo: 1.0}?.str
{foo: false, foo: 1.0}?.str?.[f64]
{foo: false, foo: 1}.String
{foo: false, foo: 1}.add
{foo: false, foo: 1}.foo
{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}.array
{foo: false, foo: add}?.String
{foo: false, foo: add}?.f64
{foo: false, foo: add}?.foo
{foo: false, foo: add}?.greet
{foo: false, foo: array, foo: foo}?.Bar
{foo: false, foo: array}.Bar?.[greet]
{foo: false, foo: array}.foo
{foo: false, foo: array}.ok
{foo: false, foo: array}?.Bar
{foo: false, foo: array}?.greet
{foo: false, foo: array}?.i
{foo: false, foo: array}?.ok
{foo: false, foo: array}?.str?.greet
{foo: false, foo: f64, foo: 1.0}.list
{foo: false, foo: f64}.Bar
{foo: false, foo: f64}.greet
{foo: false, foo: f64}.i
{foo: false, foo: f64}?.str
{foo: false, foo: f64}?.str?.f64
{foo: false, foo: false, foo: foo}?.Bar
{foo: false, foo: false}.Bar
{foo: false, foo: false}?.f64
{foo: false, foo: false}?.foo
{foo: false, foo: false}?.greet?.[foo]?.str
{foo: false, foo: false}?.ok
{foo: false, foo: foo, foo: add}.Bar
{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}.foo
{foo: false, foo: foo}.greet
{foo: false, foo: foo}.i
{foo: false, foo: foo}.list
{foo: false, foo: foo}.ok
{foo: false, foo: foo}.str
{foo: false, foo: foo}?.Bar
{foo: false, foo: foo}?.[str]
{foo: false, foo: foo}?.add
{foo: false, foo: foo}?.array
{foo: false, foo: foo}?.foo
{foo: false, foo: foo}?.i
{foo: false, foo: foo}?.str
{foo: false, foo: greet}.Bar
{foo: false, foo: greet}.add
{foo: false, foo: greet}.array
{foo: false, foo: greet}.greet
{foo: false, foo: greet}.i
{foo: false, foo: greet}.str
{foo: false, foo: greet}?.array
{foo: false, foo: greet}?.foobar
{foo: false, foo: greet}?.ok
{foo: false, foo: greet}?.str
{foo: false, foo: i}.list
{foo: false, foo: i}.ok
{foo: false, foo: i}.str
{foo: false, foo: i}?.Bar
{foo: false, foo: i}?.foo
{foo: false, foo: i}?.greet
{foo: false, foo: i}?.i
{foo: false, foo: i}?.list
{foo: false, foo: list, foo: f64}?.str
{foo: false, foo: list, foo: list}?.array
{foo: false, foo: list}.foobar
{foo: false, foo: list}?.[str]
{foo: false, foo: list}?.add
{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}.foo
{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: nil}?.ok
{foo: false, foo: nil}?.str
{foo: false, foo: ok}.add
{foo: false, foo: ok}.list
{foo: false, foo: ok}?.String
{foo: false, foo: ok}?.[str]
{foo: false, foo: ok}?.array
{foo: false, foo: ok}?.greet
{foo: false, foo: ok}?.i
{foo: false, foo: str}.array
{foo: false, foo: str}?.Bar
{foo: false, foo: str}?.String
{foo: false, foo: str}?.[str]
{foo: false, foo: true}.Bar
{foo: false, foo: true}.add
{foo: false, foo: true}.array
{foo: false, foo: true}.ok
{foo: false, foo: true}?.array
{foo: false, foo: true}?.list
{foo: false, foo: true}?.ok
{foo: false} ?? list
{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}.f64?.[ok]
{foo: false}.f64?.list
{foo: false}.foo
{foo: false}.foobar
{foo: false}.greet
{foo: false}.i
{foo: false}.i?.Bar
{foo: false}.list
{foo: false}.list?.str
{foo: false}.ok
{foo: false}.ok == i
{foo: false}.ok?.f64
{foo: false}.str
{foo: false}.str?.array
{foo: false}?.$env?.array
{foo: false}?.Bar
{foo: false}?.String
{foo: false}?.[str]
{foo: false}?.add
{foo: false}?.array
{foo: false}?.f64
{foo: false}?.f64?.Bar
{foo: false}?.f64?.array()
{foo: false}?.foo
{foo: false}?.foobar
{foo: false}?.foobar?.foo
{foo: false}?.greet
{foo: false}?.greet?.greet
{foo: false}?.i
{foo: false}?.i?.[foo]
{foo: false}?.list
{foo: false}?.ok
{foo: false}?.ok?.[foo]
{foo: false}?.str
{foo: false}?.str?.[f64]
{foo: false}?.str?.[list]
{foo: filter($env, false)}
{foo: filter(array, ok)}
{foo: filter(list, ok)}
{foo: filter(list, true)}
{foo: find(array, false)}
{foo: find(array, ok)}
{foo: find(array, true)}
{foo: find(list, false)}.str
{foo: find(list, true), foo: foo}
{foo: findIndex($env, ok)}
{foo: findIndex($env, true)}
{foo: findIndex(array, ok)}
{foo: findIndex(list, 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: f64}
{foo: float(f64)}
{foo: float(i)}
{foo: floor(0)}
{foo: floor(1), foo: nil == foo}
{foo: floor(1)}
{foo: floor(1.0)}
{foo: floor(f64)}
{foo: floor(f64)}.add
{foo: floor(i)}
{foo: foo != $env}
{foo: foo != $env}.list
{foo: foo != foo, foo: greet}
{foo: foo != foo}
{foo: foo != foo}?.greet
{foo: foo != nil}
{foo: foo == $env}
{foo: foo == foo}
{foo: foo == nil}
{foo: foo ?? $env.foo}
{foo: foo ?? $env}
{foo: foo ?? 0}
{foo: foo ?? 1.0}
{foo: foo ?? 1}
{foo: foo ?? add}
{foo: foo ?? array}
{foo: foo ?? f64}
{foo: foo ?? foo}
{foo: foo ?? greet}
{foo: foo ?? i}
{foo: foo ?? list}
{foo: foo ?? nil, foo: ok}
{foo: foo ?? nil}
{foo: foo ?? ok}
{foo: foo in list}
{foo: foo not in list, foo: f64}.i
{foo: foo not in list}
{foo: foo, foo: $env, foo: 1}?.str
{foo: foo, foo: $env, foo: add}.foo
{foo: foo, foo: $env, foo: nil}?.f64
{foo: foo, foo: $env, foo: ok}?.array
{foo: foo, foo: $env.f64}.greet
{foo: foo, foo: $env.greet}
{foo: foo, foo: $env?.[foobar]}
{foo: foo, foo: $env?.f64}
{foo: foo, foo: $env}.Bar
{foo: foo, foo: $env}.String?.str
{foo: foo, foo: $env}.add
{foo: foo, foo: $env}.array
{foo: foo, foo: $env}.f64
{foo: foo, foo: $env}.foo
{foo: foo, foo: $env}.greet
{foo: foo, foo: $env}.list
{foo: foo, foo: $env}.nil?.[foo]
{foo: foo, foo: $env}.ok
{foo: foo, foo: $env}.str
{foo: foo, foo: $env}?.Bar
{foo: foo, foo: $env}?.String
{foo: foo, foo: $env}?.[str]
{foo: foo, foo: $env}?.add
{foo: foo, foo: $env}?.array
{foo: foo, foo: $env}?.f64
{foo: foo, foo: $env}?.foo
{foo: foo, foo: $env}?.greet
{foo: foo, foo: $env}?.i
{foo: foo, foo: $env}?.list
{foo: foo, foo: $env}?.ok
{foo: foo, foo: $env}?.str != foo
{foo: foo, foo: 0, foo: add}?.str
{foo: foo, foo: 0} ?? greet
{foo: foo, foo: 0}.Bar
{foo: foo, foo: 0}.String
{foo: foo, foo: 0}.foo
{foo: foo, foo: 0}.foobar
{foo: foo, foo: 0}.greet
{foo: foo, foo: 0}.ok
{foo: foo, foo: 0}.str
{foo: foo, foo: 0}?.$env?.[list]
{foo: foo, foo: 0}?.Bar
{foo: foo, foo: 0}?.String
{foo: foo, foo: 0}?.[str]
{foo: foo, foo: 0}?.add
{foo: foo, foo: 0}?.f64
{foo: foo, foo: 0}?.foo
{foo: foo, foo: 0}?.greet
{foo: foo, foo: 0}?.list
{foo: foo, foo: 1, foo: greet}?.str
{foo: foo, foo: 1, foo: list}?.str
{foo: foo, foo: 1.0 - 1.0}
{foo: foo, foo: 1.0, foo: array}.str
{foo: foo, foo: 1.0}.Bar
{foo: foo, foo: 1.0}.String
{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}.i?.list
{foo: foo, foo: 1.0}.list
{foo: foo, foo: 1.0}.ok
{foo: foo, foo: 1.0}.str
{foo: foo, foo: 1.0}?.Bar
{foo: foo, foo: 1.0}?.String
{foo: foo, foo: 1.0}?.[str]
{foo: foo, foo: 1.0}?.add
{foo: foo, foo: 1.0}?.add?.ok
{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.0}?.ok?.[add]
{foo: foo, foo: 1.0}?.str
{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}.str
{foo: foo, foo: 1}?.add
{foo: foo, foo: 1}?.f64
{foo: foo, foo: 1}?.foo
{foo: foo, foo: 1}?.list
{foo: foo, foo: 1}?.ok
{foo: foo, foo: 1}?.str
{foo: foo, foo: [$env?.add]}
{foo: foo, foo: add, foo: foo}?.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}.foo
{foo: foo, foo: add}.greet
{foo: foo, foo: add}.i
{foo: foo, foo: add}.list
{foo: foo, foo: add}.str
{foo: foo, foo: add}?.String
{foo: foo, foo: add}?.add
{foo: foo, foo: add}?.f64
{foo: foo, foo: add}?.list
{foo: foo, foo: add}?.ok
{foo: foo, foo: add}?.str
{foo: foo, foo: array, foo: false}?.greet
{foo: foo, foo: array, foo: i}.f64
{foo: foo, foo: array}
{foo: foo, foo: array}.Bar
{foo: foo, foo: array}.String
{foo: foo, foo: array}.f64
{foo: foo, foo: array}.foo
{foo: foo, foo: array}.greet
{foo: foo, foo: array}.i
{foo: foo, foo: array}.list
{foo: foo, foo: array}.ok
{foo: foo, foo: array}.str
{foo: foo, foo: array}?.String
{foo: foo, foo: array}?.[str]
{foo: foo, foo: array}?.add
{foo: foo, foo: array}?.array
{foo: foo, foo: array}?.foo
{foo: foo, foo: array}?.greet
{foo: foo, foo: array}?.greet?.list
{foo: foo, foo: array}?.i
{foo: foo, foo: array}?.ok
{foo: foo, foo: f64, foo: 1.0}?.array
{foo: foo, foo: f64}
{foo: foo, foo: f64}.String
{foo: foo, foo: f64}.add
{foo: foo, foo: f64}.array
{foo: foo, foo: f64}.f64
{foo: foo, foo: f64}.i
{foo: foo, foo: f64}.list
{foo: foo, foo: f64}.list?.[i]
{foo: foo, foo: f64}?.Bar
{foo: foo, foo: f64}?.String
{foo: foo, foo: f64}?.add
{foo: foo, foo: f64}?.f64
{foo: foo, foo: f64}?.foo
{foo: foo, foo: f64}?.ok
{foo: foo, foo: f64}?.str
{foo: foo, foo: false, foo: list}?.str?.add
{foo: foo, foo: false}.Bar
{foo: foo, foo: false}.String
{foo: foo, foo: false}.array
{foo: foo, foo: false}.f64
{foo: foo, foo: false}.foo
{foo: foo, foo: false}.greet
{foo: foo, foo: false}.i
{foo: foo, foo: false}.list
{foo: foo, foo: false}.ok
{foo: foo, foo: false}.str
{foo: foo, foo: false}?.[str]
{foo: foo, foo: false}?.add
{foo: foo, foo: false}?.foo
{foo: foo, foo: false}?.i
{foo: foo, foo: false}?.ok
{foo: foo, foo: false}?.str
{foo: foo, foo: foo, foo: $env}.String
{foo: foo, foo: foo, foo: add}?.f64
{foo: foo, foo: foo, foo: foo}.greet
{foo: foo, foo: foo, foo: greet}
{foo: foo, foo: foo, foo: nil}.Bar
{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}.Bar?.[f64]
{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}?.Bar
{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}?.foo
{foo: foo, foo: foo}?.foobar
{foo: foo, foo: foo}?.greet
{foo: foo, foo: foo}?.list
{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}?.i
{foo: foo, foo: greet}
{foo: foo, foo: greet}.Bar
{foo: foo, foo: greet}.String
{foo: foo, foo: greet}.add
{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}?.Bar
{foo: foo, foo: greet}?.array
{foo: foo, foo: greet}?.f64
{foo: foo, foo: greet}?.foo
{foo: foo, foo: greet}?.greet
{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}?.String
{foo: foo, foo: i}?.[str]
{foo: foo, foo: i}?.array
{foo: foo, foo: i}?.f64
{foo: foo, foo: i}?.foo
{foo: foo, foo: i}?.foobar
{foo: foo, foo: i}?.greet
{foo: foo, foo: i}?.ok
{foo: foo, foo: i}?.str
{foo: foo, foo: list != list}
{foo: foo, foo: list, foo: false and false}
{foo: foo, foo: list, foo: greet}?.f64
{foo: foo, foo: list}
{foo: foo, foo: list}.String
{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}?.[str]
{foo: foo, foo: list}?.add
{foo: foo, foo: list}?.array
{foo: foo, foo: list}?.f64
{foo: foo, foo: list}?.greet
{foo: foo, foo: list}?.i
{foo: foo, foo: list}?.list
{foo: foo, foo: list}?.str
{foo: foo, foo: list}?.str?.array(1.0)
{foo: foo, foo: median(0)}
{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: 1}.greet
{foo: foo, foo: nil, foo: nil}.f64
{foo: foo, foo: nil, foo: nil}.list
{foo: foo, foo: nil, foo: ok}?.list
{foo: foo, foo: nil}.Bar
{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}.foobar?.[array]
{foo: foo, foo: nil}.foobar?.[list]
{foo: foo, foo: nil}.i
{foo: foo, foo: nil}.i?.array
{foo: foo, foo: nil}.list
{foo: foo, foo: nil}.ok
{foo: foo, foo: nil}.ok?.array()
{foo: foo, foo: nil}.str
{foo: foo, foo: nil}?.String
{foo: foo, foo: nil}?.[str]
{foo: foo, foo: nil}?.add
{foo: foo, foo: nil}?.array
{foo: foo, foo: nil}?.f64
{foo: foo, foo: nil}?.foo
{foo: foo, foo: nil}?.greet
{foo: foo, foo: nil}?.i
{foo: foo, foo: nil}?.list
{foo: foo, foo: nil}?.ok
{foo: foo, foo: nil}?.str
{foo: foo, foo: ok, foo: 1}.Bar?.i(foobar)
{foo: foo, foo: ok, foo: f64}.foo
{foo: foo, foo: ok}
{foo: foo, foo: ok}.String
{foo: foo, foo: ok}.add
{foo: foo, foo: ok}.array
{foo: foo, foo: ok}.i
{foo: foo, foo: ok}.list
{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: ok}?.foo
{foo: foo, foo: ok}?.i
{foo: foo, foo: ok}?.list
{foo: foo, foo: ok}?.str
{foo: foo, foo: str, foo: 1.0}.Bar
{foo: foo, foo: str, foo: foo}?.f64
{foo: foo, foo: str, foo: list}?.String
{foo: foo, foo: str}
{foo: foo, foo: str}.String
{foo: foo, foo: str}.f64
{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
{foo: foo, foo: str}?.f64?.ok
{foo: foo, foo: str}?.foo
{foo: foo, foo: str}?.greet
{foo: foo, foo: str}?.greet?.[i]
{foo: foo, foo: str}?.i
{foo: foo, foo: str}?.str
{foo: foo, foo: true, foo: $env}?.add
{foo: foo, foo: true, foo: array}.ok
{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}.add?.[array]
{foo: foo, foo: true}.foo
{foo: foo, foo: true}.greet?.Bar
{foo: foo, foo: true}.i
{foo: foo, foo: true}.str
{foo: foo, foo: true}?.Bar
{foo: foo, foo: true}?.String
{foo: foo, foo: true}?.[str]
{foo: foo, foo: true}?.add
{foo: foo, foo: true}?.array
{foo: foo, foo: true}?.f64
{foo: foo, foo: true}?.list
{foo: foo, foo: true}?.list?.[i].Bar()
{foo: foo, foo: true}?.ok
{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: list}
{foo: foo.Bar}
{foo: foo.Bar}.greet
{foo: foo.Bar}.list
{foo: foo.Bar}?.f64
{foo: foo.String() not matches str}
{foo: foo.String()}
{foo: foo.String()}?.ok
{foo: foo.String, foo: ok}
{foo: foo.String, foo: str}
{foo: foo.String}
{foo: foo.String}.String
{foo: foo.String}.add
{foo: foo.String}.array
{foo: foo.String}.greet
{foo: foo.String}.str
{foo: foo.String}?.add
{foo: foo.String}?.str
{foo: foo?.Bar, foo: add}
{foo: foo?.Bar}
{foo: foo?.Bar}?.list
{foo: foo?.String(), foo: i}
{foo: foo?.String()}
{foo: foo?.String()}.Bar
{foo: foo?.String()}?.list
{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} ?? $env?.f64
{foo: foo} ?? add
{foo: foo} ?? greet
{foo: foo} ?? ok
{foo: foo}.Bar
{foo: foo}.String
{foo: foo}.String != str
{foo: foo}.String?.[i]
{foo: foo}.add
{foo: foo}.add?.add()
{foo: foo}.array
{foo: foo}.array?.[str]
{foo: foo}.array?.foo
{foo: foo}.array?.greet()
{foo: foo}.array?.i
{foo: foo}.f64
{foo: foo}.f64?.Bar
{foo: foo}.f64?.[array]
{foo: foo}.f64?.[f64]
{foo: foo}.f64?.add
{foo: foo}.f64?.i
{foo: foo}.f64?.ok
{foo: foo}.f64?.str
{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?.[i]
{foo: foo}.greet?.[ok]
{foo: foo}.greet?.array()
{foo: foo}.i
{foo: foo}.i?.[f64]
{foo: foo}.i?.add
{foo: foo}.list
{foo: foo}.list?.[f64]
{foo: foo}.list?.[str]?.foobar
{foo: foo}.list?.str
{foo: foo}.ok
{foo: foo}.ok?.[add].add()
{foo: foo}.ok?.f64
{foo: foo}.ok?.ok
{foo: foo}.str
{foo: foo}.str?.String
{foo: foo}.str?.[array]
{foo: foo}.str?.greet
{foo: foo}?.Bar
{foo: foo}?.String
{foo: foo}?.String?.Bar
{foo: foo}?.String?.String()
{foo: foo}?.String?.array.str
{foo: foo}?.[str]
{foo: foo}?.[str]?.String
{foo: foo}?.add
{foo: foo}?.add?.f64(foobar, foobar)
{foo: foo}?.add?.i
{foo: foo}?.add?.ok
{foo: foo}?.add?.str
{foo: foo}?.array
{foo: foo}?.array?.String?.[foo]
{foo: foo}?.array?.[foo]
{foo: foo}?.array?.i
{foo: foo}?.f64
{foo: foo}?.f64?.[add]
{foo: foo}?.f64?.[list]
{foo: foo}?.f64?.[ok]
{foo: foo}?.f64?.str
{foo: foo}?.foo
{foo: foo}?.foobar
{foo: foo}?.foobar == foo
{foo: foo}?.foobar?.[add]
{foo: foo}?.foobar?.[array]
{foo: foo}?.foobar?.array
{foo: foo}?.foobar?.foo
{foo: foo}?.foobar?.greet(foobar)
{foo: foo}?.greet
{foo: foo}?.greet?.String?.[greet]
{foo: foo}?.greet?.[f64]
{foo: foo}?.greet?.[i]
{foo: foo}?.greet?.[str]
{foo: foo}?.i
{foo: foo}?.i?.[add]
{foo: foo}?.i?.ok
{foo: foo}?.list
{foo: foo}?.list?.[add]?.str
{foo: foo}?.list?.add
{foo: foo}?.list?.foo
{foo: foo}?.list?.list
{foo: foo}?.ok
{foo: foo}?.ok?.Bar
{foo: foo}?.ok?.String
{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 != greet}.foo
{foo: greet != nil}
{foo: greet == $env}
{foo: greet == greet}
{foo: greet ?? $env}
{foo: greet ?? 0}
{foo: greet ?? 1.0}
{foo: greet ?? 1}
{foo: greet ?? add}
{foo: greet ?? f64, foo: i}
{foo: greet ?? f64}
{foo: greet ?? false}
{foo: greet ?? foo}
{foo: greet ?? greet}
{foo: greet ?? nil}
{foo: greet($env?.[str])}
{foo: greet(str), foo: array}
{foo: greet(str)}
{foo: greet(str)}.String
{foo: greet(str)}.ok
{foo: greet(str)}.str
{foo: greet, foo: !false}
{foo: greet, foo: $env.array}
{foo: greet, foo: $env.f64}
{foo: greet, foo: $env.ok}
{foo: greet, foo: $env.str}
{foo: greet, foo: $env?.ok}
{foo: greet, foo: $env?.str}
{foo: greet, foo: $env}.Bar
{foo: greet, foo: $env}.Bar?.add
{foo: greet, foo: $env}.String
{foo: greet, foo: $env}.add
{foo: greet, foo: $env}.greet
{foo: greet, foo: $env}.str
{foo: greet, foo: $env}?.String
{foo: greet, foo: $env}?.add
{foo: greet, foo: $env}?.array
{foo: greet, foo: $env}?.greet
{foo: greet, foo: $env}?.list
{foo: greet, foo: $env}?.ok
{foo: greet, foo: 0, foo: foo}?.String
{foo: greet, foo: 0}.String
{foo: greet, foo: 0}.foo
{foo: greet, foo: 0}.i
{foo: greet, foo: 0}?.Bar
{foo: greet, foo: 0}?.add
{foo: greet, foo: 0}?.f64
{foo: greet, foo: 0}?.ok
{foo: greet, foo: 1 ** f64}
{foo: greet, foo: 1, foo: $env}?.Bar
{foo: greet, foo: 1.0}.Bar
{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}?.f64?.[i]
{foo: greet, foo: 1.0}?.list
{foo: greet, foo: 1.0}?.str
{foo: greet, foo: 1}.Bar
{foo: greet, foo: 1}.foo
{foo: greet, foo: 1}.list
{foo: greet, foo: 1}?.[str]
{foo: greet, foo: 1}?.i
{foo: greet, foo: 1}?.ok
{foo: greet, foo: [$env]}
{foo: greet, foo: add}
{foo: greet, foo: add}.array
{foo: greet, foo: add}.foo
{foo: greet, foo: add}?.add
{foo: greet, foo: add}?.add?.[add]
{foo: greet, foo: add}?.f64
{foo: greet, foo: add}?.foo
{foo: greet, foo: add}?.i
{foo: greet, foo: array}
{foo: greet, foo: array} ?? add
{foo: greet, foo: array}.String
{foo: greet, foo: array}.array
{foo: greet, foo: array}.foo
{foo: greet, foo: array}?.array
{foo: greet, foo: f64}
{foo: greet, foo: f64}.String
{foo: greet, foo: f64}.greet
{foo: greet, foo: f64}.i
{foo: greet, foo: f64}?.Bar
{foo: greet, foo: f64}?.String
{foo: greet, foo: f64}?.i
{foo: greet, foo: f64}?.list
{foo: greet, foo: false == nil}
{foo: greet, foo: false, foo: add}.Bar
{foo: greet, foo: false, foo: foo}.String
{foo: greet, foo: false}.add
{foo: greet, foo: false}.array
{foo: greet, foo: false}.f64
{foo: greet, foo: false}.greet
{foo: greet, foo: false}.ok
{foo: greet, foo: false}.str
{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 ?? f64}
{foo: greet, foo: foo, foo: array}
{foo: greet, foo: foo, foo: greet}?.add
{foo: greet, foo: foo.Bar}
{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}.ok?.list
{foo: greet, foo: foo}?.Bar
{foo: greet, foo: foo}?.Bar?.[ok]
{foo: greet, foo: foo}?.String
{foo: greet, foo: foo}?.[str]
{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}?.list?.str
{foo: greet, foo: foo}?.ok
{foo: greet, foo: foo}?.str
{foo: greet, foo: greet(str)}
{foo: greet, foo: greet}
{foo: greet, foo: greet}?.str
{foo: greet, foo: i == 1.0}
{foo: greet, foo: i}
{foo: greet, foo: i}.list
{foo: greet, foo: i}?.String
{foo: greet, foo: list}
{foo: greet, foo: list}.Bar
{foo: greet, foo: list}.list
{foo: greet, foo: list}.str
{foo: greet, foo: list}.true?.f64(false)
{foo: greet, foo: list}?.add
{foo: greet, foo: list}?.f64
{foo: greet, foo: nil == str}
{foo: greet, foo: nil}.add
{foo: greet, foo: nil}.array
{foo: greet, foo: nil}.f64
{foo: greet, foo: nil}.f64?.[foo]
{foo: greet, foo: nil}.foo(foobar?.[ok])
{foo: greet, foo: nil}.greet
{foo: greet, foo: nil}?.[str]
{foo: greet, foo: nil}?.foo
{foo: greet, foo: nil}?.greet
{foo: greet, foo: nil}?.ok
{foo: greet, foo: ok}
{foo: greet, foo: ok}.foo
{foo: greet, foo: ok}.i
{foo: greet, foo: ok}?.array
{foo: greet, foo: ok}?.f64
{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}.String
{foo: greet, foo: str}.add
{foo: greet, foo: str}.foo
{foo: greet, foo: str}.ok
{foo: greet, foo: str}?.f64
{foo: greet, foo: trimPrefix(str)}
{foo: greet, foo: true}.Bar
{foo: greet, foo: true}?.String
{foo: greet, foo: true}?.greet
{foo: greet, foo: true}?.ok
{foo: greet, foo: true}?.str
{foo: greet}
{foo: greet} ?? 1 ?? 1.0
{foo: greet} ?? add
{foo: greet}.Bar
{foo: greet}.Bar?.String
{foo: greet}.Bar?.ok
{foo: greet}.String
{foo: greet}.String?.str()
{foo: greet}.add
{foo: greet}.add?.ok
{foo: greet}.array
{foo: greet}.array?.i
{foo: greet}.f64
{foo: greet}.f64?.String
{foo: greet}.f64?.f64
{foo: greet}.foo
{foo: greet}.foobar
{foo: greet}.foobar?.[1.0]
{foo: greet}.foobar?.[foo]
{foo: greet}.foobar?.foo()
{foo: greet}.foobar?.str?.f64
{foo: greet}.greet
{foo: greet}.greet?.i
{foo: greet}.greet?.str
{foo: greet}.i
{foo: greet}.list
{foo: greet}.list?.Bar()
{foo: greet}.list?.[f64]
{foo: greet}.list?.list?.[f64]
{foo: greet}.ok
{foo: greet}.ok?.Bar
{foo: greet}.ok?.add
{foo: greet}.str
{foo: greet}?.Bar
{foo: greet}?.String
{foo: greet}?.String?.String
{foo: greet}?.[str]
{foo: greet}?.add
{foo: greet}?.add?.String
{foo: greet}?.array
{foo: greet}?.array?.[array]
{foo: greet}?.f64
{foo: greet}?.f64?.foo(array)
{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}?.ok?.list
{foo: greet}?.str
{foo: groupBy(array, #)}
{foo: groupBy(array, 0), foo: min($env)}
{foo: groupBy(array, 1.0)}
{foo: groupBy(array, f64)}
{foo: groupBy(array, false)}
{foo: groupBy(array, foo)}
{foo: groupBy(list, #)}
{foo: groupBy(list, #.Bar)}
{foo: groupBy(list, 0)}
{foo: groupBy(list, 1)}
{foo: groupBy(list, foo)}
{foo: groupBy(list, foo.String())}
{foo: groupBy(list, i)}
{foo: groupBy(list, ok)}
{foo: groupBy(list, true)}
{foo: i != $env}?.String
{foo: i != 0}
{foo: i != 1.0}
{foo: i != f64}
{foo: i != f64}?.ok
{foo: i != i, foo: greet(str)}
{foo: i % 1}
{foo: i * 0}
{foo: i * 1.0}
{foo: i * 1}
{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 + 1.0}
{foo: i + 1}
{foo: i + 1}?.i
{foo: i + f64}
{foo: i + i}
{foo: i - 0}
{foo: i - 1}
{foo: i .. 0}
{foo: i .. 1, foo: i}
{foo: i .. 1}
{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 < f64}
{foo: i < i}
{foo: i <= 0}
{foo: i <= 1.0}
{foo: i <= f64}
{foo: i <= i}
{foo: i == $env}
{foo: i == $env}?.Bar
{foo: i == 1.0}
{foo: i == nil}
{foo: i > 0, foo: 1 >= f64}
{foo: i >= 0}
{foo: i >= 1.0}
{foo: i >= 1}
{foo: i >= f64}
{foo: i >= f64}.str
{foo: i ?? $env}
{foo: i ?? 0}
{foo: i ?? 1.0}
{foo: i ?? array}
{foo: i ?? foo}
{foo: i ?? greet}
{foo: i ?? str}
{foo: i ^ 0}
{foo: i ^ 1.0}
{foo: i ^ 1}
{foo: i ^ f64}
{foo: i ^ i, foo: array}
{foo: i ^ i}
{foo: i not in array}
{foo: i not in array}?.greet
{foo: i | bitnand(1)}
{foo: i | bitor(i)}
{foo: i | bitushr(i)}
{foo: i | bitxor(i)}
{foo: i | median(i)}
{foo: i, foo: $env != foo}
{foo: i, foo: $env != ok}
{foo: i, foo: $env, foo: nil}?.add
{foo: i, foo: $env?.[Bar]}
{foo: i, foo: $env}.add
{foo: i, foo: $env}.foo
{foo: i, foo: $env}.ok
{foo: i, foo: $env}?.[str]
{foo: i, foo: $env}?.list
{foo: i, foo: 0 ?? f64}
{foo: i, foo: 0}.String
{foo: i, foo: 0}.greet
{foo: i, foo: 0}?.Bar
{foo: i, foo: 0}?.f64
{foo: i, foo: 0}?.ok?.str
{foo: i, foo: 1 - f64}
{foo: i, foo: 1.0 < 0}
{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}.array
{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}.str
{foo: i, foo: 1.0}?.String
{foo: i, foo: 1.0}?.add
{foo: i, foo: 1.0}?.f64
{foo: i, foo: 1.0}?.ok
{foo: i, foo: 1.0}?.str
{foo: i, foo: 1}.f64
{foo: i, foo: 1}?.array
{foo: i, foo: 1}?.list
{foo: i, foo: 1}?.ok
{foo: i, foo: add}
{foo: i, foo: add}.i
{foo: i, foo: add}.str
{foo: i, foo: add}?.String
{foo: i, foo: add}?.foo
{foo: i, foo: add}?.i
{foo: i, foo: add}?.str
{foo: i, foo: array}
{foo: i, foo: array}.f64
{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: f64}?.list
{foo: i, foo: f64}?.ok
{foo: i, foo: false}.array
{foo: i, foo: false}.f64?.array
{foo: i, foo: false}.str
{foo: i, foo: false}?.Bar
{foo: i, foo: false}?.String
{foo: i, foo: false}?.i
{foo: i, foo: false}?.str
{foo: i, foo: foo, foo: $env}.ok
{foo: i, foo: foo?.String}
{foo: i, foo: foo}
{foo: i, foo: foo}.Bar
{foo: i, foo: foo}.String
{foo: i, foo: foo}.String?.array
{foo: i, foo: foo}.array
{foo: i, foo: foo}.f64
{foo: i, foo: foo}.f64?.foo
{foo: i, foo: foo}.greet
{foo: i, foo: foo}.list
{foo: i, foo: foo}?.String
{foo: i, foo: foo}?.array
{foo: i, foo: foo}?.greet
{foo: i, foo: foo}?.i
{foo: i, foo: foo}?.list
{foo: i, foo: foo}?.list == foo
{foo: i, foo: foo}?.ok
{foo: i, foo: foo}?.str
{foo: i, foo: greet(str)}
{foo: i, foo: greet, foo: nil}?.Bar
{foo: i, foo: greet}
{foo: i, foo: greet}.Bar
{foo: i, foo: greet}.foo
{foo: i, foo: greet}.ok
{foo: i, foo: greet}?.String
{foo: i, foo: greet}?.f64
{foo: i, foo: greet}?.list
{foo: i, foo: greet}?.str
{foo: i, foo: i >= 1}
{foo: i, foo: i, foo: 0}?.ok
{foo: i, foo: i}
{foo: i, foo: i}.String
{foo: i, foo: i}.f64
{foo: i, foo: i}.foo
{foo: i, foo: i}?.Bar
{foo: i, foo: i}?.[str]
{foo: i, foo: i}?.i
{foo: i, foo: list | reduce(greet)}
{foo: i, foo: list}
{foo: i, foo: list}?.String
{foo: i, foo: list}?.[str]
{foo: i, foo: list}?.array
{foo: i, foo: list}?.list
{foo: i, foo: map(list, foo)}
{foo: i, foo: nil, foo: true}.array
{foo: i, foo: nil}.array
{foo: i, foo: nil}.array?.f64
{foo: i, foo: nil}.foo
{foo: i, foo: nil}.list
{foo: i, foo: nil}?.Bar
{foo: i, foo: nil}?.[str]
{foo: i, foo: nil}?.add
{foo: i, foo: nil}?.foo
{foo: i, foo: nil}?.list
{foo: i, foo: ok, foo: 1.0}?.ok
{foo: i, foo: ok, foo: ok}.greet?.list(array)
{foo: i, foo: ok}
{foo: i, foo: sortBy(array, #)}.i
{foo: i, foo: str}
{foo: i, foo: str}.array
{foo: i, foo: str}.f64
{foo: i, foo: str}.foo
{foo: i, foo: str}.foobar?.i()
{foo: i, foo: str}.i
{foo: i, foo: str}?.Bar
{foo: i, foo: str}?.add
{foo: i, foo: str}?.add?.[str]
{foo: i, foo: str}?.f64
{foo: i, foo: str}?.greet
{foo: i, foo: str}?.list
{foo: i, foo: true, foo: add}.str
{foo: i, foo: true, foo: foo}.Bar
{foo: i, foo: true}.foo
{foo: i, foo: true}?.f64
{foo: i, foo: true}?.list
{foo: i, foo: true}?.ok
{foo: i, foo: true}?.str
{foo: i, foo: {foo: add, foo: true}}
{foo: i, foo: {foo: str}}
{foo: i, foo: {foo: true}}?.foo
{foo: i..i}
{foo: if false { 1 } else { 1.0 }}
{foo: if false { foo } else { $env }}
{foo: if false { str } else { array }}
{foo: if false { true } else { greet }}
{foo: if ok { 1 } else { foo }}
{foo: if true { $env } else { array }}
{foo: if true { 0 } else { 1.0 }}
{foo: if true { 1.0 } else { foo }}
{foo: if true { f64 } else { add }}
{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} ?? add
{foo: i} not in [nil]
{foo: i}.$env?.Bar(Bar)
{foo: i}.Bar
{foo: i}.Bar?.list
{foo: i}.String
{foo: i}.String?.i
{foo: i}.add
{foo: i}.add?.[list]?.[greet]
{foo: i}.add?.add
{foo: i}.add?.list()
{foo: i}.array
{foo: i}.array?.Bar
{foo: i}.array?.[str]
{foo: i}.f64
{foo: i}.f64?.[foo]
{foo: i}.f64?.[list]
{foo: i}.f64?.foo
{foo: i}.foo
{foo: i}.foo ?? 1
{foo: i}.foobar
{foo: i}.greet
{foo: i}.greet?.add
{foo: i}.greet?.greet
{foo: i}.i
{foo: i}.i?.ok()
{foo: i}.list
{foo: i}.list?.greet()
{foo: i}.nil?.array
{foo: i}.not
{foo: i}.ok
{foo: i}.ok?.f64
{foo: i}.str
{foo: i}.str?.[nil]
{foo: i}?.Bar
{foo: i}?.Bar?.String
{foo: i}?.String
{foo: i}?.String?.[str]
{foo: i}?.[str]
{foo: i}?.[str]?.[add]
{foo: i}?.add
{foo: i}?.add?.String()
{foo: i}?.array
{foo: i}?.array?.[foo]
{foo: i}?.array?.greet
{foo: i}?.f64
{foo: i}?.f64?.greet
{foo: i}?.foo
{foo: i}?.foo == add
{foo: i}?.foobar
{foo: i}?.greet
{foo: i}?.greet?.[greet]
{foo: i}?.greet?.ok
{foo: i}?.i
{foo: i}?.i?.f64
{foo: i}?.list
{foo: i}?.list?.ok
{foo: i}?.nil not contains $env
{foo: i}?.ok
{foo: i}?.ok?.array
{foo: i}?.str
{foo: i}?.str?.str
{foo: keys($env), foo: list}
{foo: keys($env)}
{foo: keys($env)}?.i
{foo: keys($env)}?.list
{foo: keys($env)}?.ok
{foo: last($env)?.String}
{foo: last($env)}
{foo: last(array)}
{foo: last(list), foo: ok}
{foo: last(list)}
{foo: len($env)}
{foo: len($env)}.foo
{foo: len(array)}
{foo: len(list)}
{foo: len({foo: true})}
{foo: let foobar = false; foobar}
{foo: let foobar = str; foobar}
{foo: let tmp = ok; tmp}
{foo: list != $env}
{foo: list != array}
{foo: list != list}
{foo: list != nil}
{foo: list == $env?.[str]}
{foo: list == $env}
{foo: list == list}
{foo: list == list}.array
{foo: list == nil}
{foo: list ?? $env}
{foo: list ?? 0}
{foo: list ?? 1.0}
{foo: list ?? f64}
{foo: list ?? foo}
{foo: list ?? greet}
{foo: list ?? list}
{foo: list ?? nil}
{foo: list ?? str}
{foo: list | all(ok)}
{foo: list | all(true)}
{foo: list | count(false)}
{foo: list | findIndex(false)}
{foo: list | findIndex(true)}.add
{foo: list | groupBy(#)}
{foo: list | groupBy(1.0)}
{foo: list | groupBy(foo)}
{foo: list | groupBy(ok)}
{foo: list | groupBy(str)}
{foo: list | map(#)}
{foo: list | map(1.0)}
{foo: list | map(i)}
{foo: list | one(false)}
{foo: list | reduce(#)}
{foo: list | reduce(#.Bar, nil)}
{foo: list | reduce(#.String, nil)}
{foo: list | reduce($env)}
{foo: list | reduce(0)}
{foo: list | reduce(f64)}
{foo: list | reduce(false)}
{foo: list | reduce(foo)}
{foo: list | reduce(ok)}
{foo: list | reduce(str)}
{foo: list | sortBy(.Bar)}
{foo: list | sortBy(0)}
{foo: list | sortBy(1), foo: str}.foo
{foo: list | sortBy(1.0)}
{foo: list | sortBy(i)}
{foo: list | sum(1.0)}
{foo: list, foo: $env ?? list}
{foo: list, foo: $env.f64}
{foo: list, foo: $env.ok}
{foo: list, foo: $env?.array}
{foo: list, foo: $env?.f64}
{foo: list, foo: $env}.String
{foo: list, foo: $env}.add
{foo: list, foo: $env}.foo
{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: 0}.list
{foo: list, foo: 0}?.Bar
{foo: list, foo: 0}?.list
{foo: list, foo: 1, foo: false}?.list
{foo: list, foo: 1.0 == 1.0}
{foo: list, foo: 1.0, foo: true}?.i
{foo: list, foo: 1.0}.f64
{foo: list, foo: 1.0}.foo
{foo: list, foo: 1.0}.list
{foo: list, foo: 1.0}?.String
{foo: list, foo: 1.0}?.[str]
{foo: list, foo: 1.0}?.add
{foo: list, foo: 1.0}?.greet
{foo: list, foo: 1.0}?.i
{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: 1}?.list
{foo: list, foo: add}
{foo: list, foo: add}.array
{foo: list, foo: add}.f64
{foo: list, foo: add}.greet
{foo: list, foo: add}.i
{foo: list, foo: add}?.[str]
{foo: list, foo: add}?.array
{foo: list, foo: add}?.f64
{foo: list, foo: array}
{foo: list, foo: array}.f64
{foo: list, foo: array}.greet
{foo: list, foo: array}.i
{foo: list, foo: array}.ok
{foo: list, foo: array}.str
{foo: list, foo: array}?.array
{foo: list, foo: array}?.f64
{foo: list, foo: array}?.ok
{foo: list, foo: f64 - f64}
{foo: list, foo: f64}
{foo: list, foo: f64}.foo
{foo: list, foo: f64}.greet
{foo: list, foo: f64}?.Bar
{foo: list, foo: false || $env}
{foo: list, foo: false}.f64
{foo: list, foo: false}.foobar
{foo: list, foo: false}?.[str]
{foo: list, foo: false}?.add
{foo: list, foo: false}?.f64
{foo: list, foo: false}?.foo
{foo: list, foo: false}?.greet
{foo: list, foo: false}?.i
{foo: list, foo: false}?.ok
{foo: list, foo: foo, foo: list}.Bar
{foo: list, foo: foo, foo: true}.String
{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}.i
{foo: list, foo: foo}.ok
{foo: list, foo: foo}?.Bar
{foo: list, foo: foo}?.[str]
{foo: list, foo: foo}?.add
{foo: list, foo: foo}?.foo
{foo: list, foo: foo}?.foobar?.[str]
{foo: list, foo: greet}
{foo: list, foo: greet}.list
{foo: list, foo: greet}.str
{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: i}.foobar?.array
{foo: list, foo: list}
{foo: list, foo: list}.Bar
{foo: list, foo: list}.String
{foo: list, foo: list}.foo
{foo: list, foo: list}.list
{foo: list, foo: list}?.String
{foo: list, foo: list}?.foo
{foo: list, foo: list}?.greet
{foo: list, foo: list}?.list
{foo: list, foo: list}?.ok
{foo: list, foo: max(0)}
{foo: list, foo: median(array)}
{foo: list, foo: nil} ?? f64
{foo: list, foo: nil}.String
{foo: list, foo: nil}.add
{foo: list, foo: nil}.foo
{foo: list, foo: nil}.greet
{foo: list, foo: nil}.list
{foo: list, foo: nil}.str?.list
{foo: list, foo: nil}?.String
{foo: list, foo: nil}?.[str]
{foo: list, foo: nil}?.i
{foo: list, foo: nil}?.str
{foo: list, foo: ok}
{foo: list, foo: ok}.add
{foo: list, foo: ok}.ok
{foo: list, foo: ok}?.Bar
{foo: list, foo: ok}?.[str]
{foo: list, foo: ok}?.array
{foo: list, foo: ok}?.foo
{foo: list, foo: ok}?.i
{foo: list, foo: str, foo: abs(f64)}
{foo: list, foo: str}
{foo: list, foo: str}.String
{foo: list, foo: str}.array
{foo: list, foo: str}.list
{foo: list, foo: str}?.String
{foo: list, foo: str}?.i
{foo: list, foo: str}?.list
{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]}.greet?.[array]
{foo: list?.[i]}.ok
{foo: list[0:]}
{foo: list[:0]}
{foo: list[i:]}
{foo: list}
{foo: list} ?? reduce($env, 1.0, 1)
{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}.i?.[foo]
{foo: list}.list
{foo: list}.list?.[f64]
{foo: list}.list?.[greet]
{foo: list}.ok
{foo: list}.ok?.Bar
{foo: list}.ok?.[f64]
{foo: list}.str
{foo: list}?.Bar
{foo: list}?.Bar?.[foo]
{foo: list}?.Bar?.[greet]
{foo: list}?.Bar?.[list]
{foo: list}?.Bar?.add
{foo: list}?.String
{foo: list}?.String?.[array]
{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?.array
{foo: list}?.f64?.greet
{foo: list}?.f64?.ok
{foo: list}?.foo
{foo: list}?.foobar
{foo: list}?.greet
{foo: list}?.greet?.list
{foo: list}?.i
{foo: list}?.i?.[greet]
{foo: list}?.i?.[i]
{foo: list}?.i?.array
{foo: list}?.list
{foo: list}?.ok
{foo: list}?.ok?.[ok]
{foo: list}?.str
{foo: list}?.str?.[list]
{foo: list}?.str?.[str]
{foo: lower(str)}
{foo: lower(str)}?.[str]
{foo: map($env, $env)}
{foo: map($env, 0)}
{foo: map($env, 1)}
{foo: map($env, 1.0), foo: i}
{foo: map($env, 1.0)}
{foo: map($env, array)}
{foo: map($env, f64)}
{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($env, str)}
{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, .String)}
{foo: map(list, add)}
{foo: map(list, foo)}
{foo: map(list, greet)}
{foo: map(list, ok)}
{foo: max($env), foo: array}
{foo: max($env)}
{foo: max($env)}.i
{foo: max(0)}
{foo: max(1)}
{foo: max(1.0)}
{foo: max(1.0, 1.0)}
{foo: max(array)}
{foo: max(f64)}
{foo: max(f64)}?.str
{foo: max(i)}
{foo: mean(0)}
{foo: mean(1)}
{foo: mean(1, 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: mean(i, 1)}
{foo: median(0)}
{foo: median(0)}?.ok
{foo: median(1)}
{foo: median(1.0)}
{foo: median(array)}
{foo: median(array, 1.0)}
{foo: median(f64), foo: i}
{foo: median(f64)}
{foo: median(f64, i)}.i
{foo: median(flatten(array))}
{foo: median(i)}
{foo: median(i, array)}.Bar
{foo: min($env)?.String}
{foo: min($env)}
{foo: min(0)}
{foo: min(1), foo: ok}
{foo: min(1)}
{foo: min(1, 1.0)}
{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: foo}
{foo: nil != $env}
{foo: nil != 0}
{foo: nil != 1.0}
{foo: nil != 1}
{foo: nil != 1}.ok
{foo: nil != add}
{foo: nil != array}
{foo: nil != f64}
{foo: nil != false, foo: i}
{foo: nil != false}
{foo: nil != foo?.String()}
{foo: nil != foo}
{foo: nil != foo}.str
{foo: nil != greet}
{foo: nil != i, foo: list}
{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 == 1}
{foo: nil == add}
{foo: nil == array}
{foo: nil == f64}
{foo: nil == false}
{foo: nil == foo}
{foo: nil == greet}
{foo: nil == list}?.Bar
{foo: nil == nil}
{foo: nil == ok}
{foo: nil == true}
{foo: nil ?? $env}
{foo: nil ?? 0}
{foo: nil ?? 1.0}
{foo: nil ?? 1}
{foo: nil ?? add}
{foo: nil ?? array}
{foo: nil ?? f64}
{foo: nil ?? false, foo: i}
{foo: nil ?? false}
{foo: nil ?? foo}
{foo: nil ?? greet}
{foo: nil ?? i}
{foo: nil ?? list, foo: f64}
{foo: nil ?? nil, foo: f64}
{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 not in array}
{foo: nil not in list}
{foo: nil, foo: $env}.Bar
{foo: nil, foo: $env}.String
{foo: nil, foo: $env}.add
{foo: nil, foo: $env}.array
{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}?.add
{foo: nil, foo: $env}?.foo
{foo: nil, foo: $env}?.i
{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}.Bar
{foo: nil, foo: 0}.String
{foo: nil, foo: 0}.f64
{foo: nil, foo: 0}.list
{foo: nil, foo: 0}.ok
{foo: nil, foo: 0}?.Bar
{foo: nil, foo: 0}?.String?.[f64]
{foo: nil, foo: 0}?.add
{foo: nil, foo: 0}?.array
{foo: nil, foo: 0}?.f64
{foo: nil, foo: 0}?.greet
{foo: nil, foo: 0}?.ok
{foo: nil, foo: 1, foo: false}?.String
{foo: nil, foo: 1, foo: foo}.ok
{foo: nil, foo: 1.0, foo: 1}.f64
{foo: nil, foo: 1.0, foo: array}?.str
{foo: nil, foo: 1.0}.Bar
{foo: nil, foo: 1.0}.String
{foo: nil, foo: 1.0}.add
{foo: nil, foo: 1.0}.array
{foo: nil, foo: 1.0}.foo
{foo: nil, foo: 1.0}.greet
{foo: nil, foo: 1.0}.i
{foo: nil, foo: 1.0}.list
{foo: nil, foo: 1.0}.nil?.[greet]
{foo: nil, foo: 1.0}.str
{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}?.list
{foo: nil, foo: 1.0}?.ok
{foo: nil, foo: 1.0}?.str
{foo: nil, foo: 1}.Bar
{foo: nil, foo: 1}.String
{foo: nil, foo: 1}.add
{foo: nil, foo: 1}.array
{foo: nil, foo: 1}.f64
{foo: nil, foo: 1}.i
{foo: nil, foo: 1}.list
{foo: nil, foo: 1}?.[str]
{foo: nil, foo: 1}?.add
{foo: nil, foo: 1}?.f64
{foo: nil, foo: 1}?.foo
{foo: nil, foo: add}.Bar
{foo: nil, foo: add}.f64
{foo: nil, foo: add}.i
{foo: nil, foo: add}.list
{foo: nil, foo: add}?.Bar
{foo: nil, foo: add}?.String
{foo: nil, foo: add}?.add
{foo: nil, foo: add}?.foo
{foo: nil, foo: add}?.i
{foo: nil, foo: add}?.ok
{foo: nil, foo: array, foo: add}?.add
{foo: nil, foo: array}.foo
{foo: nil, foo: array}.str
{foo: nil, foo: array}?.[str]
{foo: nil, foo: array}?.array
{foo: nil, foo: array}?.array?.[foo]
{foo: nil, foo: array}?.f64
{foo: nil, foo: array}?.foobar
{foo: nil, foo: array}?.greet
{foo: nil, foo: array}?.i
{foo: nil, foo: f64}.String
{foo: nil, foo: f64}.add
{foo: nil, foo: f64}.f64
{foo: nil, foo: f64}.greet
{foo: nil, foo: f64}?.Bar
{foo: nil, foo: f64}?.array
{foo: nil, foo: f64}?.greet
{foo: nil, foo: f64}?.ok
{foo: nil, foo: false}.Bar
{foo: nil, foo: false}.f64
{foo: nil, foo: false}.foo
{foo: nil, foo: false}.list
{foo: nil, foo: false}?.f64
{foo: nil, foo: false}?.greet
{foo: nil, foo: false}?.i
{foo: nil, foo: false}?.list
{foo: nil, foo: false}?.ok
{foo: nil, foo: foo, foo: 1}.foo
{foo: nil, foo: foo, foo: 1}.i
{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, foo: true}.ok
{foo: nil, foo: foo}.String
{foo: nil, foo: foo}.add
{foo: nil, foo: foo}.array
{foo: nil, foo: foo}.foo
{foo: nil, foo: foo}.greet
{foo: nil, foo: foo}.i
{foo: nil, foo: foo}.ok
{foo: nil, foo: foo}.str
{foo: nil, foo: foo}?.Bar
{foo: nil, foo: foo}?.[str]
{foo: nil, foo: foo}?.add
{foo: nil, foo: foo}?.f64
{foo: nil, foo: foo}?.foo
{foo: nil, foo: foo}?.greet
{foo: nil, foo: foo}?.i
{foo: nil, foo: foo}?.list in list
{foo: nil, foo: foo}?.ok
{foo: nil, foo: foo}?.ok?.Bar()
{foo: nil, foo: foo}?.str
{foo: nil, foo: greet, foo: nil}.add
{foo: nil, foo: greet}.String
{foo: nil, foo: greet}.array
{foo: nil, foo: greet}.i
{foo: nil, foo: greet}.ok
{foo: nil, foo: greet}?.f64
{foo: nil, foo: greet}?.foo
{foo: nil, foo: greet}?.greet
{foo: nil, foo: greet}?.i
{foo: nil, foo: greet}?.str
{foo: nil, foo: i, foo: $env}.f64
{foo: nil, foo: i, foo: foo}?.i
{foo: nil, foo: i, foo: greet}?.String
{foo: nil, foo: i}.f64
{foo: nil, foo: i}.foo
{foo: nil, foo: i}.greet
{foo: nil, foo: i}.i
{foo: nil, foo: i}.list
{foo: nil, foo: i}.ok
{foo: nil, foo: i}?.String
{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}.ok
{foo: nil, foo: list}?.Bar
{foo: nil, foo: list}?.f64
{foo: nil, foo: list}?.foo
{foo: nil, foo: list}?.i
{foo: nil, foo: list}?.str
{foo: nil, foo: nil, foo: 1.0}?.array
{foo: nil, foo: nil, foo: greet}?.[str]
{foo: nil, foo: nil, foo: i}?.String
{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}.i
{foo: nil, foo: nil}.ok
{foo: nil, foo: nil}.str
{foo: nil, foo: nil}?.Bar
{foo: nil, foo: nil}?.String
{foo: nil, foo: nil}?.add
{foo: nil, foo: nil}?.array
{foo: nil, foo: nil}?.array?.array(foobar)
{foo: nil, foo: nil}?.f64
{foo: nil, foo: nil}?.foo
{foo: nil, foo: nil}?.i
{foo: nil, foo: nil}?.list
{foo: nil, foo: nil}?.ok
{foo: nil, foo: nil}?.str
{foo: nil, foo: ok, foo: nil}.String
{foo: nil, foo: ok}.Bar
{foo: nil, foo: ok}.String
{foo: nil, foo: ok}.add
{foo: nil, foo: ok}.array
{foo: nil, foo: ok}.f64
{foo: nil, foo: ok}.foo
{foo: nil, foo: ok}.i
{foo: nil, foo: ok}?.Bar?.[add]
{foo: nil, foo: ok}?.array
{foo: nil, foo: ok}?.f64
{foo: nil, foo: ok}?.foo
{foo: nil, foo: ok}?.str?.[greet]
{foo: nil, foo: str}.String
{foo: nil, foo: str}.add
{foo: nil, foo: str}.array
{foo: nil, foo: str}.f64
{foo: nil, foo: str}.foo
{foo: nil, foo: str}.greet
{foo: nil, foo: str}.i
{foo: nil, foo: str}.ok
{foo: nil, foo: str}.str
{foo: nil, foo: str}?.add
{foo: nil, foo: str}?.f64
{foo: nil, foo: true, foo: str}.list
{foo: nil, foo: true}.String
{foo: nil, foo: true}.f64
{foo: nil, foo: true}.ok
{foo: nil, foo: true}.str
{foo: nil, foo: true}?.String
{foo: nil, foo: true}?.i
{foo: nil, foo: true}?.ok
{foo: nil} ?? array
{foo: nil} ?? foo
{foo: nil} ?? ok
{foo: nil} not in $env?.[String]
{foo: nil}.Bar
{foo: nil}.Bar?.add?.list
{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}.add?.[str]
{foo: nil}.array
{foo: nil}.array?.[array]
{foo: nil}.array?.[foo]
{foo: nil}.array?.[i]
{foo: nil}.array?.[ok]
{foo: nil}.array?.[str]
{foo: nil}.array?.str
{foo: nil}.f64
{foo: nil}.f64?.[list].ok
{foo: nil}.f64?.f64
{foo: nil}.f64?.i
{foo: nil}.foo
{foo: nil}.foo?.[list]
{foo: nil}.foo?.ok
{foo: nil}.foobar
{foo: nil}.foobar?.i
{foo: nil}.greet
{foo: nil}.greet?.[add]
{foo: nil}.greet?.[f64]
{foo: nil}.greet?.[foo]
{foo: nil}.greet?.greet(foo)
{foo: nil}.i
{foo: nil}.list
{foo: nil}.list?.String
{foo: nil}.list?.String()
{foo: nil}.list?.list
{foo: nil}.not
{foo: nil}.ok
{foo: nil}.ok?.String
{foo: nil}.ok?.greet
{foo: nil}.str
{foo: nil}.str?.ok
{foo: nil}?.$env?.str
{foo: nil}?.Bar
{foo: nil}?.Bar?.String
{foo: nil}?.String
{foo: nil}?.String?.add
{foo: nil}?.String?.greet
{foo: nil}?.[str]
{foo: nil}?.[str]?.[list]
{foo: nil}?.[str]?.[str]
{foo: nil}?.[str]?.ok
{foo: nil}?.add
{foo: nil}?.add?.Bar
{foo: nil}?.add?.add
{foo: nil}?.array
{foo: nil}?.array?.Bar
{foo: nil}?.f64
{foo: nil}?.f64?.[i]
{foo: nil}?.foo
{foo: nil}?.foo != f64
{foo: nil}?.foo?.[f64]
{foo: nil}?.foo?.[ok]
{foo: nil}?.foo?.i
{foo: nil}?.foo?.str
{foo: nil}?.foobar
{foo: nil}?.foobar or true
{foo: nil}?.foobar?.add
{foo: nil}?.greet
{foo: nil}?.greet?.ok
{foo: nil}?.i
{foo: nil}?.i?.[greet]
{foo: nil}?.i?.[str]
{foo: nil}?.list
{foo: nil}?.list?.[list]
{foo: nil}?.list?.f64(foobar)
{foo: nil}?.ok
{foo: nil}?.ok?.[f64]
{foo: nil}?.ok?.add
{foo: nil}?.str
{foo: nil}?.str?.f64()
{foo: nil}?.str?.list
{foo: nil}?.str?.ok
{foo: none($env, false)}
{foo: none($env, ok)}
{foo: none($env, true)}
{foo: none(list, ok)}
{foo: none(list, true)}
{foo: not false}
{foo: not false}?.add
{foo: not false}?.ok
{foo: not ok && $env}
{foo: not ok}
{foo: not true, foo: add}
{foo: not true, foo: array}
{foo: not true, foo: str}
{foo: not true}
{foo: not true}.f64
{foo: not true}?.str
{foo: ok != $env}
{foo: ok != false}
{foo: ok != nil}
{foo: ok != ok}
{foo: ok != true}
{foo: ok && $env}
{foo: ok && false}
{foo: ok && ok}
{foo: ok == $env}
{foo: ok == $env}.String
{foo: ok == false}
{foo: ok == nil}
{foo: ok == ok}
{foo: ok == true}
{foo: ok == true}.f64
{foo: ok ? 1.0 : 1}
{foo: ok ? 1.0 : greet}
{foo: ok ? add : f64}
{foo: ok ? foo : 0}
{foo: ok ? greet : add}
{foo: ok ? greet : list}
{foo: ok ? nil : foo}
{foo: ok ?: array}
{foo: ok ?: nil}
{foo: ok ?? $env}
{foo: ok ?? 0}
{foo: ok ?? 1.0}
{foo: ok ?? 1}
{foo: ok ?? array}
{foo: ok ?? false}
{foo: ok ?? foo}
{foo: ok ?? i}
{foo: ok ?? list}
{foo: ok ?? true, foo: $env.list}
{foo: ok and $env}
{foo: ok and true}
{foo: ok or $env}
{foo: ok or false}
{foo: ok || $env}
{foo: ok || ok}
{foo: ok || true}
{foo: ok, foo: $env, foo: foo}?.array
{foo: ok, foo: $env.add}
{foo: ok, foo: $env.str}
{foo: ok, foo: $env?.array}
{foo: ok, foo: $env?.i, foo: str}
{foo: ok, foo: $env}.foo
{foo: ok, foo: $env}.i
{foo: ok, foo: $env}.ok
{foo: ok, foo: $env}?.Bar
{foo: ok, foo: $env}?.String
{foo: ok, foo: $env}?.[str]
{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, foo: array}?.String
{foo: ok, foo: 0}.Bar
{foo: ok, foo: 0}.String
{foo: ok, foo: 0}.ok
{foo: ok, foo: 0}?.list
{foo: ok, foo: 0}?.ok
{foo: ok, foo: 0}?.str
{foo: ok, foo: 1, foo: nil}?.str
{foo: ok, foo: 1.0 - i}
{foo: ok, foo: 1.0}.Bar
{foo: ok, foo: 1.0}.f64
{foo: ok, foo: 1.0}.foo
{foo: ok, foo: 1.0}.greet
{foo: ok, foo: 1.0}.i
{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}?.f64
{foo: ok, foo: 1.0}?.foo
{foo: ok, foo: 1.0}?.greet
{foo: ok, foo: 1.0}?.i
{foo: ok, foo: 1.0}?.ok
{foo: ok, foo: 1}.array
{foo: ok, foo: 1}.greet
{foo: ok, foo: 1}?.[str]
{foo: ok, foo: 1}?.add?.String
{foo: ok, foo: 1}?.greet
{foo: ok, foo: add ?? 1.0}
{foo: ok, foo: add, foo: 1.0}?.greet
{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 | map(1.0)}
{foo: ok, foo: array}
{foo: ok, foo: array}.String
{foo: ok, foo: array}.greet
{foo: ok, foo: array}.str
{foo: ok, foo: array}?.String
{foo: ok, foo: array}?.String?.[f64]
{foo: ok, foo: array}?.add
{foo: ok, foo: array}?.f64
{foo: ok, foo: array}?.foo
{foo: ok, foo: array}?.list
{foo: ok, foo: f64 <= i}
{foo: ok, foo: f64, foo: $env}?.foo
{foo: ok, foo: f64}
{foo: ok, foo: f64}.foo
{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: f64}?.i
{foo: ok, foo: false}?.String
{foo: ok, foo: false}?.f64
{foo: ok, foo: false}?.ok
{foo: ok, foo: false}?.str
{foo: ok, foo: foo?.Bar}
{foo: ok, foo: foo}
{foo: ok, foo: foo}.Bar
{foo: ok, foo: foo}.add
{foo: ok, foo: foo}.array
{foo: ok, foo: foo}.f64
{foo: ok, foo: foo}.foo
{foo: ok, foo: foo}.greet
{foo: ok, foo: foo}.i
{foo: ok, foo: foo}.list
{foo: ok, foo: foo}.ok
{foo: ok, foo: foo}.str
{foo: ok, foo: foo}?.Bar
{foo: ok, foo: foo}?.array
{foo: ok, foo: foo}?.f64
{foo: ok, foo: foo}?.foo
{foo: ok, foo: foo}?.list
{foo: ok, foo: foo}?.ok
{foo: ok, foo: foo}?.str
{foo: ok, foo: greet}
{foo: ok, foo: greet}.greet
{foo: ok, foo: greet}.i
{foo: ok, foo: greet}?.greet
{foo: ok, foo: greet}?.list
{foo: ok, foo: i <= f64}
{foo: ok, foo: i, foo: true}.foo
{foo: ok, foo: i}
{foo: ok, foo: i}.Bar
{foo: ok, foo: i}.list
{foo: ok, foo: i}?.list
{foo: ok, foo: list, foo: 0}.i
{foo: ok, foo: list}
{foo: ok, foo: list}.i
{foo: ok, foo: list}.str
{foo: ok, foo: list}?.array
{foo: ok, foo: list}?.foo
{foo: ok, foo: list}?.greet
{foo: ok, foo: list}?.ok
{foo: ok, foo: list}?.str
{foo: ok, foo: mean(0)}
{foo: ok, foo: nil == ok}
{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} ?? i
{foo: ok, foo: nil}.Bar
{foo: ok, foo: nil}.String
{foo: ok, foo: nil}.add
{foo: ok, foo: nil}.array
{foo: ok, foo: nil}.foo
{foo: ok, foo: nil}.greet
{foo: ok, foo: nil}.i
{foo: ok, foo: nil}.list
{foo: ok, foo: nil}?.foo
{foo: ok, foo: nil}?.ok
{foo: ok, foo: nil}?.str
{foo: ok, foo: nil}?.str?.i()
{foo: ok, foo: ok}
{foo: ok, foo: ok}.f64
{foo: ok, foo: ok}.i?.greet
{foo: ok, foo: ok}?.list
{foo: ok, foo: str}
{foo: ok, foo: str}.f64
{foo: ok, foo: str}.greet
{foo: ok, foo: str}?.f64
{foo: ok, foo: str}?.list
{foo: ok, foo: true, foo: str}?.String
{foo: ok, foo: true}.Bar
{foo: ok, foo: true}.array
{foo: ok, foo: true}.greet
{foo: ok, foo: true}.true?.add
{foo: ok, foo: true}?.Bar
{foo: ok, foo: true}?.[str]
{foo: ok, foo: true}?.add
{foo: ok, foo: true}?.array?.greet
{foo: ok, foo: true}?.f64
{foo: ok, foo: true}?.list
{foo: ok, foo: true}?.ok
{foo: ok, foo: true}?.str
{foo: ok}
{foo: ok} ?? str
{foo: ok}.Bar
{foo: ok}.String
{foo: ok}.add
{foo: ok}.add?.greet()
{foo: ok}.array
{foo: ok}.array?.String
{foo: ok}.f64
{foo: ok}.f64?.[greet]
{foo: ok}.foo
{foo: ok}.foobar
{foo: ok}.greet
{foo: ok}.greet?.add
{foo: ok}.i
{foo: ok}.i?.[list]
{foo: ok}.i?.[ok]
{foo: ok}.list
{foo: ok}.ok
{foo: ok}.ok matches $env
{foo: ok}.ok?.greet
{foo: ok}.str
{foo: ok}?.Bar
{foo: ok}?.Bar?.[greet]
{foo: ok}?.Bar?.[list]
{foo: ok}?.Bar?.[str]
{foo: ok}?.String
{foo: ok}?.String?.[i]
{foo: ok}?.String?.[str]
{foo: ok}?.[str]
{foo: ok}?.[str]?.[array]
{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}?.foo != foo
{foo: ok}?.foobar
{foo: ok}?.foobar?.ok(foo)
{foo: ok}?.greet
{foo: ok}?.i
{foo: ok}?.i?.ok
{foo: ok}?.list
{foo: ok}?.nil?.greet
{foo: ok}?.ok
{foo: ok}?.str
{foo: one($env, false)}
{foo: one($env, true)}
{foo: one(array, ok)}
{foo: one(array, true)}
{foo: one(list, false)}
{foo: one(list, ok)}
{foo: one(list, true)}
{foo: reduce($env, #acc, foo)}
{foo: reduce(array, #)}
{foo: reduce(array, $env, $env)}
{foo: reduce(array, 0)}
{foo: reduce(array, add)}
{foo: reduce(array, array)}
{foo: reduce(array, f64)}
{foo: reduce(array, list)}
{foo: reduce(array, ok, $env)}
{foo: reduce(array, str)}
{foo: reduce(list, #)}
{foo: reduce(list, #.Bar)}
{foo: reduce(list, #.String)}
{foo: reduce(list, $env)}
{foo: reduce(list, 1.0)}
{foo: reduce(list, add)}
{foo: reduce(list, array)}.str
{foo: reduce(list, f64)}
{foo: reduce(list, false), foo: 1.0 * f64}
{foo: reduce(list, false)}
{foo: reduce(list, foo)}
{foo: reduce(list, ok)}
{foo: reduce(list, str)}
{foo: reduce(map(array, $env), #.list | reduce(foo))}
{foo: reverse(array)}
{foo: reverse(list)}
{foo: round(0)}
{foo: round(0)}?.Bar
{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: str}
{foo: sort(array)}
{foo: sortBy(array, #)}
{foo: sortBy(array, 0)}
{foo: sortBy(array, 1)}
{foo: sortBy(array, 1.0)}
{foo: sortBy(array, f64)}
{foo: sortBy(list, #.Bar)}
{foo: sortBy(list, 1.0)}
{foo: sortBy(list, i)}
{foo: sortBy(list, str)}
{foo: str != $env?.[Bar]}
{foo: str != $env}
{foo: str < str}
{foo: str == $env}
{foo: str == nil}
{foo: str == str}
{foo: str >= str, foo: str}
{foo: str ?? 0}
{foo: str ?? 1.0}
{foo: str ?? add}
{foo: str ?? array}
{foo: str ?? f64}
{foo: str ?? false}
{foo: str ?? foo}
{foo: str ?? true}
{foo: str contains str}
{foo: str endsWith 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 not startsWith str}
{foo: str startsWith str}
{foo: str, foo: $env != 0}
{foo: str, foo: $env, foo: 0}?.add
{foo: str, foo: $env, foo: nil}.str
{foo: str, foo: $env.f64}
{foo: str, foo: $env.greet}
{foo: str, foo: $env?.add}
{foo: str, foo: $env?.foobar}
{foo: str, foo: $env}.foo
{foo: str, foo: $env}.foobar?.list()
{foo: str, foo: $env}.greet
{foo: str, foo: $env}.list
{foo: str, foo: $env}.str
{foo: str, foo: $env}?.[str]
{foo: str, foo: $env}?.f64
{foo: str, foo: $env}?.foo
{foo: str, foo: $env}?.str
{foo: str, foo: 0, foo: f64}?.foo
{foo: str, foo: 0, foo: nil}?.add
{foo: str, foo: 0}.add
{foo: str, foo: 0}.foobar
{foo: str, foo: 0}.ok
{foo: str, foo: 0}?.add
{foo: str, foo: 0}?.array
{foo: str, foo: 0}?.ok
{foo: str, foo: 1.0, foo: greet}?.add
{foo: str, foo: 1.0}.String
{foo: str, foo: 1.0}.f64
{foo: str, foo: 1.0}.foo
{foo: str, foo: 1.0}.greet
{foo: str, foo: 1.0}.i
{foo: str, foo: 1.0}.list
{foo: str, foo: 1.0}.ok
{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}.ok
{foo: str, foo: 1}.str
{foo: str, foo: 1}?.String
{foo: str, foo: 1}?.add
{foo: str, foo: 1}?.i
{foo: str, foo: 1}?.list
{foo: str, foo: [f64]}
{foo: str, foo: add, foo: f64}?.ok
{foo: str, foo: add, foo: str}?.f64
{foo: str, foo: add}
{foo: str, foo: add}.Bar
{foo: str, foo: add}.String
{foo: str, foo: add}.f64
{foo: str, foo: add}.greet
{foo: str, foo: add}.i
{foo: str, foo: add}?.[str]
{foo: str, foo: add}?.array
{foo: str, foo: array}
{foo: str, foo: array}.greet
{foo: str, foo: array}.i
{foo: str, foo: array}.list
{foo: str, foo: array}.ok
{foo: str, foo: array}?.String
{foo: str, foo: array}?.add
{foo: str, foo: array}?.foo
{foo: str, foo: array}?.i
{foo: str, foo: ceil(1.0)}
{foo: str, foo: f64}
{foo: str, foo: f64} ?? foo
{foo: str, foo: f64}.add
{foo: str, foo: f64}?.String
{foo: str, foo: f64}?.add
{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}.i
{foo: str, foo: false}?.[str]
{foo: str, foo: false}?.greet?.[add]
{foo: str, foo: false}?.i
{foo: str, foo: false}?.str
{foo: str, foo: foo, foo: array}?.str
{foo: str, foo: foo.String}
{foo: str, foo: foo}
{foo: str, foo: foo}.Bar
{foo: str, foo: foo}.array
{foo: str, foo: foo}.f64?.foo
{foo: str, foo: foo}.greet
{foo: str, foo: foo}.i
{foo: str, foo: foo}.list
{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}.String
{foo: str, foo: greet}.greet?.[greet]
{foo: str, foo: greet}.ok
{foo: str, foo: greet}?.add
{foo: str, foo: greet}?.array
{foo: str, foo: i}
{foo: str, foo: i}.Bar
{foo: str, foo: i}.add
{foo: str, foo: i}.array
{foo: str, foo: i}.foo
{foo: str, foo: i}?.Bar
{foo: str, foo: i}?.list
{foo: str, foo: last($env)}
{foo: str, foo: list}
{foo: str, foo: list}.String
{foo: str, foo: list}.add
{foo: str, foo: list}.f64
{foo: str, foo: list}.ok
{foo: str, foo: list}?.add
{foo: str, foo: list}?.foo
{foo: str, foo: list}?.str
{foo: str, foo: map($env, 0)}
{foo: str, foo: median(1.0)}
{foo: str, foo: nil, foo: i}?.array
{foo: str, foo: nil}.add
{foo: str, foo: nil}.i
{foo: str, foo: nil}?.Bar
{foo: str, foo: nil}?.i
{foo: str, foo: nil}?.list
{foo: str, foo: ok, foo: $env}.add
{foo: str, foo: ok, foo: array}
{foo: str, foo: ok}
{foo: str, foo: ok}.f64
{foo: str, foo: ok}.list
{foo: str, foo: ok}?.Bar
{foo: str, foo: ok}?.String
{foo: str, foo: ok}?.[str]
{foo: str, foo: ok}?.foobar != foo
{foo: str, foo: ok}?.greet
{foo: str, foo: str, foo: true}?.add
{foo: str, foo: str}
{foo: str, foo: str}.add
{foo: str, foo: str}.f64
{foo: str, foo: str}.foo
{foo: str, foo: str}?.array
{foo: str, foo: str}?.greet
{foo: str, foo: str}?.list
{foo: str, foo: toJSON(0)}
{foo: str, foo: true}.Bar
{foo: str, foo: true}.array
{foo: str, foo: true}.ok?.String
{foo: str, foo: true}?.Bar
{foo: str, foo: true}?.array
{foo: str, foo: true}?.foo
{foo: str, foo: true}?.i
{foo: str, foo: true}?.ok
{foo: str[:1]}
{foo: str[:i]}
{foo: string($env), foo: list}
{foo: string($env)}
{foo: string(0)}
{foo: string(1)}
{foo: string(1.0), foo: add}
{foo: string(1.0)}
{foo: string(add)}
{foo: string(array)}
{foo: string(array)}.foo
{foo: string(f64)}
{foo: string(false), foo: add}
{foo: string(foo)}
{foo: string(greet), foo: array}
{foo: string(greet)}
{foo: string(greet)}.greet
{foo: string(i)}
{foo: string(list), foo: i}
{foo: string(list)}
{foo: string(nil)}
{foo: string(ok)}
{foo: string(str)}
{foo: string(str)}.i
{foo: string(true)}
{foo: str}
{foo: str} != $env?.[Bar]
{foo: str} != nil || $env
{foo: str} ?? $env.i
{foo: str} ?? str
{foo: str}.Bar
{foo: str}.String
{foo: str}.String?.[ok]
{foo: str}.add
{foo: str}.array
{foo: str}.f64
{foo: str}.f64?.[list]
{foo: str}.f64?.[str]
{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}.list?.[add]
{foo: str}.ok
{foo: str}.ok?.array
{foo: str}.ok?.str
{foo: str}.str
{foo: str}?.Bar
{foo: str}?.Bar?.String
{foo: str}?.Bar?.[str]
{foo: str}?.String
{foo: str}?.String?.[i]
{foo: str}?.[str]
{foo: str}?.[str]?.greet
{foo: str}?.add
{foo: str}?.add?.add
{foo: str}?.array
{foo: str}?.array?.[i]
{foo: str}?.array?.ok
{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}?.greet?.i
{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: str}?.str?.f64
{foo: sum($env, 1)}
{foo: sum($env, 1.0)}
{foo: sum($env, f64)}
{foo: sum($env, i)}
{foo: sum(array), foo: list}
{foo: sum(array), foo: ok}
{foo: sum(array)}
{foo: sum(array)}.String
{foo: sum(array)}.foo
{foo: sum(array)}?.array
{foo: sum(array, #)}
{foo: sum(array, 1.0)}
{foo: sum(list, 1)}
{foo: sum(list, 1.0)}
{foo: take(list, 1)}
{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(false)}.list
{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(foo?.Bar)}
{foo: trim(str)}
{foo: trimPrefix(foo.Bar)}
{foo: trimPrefix(str)}
{foo: trimSuffix(str)}
{foo: trimSuffix(string(nil))}
{foo: true != $env}
{foo: true != false}
{foo: true != nil}
{foo: true != ok}
{foo: true && $env}
{foo: true && true}
{foo: true && true}.String
{foo: true == $env}
{foo: true == false}
{foo: true == nil, foo: i}
{foo: true == nil}
{foo: true == true}
{foo: true ? 1 : 1.0}
{foo: true ? add : i}
{foo: true ? false : greet}
{foo: true ? list : 1}
{foo: true ? ok : 0}
{foo: true ?: foo}
{foo: true ?? 0}
{foo: true ?? 1}
{foo: true ?? f64}
{foo: true ?? foo}
{foo: true ?? greet}
{foo: true ?? nil}
{foo: true ?? str}
{foo: true and ok}
{foo: true or $env}
{foo: true or $env}?.[str]
{foo: true or false}
{foo: true or ok}
{foo: true or true}
{foo: true || $env}
{foo: true || false}
{foo: true || ok}
{foo: true || true}
{foo: true, foo: $env, foo: 1.0}?.greet
{foo: true, foo: $env} ?? foo.Bar
{foo: true, foo: $env}.array
{foo: true, foo: $env}.f64
{foo: true, foo: $env}.greet
{foo: true, foo: $env}.i
{foo: true, foo: $env}.list
{foo: true, foo: $env}?.String
{foo: true, foo: $env}?.[str]
{foo: true, foo: $env}?.add
{foo: true, foo: $env}?.array
{foo: true, foo: $env}?.foo
{foo: true, foo: $env}?.i
{foo: true, foo: $env}?.list
{foo: true, foo: $env}?.ok
{foo: true, foo: 0} != array ?? ok
{foo: true, foo: 0}.$env?.[i]?.f64?.[add]
{foo: true, foo: 0}.foo
{foo: true, foo: 0}.str
{foo: true, foo: 0}?.array
{foo: true, foo: 0}?.i
{foo: true, foo: 1.0, foo: nil}.list
{foo: true, foo: 1.0, foo: true}?.[str]
{foo: true, foo: 1.0}.Bar
{foo: true, foo: 1.0}.array
{foo: true, foo: 1.0}.i
{foo: true, foo: 1.0}.i?.[str].add
{foo: true, foo: 1.0}.ok
{foo: true, foo: 1.0}?.String
{foo: true, foo: 1.0}?.f64
{foo: true, foo: 1.0}?.i
{foo: true, foo: 1.0}?.list
{foo: true, foo: 1.0}?.ok
{foo: true, foo: 1.0}?.str
{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: 1}?.ok
{foo: true, foo: 1}?.str
{foo: true, foo: add}.add
{foo: true, foo: add}.f64
{foo: true, foo: add}.i
{foo: true, foo: add}?.Bar
{foo: true, foo: add}?.String
{foo: true, foo: add}?.array
{foo: true, foo: add}?.f64
{foo: true, foo: add}?.greet
{foo: true, foo: add}?.str
{foo: true, foo: array}.add
{foo: true, foo: array}.f64
{foo: true, foo: array}.i
{foo: true, foo: array}?.add
{foo: true, foo: array}?.greet
{foo: true, foo: f64}.greet
{foo: true, foo: f64}.i
{foo: true, foo: f64}.ok
{foo: true, foo: f64}?.foo
{foo: true, foo: false}.Bar
{foo: true, foo: false}.i?.[ok]
{foo: true, foo: false}?.foo
{foo: true, foo: false}?.greet
{foo: true, foo: false}?.i
{foo: true, foo: foo}.Bar
{foo: true, foo: foo}.String
{foo: true, foo: foo}.array
{foo: true, foo: foo}.f64
{foo: true, foo: foo}.greet
{foo: true, foo: foo}.i
{foo: true, foo: foo}.ok
{foo: true, foo: foo}.str?.list()
{foo: true, foo: foo}?.Bar
{foo: true, foo: foo}?.String
{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}.array
{foo: true, foo: greet}.f64
{foo: true, foo: greet}.foo
{foo: true, foo: greet}?.[str]
{foo: true, foo: greet}?.f64
{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}?.[str]?.add
{foo: true, foo: i}?.array
{foo: true, foo: i}?.list
{foo: true, foo: list}.String
{foo: true, foo: list}.String?.Bar
{foo: true, foo: list}.array
{foo: true, foo: list}?.Bar
{foo: true, foo: list}?.[str]
{foo: true, foo: list}?.f64
{foo: true, foo: list}?.foo
{foo: true, foo: list}?.greet
{foo: true, foo: nil, foo: i}?.i?.i
{foo: true, foo: nil, foo: list}?.[str]
{foo: true, foo: nil}.add
{foo: true, foo: nil}?.Bar
{foo: true, foo: nil}?.String
{foo: true, foo: nil}?.add
{foo: true, foo: nil}?.greet
{foo: true, foo: ok, foo: 1.0}?.greet
{foo: true, foo: ok}.Bar
{foo: true, foo: ok}.add
{foo: true, foo: ok}.array
{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}.greet
{foo: true, foo: str}.list
{foo: true, foo: str}.ok
{foo: true, foo: str}.str
{foo: true, foo: str}?.array
{foo: true, foo: str}?.array?.add
{foo: true, foo: str}?.f64
{foo: true, foo: str}?.greet
{foo: true, foo: str}?.ok
{foo: true, foo: true, foo: greet}?.f64
{foo: true, foo: true}.add
{foo: true, foo: true}.foo
{foo: true, foo: true}.i
{foo: true, foo: true}.list
{foo: true, foo: true}?.array
{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}.f64?.array.i()
{foo: true}.false == add
{foo: true}.foo
{foo: true}.foo ? ok : nil
{foo: true}.foobar
{foo: true}.greet
{foo: true}.i
{foo: true}.i == i
{foo: true}.list
{foo: true}.list?.[str]
{foo: true}.ok
{foo: true}.ok?.add
{foo: true}.ok?.array
{foo: true}.str
{foo: true}.str?.[list]
{foo: true}.str?.ok
{foo: true}?.$env ?? i
{foo: true}?.Bar
{foo: true}?.Bar?.[list]
{foo: true}?.Bar?.f64
{foo: true}?.Bar?.list
{foo: true}?.String
{foo: true}?.String?.[greet]
{foo: true}?.String?.[ok]
{foo: true}?.[str]
{foo: true}?.[str]?.foo?.[greet]
{foo: true}?.add
{foo: true}?.add?.[add]
{foo: true}?.add?.[foo]
{foo: true}?.add?.ok
{foo: true}?.array
{foo: true}?.array?.[ok]
{foo: true}?.f64
{foo: true}?.f64?.[add]
{foo: true}?.foo
{foo: true}?.foobar?.i()
{foo: true}?.greet
{foo: true}?.greet?.[greet]
{foo: true}?.greet?.foo
{foo: true}?.greet?.greet
{foo: true}?.i
{foo: true}?.i?.Bar
{foo: true}?.i?.[ok]
{foo: true}?.i?.foo
{foo: true}?.list
{foo: true}?.list?.[greet]
{foo: true}?.ok
{foo: true}?.ok?.Bar
{foo: true}?.ok?.[greet]?.list
{foo: true}?.str
{foo: true}?.str?.[f64]
{foo: true}?.str?.greet
{foo: true}?.str?.i
{foo: type($env)}
{foo: type(0)}
{foo: type(1)}
{foo: type(1.0)}
{foo: type(1.0)}?.[str]
{foo: type(1.0)}?.f64
{foo: type(add)}
{foo: type(array)}
{foo: type(f64)}
{foo: type(false)}
{foo: type(foo), foo: add}
{foo: type(foo), foo: f64}
{foo: type(foo)}
{foo: type(greet)}
{foo: type(i)}
{foo: type(list)}
{foo: type(nil)}
{foo: type(ok), foo: add}
{foo: type(ok)}
{foo: type(str)}
{foo: type(true)}
{foo: uniq(array)}
{foo: uniq(list)}
{foo: upper(str)}
{foo: values($env)}
{foo: values($env)}.String
{foo: {foo: $env, foo: i}}
{foo: {foo: $env}}
{foo: {foo: $env}}?.i
{foo: {foo: 0, foo: $env}}
{foo: {foo: 0, foo: 1.0}}
{foo: {foo: 0, foo: foo, foo: $env}}
{foo: {foo: 0, foo: foo}}
{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: 1.0, foo: foo}}
{foo: {foo: 1.0, foo: true}}
{foo: {foo: 1.0}}
{foo: {foo: 1}}
{foo: {foo: add, foo: $env}}
{foo: {foo: add, foo: foo}}
{foo: {foo: add, foo: greet}}
{foo: {foo: add}}
{foo: {foo: array, foo: 1.0}}
{foo: {foo: array}}
{foo: {foo: f64, foo: $env}}
{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: foo}}
{foo: {foo: foo}, foo: $env?.greet}
{foo: {foo: foo}?.String}
{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: f64}
{foo: {foo: list}.String}
{foo: {foo: list}}
{foo: {foo: list}}?.String
{foo: {foo: nil, foo: $env}}
{foo: {foo: nil, foo: 1}}
{foo: {foo: nil, foo: foo}}
{foo: {foo: nil}, foo: $env?.String}
{foo: {foo: nil}}
{foo: {foo: ok, foo: nil}}
{foo: {foo: ok, foo: true}}
{foo: {foo: ok}, foo: ok}
{foo: {foo: ok}?.[str], foo: f64}
{foo: {foo: ok}}
{foo: {foo: ok}}.list
{foo: {foo: ok}}?.i
{foo: {foo: str}}
{foo: {foo: true, foo: foo}}
{foo: {foo: true}}
