PRINT value;

(print value)

' here are the comments

; here are the comments

' Simple Value
114514
' Operator Expression
(1919 + 810)
' Function
abs(-10)

; Simple Value
114514
; Operator Expression
(+ 1919 810)
; Function
(abs -10)

1;

LET complex_expr = (((1 + 2) * 3) - (4 / 5));

LET homo = 114514;
PRINT homo;

(define homo 114514)
(print homo)

(define show print)
(show 1919810)

DEF id(x)
    RETURN x;
END

(define id
    (lambda (x) x))

(+ 
    ((lambda (x) (* x x)) 100) 
    104514)

DEF fib(x)
    IF (x < 2) THEN
        RETURN 1;
    ELSE
        RETURN (fib((x - 1)) + fib((x - 2)));
    END
END

(define fib
    (lambda (x)
        (if (< x 2)
            1
            (+ (fib (- x 1)) (fib (- x 2))))))

' sqrt
DEF sqrt(x)
    DEF abs(x)
        IF (x > 0) THEN
            RETURN x;
        ELSE
            RETURN (0 - x);
        END
    END

    DEF good_enough(g,w)
        RETURN (abs(((g * g) - w)) < (g / 100000));
    END

    DEF guess(g,w)
        IF good_enough(g,w) THEN
            RETURN g;
        ELSE
            RETURN guess(improve(g,w),w);
        END
    END

    DEF improve(g,w)
        RETURN ((g + (w / g)) / 2);
    END

    RETURN guess(1,x);
END

PRINT sqrt(1919810);

; sqrt
(define sqrt
    (lambda (x) 
        (define abs (lambda (x) (if (> x 0) x (- x))))
        (define good-enough?
            (lambda (g w)
                (< (abs (- (* g g) w)) (/ g 100000))))
        (define guess
            (lambda (g w)
                (if (good-enough? g w)
                    g
                    (guess (improve g w) w))))
        (define improve
            (lambda (g w)
                (/ (+ g (/ w g)) 2)))
        (guess 1 x)))

(print (sqrt 1919810))

DEF cons(x,y)
    DEF temp(op)
        RETURN op(x,y);
    END
    RETURN temp;
END

DEF car(cons)
    DEF temp(x,y)
        RETURN x;
    END
    RETURN cons(temp);
END

' (1,2) => 1
car(cons(1,2));

(define cons
    (lambda (a d)
        (lambda (op) (op a d))))

(define car
    (lambda (cons)
        (cons (lambda (a d) a))))

; (1,2) => 1
(car (cons 1 2))