__all__ = ["Lispython"]

__version__ = '2.0.0'

from mcpyrate.quotes import macros, q # noqa: F401

from mcpyrate.dialects import Dialect

from mcpyrate.splicing import splice_dialect

class Lispython(Dialect):

"""**Schemers rejoice!**

def transform_ast(self, tree): # tree is an ast.Module

with q as template:

from unpythonic.syntax import (macros, tco, autoreturn, # noqa: F401, F811

multilambda, quicklambda, namedlambda, f,

let, letseq, letrec,

dlet, dletseq, dletrec,

blet, bletseq, bletrec,

local, delete, do, do0,

let_syntax, abbrev,

cond)

# auxiliary syntax elements for the macros

from unpythonic.syntax import where, block, expr # noqa: F401, F811

from unpythonic import cons, car, cdr, ll, llist, nil, prod, dyn # noqa: F401, F811

with namedlambda, autoreturn, quicklambda, multilambda, tco:

__paste_here__ # noqa: F821, just a splicing marker.

tree.body = splice_dialect(tree.body, template, "__paste_here__")

return tree

from ...dialects import dialects, Lispython # noqa: F401

from ...syntax import macros, continuations, call_cc # noqa: F401

from ...fold import foldl

from operator import mul

def main():

assert prod((2, 3, 4)) == 24 # noqa: F821, bye missing battery, hello new dialect builtin

assert foldl(mul, 1, (2, 3, 4)) == 24

# cons, car, cdr, ll, llist are builtins (for more linked list utils, import them from unpythonic)

c = cons(1, 2) # noqa: F821

assert tuple(c) == (1, 2)

assert car(c) == 1 # noqa: F821

assert cdr(c) == 2 # noqa: F821

assert ll(1, 2, 3) == llist((1, 2, 3)) # noqa: F821

# all unpythonic.syntax let[], letseq[], letrec[] constructs are builtins

# (including the decorator versions, let_syntax and abbrev)

x = let[(a, 21) in 2 * a] # noqa: F821

assert x == 42

x = letseq[((a, 1), # noqa: F821

(a, 2 * a), # noqa: F821

(a, 2 * a)) in # noqa: F821

a] # noqa: F821

assert x == 4

# rackety cond

a = lambda x: cond[x < 0, "nope", # noqa: F821

x % 2 == 0, "even",

"odd"]

assert a(-1) == "nope"

assert a(2) == "even"

assert a(3) == "odd"

# auto-TCO (both in defs and lambdas), implicit return in tail position

def fact(n):

def f(k, acc):

if k == 1:

return acc # "return" still available for early return

f(k - 1, k * acc)

f(n, acc=1)

assert fact(4) == 24

fact(5000) # no crash (and correct result, since Python uses bignums transparently)

t = letrec[((evenp, lambda x: (x == 0) or oddp(x - 1)), # noqa: F821

(oddp, lambda x:(x != 0) and evenp(x - 1))) in # noqa: F821

evenp(10000)] # no crash # noqa: F821

assert t is True

# lambdas are named automatically

square = lambda x: x**2

assert square(3) == 9

assert square.__name__ == "square"

# the underscore (NOTE: due to this, "f" is a reserved name in lispython)

cube = f[_**3] # noqa: F821

assert cube(3) == 27

assert cube.__name__ == "cube"

# lambdas can have multiple expressions and local variables

#

# If you need to return a literal list from a lambda, use an extra set of

# brackets; the outermost brackets always enable multiple-expression mode.

#

test = lambda x: [local[y << 2 * x], # noqa: F821, local[name << value] makes a local variable

y + 1] # noqa: F821

assert test(10) == 21

a = lambda x: [local[t << x % 2], # noqa: F821

cond[t == 0, "even", # noqa: F821

t == 1, "odd",

None]] # cond[] requires an else branch

assert a(2) == "even"

assert a(3) == "odd"

# actually the multiple-expression environment is an unpythonic.syntax.do[],

# which can be used in any expression position.

x = do[local[z << 2], # noqa: F821

3 * z] # noqa: F821

assert x == 6

# do0[] is the same, but returns the value of the first expression instead of the last one.

x = do0[local[z << 3], # noqa: F821

print("hi from do0, z is {}".format(z))] # noqa: F821

assert x == 3

# MacroPy #21; namedlambda must be in its own with block in the

# dialect implementation or this particular combination will fail

# (uncaught jump, __name__ not set).

t = letrec[((evenp, lambda x: (x == 0) or oddp(x - 1)), # noqa: F821

(oddp, lambda x:(x != 0) and evenp(x - 1))) in # noqa: F821

[local[x << evenp(100)], # noqa: F821, multi-expression let body is a do[] environment

(x, evenp.__name__, oddp.__name__)]] # noqa: F821

assert t == (True, "evenp", "oddp")

with continuations: # should be skipped by the implicit tco inserted by the dialect

k = None # kontinuation

def setk(*args, cc):

nonlocal k

k = cc # current continuation, i.e. where to go after setk() finishes

args # tuple means multiple-return-values

def doit():

lst = ['the call returned']

*more, = call_cc[setk('A')]

lst + list(more)

assert doit() == ['the call returned', 'A']

# We can now send stuff into k, as long as it conforms to the

# signature of the assignment targets of the "call_cc".

assert k('again') == ['the call returned', 'again']

assert k('thrice', '!') == ['the call returned', 'thrice', '!']

print("All tests PASSED")

if __name__ == '__main__':

main()