Added basic lambda parser
parent
d42b772092
commit
99217297d2
GPG Key ID:
AD62BB059C2AAEE4
|
|
@ -0,0 +1,104 @@
|
||||||
|
from parser import Parser
|
||||||
|
import tokens
|
||||||
|
|
||||||
|
|
||||||
|
class lambda_runner:
|
||||||
|
def __init__(self):
|
||||||
|
self.macro_table = {}
|
||||||
|
self.expr = None
|
||||||
|
|
||||||
|
# Apply a list of definitions
|
||||||
|
def run_names(self, lines):
|
||||||
|
print("Added names:")
|
||||||
|
for l in lines:
|
||||||
|
if isinstance(l, str):
|
||||||
|
e = Parser.parse_assign(l)
|
||||||
|
else:
|
||||||
|
e = l
|
||||||
|
|
||||||
|
if e.label in self.macro_table:
|
||||||
|
raise NameError(f"Label {e.label} exists!")
|
||||||
|
|
||||||
|
e.exp.bind_variables()
|
||||||
|
self.macro_table[e.label] = e.exp
|
||||||
|
print(f"\t{e}")
|
||||||
|
print("\n")
|
||||||
|
|
||||||
|
def set_expr(self, expr: str | None = None):
|
||||||
|
if expr == None:
|
||||||
|
self.expr = None
|
||||||
|
print("Removed expression.\n")
|
||||||
|
return
|
||||||
|
|
||||||
|
self.expr = Parser.parse_expression(expr)
|
||||||
|
self.expr.bind_variables()
|
||||||
|
print(f"Set expression to {self.expr}\n")
|
||||||
|
|
||||||
|
def run(self):
|
||||||
|
if isinstance(self.expr, tokens.lambda_apply):
|
||||||
|
self.expr = self.expr.expand(self.macro_table)
|
||||||
|
elif isinstance(self.expr, tokens.lambda_func):
|
||||||
|
self.expr = self.expr.expand(self.macro_table)
|
||||||
|
else:
|
||||||
|
return None
|
||||||
|
return self.expr
|
||||||
|
|
||||||
|
|
||||||
|
r = lambda_runner()
|
||||||
|
|
||||||
|
r.run_names([
|
||||||
|
"T = a -> b -> a",
|
||||||
|
"F = a -> b -> a",
|
||||||
|
"NOT = a -> (a F T)",
|
||||||
|
"AND = a -> b -> (a F b)",
|
||||||
|
"OR = a -> b -> (a T b)",
|
||||||
|
"XOR = a -> b -> (a (NOT a b) b)"
|
||||||
|
])
|
||||||
|
|
||||||
|
r.run_names([
|
||||||
|
"w = x -> (x x)",
|
||||||
|
"W = (w w)",
|
||||||
|
"Y = f -> ( (x -> (f (x x))) (x -> (f (x x))) )",
|
||||||
|
#"l = if_true -> if_false -> which -> ( which if_true if_false )"
|
||||||
|
])
|
||||||
|
|
||||||
|
r.run_names([
|
||||||
|
"inc = n -> f -> x -> (f (n f x))",
|
||||||
|
"zero = a -> x -> x",
|
||||||
|
"one = f -> x -> (f x)",
|
||||||
|
])
|
||||||
|
|
||||||
|
print("\n")
|
||||||
|
|
||||||
|
#AND = r.run()
|
||||||
|
#OR = r.run()
|
||||||
|
#XOR = r.run()
|
||||||
|
|
||||||
|
r.set_expr(
|
||||||
|
"(" +
|
||||||
|
"inc (inc (inc (zero)))"
|
||||||
|
+ ")"
|
||||||
|
)
|
||||||
|
|
||||||
|
print(repr(r.expr))
|
||||||
|
print("")
|
||||||
|
|
||||||
|
outs = [str(r.expr)]
|
||||||
|
for i in range(300):
|
||||||
|
x = r.run()
|
||||||
|
s = str(x)
|
||||||
|
p = s if len(s) < 100 else s[:97] + "..."
|
||||||
|
|
||||||
|
if s in outs:
|
||||||
|
print(p)
|
||||||
|
print("\nLoop detected, exiting.")
|
||||||
|
break
|
||||||
|
|
||||||
|
if x is None:
|
||||||
|
print("\nCannot evaluate any further.")
|
||||||
|
break
|
||||||
|
|
||||||
|
outs.append(s)
|
||||||
|
print(p)
|
||||||
|
|
||||||
|
print(f"Performed {i} {'operations' if i != 1 else 'operation'}.")
|
||||||
|
|
@ -0,0 +1,65 @@
|
||||||
|
import pyparsing as pp
|
||||||
|
import tokens
|
||||||
|
|
||||||
|
class Parser:
|
||||||
|
"""
|
||||||
|
Macro_def must be on its own line.
|
||||||
|
macro_def :: var = expr
|
||||||
|
|
||||||
|
var :: word
|
||||||
|
lambda_fun :: var -> expr
|
||||||
|
call :: '(' (var | expr) ')' +
|
||||||
|
expr :: define | var | call | '(' expr ')'
|
||||||
|
"""
|
||||||
|
|
||||||
|
lp = pp.Suppress("(")
|
||||||
|
rp = pp.Suppress(")")
|
||||||
|
func_char = pp.Suppress("->")
|
||||||
|
macro_char = pp.Suppress("=")
|
||||||
|
|
||||||
|
# Simple tokens
|
||||||
|
pp_expr = pp.Forward()
|
||||||
|
pp_name = pp.Word(pp.alphas + "_")
|
||||||
|
pp_name.set_parse_action(tokens.macro.from_parse)
|
||||||
|
|
||||||
|
# Function definitions.
|
||||||
|
# Right associative.
|
||||||
|
#
|
||||||
|
# <var> => <exp>
|
||||||
|
pp_lambda_fun = pp_name + func_char + pp_expr
|
||||||
|
pp_lambda_fun.set_parse_action(tokens.lambda_func.from_parse)
|
||||||
|
|
||||||
|
# Assignment.
|
||||||
|
# Can only be found at the start of a line.
|
||||||
|
#
|
||||||
|
# <var> = <exp>
|
||||||
|
pp_macro_def = pp.line_start() + pp_name + macro_char + pp_expr
|
||||||
|
pp_macro_def.set_parse_action(tokens.macro_expression.from_parse)
|
||||||
|
|
||||||
|
# Function calls.
|
||||||
|
# `tokens.lambda_func.from_parse` handles chained calls.
|
||||||
|
#
|
||||||
|
# <var>(<exp>)
|
||||||
|
# <var>(<exp>)(<exp>)(<exp>)
|
||||||
|
# (<exp>)(<exp>)
|
||||||
|
# (<exp>)(<exp>)(<exp>)(<exp>)
|
||||||
|
pp_call = pp.Forward()
|
||||||
|
pp_call <<= pp_expr[2, ...]
|
||||||
|
pp_call.set_parse_action(tokens.lambda_apply.from_parse)
|
||||||
|
|
||||||
|
pp_expr <<= pp_lambda_fun ^ (lp + pp_expr + rp) ^ pp_name ^ (lp + pp_call + rp)
|
||||||
|
pp_all = pp_expr | pp_macro_def
|
||||||
|
|
||||||
|
@staticmethod
|
||||||
|
def parse_expression(line):
|
||||||
|
return Parser.pp_expr.parse_string(line, parse_all = True)[0]
|
||||||
|
|
||||||
|
@staticmethod
|
||||||
|
def parse_assign(line):
|
||||||
|
return (
|
||||||
|
Parser.pp_macro_def
|
||||||
|
).parse_string(line, parse_all = True)[0]
|
||||||
|
|
||||||
|
@staticmethod
|
||||||
|
def run_tests(lines):
|
||||||
|
return Parser.pp_macro_def.run_tests(lines)
|
||||||
|
|
@ -0,0 +1,420 @@
|
||||||
|
from typing import Type
|
||||||
|
|
||||||
|
|
||||||
|
class free_variable:
|
||||||
|
"""
|
||||||
|
Represents a free variable.
|
||||||
|
|
||||||
|
This object does not reduce to
|
||||||
|
anything, since it has no meaning.
|
||||||
|
|
||||||
|
Any name in an expression that isn't
|
||||||
|
a macro or a bound variable is assumed
|
||||||
|
to be a free variable.
|
||||||
|
"""
|
||||||
|
|
||||||
|
def __init__(self, label: str):
|
||||||
|
self.label = label
|
||||||
|
|
||||||
|
def __repr__(self):
|
||||||
|
return f"<freevar {self.label}>"
|
||||||
|
|
||||||
|
def __str__(self):
|
||||||
|
return f"{self.label}"
|
||||||
|
|
||||||
|
|
||||||
|
class macro:
|
||||||
|
"""
|
||||||
|
Represents a "macro" in lambda calculus,
|
||||||
|
a variable that expands to an expression.
|
||||||
|
|
||||||
|
These don't have inherent logic, they
|
||||||
|
just make writing and reading expressions
|
||||||
|
easier.
|
||||||
|
|
||||||
|
These are defined as follows:
|
||||||
|
<macro name> = <expression>
|
||||||
|
"""
|
||||||
|
|
||||||
|
@staticmethod
|
||||||
|
def from_parse(result):
|
||||||
|
return macro(
|
||||||
|
result[0],
|
||||||
|
)
|
||||||
|
|
||||||
|
def __init__(self, name):
|
||||||
|
self.name = name
|
||||||
|
def __repr__(self):
|
||||||
|
return f"<{self.name}>"
|
||||||
|
def __str__(self):
|
||||||
|
return self.name
|
||||||
|
|
||||||
|
def __eq__(self, other):
|
||||||
|
if not isinstance(other, macro):
|
||||||
|
raise TypeError("Can only compare macro with macro")
|
||||||
|
return self.name == other.name
|
||||||
|
|
||||||
|
def expand(self, macro_table = {}, *, auto_free_vars = True):
|
||||||
|
if self.name in macro_table:
|
||||||
|
return macro_table[self.name]
|
||||||
|
elif not auto_free_vars:
|
||||||
|
raise NameError(f"Name {self.name} is not defined!")
|
||||||
|
else:
|
||||||
|
return free_variable(self.name)
|
||||||
|
|
||||||
|
|
||||||
|
class macro_expression:
|
||||||
|
"""
|
||||||
|
Represents a line that looks like
|
||||||
|
<name> = <expression>
|
||||||
|
|
||||||
|
Doesn't do anything particularly interesting,
|
||||||
|
just holds an expression until it is stored
|
||||||
|
in the runner's macro table.
|
||||||
|
"""
|
||||||
|
|
||||||
|
@staticmethod
|
||||||
|
def from_parse(result):
|
||||||
|
return macro_expression(
|
||||||
|
result[0].name,
|
||||||
|
result[1]
|
||||||
|
)
|
||||||
|
|
||||||
|
def __init__(self, label, exp):
|
||||||
|
self.label = label
|
||||||
|
self.exp = exp
|
||||||
|
|
||||||
|
def __repr__(self):
|
||||||
|
return f"<{self.label} := {self.exp!r}>"
|
||||||
|
|
||||||
|
def __str__(self):
|
||||||
|
return f"{self.label} := {self.exp}"
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
bound_variable_counter = 0
|
||||||
|
class bound_variable:
|
||||||
|
def __init__(self, forced_id = None):
|
||||||
|
global bound_variable_counter
|
||||||
|
|
||||||
|
if forced_id is None:
|
||||||
|
self.identifier = bound_variable_counter
|
||||||
|
bound_variable_counter += 1
|
||||||
|
else:
|
||||||
|
self.identifier = forced_id
|
||||||
|
|
||||||
|
def __eq__(self, other):
|
||||||
|
if not isinstance(other, bound_variable):
|
||||||
|
raise TypeError(f"Cannot compare bound_variable with {type(other)}")
|
||||||
|
return self.identifier == other.identifier
|
||||||
|
|
||||||
|
def __repr__(self):
|
||||||
|
return f"<in {self.identifier}>"
|
||||||
|
|
||||||
|
class lambda_func:
|
||||||
|
"""
|
||||||
|
Represents a function.
|
||||||
|
Defined like λa.aa
|
||||||
|
|
||||||
|
After being created by the parser, a function
|
||||||
|
needs to have its variables bound. This cannot
|
||||||
|
happen during parsing, since the parser creates
|
||||||
|
functions "inside-out," and we need all inner
|
||||||
|
functions before we bind variables.
|
||||||
|
"""
|
||||||
|
|
||||||
|
@staticmethod
|
||||||
|
def from_parse(result):
|
||||||
|
return lambda_func(
|
||||||
|
result[0],
|
||||||
|
result[1]
|
||||||
|
)
|
||||||
|
|
||||||
|
def __init__(self, input_var, output):
|
||||||
|
self.input = input_var
|
||||||
|
self.output = output
|
||||||
|
|
||||||
|
def __repr__(self) -> str:
|
||||||
|
return f"<{self.input!r} → {self.output!r}>"
|
||||||
|
|
||||||
|
def __str__(self) -> str:
|
||||||
|
return f"λ{self.input}.{self.output}"
|
||||||
|
|
||||||
|
|
||||||
|
def bind_variables(
|
||||||
|
self,
|
||||||
|
placeholder: macro | None = None,
|
||||||
|
val: bound_variable | None = None,
|
||||||
|
*,
|
||||||
|
binding_self: bool = False
|
||||||
|
) -> None:
|
||||||
|
"""
|
||||||
|
Go through this function and all the functions inside it,
|
||||||
|
and replace the strings generated by the parser with bound
|
||||||
|
variables or free variables.
|
||||||
|
|
||||||
|
If values are passed to `placeholder` and `val,`
|
||||||
|
we're binding the variable of a function containing
|
||||||
|
this one. If they are both none, start the binding
|
||||||
|
chain with this function.
|
||||||
|
|
||||||
|
If only one of those arguments is None, something is very wrong.
|
||||||
|
|
||||||
|
`placeholder` is a macro, NOT A STRING!
|
||||||
|
The parser assumes all names are macros at first, variable
|
||||||
|
binding fixes those that are actually bound variables.
|
||||||
|
|
||||||
|
If `binding_self` is True, don't throw an error on a name conflict
|
||||||
|
and don't bind this function's input variable.
|
||||||
|
This is used when we're calling this method to bind this function's
|
||||||
|
variable.
|
||||||
|
"""
|
||||||
|
|
||||||
|
|
||||||
|
if (placeholder is None) and (val != placeholder):
|
||||||
|
raise Exception(
|
||||||
|
"Error while binding variables: placeholder and val are both None."
|
||||||
|
)
|
||||||
|
|
||||||
|
# We only need to check for collisions if we're
|
||||||
|
# binding another function's variable. If this
|
||||||
|
# function starts the bind chain, skip that step.
|
||||||
|
if not ((placeholder is None) and (val is None)):
|
||||||
|
if not binding_self and isinstance(self.input, macro):
|
||||||
|
if self.input == placeholder:
|
||||||
|
raise NameError("Bound variable name conflict.")
|
||||||
|
|
||||||
|
# If this function's variables haven't been bound yet,
|
||||||
|
# bind them BEFORE binding the outer function's.
|
||||||
|
#
|
||||||
|
# If we bind inner functions' variables before outer
|
||||||
|
# functions' variables, we won't be able to detect
|
||||||
|
# name conflicts.
|
||||||
|
if isinstance(self.input, macro) and not binding_self:
|
||||||
|
new_bound_var = bound_variable()
|
||||||
|
self.bind_variables(
|
||||||
|
self.input,
|
||||||
|
new_bound_var,
|
||||||
|
binding_self = True
|
||||||
|
)
|
||||||
|
self.input = new_bound_var
|
||||||
|
|
||||||
|
|
||||||
|
# Bind variables inside this function.
|
||||||
|
if isinstance(self.output, macro):
|
||||||
|
if self.output == placeholder:
|
||||||
|
self.output = val
|
||||||
|
elif isinstance(self.output, lambda_func):
|
||||||
|
self.output.bind_variables(placeholder, val)
|
||||||
|
elif isinstance(self.output, lambda_apply):
|
||||||
|
self.output.bind_variables(placeholder, val)
|
||||||
|
|
||||||
|
# Expand this function's output.
|
||||||
|
# For functions, this isn't done unless
|
||||||
|
# its explicitly asked for.
|
||||||
|
def expand(self, macro_table = {}):
|
||||||
|
new_out = self.output
|
||||||
|
if isinstance(self.output, macro):
|
||||||
|
new_out = self.output.expand(macro_table)
|
||||||
|
|
||||||
|
# If the macro becomes a free variable, expand again.
|
||||||
|
if isinstance(new_out, free_variable):
|
||||||
|
lambda_func(
|
||||||
|
self.input,
|
||||||
|
new_out
|
||||||
|
).expand(macro_table)
|
||||||
|
|
||||||
|
elif isinstance(self.output, lambda_func):
|
||||||
|
new_out = self.output.expand(macro_table)
|
||||||
|
elif isinstance(self.output, lambda_apply):
|
||||||
|
new_out = self.output.expand(macro_table)
|
||||||
|
return lambda_func(
|
||||||
|
self.input,
|
||||||
|
new_out
|
||||||
|
)
|
||||||
|
|
||||||
|
def apply(
|
||||||
|
self,
|
||||||
|
val,
|
||||||
|
*,
|
||||||
|
bound_var: bound_variable | None = None
|
||||||
|
):
|
||||||
|
"""
|
||||||
|
Substitute `bound_var` into all instances of a bound variable `var`.
|
||||||
|
If `bound_var` is none, use this functions bound variable.
|
||||||
|
Returns a new object.
|
||||||
|
"""
|
||||||
|
|
||||||
|
calling_self = False
|
||||||
|
if bound_var is None:
|
||||||
|
calling_self = True
|
||||||
|
bound_var = self.input
|
||||||
|
new_out = self.output
|
||||||
|
if isinstance(self.output, bound_variable):
|
||||||
|
if self.output == bound_var:
|
||||||
|
new_out = val
|
||||||
|
elif isinstance(self.output, lambda_func):
|
||||||
|
new_out = self.output.apply(val, bound_var = bound_var)
|
||||||
|
elif isinstance(self.output, lambda_apply):
|
||||||
|
new_out = self.output.sub_bound_var(val, bound_var = bound_var)
|
||||||
|
else:
|
||||||
|
raise TypeError("Cannot apply a function to {self.output!r}")
|
||||||
|
|
||||||
|
# If we're applying THIS function,
|
||||||
|
# just give the output
|
||||||
|
if calling_self:
|
||||||
|
return new_out
|
||||||
|
|
||||||
|
# If we're applying another function,
|
||||||
|
# return this one with substitutions
|
||||||
|
else:
|
||||||
|
return lambda_func(
|
||||||
|
self.input,
|
||||||
|
new_out
|
||||||
|
)
|
||||||
|
|
||||||
|
|
||||||
|
class lambda_apply:
|
||||||
|
"""
|
||||||
|
Represents a function application.
|
||||||
|
Has two elements: fn, the function,
|
||||||
|
and arg, the thing it acts upon.
|
||||||
|
|
||||||
|
Parentheses are handled by the parser, and
|
||||||
|
chained functions are handled by from_parse.
|
||||||
|
"""
|
||||||
|
|
||||||
|
@staticmethod
|
||||||
|
def from_parse(result):
|
||||||
|
if len(result) == 2:
|
||||||
|
return lambda_apply(
|
||||||
|
result[0],
|
||||||
|
result[1]
|
||||||
|
)
|
||||||
|
elif len(result) > 2:
|
||||||
|
return lambda_apply.from_parse([
|
||||||
|
lambda_apply(
|
||||||
|
result[0],
|
||||||
|
result[1]
|
||||||
|
)] + result[2:]
|
||||||
|
)
|
||||||
|
|
||||||
|
def __init__(
|
||||||
|
self,
|
||||||
|
fn,
|
||||||
|
arg
|
||||||
|
):
|
||||||
|
self.fn = fn
|
||||||
|
self.arg = arg
|
||||||
|
|
||||||
|
def __repr__(self) -> str:
|
||||||
|
return f"<{self.fn!r} | {self.arg!r}>"
|
||||||
|
|
||||||
|
def __str__(self) -> str:
|
||||||
|
return f"({self.fn} {self.arg})"
|
||||||
|
|
||||||
|
def bind_variables(
|
||||||
|
self,
|
||||||
|
placeholder: macro | None = None,
|
||||||
|
val: bound_variable | None = None
|
||||||
|
) -> None:
|
||||||
|
"""
|
||||||
|
Does exactly what lambda_func.bind_variables does,
|
||||||
|
but acts on applications instead.
|
||||||
|
|
||||||
|
There will be little documentation in this method,
|
||||||
|
see lambda_func.bind_variables.
|
||||||
|
"""
|
||||||
|
|
||||||
|
if (placeholder is None) and (val != placeholder):
|
||||||
|
raise Exception(
|
||||||
|
"Error while binding variables: placeholder and val are both None."
|
||||||
|
)
|
||||||
|
|
||||||
|
# If val and placeholder are None,
|
||||||
|
# everything below should still work as expected.
|
||||||
|
if isinstance(self.fn, macro) and placeholder is not None:
|
||||||
|
if self.fn == placeholder:
|
||||||
|
self.fn = val
|
||||||
|
elif isinstance(self.fn, lambda_func):
|
||||||
|
self.fn.bind_variables(placeholder, val)
|
||||||
|
elif isinstance(self.fn, lambda_apply):
|
||||||
|
self.fn.bind_variables(placeholder, val)
|
||||||
|
|
||||||
|
if isinstance(self.arg, macro) and placeholder is not None:
|
||||||
|
if self.arg == placeholder:
|
||||||
|
self.arg = val
|
||||||
|
elif isinstance(self.arg, lambda_func):
|
||||||
|
self.arg.bind_variables(placeholder, val)
|
||||||
|
elif isinstance(self.arg, lambda_apply):
|
||||||
|
self.arg.bind_variables(placeholder, val)
|
||||||
|
|
||||||
|
def sub_bound_var(
|
||||||
|
self,
|
||||||
|
val,
|
||||||
|
*,
|
||||||
|
bound_var: bound_variable
|
||||||
|
):
|
||||||
|
|
||||||
|
new_fn = self.fn
|
||||||
|
if isinstance(self.fn, bound_variable):
|
||||||
|
if self.fn == bound_var:
|
||||||
|
new_fn = val
|
||||||
|
elif isinstance(self.fn, lambda_func):
|
||||||
|
new_fn = self.fn.apply(val, bound_var = bound_var)
|
||||||
|
elif isinstance(self.fn, lambda_apply):
|
||||||
|
new_fn = self.fn.sub_bound_var(val, bound_var = bound_var)
|
||||||
|
|
||||||
|
new_arg = self.arg
|
||||||
|
if isinstance(self.arg, bound_variable):
|
||||||
|
if self.arg == bound_var:
|
||||||
|
new_arg = val
|
||||||
|
elif isinstance(self.arg, lambda_func):
|
||||||
|
new_arg = self.arg.apply(val, bound_var = bound_var)
|
||||||
|
elif isinstance(self.arg, lambda_apply):
|
||||||
|
new_arg = self.arg.sub_bound_var(val, bound_var = bound_var)
|
||||||
|
|
||||||
|
return lambda_apply(
|
||||||
|
new_fn,
|
||||||
|
new_arg
|
||||||
|
)
|
||||||
|
|
||||||
|
def expand(self, macro_table = {}):
|
||||||
|
# If fn is a function, apply it.
|
||||||
|
if isinstance(self.fn, lambda_func):
|
||||||
|
return self.fn.apply(self.arg)
|
||||||
|
# If fn is an application or macro, expand it.
|
||||||
|
elif isinstance(self.fn, macro):
|
||||||
|
f = lambda_apply(
|
||||||
|
m := self.fn.expand(macro_table),
|
||||||
|
self.arg
|
||||||
|
)
|
||||||
|
|
||||||
|
# If a macro becomes a free variable,
|
||||||
|
# expand twice.
|
||||||
|
if isinstance(m, free_variable):
|
||||||
|
return f.expand(macro_table)
|
||||||
|
else:
|
||||||
|
return f
|
||||||
|
|
||||||
|
elif isinstance(self.fn, lambda_apply):
|
||||||
|
return lambda_apply(
|
||||||
|
self.fn.expand(macro_table),
|
||||||
|
self.arg
|
||||||
|
)
|
||||||
|
|
||||||
|
# If we get to this point, the function we're applying
|
||||||
|
# can't be expanded. That means it's a free or bound
|
||||||
|
# variable. If that happens, expand the arg instead.
|
||||||
|
elif (
|
||||||
|
isinstance(self.arg, lambda_apply) or
|
||||||
|
isinstance(self.arg, lambda_func)
|
||||||
|
):
|
||||||
|
return lambda_apply(
|
||||||
|
self.fn,
|
||||||
|
self.arg.expand(macro_table)
|
||||||
|
)
|
||||||
|
|
||||||
|
return self
|
||||||
Reference in New Issue