__all__ = ["Listhell"]

__version__ = '2.0.0'

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

from mcpyrate.dialects import Dialect

from mcpyrate.splicing import splice_dialect

class Listhell(Dialect):

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

with q as template:

__lang__ = "Listhell" # noqa: F841, just provide it to user code.

from unpythonic.syntax import macros, prefix, autocurry # noqa: F401, F811

# auxiliary syntax elements for the macros

from unpythonic.syntax import q, u, kw # noqa: F401

from unpythonic import apply # noqa: F401

from unpythonic import composerc as compose # compose from Right, Currying # noqa: F401

with prefix, autocurry:

__paste_here__ # noqa: F821, just a splicing marker.

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

return tree

__all__ = ["Pytkell"]

__version__ = '2.0.0'

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

from mcpyrate.dialects import Dialect

from mcpyrate.splicing import splice_dialect

class Pytkell(Dialect):

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

with q as template:

__lang__ = "Pytkell" # noqa: F841, just provide it to user code.

from unpythonic.syntax import (macros, lazy, lazyrec, lazify, autocurry, # noqa: F401, F811

let, letseq, letrec,

dlet, dletseq, dletrec,

blet, bletseq, bletrec,

local, delete, do, do0,

cond, forall)

# auxiliary syntax elements for the macros

from unpythonic.syntax import where, insist, deny # noqa: F401

# functions that have a haskelly feel to them

from unpythonic import (foldl, foldr, scanl, scanr, # noqa: F401

s, imathify, gmathify, frozendict,

memoize, fupdate, fup,

gmemoize, imemoize, fimemoize,

islice, take, drop, split_at, first, second, nth, last,

flip, rotate)

from unpythonic import composerc as compose # compose from Right, Currying (Haskell's . operator) # noqa: F401

# this is a bit lispy, but we're not going out of our way to provide

# a haskelly surface syntax for these.

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

with lazify, autocurry:

__paste_here__ # noqa: F821, just a splicing marker.

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

return tree

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

from ...syntax import macros, let, local, delete, do # noqa: F401

from ...syntax import where # for let-where # noqa: F401

from unpythonic import foldr, cons, nil, ll

def runtests():

# Function calls can be made in prefix notation, like in Lisps.

# The first element of a literal tuple is the function to call,

# the rest are its arguments.

(print, f"Hello from {__lang__}!") # noqa: F821, the dialect template defines it.

x = 42 # can write any regular Python, too

# quote operator q locally turns off the function-call transformation:

t1 = (q, 1, 2, (3, 4), 5) # q takes effect recursively # noqa: F821, the dialect template defines `q`.

t2 = (q, 17, 23, x) # unlike in Lisps, x refers to its value even in a quote # noqa: F821

(print, t1, t2)

# unquote operator u locally turns the transformation back on:

t3 = (q, (u, print, 42), (print, 42), "foo", "bar") # noqa: F821

assert t3 == (q, None, (print, 42), "foo", "bar") # noqa: F821

# quotes nest; call transformation made when quote level == 0

t4 = (q, (print, 42), (q, (u, u, print, 42)), "foo", "bar") # noqa: F821

assert t4 == (q, (print, 42), (None,), "foo", "bar") # noqa: F821

# Be careful:

#

# In LisThEll, this means "call the 0-arg function `x`".

# But if `x` is not callable, `currycall` will return

# the value as-is (needed for interaction with `call_ec`

# and some other replace-def-with-value decorators).

assert (x,) == 42

# This means "the tuple where the first element is `x`"

(q, x) # noqa: F821

# give named args with kw(...) [it's syntax, not really a function!]:

def f(*, a, b):

return (q, a, b) # noqa: F821

# in one kw(...), or...

assert (f, kw(a="hi there", b="foo")) == (q, "hi there", "foo") # noqa: F821

# in several kw(...), doesn't matter

assert (f, kw(a="hi there"), kw(b="foo")) == (q, "hi there", "foo") # noqa: F821

# in case of duplicate name across kws, rightmost wins

assert (f, kw(a="hi there"), kw(b="foo"), kw(b="bar")) == (q, "hi there", "bar") # noqa: F821

# give *args with unpythonic.fun.apply, like in Lisps:

lst = [1, 2, 3]

def g(*args, **kwargs):

return args + tuple(sorted(kwargs.items()))

assert (apply, g, lst) == (q, 1, 2, 3) # noqa: F821

# lst goes last; may have other args first

assert (apply, g, "hi", "ho", lst) == (q, "hi", "ho", 1, 2, 3) # noqa: F821

# named args in apply are also fine

assert (apply, g, "hi", "ho", lst, kw(myarg=4)) == (q, "hi", "ho", 1, 2, 3, ('myarg', 4)) # noqa: F821

# Function call transformation only applies to tuples in load context

# (i.e. NOT on the LHS of an assignment)

a, b = (q, 100, 200) # noqa: F821

assert a == 100 and b == 200

a, b = (q, b, a) # pythonic swap in prefix syntax; must quote RHS # noqa: F821

assert a == 200 and b == 100

# the prefix syntax leaves alone the let binding syntax ((name0, value0), ...)

a = let[(x, 42)][x << x + 1]

assert a == 43

# but the RHSs of the bindings are transformed normally:

def double(x):

return 2 * x

a = let[(x, (double, 21))][x << x + 1]

assert a == 43

# similarly, the prefix syntax leaves the "body tuple" of a do alone

# (syntax, not semantically a tuple), but recurses into it:

a = do[1, 2, 3]

assert a == 3

a = do[1, 2, (double, 3)]

assert a == 6

# the extra bracket syntax (implicit do) has no danger of confusion, as it's a list, not tuple

a = let[(x, 3)][[

1,

2,

(double, x)]]

assert a == 6

my_map = lambda f: (foldr, (compose, cons, f), nil) # noqa: F821

assert (my_map, double, (q, 1, 2, 3)) == (ll, 2, 4, 6) # noqa: F821

(print, "All tests PASSED")

if __name__ == '__main__':

(runtests,)

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

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

from ...misc import timer

from types import FunctionType

from operator import add, mul

def runtests():

print(f"Hello from {__lang__}!") # noqa: F821, the dialect template defines it.

# function definitions (both def and lambda) and calls are auto-curried

def add3(a, b, c):

return a + b + c

a = add3(1)

assert isinstance(a, FunctionType)

a = a(2)

assert isinstance(a, FunctionType)

a = a(3)

assert isinstance(a, int)

# actually partial evaluation so any of these works

assert add3(1)(2)(3) == 6

assert add3(1, 2)(3) == 6

assert add3(1)(2, 3) == 6

assert add3(1, 2, 3) == 6

# arguments of a function call are auto-lazified (converted to promises, MacroPy lazy[])

def addfirst2(a, b, c):

# a and b are read, so their promises are forced

# c is not used, so not evaluated either

return a + b

assert addfirst2(1)(2)(1 / 0) == 3

# let-bindings are auto-lazified

x = let[((x, 42), # noqa: F821

(y, 1 / 0)) in x] # noqa: F821

assert x == 42

# assignments are not (because they can imperatively update existing names)

try:

a = 1 / 0

except ZeroDivisionError:

pass

else:

assert False, "expected a zero division error"

# so if you want that, use lazy[] manually (it's a builtin in Pytkell)

a = lazy[1 / 0] # this blows up only when the value is read (name 'a' in Load context) # noqa: F821

# manually lazify items in a data structure literal, recursively (see unpythonic.syntax.lazyrec):

a = lazyrec[(1, 2, 3 / 0)] # noqa: F821

assert a[:-1] == (1, 2) # reading a slice forces only that slice

# laziness passes through

def g(a, b):

return a # b not used

def f(a, b):

return g(a, b) # b is passed along, but its value is not used

assert f(42, 1 / 0) == 42

def f(a, b):

return (a, b)

assert f(1, 2) == (1, 2)

assert (flip(f))(1, 2) == (2, 1) # NOTE flip reverses all (doesn't just flip the first two) # noqa: F821

# http://www.cse.chalmers.se/~rjmh/Papers/whyfp.html

my_sum = foldl(add, 0) # noqa: F821

my_prod = foldl(mul, 1) # noqa: F821

my_map = lambda f: foldr(compose(cons, f), nil) # compose is unpythonic.fun.composerc # noqa: F821

assert my_sum(range(1, 5)) == 10

assert my_prod(range(1, 5)) == 24

assert tuple(my_map((lambda x: 2 * x), (1, 2, 3))) == (2, 4, 6)

assert tuple(scanl(add, 0, (1, 2, 3))) == (0, 1, 3, 6) # noqa: F821

assert tuple(scanr(add, 0, (1, 2, 3))) == (0, 3, 5, 6) # NOTE output ordering different from Haskell # noqa: F821

# let-in

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

assert x == 42

x = let[((a, 21), # noqa: F821

(b, 17)) in # noqa: F821

2 * a + b] # noqa: F821

assert x == 59

# let-where

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

assert x == 42

x = let[2 * a + b, # noqa: F821

where((a, 21), # noqa: F821

(b, 17))] # noqa: F821

assert x == 59

# nondeterministic evaluation (essentially do-notation in the List monad)

#

# pythagorean triples

pt = forall[z << range(1, 21), # hypotenuse # noqa: F821

x << range(1, z + 1), # shorter leg # noqa: F821

y << range(x, z + 1), # longer leg # noqa: F821

insist(x * x + y * y == z * z), # see also deny() # noqa: F821

(x, y, z)] # noqa: F821

assert tuple(sorted(pt)) == ((3, 4, 5), (5, 12, 13), (6, 8, 10),

(8, 15, 17), (9, 12, 15), (12, 16, 20))

# functional update for sequences

#

tup1 = (1, 2, 3, 4, 5)

tup2 = fup(tup1)[2:] << (10, 20, 30) # fup(sequence)[idx_or_slice] << sequence_of_values # noqa: F821

assert tup2 == (1, 2, 10, 20, 30)

assert tup1 == (1, 2, 3, 4, 5)

# immutable dict, with functional update

#

d1 = frozendict(foo='bar', bar='tavern') # noqa: F821

d2 = frozendict(d1, bar='pub') # noqa: F821

assert tuple(sorted(d1.items())) == (('bar', 'tavern'), ('foo', 'bar'))

assert tuple(sorted(d2.items())) == (('bar', 'pub'), ('foo', 'bar'))

# s = mathematical Sequence (const, arithmetic, geometric, power)

#

assert last(take(10000, s(1, ...))) == 1 # noqa: F821

assert last(take(5, s(0, 1, ...))) == 4 # noqa: F821

assert last(take(5, s(1, 2, 4, ...))) == (1 * 2 * 2 * 2 * 2) # 16 # noqa: F821

assert last(take(5, s(2, 4, 16, ...))) == (((((2)**2)**2)**2)**2) # 65536 # noqa: F821

# s() takes care to avoid roundoff

assert last(take(1001, s(0, 0.001, ...))) == 1 # noqa: F821

# iterables returned by s() support infix math

# (to add infix math support to some other iterable, m(iterable))

c = s(1, 3, ...) + s(2, 4, ...) # noqa: F821

assert tuple(take(5, c)) == (3, 7, 11, 15, 19) # noqa: F821

assert tuple(take(5, c)) == (23, 27, 31, 35, 39) # consumed! # noqa: F821

# imemoize = memoize Iterable (makes a gfunc, drops math support)

# gmathify returns a new gfunc that adds infix math support

# to generators the original gfunc makes.

#

# see also gmemoize, fimemoize in unpythonic

#

mi = lambda x: gmathify(imemoize(x)) # noqa: F821

a = mi(s(1, 3, ...)) # noqa: F821

b = mi(s(2, 4, ...)) # noqa: F821

c = lambda: a() + b()

assert tuple(take(5, c())) == (3, 7, 11, 15, 19) # noqa: F821

assert tuple(take(5, c())) == (3, 7, 11, 15, 19) # now it's a new instance; no recomputation # noqa: F821

factorials = mi(scanl(mul, 1, s(1, 2, ...))) # 0!, 1!, 2!, ... # noqa: F821

assert last(take(6, factorials())) == 120 # noqa: F821

assert first(drop(5, factorials())) == 120 # noqa: F821

squares = s(1, 2, ...)**2 # noqa: F821

assert last(take(10, squares)) == 100 # noqa: F821

harmonic = 1 / s(1, 2, ...) # noqa: F821

assert last(take(10, harmonic)) == 1 / 10 # noqa: F821

# unpythonic's continuations are supported

with continuations:

k = None # kontinuation

def setk(*args, cc):

nonlocal k

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

return args # tuple means multiple-return-values

def doit():

lst = ['the call returned']

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

return 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', '!']

# as is unpythonic's tco

with tco:

def fact(n):

def f(k, acc):

if k == 1:

return acc

return f(k - 1, k * acc)

return f(n, 1) # TODO: doesn't work as f(n, acc=1) due to curry's kwarg handling

assert fact(4) == 24

print("Performance...")

with timer() as tictoc:

fact(5000) # no crash, but Pytkell is a bit slow

print(" Time taken for factorial of 5000: {:g}s".format(tictoc.dt))

print("All tests PASSED")

if __name__ == '__main__':

runtests()