root/lang/unlambda/impl/in_python/unlambda.py @ 1749

""" unlambda interpreter

# test
>>> run("`.ai")
a

"""
globals().clear()
# Main loop
#
def run(s):
    task = EvalTask(parse(s), FinalCont)
    try:
        while True:
            task = task()
    except StopIteration, e:
        return

# Continuation
# __call__(Func) returns Task
def FinalCont(f):
    def FinalTask():
        raise StopIteration
    return FinalTask

# Task
#
class Task(object): pass

def EvalTask(node, cont):
    def run():
        return node.eval(cont)
    return run

# Node
#
class Node(object):
    "parsed element"

class I(Node):
    "identity"
    def eval(self, cont):
        def I0(X, cont):
            return cont.invoke(X)
        return cont(I0)

class Dot(Node):
    "print char: `.aX => print 'a'"
    def __init__(self, c):
        self.c = c
    def eval(self, cont):
        def Dot0(X, cont):
            import sys
            sys.stdout.write(self.c)
            return cont(X)
        return cont(Dot0)
    
class Apply(Node):
    "apply: `FG = F(G)"
    def __init__(self, X, Y):
        "take 2 not-evaluated node"
        self.nX = X
        self.nY = Y
    def eval(self, cont):
        nY = self.nY
        def next(X):
            def _App1(): # task
                "evalated X and not-evaluated Y"

#                if X.isDelay:
#                     return self.cont.invoke(D1Function(self.nY))

                def next(Y):
                    def _App2(): # task
                        return X(Y, cont)
                    return _App2
                return nY.eval(next)
            return _App1
        return EvalTask(self.nX, next)
    
def _parse(iter):
    c = iter.next()
    result = {
        "i": lambda: I(),
        ".": lambda: Dot(iter.next()),
        "`": lambda: (lambda f=_parse(iter): Apply(f, _parse(iter)))(),

        "r": lambda: R(),
        "v": lambda: V(),
        "d": lambda: "(delay)", # special form
        "c": lambda: C(),
        "s": lambda: S(),
        "k": lambda: K(),
    }.get(c, lambda: _parse(iter))()
    return result

def parse(s):
    return _parse(list(s).__iter__())

def _test():
    import doctest
    reload(doctest)
    doctest.testmod()

run("`.ai")