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

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

from ..test.fixtures import session, testset

from ..ec import catch, throw, call_ec

from ..seq import begin

def runtests():

with testset("multi-return using escape continuation"):

@catch()

def f():

def g():

throw("hello from g") # the argument becomes the return value of f()

fail["This line should not be reached."] # pragma: no cover

g()

fail["This line should not be reached."] # pragma: no cover

test[f() == "hello from g"]

# throws can be tagged with human-readable labels.

with testset("tagged throws"):

@catch(tags="outer")

def outerfunc():

@catch(tags="inner")

def innerfunc():

throw(21, tag="inner")

fail["This line should not be reached."] # pragma: no cover

return 2 * innerfunc()

test[outerfunc() == 42]

@catch(tags="outer")

def outerfunc():

@catch(tags="inner")

def innerfunc():

throw(21, tag="outer")

fail["This line should not be reached."] # pragma: no cover

innerfunc()

fail["This line should not be reached."] # pragma: no cover

test[outerfunc() == 21]

# A catch can accept throws for multiple tags. These are OR'd.

@catch(tags=("outer", "something_else"))

def outerfunc():

@catch(tags="inner")

def innerfunc():

# A throw can have only one tag.

throw(42, tag="something_else")

fail["This line should not be reached."] # pragma: no cover

innerfunc()

fail["This line should not be reached."] # pragma: no cover

test[outerfunc() == 42]

with testset("escape from a lambda"):

# begin() returns the last value. What if we don't want that?

#

# This works because ec() uses the exception mechanism,

# so it interrupts the evaluation of the tuple of args

# before `begin` is even called.

result = call_ec(lambda ec:

begin(print("hi from lambda"),

ec(42), # now we can effectively "return ..." at any point from a lambda!

fail["This line should not be reached."])) # pragma: no cover

test[result == 42]

with testset("lispy call/ec (call-with-escape-continuation)"):

@call_ec

def result(ec): # effectively, just a code block!

answer = 42

ec(answer) # here this has the same effect as "return answer"...

fail["This line should not be reached."] # pragma: no cover

test[result == 42]

@call_ec

def result(ec):

answer = 42

def inner():

ec(answer) # ...but here this directly escapes from the outer def

fail["This line should not be reached."] # pragma: no cover

answer = inner()

fail["This line should not be reached."] # pragma: no cover

test[result == 42]

with testset("error case"):

with test_raises[RuntimeError, "should not be able to call an ec instance outside its dynamic extent"]:

@call_ec

def erroneous(ec):

return ec

erroneous(42) # invalid, dynamic extent of the call_ec has ended

# tests with @looped can be found in test_fploop.py

# def catching_truth_table():

# def check(tags, catch_untagged, e):

# if (tags is None and e.allow_catchall) or (catch_untagged and e.tag is None):

# return 2 # unconditional catch

# if (tags is not None and e.tag is not None): # and e.tag in tags):

# return 1 # catch if tags match

# return 0 # don't catch, pass on

# _ = None

# # in this table, we're essentially projecting bool**4 into two dimensions.

# ps = ((None, False), (None, True), # @catch points

# (set(("tag",)), False), (set(("tag",)), True))

# es = (Escape(_, None, False), Escape(_, None, True), # `throw` instances

# Escape(_, "tag", False), Escape(_, "tag", True))

# # # the other reasonable projection:

# # ps = ((None, False), (set(("tag",)), False),

# # (None, True), (set(("tag",)), True))

# # es = (Escape(_, None, False), Escape(_, "tag", False),

# # Escape(_, None, True), Escape(_, "tag", True))

# table = [[check(t, c, e) for e in es] for (t, c) in ps] # col = e, row = p

# for row in table:

# print(row)

# catching_truth_table()

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

with session(__file__):

runtests()