234 lines
7.1 KiB
Plaintext
234 lines
7.1 KiB
Plaintext
#!/usr/bin/env nomsu -V6.15.13.8
|
|
#
|
|
This file contains code that supports manipulating and using collections like lists
|
|
and dictionaries.
|
|
|
|
use "core/metaprogramming"
|
|
use "core/control_flow"
|
|
use "core/operators"
|
|
|
|
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
|
|
# List functionality:
|
|
test:
|
|
$list = [1, 2, 3, 4, 5]
|
|
$visited = {}
|
|
for $i = $x in $list:
|
|
$visited.$i = (yes)
|
|
assume ($visited == {.1, .2, .3, .4, .5})
|
|
$visited = {}
|
|
for $x in $list:
|
|
$visited.$x = (yes)
|
|
assume ($visited == {.1, .2, .3, .4, .5})
|
|
assume (($list, 2 nd to last) == 4)
|
|
assume (($list, first) == 1)
|
|
assume ($list, has 3)
|
|
assume (($list, index of 3) == 3)
|
|
assume ((size of $list) == 5)
|
|
$list, add 6
|
|
assume (($list, last) == 6)
|
|
$list, pop
|
|
assume (($list, last) == 5)
|
|
$list, remove index 1
|
|
assume (($list, first) == 2)
|
|
assume (([1, 2] + [3, 4]) == [1, 2, 3, 4])
|
|
|
|
# Dict functionality
|
|
test:
|
|
$dict = {.x = 1, .y = 2, .z = 3}
|
|
assume (size of $dict) == 3
|
|
assume [: for $k = $v in {.x = 1}: add {.key = $k, .value = $v}] ==
|
|
[{.key = "x", .value = 1}]
|
|
assume ({.x = 1, .y = 1} + {.y = 10, .z = 10}) == {.x = 1, .y = 11, .z = 10}
|
|
assume ({.x = 1, .y = 1} - {.y = 10, .z = 10}) == {.x = 1, .y = -9, .z = -10}
|
|
assume ({.x = 1, .y = 1} | {.y = 10, .z = 10}) == {.x = 1, .y = 1, .z = 10}
|
|
assume ({.x = 1, .y = 1} & {.y = 10, .z = 10}) == {.y = 1}
|
|
assume ({.x = 1, .y = 1} ~ {.y = 10, .z = 10}) == {.x = 1, .z = 10}
|
|
|
|
# Set compliments:
|
|
assume (~{.x}).y
|
|
assume ((~{.x}).x == (nil))
|
|
$sc = (~{.x, .y})
|
|
$sc.y = 99
|
|
|
|
# For now, whether $sc.y == 99 or $sc.y == (yes) is unspecified,
|
|
(but the actual behavior is (yes))
|
|
assume ($sc.y and (not $sc.x))
|
|
assume ($sc == ((~{.x, .y}) | {.y = 99}))
|
|
|
|
# Both sets:
|
|
assume (({.x, .y} & {.y, .z}) == {.y})
|
|
assume (({.x, .y} | {.y, .z}) == {.x, .y, .z})
|
|
assume (({.x, .y} ~ {.y, .z}) == {.z, .x})
|
|
|
|
# Mixed:
|
|
assume (({.x, .y} & (~{.y, .z})) == {.x})
|
|
assume (({.x, .y} | (~{.y, .z})) == (~{.z}))
|
|
assume (({.x, .y} ~ (~{.y, .z})) == (~{.x}))
|
|
|
|
# Mixed reversed:
|
|
assume (((~{.y, .z}) & {.x, .y}) == {.x})
|
|
assume (((~{.y, .z}) | {.x, .y}) == (~{.z}))
|
|
assume (((~{.y, .z}) ~ {.x, .y}) == (~{.x}))
|
|
|
|
# Both set compliments:
|
|
assume (((~{.x, .y}) & (~{.y, .z})) == (~{.x, .y, .z}))
|
|
assume (((~{.x, .y}) | (~{.y, .z})) == (~{.y}))
|
|
assume (((~{.x, .y}) ~ (~{.y, .z})) == {.x, .z})
|
|
|
|
test:
|
|
assume ((entries in {.x = 1}) == [{.key = "x", .value = 1}])
|
|
|
|
(entries in $dict) parses as [
|
|
: for $k = $v in $dict:
|
|
add {.key = $k, .value = $v}
|
|
]
|
|
|
|
test:
|
|
assume ((keys in {.x = 1}) == ["x"])
|
|
|
|
[keys in $dict, keys of $dict] all parse as [: for $k = $v in $dict: add $k]
|
|
test:
|
|
assume ((values in {.x = 1}) == [1])
|
|
[values in $dict, values of $dict] all parse as [: for $k = $v in $dict: add $v]
|
|
|
|
# Metatable stuff
|
|
test:
|
|
$t = {}
|
|
set $t's metatable to {.__tostring = ($ -> "XXX")}
|
|
assume ("\$t" == "XXX")
|
|
|
|
(set $dict's metatable to $metatable) compiles to
|
|
"setmetatable(\($dict as lua expr), \($metatable as lua expr));"
|
|
|
|
[$'s metatable, $'metatable] all compile to "getmetatable(\($ as lua expr))"
|
|
test:
|
|
assume (({} with fallback $ -> ($ + 1)).10 == 11)
|
|
|
|
($dict with fallback $key -> $value) compiles to ("
|
|
(function(d)
|
|
local mt = {}
|
|
for k,v in pairs(getmetatable(d) or {}) do mt[k] = v end
|
|
mt.__index = function(self, \($key as lua expr))
|
|
local value = \($value as lua expr)
|
|
self[\($key as lua expr)] = value
|
|
return value
|
|
end
|
|
return setmetatable(d, mt)
|
|
end)(\($dict as lua expr))
|
|
")
|
|
|
|
# Sorting
|
|
test:
|
|
$x = [3, 1, 2]
|
|
sort $x
|
|
assume ($x == [1, 2, 3])
|
|
sort $x by $ = (- $)
|
|
assume ($x == [3, 2, 1])
|
|
$keys = {.1 = 999, .2 = 0, .3 = 50}
|
|
sort $x by $ = $keys.$
|
|
assume ($x == [2, 3, 1])
|
|
(sort $items) compiles to "table.sort(\($items as lua expr));"
|
|
[sort $items by $item = $key_expr, sort $items by $item -> $key_expr]
|
|
..all parse as
|
|
do:
|
|
$keys = ({} with fallback $item -> $key_expr)
|
|
lua> "table.sort(\$items, function(x,y) return \$keys[x] < \$keys[y] end)"
|
|
|
|
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
|
|
external:
|
|
test:
|
|
assume ((sorted [3, 1, 2]) == [1, 2, 3])
|
|
|
|
[$items sorted, sorted $items] all mean:
|
|
$copy = [: for $ in $items: add $]
|
|
sort $copy
|
|
return $copy
|
|
|
|
[$items sorted by $item = $key, $items sorted by $item -> $key] all parse as
|
|
result of:
|
|
$copy = [: for $ in $items: add $]
|
|
sort $copy by $item = $key
|
|
return $copy
|
|
|
|
test:
|
|
assume ((unique [1, 2, 1, 3, 2, 3]) == [1, 2, 3])
|
|
|
|
(unique $items) means:
|
|
$unique = []
|
|
$seen = {}
|
|
for $ in $items:
|
|
unless $seen.$:
|
|
$unique, add $
|
|
$seen.$ = (yes)
|
|
return $unique
|
|
|
|
# Ranges:
|
|
test:
|
|
$r = (3 to 5)
|
|
assume ($r.2 == 4)
|
|
assume ($r is "a Range")
|
|
assume ((1 to 10, backwards) == (10 to 1 by -1))
|
|
assume ((#(1 to 10 by 2)) == 5)
|
|
$visited = []
|
|
for $ in (1 to 10 by 2):
|
|
$visited, add $
|
|
assume ($visited == [1, 3, 5, 7, 9])
|
|
$r = (1 to 10 by 2)
|
|
$visited = []
|
|
for $ in $r:
|
|
$visited, add $
|
|
assume ($visited == [1, 3, 5, 7, 9])
|
|
$range_mt = {
|
|
.__type = "a Range"
|
|
.__index =
|
|
for ($self's $key):
|
|
if ($key is "a Number"):
|
|
if (($key % 1) != 0):
|
|
return (nil)
|
|
$i = ($self.first + ($key - 1) * $self.step)
|
|
if ($self.step > 0):
|
|
if ($i > $self.last):
|
|
return (nil)
|
|
..else:
|
|
if ($i < $self.last):
|
|
return (nil)
|
|
return $i
|
|
return $range_mt.$key
|
|
|
|
.__len =
|
|
for $self:
|
|
$len = (($self.last - $self.first) / $self.step + 1)
|
|
if ($len < 0):
|
|
$len = 0
|
|
return ($len, rounded down)
|
|
|
|
.__eq =
|
|
for ($self == $other)
|
|
(($self's metatable) == ($other's metatable)) and
|
|
($self.first == $other.first) and
|
|
($self.last == $other.last) and ($self.step == $other.step)
|
|
|
|
.backwards = (for $self ($self.last to $self.first by (- $self.step)))
|
|
.__inext = $(inext)
|
|
.__next = $(inext)
|
|
.as_text =
|
|
for $self:
|
|
if ($self.step == 1):
|
|
return "(\($self.first) to \($self.last))"
|
|
..else:
|
|
return "(\($self.first) to \($self.last) by \($self.step))"
|
|
}
|
|
$range_mt.reversed = $range_mt.backwards
|
|
$range_mt.__unm = $range_mt.backwards
|
|
$range_mt.__tostring = $range_mt.as_text
|
|
$range_mt.as_nomsu = $range_mt.as_text
|
|
set $range_mt's metatable to (nil)
|
|
external:
|
|
($first to $last by $step) means
|
|
setmetatable {.first = $first, .last = $last, .step = $step} $range_mt
|
|
|
|
($first to $last) means
|
|
setmetatable {.first = $first, .last = $last, .step = 1} $range_mt
|