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

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

from ..test.fixtures import session, testset, returns_normally

from collections import Counter

import sys

from ..dispatch import generic

from ..fun import (memoize, partial, curry, apply,

identity, const,

andf, orf, notf,

flip, rotate,

composel1, composer1, composel, composer,

composelc, composerc,

to1st, to2nd, tokth, tolast, to,

withself)

from ..dynassign import dyn

from ..arity import UnknownArity

def runtests():

with testset("identity function"):

test[identity(1, 2, 3) == (1, 2, 3)]

test[identity(42) == 42]

test[identity() is None] # no args, default value

with testset("constant function"):

test[const(1, 2, 3)(42, "foo") == (1, 2, 3)]

test[const(42)("anything") == 42]

test[const()("anything") is None]

with testset("@memoize"):

evaluations = Counter()

@memoize

def f(x):

evaluations[x] += 1

return x**2

f(3)

f(3)

f(4)

f(3)

test[all(n == 1 for n in evaluations.values())] # called only once for each unique set of arguments

evaluations = 0

@memoize # <-- important part

def square(x):

nonlocal evaluations

evaluations += 1

return x**2

test[square(2) == 4]

test[evaluations == 1]

test[square(3) == 9]

test[evaluations == 2]

test[square(3) == 9]

test[evaluations == 2] # called only once for each unique set of arguments

test[square(x=3) == 9]

test[evaluations == 2] # only the resulting bindings matter, not how you pass the args

# A tuple with only one object instance per unique contents (contents must be hashable):

@memoize

def memotuple(*args):

return tuple(args)

test[memotuple((1, 2, 3)) is memotuple((1, 2, 3))]

test[memotuple((1, 2, 3)) is not memotuple((1, 2))]

# "memoize lambda": classic evaluate-at-most-once thunk

thunk = memoize(lambda: print("hi from thunk"))

thunk()

thunk()

evaluations = 0

@memoize

def t():

nonlocal evaluations

evaluations += 1

t()

t()

test[evaluations == 1]

# memoizing an instance method

#

# This works essentially because self is an argument, and custom classes

# have a default __hash__. Hence it doesn't matter that the memo lives in

# the "memoized" closure on the class object (type), where the method is,

# and not directly on the instances.

#

# For a solution storing the memo on the instances, see:

# https://github.com/ActiveState/code/tree/master/recipes/Python/577452_memoize_decorator_instance

class Foo:

def __init__(self):

self.evaluations = Counter()

self.x = 42

self.lst = [] # mutable attribute, just to be sure this works generally

@memoize

def doit(self, y):

self.evaluations[(id(self), y)] += 1

return self.x * y

foo1 = Foo()

foo1.doit(1)

foo1.doit(1)

foo1.doit(2)

foo1.doit(3)

foo1.doit(2)

test[all(n == 1 for n in foo1.evaluations.values())]

foo2 = Foo()

assert not foo2.evaluations

foo2.doit(1)

foo2.doit(1)

foo2.doit(2)

foo2.doit(3)

foo2.doit(2)

test[all(n == 1 for n in foo2.evaluations.values())]

with testset("@memoize caches exceptions"):

# exception storage in memoize

class AllOkJustTesting(Exception):

pass

evaluations = 0

@memoize

def t():

nonlocal evaluations

evaluations += 1

raise AllOkJustTesting()

olderr = None

for _ in range(3):

try:

t()

except AllOkJustTesting as err:

if olderr is not None:

test[err is olderr] # exception instance memoized, should be the same every time

olderr = err

else:

fail["memoize should not prevent exception propagation."] # pragma: no cover

test[evaluations == 1]

with testset("partial (type-checking wrapper)"):

def nottypedfunc(x):

return "ok"

def typedfunc(x: int):

return "ok"

test[returns_normally(partial(typedfunc, 42))]

test_raises[TypeError, partial(typedfunc, "abc")]

with testset("@curry"):

@curry

def add3(a, b, c):

return a + b + c

test[add3(1)(2)(3) == 6]

# actually uses partial application so these work, too

test[add3(1, 2)(3) == 6]

test[add3(1)(2, 3) == 6]

test[add3(1, 2, 3) == 6]

# curry uses the type-checking `partial`

@curry

def add3ints(a: int, b: int, c: int):

return a + b + c

test[add3ints(1)(2)(3) == 6]

test[callable(the[add3ints(1)])]

test_raises[TypeError, add3ints(1.0)]

test_raises[TypeError, add3ints(1)(2.0)]

@curry

def lispyadd(*args):

return sum(args)

test[lispyadd() == 0] # no args is a valid arity here

@curry

def foo(a, b, *, c, d):

return a, b, c, d

test[foo(5, c=23)(17, d=42) == (5, 17, 23, 42)]

# currying a thunk is essentially a no-op

evaluations = 0

@curry

def t():

nonlocal evaluations

evaluations += 1

t()

test[evaluations == 1] # t has no args, so it should have been invoked

add = lambda x, y: x + y

a = curry(add)

test[curry(a) is a] # curry wrappers should not stack

# Curry passes through extra args on the right, like in Haskell. Each

# call consumes args up to the maximum arity of the function being

# called. If the return value is callable, it is the next function

# to be (implicitly curried and then) called.

@curry

def f(x): # note f takes only one arg

return lambda y: x * y

test[f(2, 21) == 42]

# Curry raises by default when the top-level curry context exits with

# args remaining. This is so that providing too many args will still

# raise `TypeError`.

def double(x):

return 2 * x

with test_raises[TypeError, "leftover args should not be allowed by default"]:

curry(double, 2, "foo")

# To disable the error, use this trick to explicitly state you want to do so:

with test["leftover args should be allowed with manually created surrounding context"]:

with dyn.let(curry_context=["whatever"]): # any human-readable label is fine.

# a `with test` can optionally return a value, which becomes the asserted expr.

return curry(double, 2, "foo") == (4, "foo")

# Methods of builtin types have uninspectable arity up to Python 3.6.

# Python 3.7 seems to fix this at least for `list`, and PyPy3 (7.3.0; Python 3.6.9)

# doesn't have this error either.

if sys.version_info < (3, 7, 0) and sys.implementation.name == "cpython":

with testset("uninspectable builtins"):

lst = []

test_raises[UnknownArity, curry(lst.append)] # uninspectable method of builtin type

# Internal feature, used by curry macro. If uninspectables are said to be ok,

# then attempting to curry an uninspectable simply returns the original function.

#

# Due to Python's method binding machinery re-triggering the descriptor on each lookup,

# each lookup of `lst.append` will produce a *new* instance of the object that

# represents the bound method (builtin method, in this case). They print the same,

# they look the same... but they `is not` the same.

#

# To avoid this pitfall, we do the lookup exactly once - and then reuse the result.

m1 = lst.append

m2 = curry(m1, _curry_allow_uninspectable=True)

test[m2 is m1]

with testset("curry integration with @generic"): # v0.15.0+

@generic

def f(x: int):

return "int"

@generic

def f(x: float, y: str): # noqa: F811, new multimethod for the same generic function.

return "float, str"

test[callable(curry(f))]

test[curry(f, 42) == "int"]

# Although `f` has a multimethod that takes one argument, if that argument is a float,

# the call signature does not match fully. But it does match partially, so in that case

# `curry` waits for more arguments (because there is at least one multimethod that matches

# the partial arguments given so far).

test[callable(curry(f, 3.14))]

test[curry(f, 3.14, "cat") == "float, str"]

with testset("compose"):

double = lambda x: 2 * x

inc = lambda x: x + 1

inc_then_double = composer1(double, inc)

double_then_inc = composel1(double, inc)

test[inc_then_double(3) == 8]

test[double_then_inc(3) == 7]

inc2_then_double = composer1(double, inc, inc)

double_then_inc2 = composel1(double, inc, inc)

test[inc2_then_double(3) == 10]

test[double_then_inc2(3) == 8]

inc_then_double = composer(double, inc)

double_then_inc = composel(double, inc)

test[inc_then_double(3) == 8]

test[double_then_inc(3) == 7]

inc2_then_double = composer(double, inc, inc)

double_then_inc2 = composel(double, inc, inc)

test[inc2_then_double(3) == 10]

test[double_then_inc2(3) == 8]

with testset("curry in compose chain"):

def f1(a, b):

return 2 * a, 3 * b

def f2(a, b):

return a + b

f1_then_f2_a = composelc(f1, f2)

f1_then_f2_b = composerc(f2, f1)

test[f1_then_f2_a(2, 3) == f1_then_f2_b(2, 3) == 13]

def f3(a, b):

return a, b

def f4(a, b, c):

return a + b + c

f1_then_f3_then_f4 = composelc(f1, f3, f4)

test[f1_then_f3_then_f4(2, 3, 5) == 18] # extra arg passed through on the right

with testset("to1st, to2nd, tolast, to (argument shunting)"):

test[to1st(double)(1, 2, 3) == (2, 2, 3)]

test[to2nd(double)(1, 2, 3) == (1, 4, 3)]

test[tolast(double)(1, 2, 3) == (1, 2, 6)]

processor = to((0, double),

(-1, inc),

(1, composer(double, double)),

(0, inc))

test[processor(1, 2, 3) == (3, 8, 4)]

with testset("tokth error cases"):

test_raises[TypeError, tokth(3, double)()] # expect at least one argument

test_raises[IndexError, tokth(5, double)(1, 2, 3)] # k > length of arglist

with testset("flip arglist"):

def f(a, b):

return (a, b)

test[f(1, 2) == (1, 2)]

test[(flip(f))(1, 2) == (2, 1)]

test[(flip(f))(1, b=2) == (1, 2)] # b -> kwargs

with testset("rotate arglist"):

test[(rotate(-1)(identity))(1, 2, 3) == (3, 1, 2)]

test[(rotate(1)(identity))(1, 2, 3) == (2, 3, 1)]

# inner to outer: (a, b, c) -> (b, c, a) -> (a, c, b)

test[flip(rotate(-1)(identity))(1, 2, 3) == (1, 3, 2)]

with testset("rotate error cases"):

test_raises[TypeError, (rotate(1)(identity))()] # expect at least one argument

test_raises[IndexError, (rotate(5)(identity))(1, 2, 3)] # rotating more than length of arglist

with testset("lispy apply"):

def hello(*args):

return args

test[apply(hello, (1, 2, 3)) == (1, 2, 3)]

test[apply(hello, 1, (2, 3, 4)) == (1, 2, 3, 4)]

test[apply(hello, 1, 2, (3, 4, 5)) == (1, 2, 3, 4, 5)]

test[apply(hello, 1, 2, [3, 4, 5]) == (1, 2, 3, 4, 5)]

with testset("logical combinators"):

test[notf(lambda x: 2 * x)(3) is False]

test[notf(lambda x: 2 * x)(0) is True]

isint = lambda x: isinstance(x, int)

iseven = lambda x: x % 2 == 0

isstr = lambda s: isinstance(s, str)

test[andf(isint, iseven)(42) is True]

test[andf(isint, iseven)(43) is False]

pred = orf(isstr, andf(isint, iseven))

test[pred(42) is True]

test[pred("foo") is True]

test[pred(None) is False] # neither condition holds

with testset("withself (Y combinator trick)"):

fact = withself(lambda self, n: n * self(n - 1) if n > 1 else 1)

test[fact(5) == 120]

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

with session(__file__):

runtests()