# -*- coding: utf-8 -*-

from ..syntax import macros, test, test_raises # noqa: F401

from ..test.fixtures import session, testset

from functools import partial

from ..lispylet import let, letrec, dlet, dletrec, blet, bletrec

from ..seq import begin

def runtests():

with testset("basic usage"):

x = let((('a', 1),

('b', 2)),

lambda e: e.a + e.b)

test[x == 3]

x = letrec((('a', 1),

('b', lambda e:

e.a + 2)), # hence, b = 3

lambda e:

e.a + e.b)

test[x == 4]

# mutually recursive functions

t = letrec((('evenp', lambda e:

lambda x:

(x == 0) or e.oddp(x - 1)),

('oddp', lambda e:

lambda x:

(x != 0) and e.evenp(x - 1))),

lambda e:

e.evenp(42))

test[t is True]

f = lambda lst: letrec((("seen", set()),

("see", lambda e:

lambda x:

begin(e.seen.add(x),

x))),

lambda e:

[e.see(x) for x in lst if x not in e.seen])

L = [1, 1, 3, 1, 3, 2, 3, 2, 2, 2, 4, 4, 1, 2, 3]

test[f(L) == [1, 3, 2, 4]]

# Callable values always need a surrounding "lambda e: ...".

with testset("additional examples with callable values"):

test[letrec((('a', 2),

('f', lambda e:

lambda x: # callable, needs the surrounding "lambda e: ...", even though it doesn't use e.

42 * x)),

lambda e:

e.a * e.f(1)) == 84]

square = lambda x: x**2

test[letrec((('a', 2),

('f', lambda e: square)), # callable, needs "lambda e: ..."

lambda e:

e.a * e.f(10)) == 200]

def mul(x, y):

return x * y

test[letrec((('a', 2),

('f', lambda e: mul)), # "mul" is a callable

lambda e:

e.a * e.f(3, 4)) == 24]

double = partial(mul, 2)

test[letrec((('a', 2),

('f', lambda e: double)), # "double" is a callable

lambda e:

e.a * e.f(3)) == 12]

class TimesA:

def __init__(self, a):

self.a = a

def __call__(self, x):

return self.a * x

times5 = TimesA(5)

test[letrec((('a', 2),

('f', lambda e: times5)), # "times5" is a callable

lambda e:

e.a * e.f(3)) == 30]

with testset("let over lambda"):

lc = let((('count', 0),),

lambda e:

lambda: begin(e.set('count', e.count + 1),

e.count))

lc()

lc()

test[lc() == 3]

with testset("let over def"):

@dlet((('x', 17),))

def foo(*, env):

return env.x

test[foo() == 17]

@dletrec((('x', 2),

('y', lambda e: e.x + 3)))

def bar(a, *, env):

return a + env.y

test[bar(10) == 15]

@dlet((('count', 0),))

def counter(*, env):

env.count += 1

return env.count

counter()

counter()

test[counter() == 3]

with testset("let block"):

@blet((('x', 9001),))

def over9000(*, env):

return env.x

test[over9000 == 9001]

@bletrec((('evenp', lambda e:

lambda x:

(x == 0) or e.oddp(x - 1)),

('oddp', lambda e:

lambda x:

(x != 0) and e.evenp(x - 1)),))

def result(*, env):

return env.evenp(42)

test[result is True]

with testset("error cases"):

test_raises[AttributeError,

letrec((('a', lambda e:

e.b + 1), # error, e.b does not exist yet (simple value refers to binding below it)

('b', 42)),

lambda e:

e.a)]

test_raises[AttributeError,

let((('x', 0),),

lambda e:

e.set('y', 3)),

"e.y should not be defined"]

with test_raises[AttributeError, "let environment should be final (should not be able to create new bindings in it inside the let body)"]:

@blet((('x', 1),))

def error1(*, env):

env.y = 2 # error, cannot introduce new bindings into a let environment

test_raises[TypeError, let((), "not a callable")]

test_raises[TypeError, let((), lambda: None)] # body callable must be able to take in environment

test_raises[AttributeError, let((('x', 1),

('x', 2)), lambda e: e.x)] # trying to reassign same name

test_raises[TypeError, letrec((('x', lambda: 1),), lambda e: e.x)] # callable value must be able to take in environment

if __name__ == '__main__': # pragma: no cover

with session(__file__):

runtests()