builtin.lua

assert(bool({}, (abs(merge_kwargs({}, {}), 10) == 10)))
assert(bool({}, (abs(merge_kwargs({}, {}), 0) == 0)))
assert(bool({}, (abs(merge_kwargs({}, {}), (-10)) == 10)))
assert(bool({}, (abs(merge_kwargs({}, {}), 1.07) == 1.07)))
assert(bool({}, (abs(merge_kwargs({}, {}), (-0.52)) == 0.52)))
assert(bool({}, (all(merge_kwargs({}, {}), list({}, {_to_null()})) == true)))
assert(bool({}, (all(merge_kwargs({}, {}), list({}, {_to_null(1, 2)})) == true)))
assert(bool({}, (all(merge_kwargs({}, {}), list({}, {_to_null(0, 1, 2)})) == false)))
assert(bool({}, (all(merge_kwargs({}, {}), list({}, {_to_null(0, 0)})) == false)))
assert(bool({}, (any(merge_kwargs({}, {}), list({}, {_to_null()})) == false)))
assert(bool({}, (any(merge_kwargs({}, {}), list({}, {_to_null(1, 2)})) == true)))
assert(bool({}, (any(merge_kwargs({}, {}), list({}, {_to_null(0, 1, 2)})) == true)))
assert(bool({}, (any(merge_kwargs({}, {}), list({}, {_to_null(0, 0)})) == false)))
assert(bool({}, (bin(merge_kwargs({}, {}), 0) == "0b0")))
assert(bool({}, (bin(merge_kwargs({}, {}), 10) == "0b1010")))
assert(bool({}, (bin(merge_kwargs({}, {}), 100) == "0b1100100")))
assert(bool({}, (bin(merge_kwargs({}, {}), 1000) == "0b1111101000")))
assert(bool({}, bool(merge_kwargs({}, {}), true)))
assert(bool({}, bool(merge_kwargs({}, {}), 1)))
assert(bool({}, bool(merge_kwargs({}, {}), "abc")))
assert(bool({}, bool(merge_kwargs({}, {}), list({}, {_to_null(1, 2)}))))
assert(bool({}, not bool({}, bool(merge_kwargs({}, {}), false))))
assert(bool({}, not bool({}, bool(merge_kwargs({}, {}), list({}, {_to_null()})))))
assert(bool({}, not bool({}, bool(merge_kwargs({}, {}), ""))))
assert(bool({}, not bool({}, bool(merge_kwargs({}, {}), 0))))
assert(bool({}, callable(merge_kwargs({}, {}), abs)))
assert(bool({}, callable(merge_kwargs({}, {}), function(kvs, x) x = get_posarg(kvs, 'x', x, nil, 'lambda'); return x end)))
assert(bool({}, not bool({}, callable(merge_kwargs({}, {}), 0))))
assert(bool({}, not bool({}, callable(merge_kwargs({}, {}), "abc"))))
assert(bool({}, not bool({}, callable(merge_kwargs({}, {}), list({}, {_to_null()})))))
local d = dict(merge_kwargs({}, {}))
assert(bool({}, (len(merge_kwargs({}, {}), d) == 0)))
d[_to_null(1)] = "a"
d[_to_null(2)] = "b"
local e = dict(merge_kwargs({}, {}), d)
assert(bool({}, (e[_to_null(1)] == "a")))
assert(bool({}, (e[_to_null(2)] == "b")))
local d, m = divmod(merge_kwargs({}, {}), 10, 3)
assert(bool({}, ((d == 3) and (m == 1))))
d, m = divmod(merge_kwargs({}, {}), (-10), 3)
assert(bool({}, ((d == (-4)) and (m == 2))))
d, m = divmod(merge_kwargs({}, {}), 10, (-3))
assert(bool({}, ((d == (-4)) and (m == (-2)))))
d, m = divmod(merge_kwargs({}, {}), (-10), (-3))
assert(bool({}, ((d == 3) and (m == (-1)))))
local l = list({}, {_to_null(0, 1, 2, 3, 4)})
for _, i, n in enumerate(merge_kwargs({}, {}), l) do
    assert(bool({}, (i == n)))
    ::loop_label_1::
end
l = list({}, {_to_null(0, 1, 2, 3, 4, 5)})
local f = list(merge_kwargs({}, {}), filter(merge_kwargs({}, {}), nil, l))
assert(bool({}, (len(merge_kwargs({}, {}), f) == 5)))
assert(bool({}, (f[_to_null(0)] == 1)))
assert(bool({}, (f[_to_null(4)] == 5)))
f = list(merge_kwargs({}, {}), filter(merge_kwargs({}, {}), function(kvs, n) n = get_posarg(kvs, 'n', n, nil, 'lambda'); return ((mod_operator(n, 2)) == 0) end, l))
assert(bool({}, (len(merge_kwargs({}, {}), f) == 3)))
assert(bool({}, (f[_to_null(0)] == 0)))
assert(bool({}, (f[_to_null(1)] == 2)))
assert(bool({}, (f[_to_null(2)] == 4)))
d = dict({}, {[_to_null(0)] = _to_null("a"), [_to_null("x")] = _to_null("y"), [_to_null("")] = _to_null("space")})
f = list(merge_kwargs({}, {}), filter(merge_kwargs({}, {}), nil, d))
assert(bool({}, (len(merge_kwargs({}, {}), f) == 1)))
assert(bool({}, (f[_to_null(0)] == "x")))
assert(bool({}, (float(merge_kwargs({}, {}), 10) == 10.0)))
assert(bool({}, (float(merge_kwargs({}, {}), 10.4) == 10.4)))
assert(bool({}, (float(merge_kwargs({}, {}), "12") == 12.0)))
assert(bool({}, (float(merge_kwargs({}, {}), "10.8") == 10.8)))
assert(bool({}, (hex(merge_kwargs({}, {}), 0) == "0x0")))
assert(bool({}, (hex(merge_kwargs({}, {}), 10) == "0xa")))
assert(bool({}, (hex(merge_kwargs({}, {}), 100) == "0x64")))
assert(bool({}, (hex(merge_kwargs({}, {}), 1000) == "0x3e8")))
assert(bool({}, (hex(merge_kwargs({}, {}), 10000) == "0x2710")))
assert(bool({}, (hex(merge_kwargs({}, {}), 100000) == "0x186a0")))
assert(bool({}, (int(merge_kwargs({}, {})) == 0)))
assert(bool({}, (int(merge_kwargs({}, {}), 10) == 10)))
assert(bool({}, (int(merge_kwargs({}, {}), 10.5) == 10)))
assert(bool({}, (int(merge_kwargs({}, {}), (-10.5)) == (-10))))
assert(bool({}, (int(merge_kwargs({}, {}), "10", 10) == 10)))
assert(bool({}, (int(merge_kwargs({}, {}), "10", 16) == 16)))
assert(bool({}, (int(merge_kwargs({}, {}), " 10", 10) == 10)))
assert(bool({}, (int(merge_kwargs({}, {}), "10 ", 16) == 16)))
assert(bool({}, (int(merge_kwargs({}, {}), "0b10", 0) == 2)))
assert(bool({}, (int(merge_kwargs({}, {}), "0x10", 0) == 16)))
assert(bool({}, (int(merge_kwargs({}, {}), "-0b10", 0) == (-2))))
assert(bool({}, (int(merge_kwargs({}, {}), "-0x10", 0) == (-16))))
assert(bool({}, (len(merge_kwargs({}, {}), "") == 0)))
assert(bool({}, (len(merge_kwargs({}, {}), "abcd") == 4)))
assert(bool({}, (len(merge_kwargs({}, {}), list({}, {_to_null()})) == 0)))
assert(bool({}, (len(merge_kwargs({}, {}), list({}, {_to_null(1, 2, 3)})) == 3)))
assert(bool({}, (len(merge_kwargs({}, {}), dict({}, {})) == 0)))
assert(bool({}, (len(merge_kwargs({}, {}), dict({}, {[_to_null(0)] = _to_null(0), [_to_null("a")] = _to_null("z")})) == 2)))
assert(bool({}, (len(merge_kwargs({}, {}), list(merge_kwargs({}, {}))) == 0)))
l = list(merge_kwargs({}, {}), list({}, {_to_null(1, 2, 3)}))
assert(bool({}, (len(merge_kwargs({}, {}), l) == 3)))
assert(bool({}, (l[_to_null(0)] == 1)))
assert(bool({}, (l[_to_null(1)] == 2)))
assert(bool({}, (l[_to_null(2)] == 3)))
l = list({}, {_to_null(0, 1, 2, 3, 4)})
local m = list(merge_kwargs({}, {}), map(merge_kwargs({}, {}), function(kvs, x) x = get_posarg(kvs, 'x', x, nil, 'lambda'); return (math.pow(x, 2)) end, l))
assert(bool({}, (len(merge_kwargs({}, {}), m) == 5)))
assert(bool({}, (m[_to_null(0)] == 0)))
assert(bool({}, (m[_to_null(1)] == 1)))
assert(bool({}, (m[_to_null(2)] == 4)))
assert(bool({}, (m[_to_null(3)] == 9)))
assert(bool({}, (m[_to_null(4)] == 16)))
local n = list(merge_kwargs({}, {}), map(merge_kwargs({}, {}), function(kvs, x, y) x = get_posarg(kvs, 'x', x, nil, 'lambda'); y = get_posarg(kvs, 'y', y, nil, 'lambda'); return (x + y) end, l, m))
assert(bool({}, (len(merge_kwargs({}, {}), n) == 5)))
assert(bool({}, (n[_to_null(0)] == 0)))
assert(bool({}, (n[_to_null(1)] == 2)))
assert(bool({}, (n[_to_null(2)] == 6)))
assert(bool({}, (n[_to_null(3)] == 12)))
assert(bool({}, (n[_to_null(4)] == 20)))
l = list({}, {_to_null(1, 2, 3, 4, 5)})
assert(bool({}, (max(merge_kwargs({}, {}), l) == 5)))
assert(bool({}, (max(merge_kwargs({}, {}), 1, 2, 3, 4, 5) == 5)))
l = list({}, {_to_null(1, 2, 3, 4, 5)})
assert(bool({}, (min(merge_kwargs({}, {}), l) == 1)))
assert(bool({}, (min(merge_kwargs({}, {}), 1, 2, 3, 4, 5) == 1)))
assert(bool({}, (oct(merge_kwargs({}, {}), 0) == "0o0")))
assert(bool({}, (oct(merge_kwargs({}, {}), 10) == "0o12")))
assert(bool({}, (oct(merge_kwargs({}, {}), 100) == "0o144")))
assert(bool({}, (oct(merge_kwargs({}, {}), 1000) == "0o1750")))
assert(bool({}, (oct(merge_kwargs({}, {}), 10000) == "0o23420")))
assert(bool({}, (pow(merge_kwargs({}, {}), 2, 10) == 1024)))
assert(bool({}, (pow(merge_kwargs({}, {}), 2, 9, 3) == 2)))
--[[
a = 10
b = 20
c = 'message'

print()
print(a)
print(a, b)
print(a, b, c)
]]
l = (function() local result = list({}, {}) for _, i in range(merge_kwargs({}, {}), 10) do result.append({}, i) end return result end)()
assert(bool({}, (len(merge_kwargs({}, {}), l) == 10)))
assert(bool({}, (l[_to_null(0)] == 0)))
assert(bool({}, (l[_to_null(9)] == 9)))
l = (function() local result = list({}, {}) for _, i in range(merge_kwargs({}, {}), 1, 5) do result.append({}, i) end return result end)()
assert(bool({}, (len(merge_kwargs({}, {}), l) == 4)))
assert(bool({}, (l[_to_null(0)] == 1)))
assert(bool({}, (l[_to_null(1)] == 2)))
assert(bool({}, (l[_to_null(2)] == 3)))
assert(bool({}, (l[_to_null(3)] == 4)))
l = (function() local result = list({}, {}) for _, i in range(merge_kwargs({}, {}), 1, 9, 2) do result.append({}, i) end return result end)()
assert(bool({}, (len(merge_kwargs({}, {}), l) == 4)))
assert(bool({}, (l[_to_null(0)] == 1)))
assert(bool({}, (l[_to_null(1)] == 3)))
assert(bool({}, (l[_to_null(2)] == 5)))
assert(bool({}, (l[_to_null(3)] == 7)))
l = list({}, {_to_null(3, 1, 4, 1, 5, 9)})
local rl = list(merge_kwargs({}, {}), reversed(merge_kwargs({}, {}), l))
assert(bool({}, (rl[_to_null(0)] == 9)))
assert(bool({}, (rl[_to_null(1)] == 5)))
assert(bool({}, (rl[_to_null(2)] == 1)))
assert(bool({}, (rl[_to_null(3)] == 4)))
assert(bool({}, (rl[_to_null(4)] == 1)))
assert(bool({}, (rl[_to_null(5)] == 3)))
assert(bool({}, (round(merge_kwargs({}, {}), 10) == 10)))
assert(bool({}, (round(merge_kwargs({}, {}), 10, 0) == 10)))
assert(bool({}, (round(merge_kwargs({}, {}), 10, 1) == 10)))
assert(bool({}, (round(merge_kwargs({}, {}), 10, 2) == 10)))
assert(bool({}, (round(merge_kwargs({}, {}), 10, (-1)) == 10)))
assert(bool({}, (round(merge_kwargs({}, {}), 10, (-2)) == 0)))
assert(bool({}, (round(merge_kwargs({}, {}), 10.49, 0) == 10)))
assert(bool({}, (round(merge_kwargs({}, {}), 10.51, 0) == 11)))
assert(bool({}, (round(merge_kwargs({}, {}), 10.49, 1) == 10.5)))
assert(bool({}, (round(merge_kwargs({}, {}), 10.51, 1) == 10.5)))
local s = slice(merge_kwargs({}, {}), 4)
assert(bool({}, (s.start == nil)))
assert(bool({}, (s.stop == 4)))
assert(bool({}, (s.step == nil)))
s = slice(merge_kwargs({}, {}), 1, 3)
assert(bool({}, (s.start == 1)))
assert(bool({}, (s.stop == 3)))
assert(bool({}, (s.step == nil)))
s = slice(merge_kwargs({}, {}), 1, 5, 2)
assert(bool({}, (s.start == 1)))
assert(bool({}, (s.stop == 5)))
assert(bool({}, (s.step == 2)))
l = list({}, {_to_null(0, 3, (-2), 5, 6, 9)})
local sl = sorted(merge_kwargs({}, {}), l)
assert(bool({}, (len(merge_kwargs({}, {}), sl) == 6)))
assert(bool({}, (sl[_to_null(0)] == (-2))))
assert(bool({}, (sl[_to_null(1)] == 0)))
assert(bool({}, (sl[_to_null(2)] == 3)))
assert(bool({}, (sl[_to_null(3)] == 5)))
assert(bool({}, (sl[_to_null(4)] == 6)))
assert(bool({}, (sl[_to_null(5)] == 9)))
assert(bool({}, (sum(merge_kwargs({}, {}), list({}, {_to_null(1, 2, 3)})) == 6)))
assert(bool({}, (sum(merge_kwargs({}, {}), list({}, {_to_null()})) == 0)))
assert(bool({}, (sum(merge_kwargs({}, {}), list({}, {_to_null(1, 2, 3)}), 0) == 6)))
assert(bool({}, (sum(merge_kwargs({}, {}), list({}, {_to_null(1, 2, 3)}), 4) == 10)))
local t = tuple(merge_kwargs({}, {}))
assert(bool({}, (len(merge_kwargs({}, {}), t) == 0)))
t = tuple(merge_kwargs({}, {}), list({}, {_to_null(1, 2, 3, 4)}))
assert(bool({}, (t[_to_null(0)] == 1)))
assert(bool({}, (t[_to_null(1)] == 2)))
assert(bool({}, (t[_to_null(2)] == 3)))
assert(bool({}, (t[_to_null(3)] == 4)))
local l1 = list({}, {_to_null(0, 1, 2, 3, 4, 5)})
local l2 = list({}, {_to_null("a", "b", "c")})
local l3 = list({}, {_to_null(3, ".", 1, 4, 1)})
local z = list(merge_kwargs({}, {}), zip(merge_kwargs({}, {}), l1, l2, l3))
assert(bool({}, (z[_to_null(0)][_to_null(0)] == 0)))
assert(bool({}, (z[_to_null(0)][_to_null(1)] == "a")))
assert(bool({}, (z[_to_null(0)][_to_null(2)] == 3)))
assert(bool({}, (z[_to_null(1)][_to_null(0)] == 1)))
assert(bool({}, (z[_to_null(1)][_to_null(1)] == "b")))
assert(bool({}, (z[_to_null(1)][_to_null(2)] == ".")))
assert(bool({}, (z[_to_null(2)][_to_null(0)] == 2)))
assert(bool({}, (z[_to_null(2)][_to_null(1)] == "c")))
assert(bool({}, (z[_to_null(2)][_to_null(2)] == 1)))
return {
    d = d,
    e = e,
    d, m = d, m,
    l = l,
    f = f,
    m = m,
    n = n,
    rl = rl,
    s = s,
    sl = sl,
    t = t,
    l1 = l1,
    l2 = l2,
    l3 = l3,
    z = z,
}