root/lang/unlambda/impl/in_python/unlambda_lambda.py @ 1759

""" 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
>>> run("``.b`.a`ci.c")
ababc
>>> Debug.show_node = True
>>> run("``v.a.a")
(apply (apply V (print 'a')) (print 'a'))
(apply V (print 'a'))
V
>>> Debug.show_node = False
>>> run("````skk.av")
a
"""
# 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):
    return FinalTask

# Task
#

def FinalTask(X=None):
    raise StopIteration()

def EvalTask(node, cont):
    def run():
        if Debug.show_node: print node
        return node(cont)
    return run

def ApplyTask(operator, operand, cont):
    def run():
        return operator(operand, cont)
    return run

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

I = lambda: lambda c: c(lambda X, c: c(X))

class Dot(Node):
    "print char: `.aX => print 'a'"
    def __init__(self, c):
        self.c = c
    def __str__(self):
        return "(print %r)" % self.c
    def __call__(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 __call__(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(next)
                    return cont(Promise0)

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

class D(Node):
    "delay (special form)"
    def __str__(self):
         return "D"
    def __call__(self, cont):
        return cont(self)
    

class C(Node):
    "call/cc"
    def __str__(self):
        return "C"
    def __call__(self, cont):
        def C0(Y, cont):
            def C1(func, new_cont):
                return cont(func) # use old cont
            operator = Y
            operand = C1
            def Apply(): # task
                return operator(operand, cont)
            return Apply
        return cont(C0)

class V(Node):
    """void: v(x) == v
    equivalent to ` ``s``s`kskk ``s``s`kskk"""
    def __str__(self):
        return "V"
    def __call__(self, cont):
        def V0(X, cont):
            return cont(V0)
        return cont(V0)

class K(Node):
    "constant: ``kXY = X"
    def __str__(self):
        return "K"
    def __call__(self, cont):
        def K0(X, cont):
            def K1(Y, cont):
                return cont(X)
            return cont(K1)
        return cont(K0)

class S(Node):
    "substitution: ```sXYZ = ``XZ`YZ"
    def __str__(self):
        return "S"
    def __call__(self, cont):
        def S0(X, cont):
            def S1(Y, cont):
                def S2(Z, cont):
                    return EvalTask(
                        Apply(
                            Apply(Func2Node(X), Func2Node(Z)),
                            Apply(Func2Node(Y), Func2Node(Z))), cont)
                return cont(S2)
            return cont(S1)
        return cont(S0)

class Func2Node(Node):
    def __str__(self): return "%s" % self.f.func_name
    def __init__(self, f):
        self.f = f
    def __call__(self, cont):
        return cont(self.f)

class At(Node):
    def __str__(self): return "At"
    def __call__(self, cont):
        def At0(X, cont):
            import sys
            try:
                #At.c = sys.stdin.read(1)
                At.c = raw_input(">>> ")[0]
                switch = I()
            except:
                switch = V()

            return EvalTask(
                    Apply(
                        Func2Node(X),
                        switch),
                    cont)
        return cont(At0)
            
class Qu(Node):
    def __str__(self): return "(? %r)" % self.c
    def __init__(self, c):
        self.c = c

    def __call__(self, cont):
        def Qu0(X, cont):
            if At.c == self.c:
                switch = I()
            else:
                switch = V()

            return EvalTask(Apply(Func2Node(X), switch), cont)
        return cont(Qu0)

class Pipe(Node):
    def __call__(self, cont):
        def Pipe0(X, cont):
            if At.c != -1:
                switch = Dot(At.c)
            else:
                switch = V()

            return ApplyTask(X, switch, cont)
        return Pipe0

class E(Node):
    def __call__(self, cont):
        def E0(X, cont):
            return FinalTask(X)
        return E0
    
def _parse(iter):
    c = iter.next()
    result = {
        "i": lambda: I(),
        ".": lambda: Dot(iter.next()),
        "`": lambda: Apply(_parse(iter), _parse(iter)),
        "r": lambda: Dot("\n"),
        "d": lambda: D(), # special form
        "c": lambda: C(),
        "v": lambda: V(),
        "s": lambda: S(),
        "k": lambda: K(),
        "@": lambda: At(),
        "?": lambda: Qu(iter.next()),
        "|": lambda: Pipe(),
        "e": lambda: E(),
    }.get(c, lambda: _parse(iter))()
    return result

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

class Debug():
    show_node = False

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

def fib():
    "show Fibonacci numbers"
    run("""
    ```s``s``sii`ki
      `k.*``s``s`ks
     ``s`k`s`ks``s``s`ks``s`k`s`kr``s`k`sikk
      `k``s`ksk
      """)

#Debug.show_node = True
#run("`````@?a.oi.kv")