diff --git a/ast/internal/pgen/table.go b/ast/internal/pgen/table.go
index 0666e14..bb3a09a 100644
--- a/ast/internal/pgen/table.go
+++ b/ast/internal/pgen/table.go
@@ -3,146 +3,139 @@
 package pgen
 
 var Table = map[Lookup]Rule{
-	{Term: newTerm("("), NTerm: newNTerm("aexprs")}:         newRule(newNTerm("exprs")),
-	{Term: newTerm("(@"), NTerm: newNTerm("aexprs")}:        newRule(newNTerm("exprs")),
-	{Term: newTerm("(|"), NTerm: newNTerm("aexprs")}:        newRule(newNTerm("exprs")),
-	{Term: newTerm(";"), NTerm: newNTerm("aexprs")}:         newRule(newTerm(";")),
-	{Term: newTerm("["), NTerm: newNTerm("aexprs")}:         newRule(newNTerm("exprs")),
-	{Term: newTerm("id"), NTerm: newNTerm("aexprs")}:        newRule(newNTerm("exprs")),
-	{Term: newTerm("import"), NTerm: newNTerm("aexprs")}:    newRule(newNTerm("exprs")),
-	{Term: newTerm("number"), NTerm: newNTerm("aexprs")}:    newRule(newNTerm("exprs")),
-	{Term: newTerm("string"), NTerm: newNTerm("aexprs")}:    newRule(newNTerm("exprs")),
-	{Term: newTerm("]"), NTerm: newNTerm("aexprs")}:         newRule(newEpsilon()),
-	{Term: newTerm("["), NTerm: newNTerm("argdecl")}:        newRule(newTerm("["), newNTerm("argdecls"), newTerm(";"), newTerm("]")),
-	{Term: newTerm("id"), NTerm: newNTerm("argdecl")}:       newRule(newTerm("id")),
-	{Term: newTerm("["), NTerm: newNTerm("argdecls")}:       newRule(newNTerm("argdecl"), newNTerm("argdecls")),
-	{Term: newTerm("id"), NTerm: newNTerm("argdecls")}:      newRule(newNTerm("argdecl"), newNTerm("argdecls")),
-	{Term: newTerm(";"), NTerm: newNTerm("argdecls")}:       newRule(newEpsilon()),
-	{Term: newTerm("=>"), NTerm: newNTerm("argdecls")}:      newRule(newEpsilon()),
-	{Term: newTerm("("), NTerm: newNTerm("args")}:           newRule(newNTerm("single"), newNTerm("args")),
-	{Term: newTerm("(@"), NTerm: newNTerm("args")}:          newRule(newNTerm("single"), newNTerm("args")),
-	{Term: newTerm("(|"), NTerm: newNTerm("args")}:          newRule(newNTerm("single"), newNTerm("args")),
-	{Term: newTerm("["), NTerm: newNTerm("args")}:           newRule(newNTerm("single"), newNTerm("args")),
-	{Term: newTerm("id"), NTerm: newNTerm("args")}:          newRule(newNTerm("single"), newNTerm("args")),
-	{Term: newTerm("import"), NTerm: newNTerm("args")}:      newRule(newNTerm("single"), newNTerm("args")),
-	{Term: newTerm("number"), NTerm: newNTerm("args")}:      newRule(newNTerm("single"), newNTerm("args")),
-	{Term: newTerm("string"), NTerm: newNTerm("args")}:      newRule(newNTerm("single"), newNTerm("args")),
-	{Term: newTerm("--"), NTerm: newNTerm("args")}:          newRule(newEpsilon()),
-	{Term: newTerm("->"), NTerm: newNTerm("args")}:          newRule(newEpsilon()),
-	{Term: newTerm("-|"), NTerm: newNTerm("args")}:          newRule(newEpsilon()),
-	{Term: newTerm(":"), NTerm: newNTerm("args")}:           newRule(newEpsilon()),
-	{Term: newTerm(";"), NTerm: newNTerm("args")}:           newRule(newEpsilon()),
-	{Term: newTerm("=>"), NTerm: newNTerm("args")}:          newRule(newEpsilon()),
-	{Term: newTerm("{"), NTerm: newNTerm("args")}:           newRule(newEpsilon()),
-	{Term: newTerm("["), NTerm: newNTerm("array")}:          newRule(newTerm("["), newNTerm("aexprs"), newTerm("]")),
-	{Term: newTerm("("), NTerm: newNTerm("cexprs")}:         newRule(newNTerm("expr"), newTerm(";"), newNTerm("cexprs")),
-	{Term: newTerm("(@"), NTerm: newNTerm("cexprs")}:        newRule(newNTerm("expr"), newTerm(";"), newNTerm("cexprs")),
-	{Term: newTerm("(|"), NTerm: newNTerm("cexprs")}:        newRule(newNTerm("expr"), newTerm(";"), newNTerm("cexprs")),
-	{Term: newTerm("["), NTerm: newNTerm("cexprs")}:         newRule(newNTerm("expr"), newTerm(";"), newNTerm("cexprs")),
-	{Term: newTerm("id"), NTerm: newNTerm("cexprs")}:        newRule(newNTerm("expr"), newTerm(";"), newNTerm("cexprs")),
-	{Term: newTerm("import"), NTerm: newNTerm("cexprs")}:    newRule(newNTerm("expr"), newTerm(";"), newNTerm("cexprs")),
-	{Term: newTerm("let"), NTerm: newNTerm("cexprs")}:       newRule(newNTerm("letexpr"), newTerm(";"), newNTerm("cexprs")),
-	{Term: newTerm("number"), NTerm: newNTerm("cexprs")}:    newRule(newNTerm("expr"), newTerm(";"), newNTerm("cexprs")),
-	{Term: newTerm("string"), NTerm: newNTerm("cexprs")}:    newRule(newNTerm("expr"), newTerm(";"), newNTerm("cexprs")),
-	{Term: newTerm(")"), NTerm: newNTerm("cexprs")}:         newRule(newEpsilon()),
-	{Term: newTerm("|)"), NTerm: newNTerm("cexprs")}:        newRule(newEpsilon()),
-	{Term: newEOF(), NTerm: newNTerm("cexprs")}:             newRule(newEpsilon()),
-	{Term: newTerm("--"), NTerm: newNTerm("chain")}:         newRule(newTerm("--"), newNTerm("expr")),
-	{Term: newTerm("->"), NTerm: newNTerm("chain")}:         newRule(newTerm("->"), newNTerm("expr")),
-	{Term: newTerm("-|"), NTerm: newNTerm("chain")}:         newRule(newTerm("-|"), newNTerm("expr")),
-	{Term: newTerm(";"), NTerm: newNTerm("chain")}:          newRule(newEpsilon()),
-	{Term: newTerm("=>"), NTerm: newNTerm("chain")}:         newRule(newEpsilon()),
-	{Term: newTerm("("), NTerm: newNTerm("compound")}:       newRule(newTerm("("), newNTerm("cexprs"), newTerm(")")),
-	{Term: newTerm("(|"), NTerm: newNTerm("compound")}:      newRule(newTerm("(|"), newNTerm("cexprs"), newTerm("|)")),
-	{Term: newTerm("("), NTerm: newNTerm("expr")}:           newRule(newNTerm("single"), newNTerm("args"), newNTerm("switch"), newNTerm("slot"), newNTerm("chain")),
-	{Term: newTerm("(@"), NTerm: newNTerm("expr")}:          newRule(newNTerm("single"), newNTerm("args"), newNTerm("switch"), newNTerm("slot"), newNTerm("chain")),
-	{Term: newTerm("(|"), NTerm: newNTerm("expr")}:          newRule(newNTerm("single"), newNTerm("args"), newNTerm("switch"), newNTerm("slot"), newNTerm("chain")),
-	{Term: newTerm("["), NTerm: newNTerm("expr")}:           newRule(newNTerm("single"), newNTerm("args"), newNTerm("switch"), newNTerm("slot"), newNTerm("chain")),
-	{Term: newTerm("id"), NTerm: newNTerm("expr")}:          newRule(newNTerm("single"), newNTerm("args"), newNTerm("switch"), newNTerm("slot"), newNTerm("chain")),
-	{Term: newTerm("import"), NTerm: newNTerm("expr")}:      newRule(newNTerm("single"), newNTerm("args"), newNTerm("switch"), newNTerm("slot"), newNTerm("chain")),
-	{Term: newTerm("number"), NTerm: newNTerm("expr")}:      newRule(newNTerm("single"), newNTerm("args"), newNTerm("switch"), newNTerm("slot"), newNTerm("chain")),
-	{Term: newTerm("string"), NTerm: newNTerm("expr")}:      newRule(newNTerm("single"), newNTerm("args"), newNTerm("switch"), newNTerm("slot"), newNTerm("chain")),
-	{Term: newTerm("("), NTerm: newNTerm("exprs")}:          newRule(newNTerm("expr"), newTerm(";"), newNTerm("exprs")),
-	{Term: newTerm("(@"), NTerm: newNTerm("exprs")}:         newRule(newNTerm("expr"), newTerm(";"), newNTerm("exprs")),
-	{Term: newTerm("(|"), NTerm: newNTerm("exprs")}:         newRule(newNTerm("expr"), newTerm(";"), newNTerm("exprs")),
-	{Term: newTerm("["), NTerm: newNTerm("exprs")}:          newRule(newNTerm("expr"), newTerm(";"), newNTerm("exprs")),
-	{Term: newTerm("id"), NTerm: newNTerm("exprs")}:         newRule(newNTerm("expr"), newTerm(";"), newNTerm("exprs")),
-	{Term: newTerm("import"), NTerm: newNTerm("exprs")}:     newRule(newNTerm("expr"), newTerm(";"), newNTerm("exprs")),
-	{Term: newTerm("number"), NTerm: newNTerm("exprs")}:     newRule(newNTerm("expr"), newTerm(";"), newNTerm("exprs")),
-	{Term: newTerm("string"), NTerm: newNTerm("exprs")}:     newRule(newNTerm("expr"), newTerm(";"), newNTerm("exprs")),
-	{Term: newTerm("]"), NTerm: newNTerm("exprs")}:          newRule(newEpsilon()),
-	{Term: newTerm("memo"), NTerm: newNTerm("funcmod")}:     newRule(newTerm("memo")),
-	{Term: newTerm("method"), NTerm: newNTerm("funcmod")}:   newRule(newTerm("method")),
-	{Term: newTerm("rev"), NTerm: newNTerm("funcmod")}:      newRule(newTerm("rev")),
-	{Term: newTerm("memo"), NTerm: newNTerm("funcmods")}:    newRule(newNTerm("funcmod"), newNTerm("funcmods")),
-	{Term: newTerm("method"), NTerm: newNTerm("funcmods")}:  newRule(newNTerm("funcmod"), newNTerm("funcmods")),
-	{Term: newTerm("rev"), NTerm: newNTerm("funcmods")}:     newRule(newNTerm("funcmod"), newNTerm("funcmods")),
-	{Term: newTerm("id"), NTerm: newNTerm("funcmods")}:      newRule(newEpsilon()),
-	{Term: newTerm("import"), NTerm: newNTerm("import")}:    newRule(newTerm("import"), newTerm("string")),
-	{Term: newTerm("(@"), NTerm: newNTerm("lambda")}:        newRule(newTerm("(@"), newNTerm("funcmods"), newTerm("id"), newNTerm("argdecls"), newTerm("=>"), newNTerm("cexprs"), newTerm(")")),
-	{Term: newTerm("["), NTerm: newNTerm("letassign")}:      newRule(newNTerm("argdecl"), newTerm("=>"), newNTerm("expr")),
-	{Term: newTerm("id"), NTerm: newNTerm("letassign")}:     newRule(newNTerm("funcmods"), newTerm("id"), newNTerm("argdecls"), newTerm("=>"), newNTerm("expr")),
-	{Term: newTerm("memo"), NTerm: newNTerm("letassign")}:   newRule(newNTerm("funcmods"), newTerm("id"), newNTerm("argdecls"), newTerm("=>"), newNTerm("expr")),
-	{Term: newTerm("method"), NTerm: newNTerm("letassign")}: newRule(newNTerm("funcmods"), newTerm("id"), newNTerm("argdecls"), newTerm("=>"), newNTerm("expr")),
-	{Term: newTerm("rev"), NTerm: newNTerm("letassign")}:    newRule(newNTerm("funcmods"), newTerm("id"), newNTerm("argdecls"), newTerm("=>"), newNTerm("expr")),
-	{Term: newTerm("let"), NTerm: newNTerm("letexpr")}:      newRule(newTerm("let"), newNTerm("letassign")),
-	{Term: newTerm("("), NTerm: newNTerm("script")}:         newRule(newNTerm("cexprs"), newEOF()),
-	{Term: newTerm("(@"), NTerm: newNTerm("script")}:        newRule(newNTerm("cexprs"), newEOF()),
-	{Term: newTerm("(|"), NTerm: newNTerm("script")}:        newRule(newNTerm("cexprs"), newEOF()),
-	{Term: newTerm("["), NTerm: newNTerm("script")}:         newRule(newNTerm("cexprs"), newEOF()),
-	{Term: newTerm("id"), NTerm: newNTerm("script")}:        newRule(newNTerm("cexprs"), newEOF()),
-	{Term: newTerm("import"), NTerm: newNTerm("script")}:    newRule(newNTerm("cexprs"), newEOF()),
-	{Term: newTerm("let"), NTerm: newNTerm("script")}:       newRule(newNTerm("cexprs"), newEOF()),
-	{Term: newTerm("number"), NTerm: newNTerm("script")}:    newRule(newNTerm("cexprs"), newEOF()),
-	{Term: newTerm("string"), NTerm: newNTerm("script")}:    newRule(newNTerm("cexprs"), newEOF()),
-	{Term: newEOF(), NTerm: newNTerm("script")}:             newRule(newNTerm("cexprs"), newEOF()),
-	{Term: newTerm("("), NTerm: newNTerm("single")}:         newRule(newNTerm("subbable")),
-	{Term: newTerm("(@"), NTerm: newNTerm("single")}:        newRule(newNTerm("lambda")),
-	{Term: newTerm("(|"), NTerm: newNTerm("single")}:        newRule(newNTerm("subbable")),
-	{Term: newTerm("["), NTerm: newNTerm("single")}:         newRule(newNTerm("array")),
-	{Term: newTerm("id"), NTerm: newNTerm("single")}:        newRule(newNTerm("subbable")),
-	{Term: newTerm("import"), NTerm: newNTerm("single")}:    newRule(newNTerm("import")),
-	{Term: newTerm("number"), NTerm: newNTerm("single")}:    newRule(newTerm("number")),
-	{Term: newTerm("string"), NTerm: newNTerm("single")}:    newRule(newTerm("string")),
-	{Term: newTerm(":"), NTerm: newNTerm("slot")}:           newRule(newTerm(":"), newNTerm("argdecl")),
-	{Term: newTerm("--"), NTerm: newNTerm("slot")}:          newRule(newEpsilon()),
-	{Term: newTerm("->"), NTerm: newNTerm("slot")}:          newRule(newEpsilon()),
-	{Term: newTerm("-|"), NTerm: newNTerm("slot")}:          newRule(newEpsilon()),
-	{Term: newTerm(";"), NTerm: newNTerm("slot")}:           newRule(newEpsilon()),
-	{Term: newTerm("=>"), NTerm: newNTerm("slot")}:          newRule(newEpsilon()),
-	{Term: newTerm("."), NTerm: newNTerm("sub")}:            newRule(newTerm("."), newNTerm("subbable")),
-	{Term: newTerm("("), NTerm: newNTerm("sub")}:            newRule(newEpsilon()),
-	{Term: newTerm("(@"), NTerm: newNTerm("sub")}:           newRule(newEpsilon()),
-	{Term: newTerm("(|"), NTerm: newNTerm("sub")}:           newRule(newEpsilon()),
-	{Term: newTerm("--"), NTerm: newNTerm("sub")}:           newRule(newEpsilon()),
-	{Term: newTerm("->"), NTerm: newNTerm("sub")}:           newRule(newEpsilon()),
-	{Term: newTerm("-|"), NTerm: newNTerm("sub")}:           newRule(newEpsilon()),
-	{Term: newTerm(":"), NTerm: newNTerm("sub")}:            newRule(newEpsilon()),
-	{Term: newTerm(";"), NTerm: newNTerm("sub")}:            newRule(newEpsilon()),
-	{Term: newTerm("=>"), NTerm: newNTerm("sub")}:           newRule(newEpsilon()),
-	{Term: newTerm("["), NTerm: newNTerm("sub")}:            newRule(newEpsilon()),
-	{Term: newTerm("id"), NTerm: newNTerm("sub")}:           newRule(newEpsilon()),
-	{Term: newTerm("import"), NTerm: newNTerm("sub")}:       newRule(newEpsilon()),
-	{Term: newTerm("number"), NTerm: newNTerm("sub")}:       newRule(newEpsilon()),
-	{Term: newTerm("string"), NTerm: newNTerm("sub")}:       newRule(newEpsilon()),
-	{Term: newTerm("{"), NTerm: newNTerm("sub")}:            newRule(newEpsilon()),
-	{Term: newTerm("("), NTerm: newNTerm("subbable")}:       newRule(newNTerm("compound"), newNTerm("sub")),
-	{Term: newTerm("(|"), NTerm: newNTerm("subbable")}:      newRule(newNTerm("compound"), newNTerm("sub")),
-	{Term: newTerm("id"), NTerm: newNTerm("subbable")}:      newRule(newTerm("id"), newNTerm("sub")),
-	{Term: newTerm("{"), NTerm: newNTerm("switch")}:         newRule(newTerm("{"), newNTerm("switches"), newTerm("}")),
-	{Term: newTerm("--"), NTerm: newNTerm("switch")}:        newRule(newEpsilon()),
-	{Term: newTerm("->"), NTerm: newNTerm("switch")}:        newRule(newEpsilon()),
-	{Term: newTerm("-|"), NTerm: newNTerm("switch")}:        newRule(newEpsilon()),
-	{Term: newTerm(":"), NTerm: newNTerm("switch")}:         newRule(newEpsilon()),
-	{Term: newTerm(";"), NTerm: newNTerm("switch")}:         newRule(newEpsilon()),
-	{Term: newTerm("=>"), NTerm: newNTerm("switch")}:        newRule(newEpsilon()),
-	{Term: newTerm("("), NTerm: newNTerm("switches")}:       newRule(newNTerm("expr"), newTerm("=>"), newNTerm("expr"), newTerm(";"), newNTerm("switches")),
-	{Term: newTerm("(@"), NTerm: newNTerm("switches")}:      newRule(newNTerm("expr"), newTerm("=>"), newNTerm("expr"), newTerm(";"), newNTerm("switches")),
-	{Term: newTerm("(|"), NTerm: newNTerm("switches")}:      newRule(newNTerm("expr"), newTerm("=>"), newNTerm("expr"), newTerm(";"), newNTerm("switches")),
-	{Term: newTerm("["), NTerm: newNTerm("switches")}:       newRule(newNTerm("expr"), newTerm("=>"), newNTerm("expr"), newTerm(";"), newNTerm("switches")),
-	{Term: newTerm("id"), NTerm: newNTerm("switches")}:      newRule(newNTerm("expr"), newTerm("=>"), newNTerm("expr"), newTerm(";"), newNTerm("switches")),
-	{Term: newTerm("import"), NTerm: newNTerm("switches")}:  newRule(newNTerm("expr"), newTerm("=>"), newNTerm("expr"), newTerm(";"), newNTerm("switches")),
-	{Term: newTerm("number"), NTerm: newNTerm("switches")}:  newRule(newNTerm("expr"), newTerm("=>"), newNTerm("expr"), newTerm(";"), newNTerm("switches")),
-	{Term: newTerm("string"), NTerm: newNTerm("switches")}:  newRule(newNTerm("expr"), newTerm("=>"), newNTerm("expr"), newTerm(";"), newNTerm("switches")),
-	{Term: newTerm("}"), NTerm: newNTerm("switches")}:       newRule(newEpsilon()),
+	{Term: newTerm("("), NTerm: newNTerm("aexprs")}:        newRule(newNTerm("exprs")),
+	{Term: newTerm("(@"), NTerm: newNTerm("aexprs")}:       newRule(newNTerm("exprs")),
+	{Term: newTerm("(|"), NTerm: newNTerm("aexprs")}:       newRule(newNTerm("exprs")),
+	{Term: newTerm(";"), NTerm: newNTerm("aexprs")}:        newRule(newTerm(";")),
+	{Term: newTerm("["), NTerm: newNTerm("aexprs")}:        newRule(newNTerm("exprs")),
+	{Term: newTerm("id"), NTerm: newNTerm("aexprs")}:       newRule(newNTerm("exprs")),
+	{Term: newTerm("import"), NTerm: newNTerm("aexprs")}:   newRule(newNTerm("exprs")),
+	{Term: newTerm("number"), NTerm: newNTerm("aexprs")}:   newRule(newNTerm("exprs")),
+	{Term: newTerm("string"), NTerm: newNTerm("aexprs")}:   newRule(newNTerm("exprs")),
+	{Term: newTerm("]"), NTerm: newNTerm("aexprs")}:        newRule(newEpsilon()),
+	{Term: newTerm("["), NTerm: newNTerm("argdecl")}:       newRule(newTerm("["), newNTerm("argdecls"), newTerm(";"), newTerm("]")),
+	{Term: newTerm("id"), NTerm: newNTerm("argdecl")}:      newRule(newTerm("id")),
+	{Term: newTerm("["), NTerm: newNTerm("argdecls")}:      newRule(newNTerm("argdecl"), newNTerm("argdecls")),
+	{Term: newTerm("id"), NTerm: newNTerm("argdecls")}:     newRule(newNTerm("argdecl"), newNTerm("argdecls")),
+	{Term: newTerm(";"), NTerm: newNTerm("argdecls")}:      newRule(newEpsilon()),
+	{Term: newTerm("=>"), NTerm: newNTerm("argdecls")}:     newRule(newEpsilon()),
+	{Term: newTerm("("), NTerm: newNTerm("args")}:          newRule(newNTerm("single"), newNTerm("args")),
+	{Term: newTerm("(@"), NTerm: newNTerm("args")}:         newRule(newNTerm("single"), newNTerm("args")),
+	{Term: newTerm("(|"), NTerm: newNTerm("args")}:         newRule(newNTerm("single"), newNTerm("args")),
+	{Term: newTerm("["), NTerm: newNTerm("args")}:          newRule(newNTerm("single"), newNTerm("args")),
+	{Term: newTerm("id"), NTerm: newNTerm("args")}:         newRule(newNTerm("single"), newNTerm("args")),
+	{Term: newTerm("import"), NTerm: newNTerm("args")}:     newRule(newNTerm("single"), newNTerm("args")),
+	{Term: newTerm("number"), NTerm: newNTerm("args")}:     newRule(newNTerm("single"), newNTerm("args")),
+	{Term: newTerm("string"), NTerm: newNTerm("args")}:     newRule(newNTerm("single"), newNTerm("args")),
+	{Term: newTerm("--"), NTerm: newNTerm("args")}:         newRule(newEpsilon()),
+	{Term: newTerm("->"), NTerm: newNTerm("args")}:         newRule(newEpsilon()),
+	{Term: newTerm("-|"), NTerm: newNTerm("args")}:         newRule(newEpsilon()),
+	{Term: newTerm(":"), NTerm: newNTerm("args")}:          newRule(newEpsilon()),
+	{Term: newTerm(";"), NTerm: newNTerm("args")}:          newRule(newEpsilon()),
+	{Term: newTerm("=>"), NTerm: newNTerm("args")}:         newRule(newEpsilon()),
+	{Term: newTerm("{"), NTerm: newNTerm("args")}:          newRule(newEpsilon()),
+	{Term: newTerm("["), NTerm: newNTerm("array")}:         newRule(newTerm("["), newNTerm("aexprs"), newTerm("]")),
+	{Term: newTerm("("), NTerm: newNTerm("cexprs")}:        newRule(newNTerm("expr"), newTerm(";"), newNTerm("cexprs")),
+	{Term: newTerm("(@"), NTerm: newNTerm("cexprs")}:       newRule(newNTerm("expr"), newTerm(";"), newNTerm("cexprs")),
+	{Term: newTerm("(|"), NTerm: newNTerm("cexprs")}:       newRule(newNTerm("expr"), newTerm(";"), newNTerm("cexprs")),
+	{Term: newTerm("["), NTerm: newNTerm("cexprs")}:        newRule(newNTerm("expr"), newTerm(";"), newNTerm("cexprs")),
+	{Term: newTerm("id"), NTerm: newNTerm("cexprs")}:       newRule(newNTerm("expr"), newTerm(";"), newNTerm("cexprs")),
+	{Term: newTerm("import"), NTerm: newNTerm("cexprs")}:   newRule(newNTerm("expr"), newTerm(";"), newNTerm("cexprs")),
+	{Term: newTerm("let"), NTerm: newNTerm("cexprs")}:      newRule(newNTerm("letexpr"), newTerm(";"), newNTerm("cexprs")),
+	{Term: newTerm("number"), NTerm: newNTerm("cexprs")}:   newRule(newNTerm("expr"), newTerm(";"), newNTerm("cexprs")),
+	{Term: newTerm("string"), NTerm: newNTerm("cexprs")}:   newRule(newNTerm("expr"), newTerm(";"), newNTerm("cexprs")),
+	{Term: newTerm(")"), NTerm: newNTerm("cexprs")}:        newRule(newEpsilon()),
+	{Term: newTerm("|)"), NTerm: newNTerm("cexprs")}:       newRule(newEpsilon()),
+	{Term: newEOF(), NTerm: newNTerm("cexprs")}:            newRule(newEpsilon()),
+	{Term: newTerm("--"), NTerm: newNTerm("chain")}:        newRule(newTerm("--"), newNTerm("expr")),
+	{Term: newTerm("->"), NTerm: newNTerm("chain")}:        newRule(newTerm("->"), newNTerm("expr")),
+	{Term: newTerm("-|"), NTerm: newNTerm("chain")}:        newRule(newTerm("-|"), newNTerm("expr")),
+	{Term: newTerm(";"), NTerm: newNTerm("chain")}:         newRule(newEpsilon()),
+	{Term: newTerm("=>"), NTerm: newNTerm("chain")}:        newRule(newEpsilon()),
+	{Term: newTerm("("), NTerm: newNTerm("compound")}:      newRule(newTerm("("), newNTerm("cexprs"), newTerm(")")),
+	{Term: newTerm("(|"), NTerm: newNTerm("compound")}:     newRule(newTerm("(|"), newNTerm("cexprs"), newTerm("|)")),
+	{Term: newTerm("("), NTerm: newNTerm("expr")}:          newRule(newNTerm("single"), newNTerm("args"), newNTerm("switch"), newNTerm("slot"), newNTerm("chain")),
+	{Term: newTerm("(@"), NTerm: newNTerm("expr")}:         newRule(newNTerm("single"), newNTerm("args"), newNTerm("switch"), newNTerm("slot"), newNTerm("chain")),
+	{Term: newTerm("(|"), NTerm: newNTerm("expr")}:         newRule(newNTerm("single"), newNTerm("args"), newNTerm("switch"), newNTerm("slot"), newNTerm("chain")),
+	{Term: newTerm("["), NTerm: newNTerm("expr")}:          newRule(newNTerm("single"), newNTerm("args"), newNTerm("switch"), newNTerm("slot"), newNTerm("chain")),
+	{Term: newTerm("id"), NTerm: newNTerm("expr")}:         newRule(newNTerm("single"), newNTerm("args"), newNTerm("switch"), newNTerm("slot"), newNTerm("chain")),
+	{Term: newTerm("import"), NTerm: newNTerm("expr")}:     newRule(newNTerm("single"), newNTerm("args"), newNTerm("switch"), newNTerm("slot"), newNTerm("chain")),
+	{Term: newTerm("number"), NTerm: newNTerm("expr")}:     newRule(newNTerm("single"), newNTerm("args"), newNTerm("switch"), newNTerm("slot"), newNTerm("chain")),
+	{Term: newTerm("string"), NTerm: newNTerm("expr")}:     newRule(newNTerm("single"), newNTerm("args"), newNTerm("switch"), newNTerm("slot"), newNTerm("chain")),
+	{Term: newTerm("("), NTerm: newNTerm("exprs")}:         newRule(newNTerm("expr"), newTerm(";"), newNTerm("exprs")),
+	{Term: newTerm("(@"), NTerm: newNTerm("exprs")}:        newRule(newNTerm("expr"), newTerm(";"), newNTerm("exprs")),
+	{Term: newTerm("(|"), NTerm: newNTerm("exprs")}:        newRule(newNTerm("expr"), newTerm(";"), newNTerm("exprs")),
+	{Term: newTerm("["), NTerm: newNTerm("exprs")}:         newRule(newNTerm("expr"), newTerm(";"), newNTerm("exprs")),
+	{Term: newTerm("id"), NTerm: newNTerm("exprs")}:        newRule(newNTerm("expr"), newTerm(";"), newNTerm("exprs")),
+	{Term: newTerm("import"), NTerm: newNTerm("exprs")}:    newRule(newNTerm("expr"), newTerm(";"), newNTerm("exprs")),
+	{Term: newTerm("number"), NTerm: newNTerm("exprs")}:    newRule(newNTerm("expr"), newTerm(";"), newNTerm("exprs")),
+	{Term: newTerm("string"), NTerm: newNTerm("exprs")}:    newRule(newNTerm("expr"), newTerm(";"), newNTerm("exprs")),
+	{Term: newTerm("]"), NTerm: newNTerm("exprs")}:         newRule(newEpsilon()),
+	{Term: newTerm("("), NTerm: newNTerm("funcmods")}:      newRule(newTerm("("), newNTerm("expr"), newTerm(";"), newTerm(")"), newNTerm("funcmods")),
+	{Term: newTerm("id"), NTerm: newNTerm("funcmods")}:     newRule(newEpsilon()),
+	{Term: newTerm("import"), NTerm: newNTerm("import")}:   newRule(newTerm("import"), newTerm("string")),
+	{Term: newTerm("(@"), NTerm: newNTerm("lambda")}:       newRule(newTerm("(@"), newNTerm("funcmods"), newTerm("id"), newNTerm("argdecls"), newTerm("=>"), newNTerm("cexprs"), newTerm(")")),
+	{Term: newTerm("("), NTerm: newNTerm("letassign")}:     newRule(newNTerm("funcmods"), newTerm("id"), newNTerm("argdecls"), newTerm("=>"), newNTerm("expr")),
+	{Term: newTerm("["), NTerm: newNTerm("letassign")}:     newRule(newNTerm("argdecl"), newTerm("=>"), newNTerm("expr")),
+	{Term: newTerm("id"), NTerm: newNTerm("letassign")}:    newRule(newNTerm("funcmods"), newTerm("id"), newNTerm("argdecls"), newTerm("=>"), newNTerm("expr")),
+	{Term: newTerm("let"), NTerm: newNTerm("letexpr")}:     newRule(newTerm("let"), newNTerm("letassign")),
+	{Term: newTerm("("), NTerm: newNTerm("script")}:        newRule(newNTerm("cexprs"), newEOF()),
+	{Term: newTerm("(@"), NTerm: newNTerm("script")}:       newRule(newNTerm("cexprs"), newEOF()),
+	{Term: newTerm("(|"), NTerm: newNTerm("script")}:       newRule(newNTerm("cexprs"), newEOF()),
+	{Term: newTerm("["), NTerm: newNTerm("script")}:        newRule(newNTerm("cexprs"), newEOF()),
+	{Term: newTerm("id"), NTerm: newNTerm("script")}:       newRule(newNTerm("cexprs"), newEOF()),
+	{Term: newTerm("import"), NTerm: newNTerm("script")}:   newRule(newNTerm("cexprs"), newEOF()),
+	{Term: newTerm("let"), NTerm: newNTerm("script")}:      newRule(newNTerm("cexprs"), newEOF()),
+	{Term: newTerm("number"), NTerm: newNTerm("script")}:   newRule(newNTerm("cexprs"), newEOF()),
+	{Term: newTerm("string"), NTerm: newNTerm("script")}:   newRule(newNTerm("cexprs"), newEOF()),
+	{Term: newEOF(), NTerm: newNTerm("script")}:            newRule(newNTerm("cexprs"), newEOF()),
+	{Term: newTerm("("), NTerm: newNTerm("single")}:        newRule(newNTerm("subbable")),
+	{Term: newTerm("(@"), NTerm: newNTerm("single")}:       newRule(newNTerm("lambda")),
+	{Term: newTerm("(|"), NTerm: newNTerm("single")}:       newRule(newNTerm("subbable")),
+	{Term: newTerm("["), NTerm: newNTerm("single")}:        newRule(newNTerm("array")),
+	{Term: newTerm("id"), NTerm: newNTerm("single")}:       newRule(newNTerm("subbable")),
+	{Term: newTerm("import"), NTerm: newNTerm("single")}:   newRule(newNTerm("import")),
+	{Term: newTerm("number"), NTerm: newNTerm("single")}:   newRule(newTerm("number")),
+	{Term: newTerm("string"), NTerm: newNTerm("single")}:   newRule(newTerm("string")),
+	{Term: newTerm(":"), NTerm: newNTerm("slot")}:          newRule(newTerm(":"), newNTerm("argdecl")),
+	{Term: newTerm("--"), NTerm: newNTerm("slot")}:         newRule(newEpsilon()),
+	{Term: newTerm("->"), NTerm: newNTerm("slot")}:         newRule(newEpsilon()),
+	{Term: newTerm("-|"), NTerm: newNTerm("slot")}:         newRule(newEpsilon()),
+	{Term: newTerm(";"), NTerm: newNTerm("slot")}:          newRule(newEpsilon()),
+	{Term: newTerm("=>"), NTerm: newNTerm("slot")}:         newRule(newEpsilon()),
+	{Term: newTerm("."), NTerm: newNTerm("sub")}:           newRule(newTerm("."), newNTerm("subbable")),
+	{Term: newTerm("("), NTerm: newNTerm("sub")}:           newRule(newEpsilon()),
+	{Term: newTerm("(@"), NTerm: newNTerm("sub")}:          newRule(newEpsilon()),
+	{Term: newTerm("(|"), NTerm: newNTerm("sub")}:          newRule(newEpsilon()),
+	{Term: newTerm("--"), NTerm: newNTerm("sub")}:          newRule(newEpsilon()),
+	{Term: newTerm("->"), NTerm: newNTerm("sub")}:          newRule(newEpsilon()),
+	{Term: newTerm("-|"), NTerm: newNTerm("sub")}:          newRule(newEpsilon()),
+	{Term: newTerm(":"), NTerm: newNTerm("sub")}:           newRule(newEpsilon()),
+	{Term: newTerm(";"), NTerm: newNTerm("sub")}:           newRule(newEpsilon()),
+	{Term: newTerm("=>"), NTerm: newNTerm("sub")}:          newRule(newEpsilon()),
+	{Term: newTerm("["), NTerm: newNTerm("sub")}:           newRule(newEpsilon()),
+	{Term: newTerm("id"), NTerm: newNTerm("sub")}:          newRule(newEpsilon()),
+	{Term: newTerm("import"), NTerm: newNTerm("sub")}:      newRule(newEpsilon()),
+	{Term: newTerm("number"), NTerm: newNTerm("sub")}:      newRule(newEpsilon()),
+	{Term: newTerm("string"), NTerm: newNTerm("sub")}:      newRule(newEpsilon()),
+	{Term: newTerm("{"), NTerm: newNTerm("sub")}:           newRule(newEpsilon()),
+	{Term: newTerm("("), NTerm: newNTerm("subbable")}:      newRule(newNTerm("compound"), newNTerm("sub")),
+	{Term: newTerm("(|"), NTerm: newNTerm("subbable")}:     newRule(newNTerm("compound"), newNTerm("sub")),
+	{Term: newTerm("id"), NTerm: newNTerm("subbable")}:     newRule(newTerm("id"), newNTerm("sub")),
+	{Term: newTerm("{"), NTerm: newNTerm("switch")}:        newRule(newTerm("{"), newNTerm("switches"), newTerm("}")),
+	{Term: newTerm("--"), NTerm: newNTerm("switch")}:       newRule(newEpsilon()),
+	{Term: newTerm("->"), NTerm: newNTerm("switch")}:       newRule(newEpsilon()),
+	{Term: newTerm("-|"), NTerm: newNTerm("switch")}:       newRule(newEpsilon()),
+	{Term: newTerm(":"), NTerm: newNTerm("switch")}:        newRule(newEpsilon()),
+	{Term: newTerm(";"), NTerm: newNTerm("switch")}:        newRule(newEpsilon()),
+	{Term: newTerm("=>"), NTerm: newNTerm("switch")}:       newRule(newEpsilon()),
+	{Term: newTerm("("), NTerm: newNTerm("switches")}:      newRule(newNTerm("expr"), newTerm("=>"), newNTerm("expr"), newTerm(";"), newNTerm("switches")),
+	{Term: newTerm("(@"), NTerm: newNTerm("switches")}:     newRule(newNTerm("expr"), newTerm("=>"), newNTerm("expr"), newTerm(";"), newNTerm("switches")),
+	{Term: newTerm("(|"), NTerm: newNTerm("switches")}:     newRule(newNTerm("expr"), newTerm("=>"), newNTerm("expr"), newTerm(";"), newNTerm("switches")),
+	{Term: newTerm("["), NTerm: newNTerm("switches")}:      newRule(newNTerm("expr"), newTerm("=>"), newNTerm("expr"), newTerm(";"), newNTerm("switches")),
+	{Term: newTerm("id"), NTerm: newNTerm("switches")}:     newRule(newNTerm("expr"), newTerm("=>"), newNTerm("expr"), newTerm(";"), newNTerm("switches")),
+	{Term: newTerm("import"), NTerm: newNTerm("switches")}: newRule(newNTerm("expr"), newTerm("=>"), newNTerm("expr"), newTerm(";"), newNTerm("switches")),
+	{Term: newTerm("number"), NTerm: newNTerm("switches")}: newRule(newNTerm("expr"), newTerm("=>"), newNTerm("expr"), newTerm(";"), newNTerm("switches")),
+	{Term: newTerm("string"), NTerm: newNTerm("switches")}: newRule(newNTerm("expr"), newTerm("=>"), newNTerm("expr"), newTerm(";"), newNTerm("switches")),
+	{Term: newTerm("}"), NTerm: newNTerm("switches")}:      newRule(newEpsilon()),
 }
diff --git a/ast/node.go b/ast/node.go
index ad05b39..38984c5 100644
--- a/ast/node.go
+++ b/ast/node.go
@@ -23,7 +23,7 @@ type Term struct {
 	p Node
 }
 
-func (t Term) Parent() Node { // nolint
+func (t Term) Parent() Node {
 	return t.p
 }
 
@@ -32,7 +32,7 @@ func (t Term) Tok() scanner.Token {
 	return t.tok
 }
 
-func (t Term) Children() []Node { // nolint
+func (t Term) Children() []Node {
 	return nil
 }
 
@@ -49,7 +49,7 @@ func (nt NTerm) Name() string {
 	return string(nt.nt)
 }
 
-func (nt NTerm) Parent() Node { // nolint
+func (nt NTerm) Parent() Node {
 	return nt.p
 }
 
@@ -63,7 +63,7 @@ func (nt *NTerm) AddChild(n Node) {
 	nt.c = append(nt.c, n)
 }
 
-func (nt NTerm) Children() []Node { // nolint
+func (nt NTerm) Children() []Node {
 	return nt.c
 }
 
@@ -72,10 +72,10 @@ type Epsilon struct {
 	p Node
 }
 
-func (e Epsilon) Parent() Node { // nolint
+func (e Epsilon) Parent() Node {
 	return e.p
 }
 
-func (e Epsilon) Children() []Node { // nolint
+func (e Epsilon) Children() []Node {
 	return nil
 }
diff --git a/cmd/pgen/grammar.go b/cmd/pgen/grammar.go
index 2e6fbc3..53489d4 100644
--- a/cmd/pgen/grammar.go
+++ b/cmd/pgen/grammar.go
@@ -175,7 +175,7 @@ func (g Grammar) followWithout(nt NTerm, ignore []NTerm) TokenSet {
 						continue
 					}
 
-					for i := i + 1; i < len(rule); i++ { // nolint
+					for i := i + 1; i < len(rule); i++ {
 						ts.AddAll(g.First(rule[i]), rule)
 						if !g.Nullable(rule[i]) {
 							break
diff --git a/cmd/pgen/pgen.go b/cmd/pgen/pgen.go
index a5bd3c2..a80172f 100644
--- a/cmd/pgen/pgen.go
+++ b/cmd/pgen/pgen.go
@@ -37,7 +37,7 @@ func main() {
 
 	out := &formatter{w: os.Stdout}
 	if *output != "" {
-		file, err := os.Create(*output) // nolint
+		file, err := os.Create(*output)
 		if err != nil {
 			fmt.Fprintf(os.Stderr, "Error creating %q: %v", *output, err)
 			os.Exit(1)
diff --git a/cmd/wdte/stdin.go b/cmd/wdte/stdin.go
index f3a43d2..430a26b 100644
--- a/cmd/wdte/stdin.go
+++ b/cmd/wdte/stdin.go
@@ -18,10 +18,6 @@ func printRet(ret wdte.Func) {
 	case error, fmt.Stringer:
 		fmt.Printf(": %v\n", ret)
 		return
-
-	case wdte.GoFunc:
-		fmt.Println(": complex value (GoFunc)")
-		return
 	}
 
 	switch k := reflect.Indirect(reflect.ValueOf(ret)).Kind(); k {
diff --git a/readme_test.go b/readme_test.go
index 4d3a30c..809142d 100644
--- a/readme_test.go
+++ b/readme_test.go
@@ -40,7 +40,7 @@ func Sum(frame wdte.Frame, args ...wdte.Func) wdte.Func {
 	return sum
 }
 
-func ExampleREADME() {
+func Example() {
 	m, err := wdte.Parse(strings.NewReader(src), wdte.ImportFunc(im), nil)
 	if err != nil {
 		fmt.Fprintf(os.Stderr, "Error parsing script: %v\n", err)
diff --git a/repl/examples_test.go b/repl/examples_test.go
index 409cad6..31301c3 100644
--- a/repl/examples_test.go
+++ b/repl/examples_test.go
@@ -14,7 +14,7 @@ func ExamplePartial() {
 	stack, partial = repl.Partial(strings.NewReader("import 'io'"), stack, nil)
 	fmt.Println(partial)
 
-	stack, partial = repl.Partial(strings.NewReader(";"), stack, nil)
+	_, partial = repl.Partial(strings.NewReader(";"), stack, nil)
 	fmt.Println(partial)
 	// Output: true
 	// true
diff --git a/res/grammar.ebnf b/res/grammar.ebnf
index 6802ce3..2edbbe9 100644
--- a/res/grammar.ebnf
+++ b/res/grammar.ebnf
@@ -1,9 +1,6 @@
     <script> -> <cexprs> Ω
-  <funcmods> -> <funcmod> <funcmods>
+  <funcmods> -> ( <expr> ; ) <funcmods>
               | ε
-   <funcmod> -> memo
-              | rev
-              | method
   <argdecls> -> <argdecl> <argdecls>
               | ε
    <argdecl> -> id
diff --git a/scanner/scanner_test.go b/scanner/scanner_test.go
index bea2394..a12caf4 100644
--- a/scanner/scanner_test.go
+++ b/scanner/scanner_test.go
@@ -104,9 +104,13 @@ o => print "double\n" 'single\\';`,
 		},
 		{
 			name: "FuncMods",
-			in:   `memo test => ();`,
+			in:   `let (memo) test => ();`,
 			out: []scanner.Token{
-				{Type: scanner.Keyword, Val: "memo"},
+				{Type: scanner.Keyword, Val: "let"},
+				{Type: scanner.Keyword, Val: "("},
+				{Type: scanner.ID, Val: "memo"},
+				{Type: scanner.Keyword, Val: ";"},
+				{Type: scanner.Keyword, Val: ")"},
 				{Type: scanner.ID, Val: "test"},
 				{Type: scanner.Keyword, Val: "=>"},
 				{Type: scanner.Keyword, Val: "("},
diff --git a/scanner/token.go b/scanner/token.go
index 7647f13..5cfa3d1 100644
--- a/scanner/token.go
+++ b/scanner/token.go
@@ -15,7 +15,7 @@ type Token struct {
 type TokenType uint
 
 const (
-	Invalid TokenType = iota // nolint
+	Invalid TokenType = iota
 	Number
 	String
 	ID
diff --git a/scanner/util.go b/scanner/util.go
index 8c8f18b..a76e520 100644
--- a/scanner/util.go
+++ b/scanner/util.go
@@ -26,9 +26,6 @@ var (
 	}
 
 	keywords = []string{
-		"memo",
-		"rev",
-		"method",
 		"let",
 		"import",
 	}
diff --git a/std/arrays/arrays.go b/std/arrays/arrays.go
index 9dabbec..930a1ca 100644
--- a/std/arrays/arrays.go
+++ b/std/arrays/arrays.go
@@ -137,11 +137,11 @@ func Stream(frame wdte.Frame, args ...wdte.Func) wdte.Func {
 	return &streamer{a: args[0].(wdte.Array)}
 }
 
-func (a *streamer) Call(frame wdte.Frame, args ...wdte.Func) wdte.Func { // nolint
+func (a *streamer) Call(frame wdte.Frame, args ...wdte.Func) wdte.Func {
 	return a
 }
 
-func (a *streamer) Next(frame wdte.Frame) (wdte.Func, bool) { // nolint
+func (a *streamer) Next(frame wdte.Frame) (wdte.Func, bool) {
 	if a.i >= len(a.a) {
 		return nil, false
 	}
@@ -151,11 +151,11 @@ func (a *streamer) Next(frame wdte.Frame) (wdte.Func, bool) { // nolint
 	return r, true
 }
 
-func (a *streamer) String() string { // nolint
+func (a *streamer) String() string {
 	return "<stream>"
 }
 
-func (a *streamer) Reflect(name string) bool { // nolint
+func (a *streamer) Reflect(name string) bool {
 	return name == "Stream"
 }
 
diff --git a/std/io/file/file.go b/std/io/file/file.go
index 40fc2f2..271dd06 100644
--- a/std/io/file/file.go
+++ b/std/io/file/file.go
@@ -27,15 +27,15 @@ type File struct {
 	mode int
 }
 
-func (f File) Call(frame wdte.Frame, args ...wdte.Func) wdte.Func { // nolint
+func (f File) Call(frame wdte.Frame, args ...wdte.Func) wdte.Func {
 	return f
 }
 
-func (f File) String() string { // nolint
+func (f File) String() string {
 	return fmt.Sprintf("<file %q>", f.Name())
 }
 
-func (f File) Reflect(name string) bool { // nolint
+func (f File) Reflect(name string) bool {
 	return name == "File" ||
 		(((f.mode == 0) || (f.mode&modeReader != 0)) && (name == "Reader")) ||
 		(((f.mode == 0) || (f.mode&modeWriter != 0)) && (name == "Writer"))
diff --git a/std/io/io.go b/std/io/io.go
index 10d4823..5503b9e 100644
--- a/std/io/io.go
+++ b/std/io/io.go
@@ -37,7 +37,7 @@ func (stdin) String() string {
 	return "<reader(stdin)>"
 }
 
-func (stdin) Reflect(name string) bool { // nolint
+func (stdin) Reflect(name string) bool {
 	return name == "Reader"
 }
 
@@ -55,7 +55,7 @@ func (stdout) String() string {
 	return "<writer(stdout)>"
 }
 
-func (stdout) Reflect(name string) bool { // nolint
+func (stdout) Reflect(name string) bool {
 	return name == "Writer"
 }
 
@@ -73,7 +73,7 @@ func (stderr) String() string {
 	return "<writer(stderr)>"
 }
 
-func (stderr) Reflect(name string) bool { // nolint
+func (stderr) Reflect(name string) bool {
 	return name == "Writer"
 }
 
@@ -92,11 +92,11 @@ type Reader struct {
 	io.Reader
 }
 
-func (r Reader) Call(frame wdte.Frame, args ...wdte.Func) wdte.Func { // nolint
+func (r Reader) Call(frame wdte.Frame, args ...wdte.Func) wdte.Func {
 	return r
 }
 
-func (r Reader) String() string { // nolint
+func (r Reader) String() string {
 	if inner, ok := r.Reader.(fmt.Stringer); ok {
 		return inner.String()
 	}
@@ -104,7 +104,7 @@ func (r Reader) String() string { // nolint
 	return "<reader>"
 }
 
-func (r Reader) Reflect(name string) bool { // nolint
+func (r Reader) Reflect(name string) bool {
 	return name == "Reader"
 }
 
@@ -123,11 +123,11 @@ type Writer struct {
 	io.Writer
 }
 
-func (w Writer) Call(frame wdte.Frame, args ...wdte.Func) wdte.Func { // nolint
+func (w Writer) Call(frame wdte.Frame, args ...wdte.Func) wdte.Func {
 	return w
 }
 
-func (w Writer) String() string { // nolint
+func (w Writer) String() string {
 	if inner, ok := w.Writer.(fmt.Stringer); ok {
 		return inner.String()
 	}
@@ -135,7 +135,7 @@ func (w Writer) String() string { // nolint
 	return "<writer>"
 }
 
-func (w Writer) Reflect(name string) bool { // nolint
+func (w Writer) Reflect(name string) bool {
 	return name == "Writer"
 }
 
@@ -316,11 +316,11 @@ type scanner struct {
 	s *bufio.Scanner
 }
 
-func (s scanner) Call(frame wdte.Frame, args ...wdte.Func) wdte.Func { // nolint
+func (s scanner) Call(frame wdte.Frame, args ...wdte.Func) wdte.Func {
 	return s
 }
 
-func (s scanner) Next(frame wdte.Frame) (wdte.Func, bool) { // nolint
+func (s scanner) Next(frame wdte.Frame) (wdte.Func, bool) {
 	ok := s.s.Scan()
 	if !ok {
 		err := s.s.Err()
@@ -333,7 +333,7 @@ func (s scanner) Next(frame wdte.Frame) (wdte.Func, bool) { // nolint
 	return wdte.String(s.s.Text()), true
 }
 
-func (s scanner) Reflect(name string) bool { // nolint
+func (s scanner) Reflect(name string) bool {
 	return name == "Stream"
 }
 
@@ -431,11 +431,11 @@ type runeStream struct {
 	r io.RuneReader
 }
 
-func (r runeStream) Call(frame wdte.Frame, args ...wdte.Func) wdte.Func { // nolint
+func (r runeStream) Call(frame wdte.Frame, args ...wdte.Func) wdte.Func {
 	return r
 }
 
-func (r runeStream) Next(frame wdte.Frame) (wdte.Func, bool) { // nolint
+func (r runeStream) Next(frame wdte.Frame) (wdte.Func, bool) {
 	c, _, err := r.r.ReadRune()
 	if err != nil {
 		if err == io.EOF {
@@ -446,7 +446,7 @@ func (r runeStream) Next(frame wdte.Frame) (wdte.Func, bool) { // nolint
 	return wdte.Number(c), true
 }
 
-func (r runeStream) Reflect(name string) bool { // nolint
+func (r runeStream) Reflect(name string) bool {
 	return name == "Stream"
 }
 
diff --git a/std/mods.go b/std/mods.go
new file mode 100644
index 0000000..fed24fc
--- /dev/null
+++ b/std/mods.go
@@ -0,0 +1,137 @@
+package std
+
+import (
+	"github.com/DeedleFake/wdte"
+	"github.com/DeedleFake/wdte/wdteutil"
+)
+
+// A Memo wraps another function, caching the results of calls with
+// the same arguments.
+type Memo struct {
+	Func wdte.Func
+	Args []wdte.ID
+
+	cache memoCache
+}
+
+func (m *Memo) Call(frame wdte.Frame, args ...wdte.Func) wdte.Func {
+	s := frame.Scope()
+
+	check := make([]wdte.Func, 0, len(m.Args))
+	for _, id := range m.Args {
+		check = append(check, s.Get(id).Call(frame))
+	}
+
+	cached, ok := m.cache.Get(check)
+	if ok {
+		return cached
+	}
+
+	r := m.Func.Call(frame, check...)
+	m.cache.Set(check, r)
+	return r
+}
+
+type memoCache struct {
+	val  wdte.Func
+	next map[wdte.Func]*memoCache
+}
+
+func (cache *memoCache) Get(args []wdte.Func) (wdte.Func, bool) {
+	if cache == nil {
+		return nil, false
+	}
+
+	if len(args) == 0 {
+		return cache.val, true
+	}
+
+	if cache.next == nil {
+		return nil, false
+	}
+
+	return cache.next[args[0]].Get(args[1:])
+}
+
+func (cache *memoCache) Set(args []wdte.Func, val wdte.Func) {
+	if len(args) == 0 {
+		cache.val = val
+		return
+	}
+
+	if cache.next == nil {
+		cache.next = make(map[wdte.Func]*memoCache)
+	}
+
+	n := new(memoCache)
+	n.Set(args[1:], val)
+	cache.next[args[0]] = n
+}
+
+func ModMemo(frame wdte.Frame, args ...wdte.Func) wdte.Func {
+	if len(args) == 0 {
+		return wdte.GoFunc(ModMemo)
+	}
+
+	frame = frame.Sub("memo")
+
+	lambda := args[0].(*wdte.Lambda)
+
+	argIDs := make([]wdte.ID, 0, len(lambda.Args))
+	for _, arg := range lambda.Args {
+		argIDs = append(argIDs, arg.IDs()...)
+	}
+
+	next := *lambda
+	next.Expr = &Memo{
+		Func: lambda.Expr,
+		Args: argIDs,
+	}
+	return &next
+}
+
+func ModRev(frame wdte.Frame, args ...wdte.Func) wdte.Func {
+	if len(args) == 0 {
+		return wdte.GoFunc(ModRev)
+	}
+
+	frame = frame.Sub("rev")
+
+	lambda := args[0].(*wdte.Lambda)
+
+	var reverser wdte.Func
+	reverser = wdte.GoFunc(func(frame wdte.Frame, args ...wdte.Func) wdte.Func {
+		if len(args) < len(lambda.Args) {
+			return wdteutil.SaveArgsReverse(reverser, args...)
+		}
+
+		return lambda.Call(frame, args...)
+	})
+	return reverser
+}
+
+// TODO: Figure out if this is even useful enough to reimplement.
+//func ModMethod(frame wdte.Frame, args ...wdte.Func) wdte.Func {
+//	if len(args) < 2 {
+//		return wdteutil.SaveArgs(wdte.GoFunc(ModMethod), args...)
+//	}
+//
+//	frame = frame.Sub("method")
+//
+//	recv := wdte.ID(args[0].(wdte.String))
+//	f := args[1]
+//
+//	var methodizer wdte.Func
+//	methodizer = wdte.GoFunc(func(frame wdte.Frame, args ...wdte.Func) wdte.Func {
+//		if len(args) == 0 {
+//			return methodizer
+//		}
+//
+//		return wdte.GoFunc(func(frame wdte.Frame, margs ...wdte.Func) wdte.Func {
+//			frame = frame.WithScope(frame.Scope().Add(recv, margs[0]))
+//
+//			return f.Call(frame, args...)
+//		})
+//	})
+//	return methodizer
+//}
diff --git a/std/std.go b/std/std.go
index d15245b..1911b0f 100644
--- a/std/std.go
+++ b/std/std.go
@@ -72,7 +72,6 @@ func Times(frame wdte.Frame, args ...wdte.Func) wdte.Func {
 
 	p := wdte.Number(1)
 	for _, arg := range args {
-		arg = arg
 		if _, ok := arg.(error); ok {
 			return arg
 		}
@@ -381,7 +380,6 @@ func And(frame wdte.Frame, args ...wdte.Func) wdte.Func {
 	}
 
 	for _, arg := range args {
-		arg = arg
 		if arg != wdte.Bool(true) {
 			return wdte.Bool(false)
 		}
@@ -404,7 +402,6 @@ func Or(frame wdte.Frame, args ...wdte.Func) wdte.Func {
 	}
 
 	for _, arg := range args {
-		arg = arg
 		if arg == wdte.Bool(true) {
 			return wdte.Bool(true)
 		}
@@ -583,6 +580,10 @@ var Scope = wdte.S().Map(map[wdte.ID]wdte.Func{
 	"known":   wdte.GoFunc(Known),
 	"set":     wdte.GoFunc(Set),
 	"reflect": wdte.GoFunc(Reflect),
+
+	"memo": wdte.GoFunc(ModMemo),
+	"rev":  wdte.GoFunc(ModRev),
+	//"method": wdte.GoFunc(ModMethod),
 })
 
 // F returns a top-level frame that has S as its scope.
diff --git a/std/stream/end.go b/std/stream/end.go
index 5b5ec3a..be792f9 100644
--- a/std/stream/end.go
+++ b/std/stream/end.go
@@ -14,7 +14,7 @@ func (end) Call(wdte.Frame, ...wdte.Func) wdte.Func {
 	return end{}
 }
 
-func (end) Reflect(name string) bool { // nolint
+func (end) Reflect(name string) bool {
 	return name == "End"
 }
 
@@ -223,7 +223,6 @@ func Extent(frame wdte.Frame, args ...wdte.Func) wdte.Func {
 		if !ok {
 			return extent
 		}
-		n = n
 
 		i := sort.Search(len(extent), func(i int) bool {
 			return less.Call(frame, n, extent[i]) == wdte.Bool(true)
diff --git a/std/stream/stream.go b/std/stream/stream.go
index 985a101..785e22e 100644
--- a/std/stream/stream.go
+++ b/std/stream/stream.go
@@ -21,19 +21,19 @@ type Stream interface {
 // itself.
 type NextFunc func(frame wdte.Frame) (wdte.Func, bool)
 
-func (n NextFunc) Call(frame wdte.Frame, args ...wdte.Func) wdte.Func { // nolint
+func (n NextFunc) Call(frame wdte.Frame, args ...wdte.Func) wdte.Func {
 	return n
 }
 
-func (n NextFunc) Next(frame wdte.Frame) (wdte.Func, bool) { // nolint
+func (n NextFunc) Next(frame wdte.Frame) (wdte.Func, bool) {
 	return n(frame)
 }
 
-func (NextFunc) String() string { // nolint
+func (NextFunc) String() string {
 	return "<stream>"
 }
 
-func (NextFunc) Reflect(name string) bool { // nolint
+func (NextFunc) Reflect(name string) bool {
 	return name == "Stream"
 }
 
diff --git a/std/strings/strings.go b/std/strings/strings.go
index d2e3a39..c1fdad4 100644
--- a/std/strings/strings.go
+++ b/std/strings/strings.go
@@ -232,11 +232,11 @@ type reader struct {
 	*strings.Reader
 }
 
-func (r reader) Call(frame wdte.Frame, args ...wdte.Func) wdte.Func { // nolint
+func (r reader) Call(frame wdte.Frame, args ...wdte.Func) wdte.Func {
 	return r
 }
 
-func (r reader) Reflect(name string) bool { // nolint
+func (r reader) Reflect(name string) bool {
 	return name == "Reader"
 }
 
diff --git a/translate.go b/translate.go
index e1aab26..f8df2f5 100644
--- a/translate.go
+++ b/translate.go
@@ -31,35 +31,27 @@ func (m *translator) fromScript(script *ast.NTerm) (c Compound, err error) {
 	return Compound(m.fromExprs(script.Children()[0].(*ast.NTerm), nil)), nil
 }
 
-func (m *translator) fromFuncMods(funcMods *ast.NTerm) funcMod {
+func (m *translator) fromFuncMods(funcMods *ast.NTerm, mods Composite) Func {
 	switch mod := funcMods.Children()[0].(type) {
-	case *ast.NTerm:
-		return m.fromFuncMod(mod) | m.fromFuncMods(funcMods.Children()[1].(*ast.NTerm))
+	case *ast.Term:
+		return m.fromFuncMods(
+			funcMods.Children()[4].(*ast.NTerm),
+			append(mods, m.fromExpr(funcMods.Children()[1].(*ast.NTerm), 0, nil)),
+		)
 
 	case *ast.Epsilon:
-		return 0
+		// As odd as this looks, it actually does something because of the
+		// way interfaces work. Don't remove it.
+		if mods == nil {
+			return nil
+		}
+		return mods
 
 	default:
 		panic(fmt.Errorf("Malformed AST with bad <funcmods>: %T", mod))
 	}
 }
 
-func (m *translator) fromFuncMod(funcMod *ast.NTerm) funcMod {
-	switch mod := funcMod.Children()[0].(*ast.Term).Tok().Val; mod {
-	case "memo":
-		return funcModMemo
-
-	case "rev":
-		return funcModRev
-
-	case "method":
-		return funcModMethod
-
-	default:
-		panic(fmt.Errorf("Malformed AST with bad <funcmod>: %v", mod))
-	}
-}
-
 func (m *translator) fromArgDecls(argdecls *ast.NTerm, args []Assigner) []Assigner {
 	switch arg := argdecls.Children()[0].(type) {
 	case *ast.NTerm:
@@ -117,16 +109,11 @@ func (m *translator) fromLetExpr(expr *ast.NTerm) Func {
 
 	switch first := assign.Children()[0].(*ast.NTerm); first.Name() {
 	case "funcmods":
-		mods := m.fromFuncMods(first)
+		mods := m.fromFuncMods(first, nil)
 		id := ID(assign.Children()[1].(*ast.Term).Tok().Val.(string))
 		args := m.fromArgDecls(assign.Children()[2].(*ast.NTerm), nil)
 		inner := m.fromExpr(assign.Children()[4].(*ast.NTerm), 0, nil)
 
-		argIDs := make([]ID, 0, len(args))
-		for _, arg := range args {
-			argIDs = append(argIDs, arg.IDs()...)
-		}
-
 		return &LetAssigner{
 			Assigner: SimpleAssigner(id),
 			Expr:     m.fromFuncDecl(mods, id, args, inner),
@@ -273,49 +260,36 @@ func (m *translator) fromCompound(compound *ast.NTerm) Func {
 	return r
 }
 
-func (m *translator) fromFuncDecl(mods funcMod, id ID, args []Assigner, expr Func) Func {
-	if (mods == 0) && (len(args) == 0) {
-		return expr
-	}
-
-	if mods&funcModMemo != 0 {
-		argIDs := make([]ID, 0, len(args))
-		for _, arg := range args {
-			argIDs = append(argIDs, arg.IDs()...)
+func (m *translator) fromFuncDecl(mods Func, id ID, args []Assigner, expr Func) Func {
+	if len(args) == 0 {
+		if mods == nil {
+			return expr
 		}
 
-		expr = &Memo{
+		return &Modifier{
+			Mods: mods,
 			Func: expr,
-			Args: argIDs,
 		}
 	}
 
-	argSplit := func(assigners []Assigner, args []Func) ([]Assigner, []Assigner) {
-		return assigners[:len(args)], assigners[len(args):]
-	}
-	if mods&funcModRev != 0 {
-		argSplit = func(assigners []Assigner, args []Func) ([]Assigner, []Assigner) {
-			return assigners[len(assigners)-len(args):], assigners[:len(assigners)-len(args)]
-		}
+	lambda := &Lambda{
+		ID:   id,
+		Expr: expr,
+		Args: args,
 	}
 
-	var method Assigner
-	if mods&funcModMethod != 0 {
-		method = args[0]
-		args = args[1:]
+	if mods == nil {
+		return lambda
 	}
 
-	return &Lambda{
-		ID:       id,
-		Expr:     expr,
-		Args:     args,
-		ArgSplit: argSplit,
-		Method:   method,
+	return &Modifier{
+		Mods: mods,
+		Func: lambda,
 	}
 }
 
 func (m *translator) fromLambda(lambda *ast.NTerm) (f Func) {
-	mods := m.fromFuncMods(lambda.Children()[1].(*ast.NTerm))
+	mods := m.fromFuncMods(lambda.Children()[1].(*ast.NTerm), nil)
 	id := ID(lambda.Children()[2].(*ast.Term).Tok().Val.(string))
 	args := m.fromArgDecls(lambda.Children()[3].(*ast.NTerm), nil)
 	expr := Compound(m.fromExprs(lambda.Children()[5].(*ast.NTerm), nil))
@@ -390,11 +364,3 @@ func (m *translator) fromChain(chain *ast.NTerm, acc Chain) Func {
 
 	return m.fromExpr(chain.Children()[1].(*ast.NTerm), flags, acc)
 }
-
-type funcMod uint
-
-const (
-	funcModMemo funcMod = 1 << iota
-	funcModRev
-	funcModMethod
-)
diff --git a/types.go b/types.go
index 9212e2c..ebb251f 100644
--- a/types.go
+++ b/types.go
@@ -66,12 +66,12 @@ func Reflect(f Func, name string) bool {
 // when called.
 type String string
 
-func (s String) Call(frame Frame, args ...Func) Func { // nolint
+func (s String) Call(frame Frame, args ...Func) Func {
 	// TODO: Use the arguments for something. Probably concatenation.
 	return s
 }
 
-func (s String) Compare(other Func) (int, bool) { // nolint
+func (s String) Compare(other Func) (int, bool) {
 	o, ok := other.(String)
 	if !ok {
 		return -1, false
@@ -87,11 +87,11 @@ func (s String) Compare(other Func) (int, bool) { // nolint
 	return 0, true
 }
 
-func (s String) Len() int { // nolint
+func (s String) Len() int {
 	return len(s)
 }
 
-func (s String) At(index Func) (Func, error) { // nolint
+func (s String) At(index Func) (Func, error) {
 	i := int(index.(Number))
 	if (i < 0) || (i >= len(s)) {
 		return nil, fmt.Errorf("index %v is out of range [0,%v)", i, len(s))
@@ -100,7 +100,7 @@ func (s String) At(index Func) (Func, error) { // nolint
 	return String(s[i]), nil
 }
 
-func (s String) Reflect(name string) bool { // nolint
+func (s String) Reflect(name string) bool {
 	return name == "String"
 }
 
@@ -109,12 +109,12 @@ func (s String) Reflect(name string) bool { // nolint
 // when called.
 type Number float64
 
-func (n Number) Call(frame Frame, args ...Func) Func { // nolint
+func (n Number) Call(frame Frame, args ...Func) Func {
 	// TODO: Use the arguments for something, perhaps.
 	return n
 }
 
-func (n Number) Compare(other Func) (int, bool) { // nolint
+func (n Number) Compare(other Func) (int, bool) {
 	o, ok := other.(Number)
 
 	switch {
@@ -130,7 +130,7 @@ func (n Number) Compare(other Func) (int, bool) { // nolint
 	}
 }
 
-func (n Number) String() string { // nolint
+func (n Number) String() string {
 	bn := big.NewFloat(float64(n))
 	if bn.IsInt() {
 		return bn.Text('f', -1)
@@ -139,7 +139,7 @@ func (n Number) String() string { // nolint
 	return bn.Text('g', 10)
 }
 
-func (n Number) Reflect(name string) bool { // nolint
+func (n Number) Reflect(name string) bool {
 	return name == "Number"
 }
 
@@ -149,7 +149,7 @@ func (n Number) Reflect(name string) bool { // nolint
 // value in the same way as strings and numbers.
 type Array []Func
 
-func (a Array) Call(frame Frame, args ...Func) Func { // nolint
+func (a Array) Call(frame Frame, args ...Func) Func {
 	n := make(Array, 0, len(a))
 	for i := range a {
 		n = append(n, a[i].Call(frame))
@@ -157,11 +157,11 @@ func (a Array) Call(frame Frame, args ...Func) Func { // nolint
 	return n
 }
 
-func (a Array) Len() int { // nolint
+func (a Array) Len() int {
 	return len(a)
 }
 
-func (a Array) At(index Func) (Func, error) { // nolint
+func (a Array) At(index Func) (Func, error) {
 	i := int(index.(Number))
 	if (i < 0) || (i >= len(a)) {
 		return nil, fmt.Errorf("index %v is out of range [0,%v)", i, len(a))
@@ -170,7 +170,7 @@ func (a Array) At(index Func) (Func, error) { // nolint
 	return a[i], nil
 }
 
-func (a Array) Set(k, v Func) (Func, error) { // nolint
+func (a Array) Set(k, v Func) (Func, error) {
 	i := int(k.(Number))
 	if (i < 0) || (i >= len(a)) {
 		return nil, fmt.Errorf("index %v is out of bounds [0,%v]", i, len(a))
@@ -182,7 +182,7 @@ func (a Array) Set(k, v Func) (Func, error) { // nolint
 	return c, nil
 }
 
-func (a Array) String() string { // nolint
+func (a Array) String() string {
 	var buf strings.Builder
 
 	buf.WriteByte('[')
@@ -197,7 +197,7 @@ func (a Array) String() string { // nolint
 	return buf.String()
 }
 
-func (a Array) Reflect(name string) bool { // nolint
+func (a Array) Reflect(name string) bool {
 	return name == "Array"
 }
 
@@ -219,7 +219,7 @@ type Error struct {
 	Frame Frame
 }
 
-func (e Error) Call(frame Frame, args ...Func) Func { // nolint
+func (e Error) Call(frame Frame, args ...Func) Func {
 	return e
 }
 
@@ -231,7 +231,7 @@ func (e Error) Unwrap() error {
 	return e.Err
 }
 
-func (e Error) Reflect(name string) bool { // nolint
+func (e Error) Reflect(name string) bool {
 	return name == "Error"
 }
 
@@ -239,17 +239,17 @@ func (e Error) Reflect(name string) bool { // nolint
 // itself when called.
 type Bool bool
 
-func (b Bool) Call(frame Frame, args ...Func) Func { // nolint
+func (b Bool) Call(frame Frame, args ...Func) Func {
 	return b
 }
 
-func (b Bool) Compare(other Func) (int, bool) { // nolint
+func (b Bool) Compare(other Func) (int, bool) {
 	if b == other {
 		return 0, false
 	}
 	return -1, false
 }
 
-func (b Bool) Reflect(name string) bool { // nolint
+func (b Bool) Reflect(name string) bool {
 	return name == "Bool"
 }
diff --git a/wdte.go b/wdte.go
index 236e20b..3edf630 100644
--- a/wdte.go
+++ b/wdte.go
@@ -59,7 +59,7 @@ func defaultImporter(from string) (*Scope, error) {
 // used as Importers.
 type ImportFunc func(from string) (*Scope, error)
 
-func (f ImportFunc) Import(from string) (*Scope, error) { // nolint
+func (f ImportFunc) Import(from string) (*Scope, error) {
 	return f(from)
 }
 
@@ -337,11 +337,11 @@ func (s *Scope) Known() []ID {
 	return list
 }
 
-func (s *Scope) Call(frame Frame, args ...Func) Func { // nolint
+func (s *Scope) Call(frame Frame, args ...Func) Func {
 	return s
 }
 
-func (s *Scope) At(i Func) (Func, error) { // nolint
+func (s *Scope) At(i Func) (Func, error) {
 	v := s.Get(ID(i.(String)))
 	if v == nil {
 		return nil, fmt.Errorf("%v is not in scope", i)
@@ -349,11 +349,11 @@ func (s *Scope) At(i Func) (Func, error) { // nolint
 	return v, nil
 }
 
-func (s *Scope) Set(k, v Func) (Func, error) { // nolint
+func (s *Scope) Set(k, v Func) (Func, error) {
 	return s.Add(ID(k.(String)), v), nil
 }
 
-func (s *Scope) String() string { // nolint
+func (s *Scope) String() string {
 	var buf strings.Builder
 
 	buf.WriteString("scope(")
@@ -371,7 +371,7 @@ func (s *Scope) String() string { // nolint
 	return buf.String()
 }
 
-func (s *Scope) Reflect(name string) bool { // nolint
+func (s *Scope) Reflect(name string) bool {
 	return name == "Scope"
 }
 
@@ -406,7 +406,7 @@ func (s *Scope) Reflect(name string) bool { // nolint
 // be returned.
 type GoFunc func(frame Frame, args ...Func) Func
 
-func (f GoFunc) Call(frame Frame, args ...Func) (r Func) { // nolint
+func (f GoFunc) Call(frame Frame, args ...Func) (r Func) {
 	defer func() {
 		if err, ok := recover().(error); ok {
 			r = Error{
@@ -421,7 +421,7 @@ func (f GoFunc) Call(frame Frame, args ...Func) (r Func) { // nolint
 	return f(frame, args...)
 }
 
-func (f GoFunc) String() string { // nolint
+func (f GoFunc) String() string {
 	return "<go func>"
 }
 
@@ -433,7 +433,7 @@ type FuncCall struct {
 	Args []Func
 }
 
-func (f FuncCall) Call(frame Frame, args ...Func) Func { // nolint
+func (f FuncCall) Call(frame Frame, args ...Func) Func {
 	if err := frame.Context().Err(); err != nil {
 		return &Error{
 			Frame: frame,
@@ -449,7 +449,7 @@ func (f FuncCall) Call(frame Frame, args ...Func) Func { // nolint
 	return f.Func.Call(frame).Call(frame, next...)
 }
 
-func (f FuncCall) String() string { // nolint
+func (f FuncCall) String() string {
 	if inner, ok := f.Func.(fmt.Stringer); ok {
 		return inner.String()
 	}
@@ -477,7 +477,7 @@ func (p ChainPiece) Call(frame Frame, args ...Func) Func {
 	return p.Expr.Call(frame, args...)
 }
 
-func (p ChainPiece) String() string { // nolint
+func (p ChainPiece) String() string {
 	if inner, ok := p.Expr.(fmt.Stringer); ok {
 		return inner.String()
 	}
@@ -488,7 +488,7 @@ func (p ChainPiece) String() string { // nolint
 // Chain is an unevaluated chain expression.
 type Chain []*ChainPiece
 
-func (f Chain) Call(frame Frame, args ...Func) Func { // nolint
+func (f Chain) Call(frame Frame, args ...Func) Func {
 	var slotScope *Scope
 	var prev Func
 	for _, cur := range f {
@@ -539,7 +539,7 @@ func (f Chain) String() string {
 // imported function.
 type Sub []Func
 
-func (sub Sub) Call(frame Frame, args ...Func) Func { // nolint
+func (sub Sub) Call(frame Frame, args ...Func) Func {
 	scope := frame.Scope()
 	for _, f := range sub[:len(sub)-1] {
 		next := f.Call(frame.WithScope(frame.Scope().Sub(scope)))
@@ -593,7 +593,7 @@ func (c Compound) Collect(frame Frame) (letScope *Scope, last Func) {
 	return letScope, last
 }
 
-func (c Compound) Call(frame Frame, args ...Func) Func { // nolint
+func (c Compound) Call(frame Frame, args ...Func) Func {
 	s, f := c.Collect(frame)
 	return f.Call(frame.WithScope(frame.Scope().Sub(s)), args...)
 }
@@ -626,7 +626,7 @@ type Switch struct {
 	Cases [][2]Func
 }
 
-func (s Switch) Call(frame Frame, args ...Func) Func { // nolint
+func (s Switch) Call(frame Frame, args ...Func) Func {
 	check := s.Check.Call(frame)
 	if _, ok := check.(error); ok {
 		return check
@@ -650,7 +650,7 @@ func (s Switch) Call(frame Frame, args ...Func) Func { // nolint
 // in the frame that it's given and calls whatever it finds.
 type Var ID
 
-func (v Var) Call(frame Frame, args ...Func) Func { // nolint
+func (v Var) Call(frame Frame, args ...Func) Func {
 	f := frame.Scope().Get(ID(v))
 	if f == nil {
 		return &Error{
@@ -662,69 +662,6 @@ func (v Var) Call(frame Frame, args ...Func) Func { // nolint
 	return f.Call(frame, args...)
 }
 
-// A Memo wraps another function, caching the results of calls with
-// the same arguments.
-type Memo struct {
-	Func Func
-	Args []ID
-
-	cache memoCache
-}
-
-func (m *Memo) Call(frame Frame, args ...Func) Func { // nolint
-	s := frame.Scope()
-
-	check := make([]Func, 0, len(m.Args))
-	for _, id := range m.Args {
-		check = append(check, s.Get(id).Call(frame))
-	}
-
-	cached, ok := m.cache.Get(check)
-	if ok {
-		return cached
-	}
-
-	r := m.Func.Call(frame, check...)
-	m.cache.Set(check, r)
-	return r
-}
-
-type memoCache struct {
-	val  Func
-	next map[Func]*memoCache
-}
-
-func (cache *memoCache) Get(args []Func) (Func, bool) {
-	if cache == nil {
-		return nil, false
-	}
-
-	if len(args) == 0 {
-		return cache.val, true
-	}
-
-	if cache.next == nil {
-		return nil, false
-	}
-
-	return cache.next[args[0]].Get(args[1:])
-}
-
-func (cache *memoCache) Set(args []Func, val Func) {
-	if len(args) == 0 {
-		cache.val = val
-		return
-	}
-
-	if cache.next == nil {
-		cache.next = make(map[Func]*memoCache)
-	}
-
-	n := new(memoCache)
-	n.Set(args[1:], val)
-	cache.next[args[0]] = n
-}
-
 // A Lambda is a closure. When called, it calls its inner expression
 // with itself and its own arguments placed into the scope. In other
 // words, given the lambda
@@ -735,11 +672,9 @@ func (cache *memoCache) Set(args []Func, val Func) {
 // and its first and second arguments under the IDs "x" and "y",
 // respectively. It will then evaluate `+ x y` in that new scope.
 type Lambda struct {
-	ID       ID
-	Expr     Func
-	Args     []Assigner
-	ArgSplit func([]Assigner, []Func) ([]Assigner, []Assigner)
-	Method   Assigner
+	ID   ID
+	Expr Func
+	Args []Assigner
 
 	Scope    *Scope
 	Original *Lambda
@@ -753,24 +688,21 @@ func (lambda *Lambda) original() *Lambda {
 	return lambda.Original
 }
 
-func (lambda *Lambda) Call(frame Frame, args ...Func) Func { // nolint
+func (lambda *Lambda) Call(frame Frame, args ...Func) Func {
 	scope := lambda.Scope
 	if scope == nil {
 		scope = frame.Scope()
 	}
 
 	if len(args) < len(lambda.Args) {
-		assigners, rem := lambda.ArgSplit(lambda.Args, args)
 		for i := range args {
-			scope, _ = assigners[i].Assign(frame, scope, args[i])
+			scope, _ = lambda.Args[i].Assign(frame, scope, args[i])
 		}
 
 		return &Lambda{
-			ID:       lambda.ID,
-			Expr:     lambda.Expr,
-			Args:     rem,
-			ArgSplit: lambda.ArgSplit,
-			Method:   lambda.Method,
+			ID:   lambda.ID,
+			Expr: lambda.Expr,
+			Args: lambda.Args[len(args):],
 
 			Scope:    scope,
 			Original: lambda.original(),
@@ -781,24 +713,12 @@ func (lambda *Lambda) Call(frame Frame, args ...Func) Func { // nolint
 		scope, _ = lambda.Args[i].Assign(frame, scope, args[i])
 	}
 
-	if lambda.Method != nil {
-		return &Lambda{
-			ID:       lambda.ID,
-			Expr:     lambda.Expr,
-			Args:     []Assigner{lambda.Method},
-			ArgSplit: lambda.ArgSplit,
-
-			Scope:    scope,
-			Original: lambda.original(),
-		}
-	}
-
 	original := lambda.original()
 	scope = scope.Add(original.ID, original)
 	return lambda.Expr.Call(frame.WithScope(scope))
 }
 
-func (lambda *Lambda) String() string { // nolint
+func (lambda *Lambda) String() string {
 	var buf strings.Builder
 
 	fmt.Fprintf(&buf, "(@ %v", lambda.ID)
@@ -967,3 +887,41 @@ func (a LetAssigner) Assign(frame Frame, scope *Scope, val Func) (*Scope, Func)
 func (a LetAssigner) String() string {
 	return fmt.Sprint(a.Assigner)
 }
+
+// Composite represents a composite function. When called, it calls
+// its components in reverse order on their previous results. In other
+// words,
+//
+//    Composite{func1, func2, func3}.Call(frame, arg1, arg2)
+//
+// is the equivalent of
+//
+//    func1 (func2 (func3 arg1 arg2))
+type Composite []Func
+
+func (c Composite) Call(frame Frame, args ...Func) Func {
+	r := Func(c)
+	prev := args
+	for i := len(c) - 1; i >= 0; i-- {
+		n := r
+		r = c[i].Call(frame).Call(frame, prev...)
+		prev = []Func{n}
+
+		if _, ok := r.(error); ok {
+			return r
+		}
+	}
+
+	return r
+}
+
+// Modifier applies modifications to a function before passing it its
+// own arguments by calling Mods and passing it Func.
+type Modifier struct {
+	Mods Func
+	Func Func
+}
+
+func (m Modifier) Call(frame Frame, args ...Func) Func {
+	return m.Mods.Call(frame, m.Func).Call(frame, args...)
+}
diff --git a/wdte_test.go b/wdte_test.go
index cf057c2..c8047ac 100644
--- a/wdte_test.go
+++ b/wdte_test.go
@@ -207,33 +207,35 @@ func TestBasics(t *testing.T) {
 		},
 		{
 			name:   "Simple/Memo",
-			script: `let memo test n => + n 3; let main => (test 5; test 5); main;`,
+			script: `let (memo) test n => + n 3; let main => (test 5; test 5); main;`,
 			ret:    wdte.Number(8),
 		},
 		{
 			name:   "Simple/Memo/Pattern",
-			script: `let memo test [a b] c => + a b c; (test [1; 2] 3; test [1; 2] 3);`,
+			script: `let (memo) test [a b] c => + a b c; (test [1; 2] 3; test [1; 2] 3);`,
 			ret:    wdte.Number(6),
 		},
 		{
 			name:   "Simple/Memo/Patter/Complex",
-			script: `let memo test [a [b]] c => + a b c; (test [1; [2]] 3; test [1; [2]] 3);`,
+			script: `let (memo) test [a [b]] c => + a b c; (test [1; [2]] 3; test [1; [2]] 3);`,
 			ret:    wdte.Number(6),
 		},
 		{
 			name:   "Simple/Rev",
-			script: `let rev test a b c => [a; b; c]; (test 1 2) 3;`,
+			script: `let (rev) test a b c => [a; b; c]; (test 1 2) 3;`,
 			ret:    wdte.Array{wdte.Number(3), wdte.Number(1), wdte.Number(2)},
 		},
 		{
-			name:   "Simple/Method",
-			script: `let method test r a b => [r; a; b]; 3 -> test 1 2;`,
-			ret:    wdte.Array{wdte.Number(3), wdte.Number(1), wdte.Number(2)},
+			disabled: true,
+			name:     "Simple/Method",
+			script:   `let (method 'r') test a b => [r; a; b]; 3 -> test 1 2;`,
+			ret:      wdte.Array{wdte.Number(3), wdte.Number(1), wdte.Number(2)},
 		},
 		{
-			name:   "Simple/RevMethod",
-			script: `let method rev test r a b c => [r; a; b; c]; 0 -> (test 1 2) 3;`,
-			ret:    wdte.Array{wdte.Number(0), wdte.Number(3), wdte.Number(1), wdte.Number(2)},
+			disabled: true,
+			name:     "Simple/RevMethod",
+			script:   `let (method 'r') (rev) test a b c => [r; a; b; c]; 0 -> (test 1 2) 3;`,
+			ret:      wdte.Array{wdte.Number(0), wdte.Number(3), wdte.Number(1), wdte.Number(2)},
 		},
 		{
 			name:   "Simple/VariableArgs",
@@ -289,7 +291,7 @@ func TestBasics(t *testing.T) {
 			// Wonder why memo exists? Try removing the keyword from this
 			// test script and see what happens.
 			name:   "Fib/Memo",
-			script: `let memo main n => n { <= 1 => n; true => + (main (- n 2)) (main (- n 1)); }; main 38;`,
+			script: `let (memo) main n => n { <= 1 => n; true => + (main (- n 2)) (main (- n 1)); }; main 38;`,
 			ret:    wdte.Number(39088169),
 		},
 		{
@@ -351,7 +353,7 @@ func TestBasics(t *testing.T) {
 		},
 		{
 			name:   "Lambda/Fib/Memo",
-			script: `let test a => a 38; test (@ memo t n => n { <= 1 => n; true => + (t (- n 2)) (t (- n 1)); };);`,
+			script: `let test a => a 38; test (@ (memo) t n => n { <= 1 => n; true => + (t (- n 2)) (t (- n 1)); };);`,
 			ret:    wdte.Number(39088169),
 		},
 		{