class B:

def __init__ (self, name):

self.name = name

def __str__ (self):

return self.name

classify = fun.Function (object, name="classify")

@classify.match (fun.catch (lambda a: a % 2 == 0))

def classify_even (a):

return "even"

@classify.match (fun.catch (lambda a: a % 3 == 0))

def classify_div3 (a, **kwargs):

return "divisible by 3"

@classify.match (fun.val == 0, priority=1)

def classify_zero (a):

return "zero"

@classify.match (lambda a: a > 5, priority=1)

def classify_big (a):

return "big"

@classify.match (fun.any)

def classify_unclassified (a):

return "unclassified"

@classify.match (fun.matchclass (B), priority=2)

def classify_string (a):

return "B"

@classify.match (fun.matchattr (name = "xxx"), priority=3)

def classify_xxx (a):

return "B(xxx)"

assert classify (0) == "zero"

assert classify (1) == "unclassified"

assert classify (2) == "even"

assert classify (3) == "divisible by 3"

assert classify (4) == "even"

assert classify (5) == "unclassified"

assert classify (6) == "big"

assert classify (7) == "big"

assert classify (8) == "big"

assert classify (9) == "big"

assert classify (B ("xx")) == "B"

class C:

def __init__ (self, name, value):

self.name = name

self.value = value

test = fun.Function (object, name="test")

@test.match (fun.bind (X = fun.if_else (fun.matchattr (name = "abc"),

lambda arg: arg.value)))

def do (arg):

return "1:" + X

@test.match (fun.bind (X = fun.if_else (fun.matchattr (name = "def"),

lambda arg: arg.value)))

def do (arg):

return "2:" + X

@test.match (fun.any)

def do (arg):

return "default"

assert test (C ("test", "")) == "default"

assert test (C ("abc", "yay!")) == "1:yay!"

class A:

def __init__ (self, a):

self.m_a = a

def a (self):

return self.m_a

class B:

pass

x = fun.Function (object, object)

@x.match (fun.any, fun.any)

def do (i, j):

return "%s, %s" % (i, j)

@x.match (fun.matchclass (B), fun.any)

def do (i, j):

return "some B, %s" % j

@x.match (fun.any, fun.val == 5)

def do (i, j):

return "%s, value 5" % i

@x.match (fun.bind (X = fun.catch (lambda arg: arg.a ())), fun.any)

def do (i, j):

return "a=%s, %s" % (X, j)

assert (x (1, 2) == "1, 2")

assert (x (A (1), 2) == "a=1, 2")

assert (x (B (), 2) == "some B, 2")

x = fun.Function (object)

# Faulty branch. Calling x must assert.

@x.match (lambda arg: arg)

def do (a):

pass

try:

x (True)

except AssertionError:

assert False, "x (True) failed"

try:

x (8)

asserted = False

except AssertionError:

asserted = True

x = fun.Function (object)

@x.match (fun.any)

def do (i):

return 1

@x.match (fun.val != 3)

def do (i):

return 2

assert x (0) == 2

assert x (1) == 2

assert x (2) == 2

assert x (3) == 1

assert x (4) == 2

assert x (5) == 2

x = fun.Function (object)

@x.match (fun.any)

def do (i):

return 1

@x.match (fun.take_first (fun.val == 2))

def do (i):

return 2

assert x (0) == 1

assert x (0) == 1

assert x (1) == 1

assert x (1) == 1

assert x (2) == 2

assert x (2) == 1

assert x (3) == 1

x = fun.Function (object)

@x.match (fun.any)

def do (i):

return 1

@x.match (fun.or_ (fun.val == 1, fun.val == 2))

def do (i):

return 2

assert x (0) == 1

assert x (0) == 1

assert x (1) == 2

assert x (1) == 2

assert x (2) == 2

assert x (2) == 2

assert x (3) == 1

x = fun.Function (object)

@x.match (fun.any)

def do (i):

return 1

@x.match (fun.and_ (fun.val != 1, fun.val != 2))

def do (i):

return 2

assert x (0) == 2

assert x (0) == 2

assert x (1) == 1

assert x (1) == 1

assert x (2) == 1

assert x (2) == 1

assert x (3) == 2

x = fun.Function ()

q = []

@x.match ()

def do ():

q.append (1)

@x.match (priority=1)

def do ():

next ()

q.append (2)

@x.match (priority=2)

def do ():

next ()

q.append (3)

x ()

class X:

def __init__ (self):

self.x = fun.Function (int)

@self.x.match (int)

def do (i):

return i + 1