
(def range
    (lambda (x y)
        (?: (< x y)
            (cons x (range (+ x 1) y))
            `())))

(define range0 (range 0))

(range 1 10)
(range0 10)

# (def map
#     (lambda (func list)
#         (if/else (null? list)
#             list
#             (cons (func (car list)) (map func (cdr list))))))
# 
# (map (lambda (x) (+ x 1)) (range 1 10))
# 
# (def filter
#     (lambda (func list)
#         (if/else (null? list)
#             list
#             (let1! a (filter func (cdr list))
#                 (if/else (func (car list))
#                     (cons (car list) a)
#                     a
#                 )
#             )
#         )
#     )
# )
# 
# (filter (lambda (x) (== (% x 2) 0)) (range0 20))
# 
# (apply + 1 2 3)
# 
#
# # comments
# 
# # # (define fib
# # #     (lambda (x)
# # #         (?: (> x 1)
# # #             (+ (fib (- x 1)) (fib (- x 2)))
# # #             1)))
# # 
# # # (fib 1)
# # # (fib 2)
# # # (fib 3)
# # # (fib 4)
# # # (fib 5)
# 
# (define! let1!
#     (lambda! (a b c)
#         ((lambda (list! a) c) b)))
# 
# (let1! x 3 (+ x 2))
# 
# # (define! let2!
# #     (lambda! (a b c d e)
# #         ((lambda (list! a b) e) c d)))
# # 
# # (let2! x y 3 5 (+ x y 2))
# 
# # (define! let3!
# #     (lambda! (a b c)
# #         (cons! (lambda a c) b)))
# # 
# # (let3! (x y z) (1 2 3) (+ x y z 2))
# 
# # (define Y
# #    (lambda (f)
# #         (f (lambda (x) ((Y f) x)))))
# # 
# # (define almost-factorial
# #     (lambda (f)
# #         (lambda (n)
# #             (if/else (= n 0)
# #                 1
# #                 (* n (f (- n 1)))))))
# # 
# # (define factorial (Y almost-factorial))
# # 
# # (factorial 1)
# # (factorial 2)
# # (factorial 3)
# # (factorial 4)
# 
# # (let1! x 3 (+ x 2))
# 
# # (define almost
# #     (lambda (f n)
# #         (if/else (= n 0)
# #             1
# #             (* n (f f (- n 1))))))
# 
# (define factorial
#     (let1! almost
#         (lambda (f n)
#             (if/else (= n 0)
#                 1
#                 (* n (f f (- n 1)))))
#         (lambda (x) (almost almost x))))
# 
# (factorial 1)
# (factorial 2)
# (factorial 3)
# (factorial 4)
# 
# 
# 
# 

