Initial commit, mostly working. Slightly broken.
This commit is contained in:
Bruce Hill
commit
4c584bd2ed
193
game1.moon
Executable file
193
game1.moon
Executable file
@ -0,0 +1,193 @@
|
||||
#!/usr/bin/env moon
|
||||
nomic = require 'nomic'
|
||||
game = nomic()
|
||||
|
||||
|
||||
game\def [[say $str]], (locals)=>
|
||||
with locals
|
||||
print(.str)
|
||||
return nil
|
||||
|
||||
game\def [[return $retval]], (locals)=> locals.retval
|
||||
|
||||
game\def [[do $thunk]], (locals)=>
|
||||
locals.thunk\run(@, locals)
|
||||
|
||||
game\def {[[true]], [[yes]]}, (locals)=> true
|
||||
game\def {[[false]], [[no]]}, (locals)=> false
|
||||
game\def {[[nil]], [[None]], [[nop]]}, (locals)=> nil
|
||||
|
||||
game\run [[say "Hello world!"]]
|
||||
game\run [[
|
||||
say "Hello!"
|
||||
say "World!"
|
||||
]]
|
||||
|
||||
game\def {[[greet]], [[say hello]]}, [[say "Hello!"]]
|
||||
game\run[[greet]]
|
||||
game\run[[say hello]]
|
||||
|
||||
|
||||
game\run [[say (return "returned value")]]
|
||||
|
||||
game\run [[do {say "did"}]]
|
||||
|
||||
game\run [[say 5]]
|
||||
game\run [[say -5]]
|
||||
|
||||
|
||||
game\def [[fart]], [[say "poot"]]
|
||||
game\run [[fart]]
|
||||
game\def [[fart twice]], [[
|
||||
say "poot"
|
||||
say "poot again"
|
||||
]]
|
||||
game\run [[fart twice]]
|
||||
|
||||
game\def [[sum $items]], (locals)=>
|
||||
tot = 0
|
||||
for x in *locals.items do tot += x
|
||||
return tot
|
||||
|
||||
game\run "say [1,2,3]"
|
||||
game\run "sum [1,2,3]"
|
||||
game\run "say (sum [1,2,3])"
|
||||
|
||||
game\def [[print $x]], [[say $x]]
|
||||
game\run [[print "printing variables works"]]
|
||||
|
||||
|
||||
game\def [[you]], (_)=> @you
|
||||
game\run [[you]]
|
||||
game\run [[say (you)]]
|
||||
|
||||
game\def [[five]], [[return 5]]
|
||||
game\run [[say (five)]]
|
||||
game\def [[$x squared]], (locals)=> locals.x^2
|
||||
game\run [[say ((five) squared)]]
|
||||
|
||||
|
||||
game\def [[remember that $key $relation $value]], (locals)=>
|
||||
with locals
|
||||
assert .relation, "no relation!!"
|
||||
if not @relations[.relation] then @relations[.relation] = {}
|
||||
@relations[.relation][.key] = .value
|
||||
|
||||
game\def [[remember that $key $relation]], [[remember that $key $relation (true)]]
|
||||
|
||||
game\def [[forget about $key $relation]], (locals)=>
|
||||
with locals
|
||||
if not @relations[.relation] then @relations[.relation] = {}
|
||||
@relations[.relation][.key] = nil
|
||||
|
||||
game\def [[the value of $key $relation]], (locals)=>
|
||||
with locals
|
||||
return (@relations[.relation] or {})[.key]
|
||||
|
||||
game\def [[it is true that $key $relation $value]], [[return ((the value of $key $relation) == $value)]]
|
||||
|
||||
game\def [[it is true that $key $relation]], [[return ((the value of $key $relation) == (true))]]
|
||||
|
||||
|
||||
game\run [[remember that "socrates" "is mortal"]]
|
||||
game\run [[say (the value of "socrates" "is mortal")]]
|
||||
|
||||
game\def [[$x == $y]], (locals)=>
|
||||
with locals
|
||||
print("testing equality of #{.x} and #{.y}")
|
||||
if type(.x) != type(.y)
|
||||
return false
|
||||
if type(.x) == 'table'
|
||||
for k,v in pairs(.x)
|
||||
if .y[k] != v
|
||||
return false
|
||||
for k,v in pairs(.y)
|
||||
if .x[k] != v
|
||||
return false
|
||||
return true
|
||||
else
|
||||
return .x == .y
|
||||
|
||||
game\def [[not $x]], (locals)=> not locals.x
|
||||
|
||||
game\def [[$x != $y]], [[return (not (x == y))]]
|
||||
|
||||
game\def [[$x < $y]], (locals)=> locals.x < locals.y
|
||||
|
||||
game\def [[$x <= $y]], (locals)=> locals.x <= locals.y
|
||||
|
||||
game\def [[$x > $y]], (locals)=> locals.x > locals.y
|
||||
|
||||
game\def [[$x >= $y]], (locals)=> locals.x >= locals.y
|
||||
|
||||
-- TODO: the rest of the comparisons
|
||||
|
||||
game\def [[if $condition then $body else $else_body]], (locals)=>
|
||||
with locals
|
||||
if .condition
|
||||
return .body\run(@, locals)
|
||||
else return .else_body\run(@, locals)
|
||||
|
||||
game\def [[if $condition then $body]], [[if $condition then $body else {}]]
|
||||
game\def [[when $condition do $body]], [[if $condition then $body else {}]]
|
||||
|
||||
game\def [[all keys where $relation is $value]], (locals)=>
|
||||
with locals
|
||||
result = {}
|
||||
for k,v in pairs(@relations[.relation] or {})
|
||||
if v == .value
|
||||
table.insert(result, k)
|
||||
return result
|
||||
|
||||
game\run [[if (1 == 1) then {say "Affirmative"} else {say "Negatory"}]]
|
||||
game\run [[if (1 == 2) then {say "Affirmative"} else {say "Negatory"}]]
|
||||
game\run [[if (1 == 2) then {say "Affirmative"}]]
|
||||
|
||||
game\run [[say (if (1 == 1) then {return "Ternary yes"} else {return "Ternary no"})]]
|
||||
|
||||
game\def [[$who is a member]], [[return (it is true that $who "is a member")]]
|
||||
game\def [[you are a member]], [[return ((you) is a member)]]
|
||||
game\run [[say (you are a member)]]
|
||||
error("done")
|
||||
|
||||
game\run [[
|
||||
if (you are a member) then {say "youre a member!"} else {say "youre not a member"}
|
||||
]]
|
||||
|
||||
|
||||
|
||||
|
||||
[[
|
||||
def: $who is a member
|
||||
return it is true that $who "is a member"
|
||||
|
||||
def: you are a member
|
||||
return (you) is a member
|
||||
|
||||
def: members
|
||||
alias: all members
|
||||
return all keys where "is a member" is "yes"
|
||||
|
||||
def: let $someone join
|
||||
if (you are a member) then {
|
||||
remember that $someone "is a member"
|
||||
}
|
||||
|
||||
def: propose $def
|
||||
if (you are a member) then {
|
||||
remember that $def "is pending"
|
||||
vote yes on $def
|
||||
}
|
||||
|
||||
def: make $voter vote yes on $def
|
||||
alias: make $voter approve $def
|
||||
remember $def "is approved by" $voter
|
||||
if ((all members) == (all $def "is approved by" ?)) then {
|
||||
forget $def "is approved by" ?
|
||||
add def $def
|
||||
}
|
||||
|
||||
def: vote yes on $def
|
||||
make (you) vote yes on $def
|
||||
|
||||
]]
|
||||
169
nomic.moon
Normal file
169
nomic.moon
Normal file
@ -0,0 +1,169 @@
|
||||
re = require 're'
|
||||
lpeg = require 'lpeg'
|
||||
moon = require 'moon'
|
||||
type = moon.type
|
||||
|
||||
export __DEBUG__
|
||||
|
||||
invocation_def = [[
|
||||
name <- {| {chunk} (" " {chunk})* |} -> semicolonify
|
||||
chunk <- ({"$"} %S+) / ({%S+})
|
||||
]]
|
||||
invocation_def = re.compile(invocation_def, {semicolonify: (bits) -> table.concat(bits, ";")})
|
||||
|
||||
|
||||
as_value = (x, globals, locals)->
|
||||
assert (globals and locals), "Shit's fucked"
|
||||
if type(x) == 'number' or type(x) == 'string' or type(x) == 'table'
|
||||
return x
|
||||
ret = x\as_value globals, locals
|
||||
return ret
|
||||
|
||||
class Var
|
||||
new:(@name)=>
|
||||
as_value:(globals, locals)=>
|
||||
if __DEBUG__
|
||||
print("Looking up variable #{@name} = #{locals[@name]}")
|
||||
if locals[@name] == nil
|
||||
print("LOCALS:")
|
||||
for k,v in pairs locals
|
||||
print(" #{k} = #{v}")
|
||||
print("GLOBALS:")
|
||||
for k,v in pairs globals
|
||||
print(" #{k} = #{v}")
|
||||
error("Could not find #{@name}")
|
||||
locals[@name]
|
||||
__tostring:=> "Var(#{@text})"
|
||||
|
||||
class Word
|
||||
new:(@text)=>
|
||||
__tostring:=> "Word(#{@text})"
|
||||
|
||||
class Action
|
||||
new:(tokens)=>
|
||||
words = [(if type(t) == Word then t.text else "$") for t in *tokens]
|
||||
@name = table.concat(words, ";")
|
||||
if __DEBUG__
|
||||
print("ACTION: #{@name}")
|
||||
for t in *tokens
|
||||
print(" TOKEN: #{t}")
|
||||
@args = [t for t in *tokens when type(t) != Word]
|
||||
|
||||
__tostring:=> "Action(#{@name})"
|
||||
|
||||
as_value:(globals, locals)=>
|
||||
assert((globals and locals), "f'd up")
|
||||
ret = @\run globals, locals
|
||||
return ret
|
||||
|
||||
run:(globals, locals)=>
|
||||
assert((globals and locals), "f'd up")
|
||||
rule = globals.rules[@name]
|
||||
unless rule
|
||||
error("Tried to run rule, but couldn't find: #{@name}")
|
||||
arg_names = rule.arg_names
|
||||
new_locals = {}
|
||||
for i, arg in ipairs(@args)
|
||||
new_locals[arg_names[i]] = as_value(arg, globals, locals)
|
||||
|
||||
ret = rule.fn(globals, new_locals)
|
||||
return ret
|
||||
|
||||
class Thunk
|
||||
new:(@actions)=>
|
||||
if __DEBUG__
|
||||
print("CONSTRUCTING THUNK WITH ACTIONS:")
|
||||
for k,v in pairs @actions
|
||||
print(" #{k} = #{v}")
|
||||
as_value:=>@
|
||||
run:(globals, locals)=>
|
||||
assert((globals and locals), "f'd up")
|
||||
ret = nil
|
||||
for a in *@actions
|
||||
ret = a\run globals,locals
|
||||
return ret
|
||||
__tostring:=>
|
||||
"Thunk(#{table.concat([tostring(a) for a in *@actions], ", ") .. tostring(@actions.returnValue or "") })"
|
||||
|
||||
lingo = [[
|
||||
actions <- {| (%nl " "*)* ((" "*) action ((%nl " "*)+ action)*)? (%nl " "*)* |} -> Thunk
|
||||
action <- {| token (" "+ token)* " "* |} -> Action
|
||||
token <- expression / ({(!"[" [^ {}()$])+} -> Word)
|
||||
expression <- number / string / list / variable / thunk / subexpression
|
||||
number <- ('-'? [0-9]+ ("." [0-9]+)?) -> tonumber
|
||||
string <- ('"' {(("\\" .) / [^"])*} '"') -> tostring
|
||||
list <- {| '[' (expression (',' (' '*) expression)*)? ']' |}
|
||||
variable <- ("$" {%S+}) -> Var
|
||||
subexpression <- "(" action ")"
|
||||
thunk <- ("{" {| actions |} "}") -> Thunk
|
||||
]]
|
||||
defs = {
|
||||
Var: (...)->Var(...)
|
||||
Word: (...)->Word(...)
|
||||
Action: (...)->Action(...)
|
||||
Thunk: (...)->Thunk(...)
|
||||
tostring: tostring
|
||||
tonumber: tonumber
|
||||
}
|
||||
lingo = re.compile lingo, defs
|
||||
|
||||
class Rule
|
||||
new:(invocations, action)=>
|
||||
if type(action) == 'string'
|
||||
@body_str = action
|
||||
thunk = lingo\match action
|
||||
unless thunk
|
||||
error("failed to parse!")
|
||||
@fn = (globals,locals)-> thunk\run(globals, locals)
|
||||
else
|
||||
@body_str = "<lua function>"
|
||||
@fn = action
|
||||
|
||||
eq = (x,y)->
|
||||
if #x != #y then return false
|
||||
for i=1,#x
|
||||
if x[i] != y[i] then return false
|
||||
return true
|
||||
|
||||
@raw_invocations = invocations
|
||||
@invocations = {}
|
||||
for raw_invocation in *invocations
|
||||
name_bits = {}
|
||||
arg_names = {}
|
||||
for chunk in raw_invocation\gmatch("%S+")
|
||||
if chunk\sub(1,1) == "$"
|
||||
table.insert name_bits, "$"
|
||||
table.insert arg_names, chunk\sub(2,-1)
|
||||
else
|
||||
table.insert name_bits, chunk
|
||||
if @arg_names
|
||||
assert(eq(arg_names, @arg_names), "Attempt to use an alias with different variables")
|
||||
else
|
||||
@arg_names = arg_names
|
||||
invocation = table.concat name_bits, ";"
|
||||
table.insert @invocations, invocation
|
||||
|
||||
__tostring:=>
|
||||
"Rule: #{table.concat(@raw_invocations, " | ")} :=\n #{@body_str\gsub("\n","\n ")}"
|
||||
|
||||
|
||||
def = (game, invocation, action)->
|
||||
invocations = if type(invocation) == 'table' then invocation else {invocation}
|
||||
rule = Rule(invocations, action)
|
||||
for invocation in *rule.invocations
|
||||
game.rules[invocation] = rule
|
||||
print rule
|
||||
|
||||
run = (game, str)->
|
||||
print(">> #{str\gsub("\n", "\n.. ")}")
|
||||
thunk = lingo\match str
|
||||
unless thunk
|
||||
error("failed to parse nomic:\n#{str}")
|
||||
game.you = "@spill"
|
||||
ret = thunk\run game, {}
|
||||
if ret != nil
|
||||
print("= #{ret}")
|
||||
return ret
|
||||
|
||||
return ()->
|
||||
{rules:{}, relations:{}, :run, :def}
|
||||
Loading…
Reference in New Issue
Block a user