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

""" unlambda interpreter

# test
>>> run("`.ai")
a
>>> run("``i.ai")
a
>>> run("`i`.ai")
a
>>> run("`d`.ai")
>>> run("``d`.aii")
a
>>> run("`.b`i`.ai")
ab
>>> run("`.b`d`.ai")
b
>>> run("``.b`d`.aii")
ba
"""

# 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():
        #print node
        return node.eval(cont)
    return run

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

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

class Dot(Node):
    "print char: `.aX => print 'a'"
    def __init__(self, c):
        self.c = c
    def __str__(self):
        return "(print %r)" % self.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 __str__(self):
        return "(apply %s %s)" % (self.nX, self.nY)
    def eval(self, cont):
        nY = self.nY
        def next(X):
            def _App1(): # task
                "evalated X and not-evaluated Y"

                if X.__class__ == D:
                    def Promise0(Y, cont):
                        def next(X):
                            def Promise1(X, cont):
                                return X(Y, cont)
                            return cont(Promise1)
                        return nY.eval(next)
                    return cont(Promise0)

                def next(Y):
                    def _App2(): # task
                        return X(Y, cont)
                    return _App2
                return nY.eval(next)
            return _App1
        return EvalTask(self.nX, next)

class D(Node):
    def __str__(self):
         return "D"
    def eval(self, cont):
        return cont(self)
    def __call__(self, Y, cont):
        raise NotImplemented

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: Dor("\n"),
        "d": lambda: D(), # special form

        "v": lambda: V(),
        "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()