Writing HG LISP in Python, kind of

  From my recent postings in other newsgroups: The precending
  generator rewritten in Python in a style that tries to
  imitate LISP with the means of Python.

CADD = lambda Z1, Z2: [
    Z1[0] + Z2[0],
    Z1[1] + Z2[1]
]

CMUL = lambda Z1, Z2: [
    (Z1[0] * Z2[0]) - (Z1[1] * Z2[1]),
    (Z1[0] * Z2[1]) + (Z1[1] * Z2[0])
]

CABS = lambda Z: (
    ((Z[0] ** 2) + (Z[1] ** 2)) ** 0.5
)

MANDELBROT = lambda X, Y: (
    (lambda C, Z, A: (
        (lambda ITERATE: ITERATE(C, Z, A, ITERATE))(
            lambda C, Z, A, ITERATE: (
                126 - C if C < 32 or CABS(Z) > 2 else (
                    (lambda TEMP_CMUL, TEMP_CADD: (
                        ITERATE(
                            C - 1,
                            TEMP_CADD,
                            A,
                            ITERATE
                        )
                    ))(
                        CMUL(Z, Z),
                        CADD(A, CMUL(Z, Z))
                    )
                )
            )
        )
    ))(126, [X, Y], [X, Y])
)

GENERATE_MANDELBROT = lambda: (
    (lambda LOOP_Y: LOOP_Y(-1, LOOP_Y))(
        lambda Y, LOOP_Y: None if Y > 1.1 else (
            (lambda LOOP_X: LOOP_X(-2, LOOP_X))(
                lambda X, LOOP_X: None if X > 1 else (
                    (lambda CHAR_CODE: (
                        print(" " if CHAR_CODE < 50 else "*",end=''),
                        LOOP_X(X + 0.04, LOOP_X)
                    ))(
                        MANDELBROT(X, Y)
                    )
                )
            ),
            print(),
            LOOP_Y(Y + 0.1, LOOP_Y)
        )
    )
)

GENERATE_MANDELBROT()