def parse_import(form):
check(len(form) >= 2, '`import` requires 1+ args', form)
form = form[1:]
if is_list(form[0]):
symbols = form.pop(0)
check(all(is_symbol(x) for x in symbols),
'imported names must be symbols', symbols)
form.pop(0)
else:
symbols = None
source = form.pop(0)
check(is_symbol(source), 'import source must be a symbol', source)
alias = form[1] if form else None
if alias:
check(is_symbol(alias), 'import alias must be a symbol', alias)
return Import(source, symbols, alias)
def parse(cls, L):
if not (is_list(L) and all(is_symbol(p) for p in L)):
_err('params must be list of symbols', L)
required_names = [sym.name for sym in cls._parse_required(L)]
optional_names = [sym.name for sym in cls._parse_optional(L)]
rest = cls._parse_rest(L)
rest_name = rest and rest.name or None
return cls(required_names, optional_names, rest_name)
def parse(cls, L):
if len(L) != 3:
_err('wrong number of args to def', L)
sym = L[1]
if not is_symbol(sym):
_err('first arg to def must be symbol', L)
val = L[2]
return cls(sym, val)
def parse_params(form):
check(
is_list(form) and all(is_symbol(p) for p in form),
'params must be a list of symbols', form)
required = _parse_required_params(form)
optional = _parse_optional_params(form)
rest = _parse_rest_param(form)
return Params(required, optional, rest)
def define(cls, L):
if len(L) < 3:
_err('wrong number of args to defmacro', L)
name = L[1]
if not is_symbol(name):
_err('invalid macro name', name)
params = Params.parse(L[2])
body = L[3:]
return Def(name, cls(params, body))
def parse(expr):
if is_list(expr) and expr and is_symbol(expr[0]):
try:
f = SPECIAL_FORMS[expr[0]]
except KeyError:
pass
else:
expr = f(expr)
return expr
def eval__Import(self, node): # pylint: disable=invalid-name
symbols = '*' if is_symbol(node.names) and node.names.name == '*' \
else tuple(sym.name for sym in node.names) if is_list(node.names) \
else ()
alias = node.alias.name if node.alias else None
if node.source.ns == 'py':
self.ns.import_module(self.ns.load_module(node.source.name),
symbols, alias)
else:
self.ns.import_ns(self.ns.load_ns(node.source.name), symbols,
alias)
def parse_def(form):
check(len(form) == 3, '`def` requires 2 args', form)
_, sym, val = form
check(is_symbol(sym), '`def` name must be a symbol', form)
# If namespace `a` imports symbol `foo` from namespace `b`, then provides
# `(def foo …)`, the reader resolves the symbol to `b/foo`, but the
# intention is to define `a/foo`. To get that behaviour, we discard the
# symbol namespace here.
#
# FIXME: this leads to confusing behaviour if a namespaced symbol is passed
# to the reader. We should throw an error we read a qualified symbol that
# resolves to another namespace, not silently rewrite it.
sym = Symbol(sym.name, None, sym.meta)
return Def(sym, val)
def parse_defmacro(form):
check(len(form) >= 3, '`defmacro` requires 2+ args', form)
_, name, params, *body = form
check(is_symbol(name), 'macro name must be a symbol', name)
return Def(name, Macro(parse_params(params), body))
