72 lines
4.4 KiB
Plaintext
72 lines
4.4 KiB
Plaintext
(define (nil? x) "Checks if the argument is nil." (= x nil))
|
|
|
|
(define (number? x) "Checks if the argument is a number." (= (type x) :number))
|
|
|
|
(define (symbol? x) "Checks if the argument is a symbol." (= (type x) :symbol))
|
|
|
|
(define (keyword? x) "Checks if the argument is a keyword." (= (type x) :keyword))
|
|
|
|
(define (pair? x) "Checks if the argument is a pair." (= (type x) :pair))
|
|
|
|
(define (string? x) "Checks if the argument is a string." (= (type x) :string))
|
|
|
|
(define (lambda? x) "Checks if the argument is a function." (= (type x) :dynamic-function))
|
|
|
|
(define (special-lambda? x) "Checks if the argument is a macro." (= (type x) :dynamic-macro))
|
|
|
|
(define (built-n-function? x) "Checks if the argument is a built-in function." (= (type x) :built-in-function))
|
|
|
|
(define (apply fun seq) "Applies the funciton to the sequence, as in calls the function with
|
|
ithe sequence as arguemens." (eval (pair fun seq)))
|
|
|
|
(define (end seq) "Returns the last pair in the sqeuence." (if (or (nil? seq) (not (pair? (rest seq)))) seq (end (rest seq))))
|
|
|
|
(define (last seq) "Returns the (first) of the last (pair) of the given sequence." (first (end seq)))
|
|
|
|
(define (extend seq elem) "Extends a list with the given element, by putting it in
|
|
the (rest) of the last element of the sequence." (if (pair? seq) (prog (define e (end seq)) (mutate e (pair (first e) elem)) seq) elem))
|
|
|
|
(define (append seq elem) "Appends an element to a sequence, by extendeing the list
|
|
with (pair elem nil)." (extend seq (pair elem nil)))
|
|
|
|
(define (length seq) "Returns the length of the given sequence." (if (nil? seq) 0.000000 (+ 1.000000 (length (rest seq)))))
|
|
|
|
(define (increment val) "Adds one to the argument." (+ val 1.000000))
|
|
|
|
(define (decrement val) "Subtracts one from the argument." (- val 1.000000))
|
|
|
|
(define (range :keys from :defaults-to 0.000000 to) "Returns a sequence of numbers starting with the number defined
|
|
by the key 'from' and ends with the number defined in 'to'." (if (< from to) ([C-function] (pair from (range :from (+ 1.000000 from) :to to))) nil))
|
|
|
|
(define (range-while :keys from :defaults-to 0.000000 to) "Returns a sequence of numbers starting with the number defined
|
|
by the key 'from' and ends with the number defined in 'to'." (define result (list (copy from))) (define head result) (mutate from (increment from)) (while (< from to) (prog (mutate head (pair (first head) (pair (copy from) nil))) (define head (rest head)) (mutate from (increment from)))) result)
|
|
|
|
(define (map fun seq) "Takes a function and a sequence as arguments and returns a new
|
|
sequence which contains the results of using the first sequences
|
|
elemens as argument to that function." (if (nil? seq) seq (pair (fun (first seq)) (map fun (rest seq)))))
|
|
|
|
(define (reduce fun seq) "Takes a function and a sequence as arguments and applies the
|
|
function to the argument sequence. This only works correctly if
|
|
the given function accepts a variable amount of parameters. If
|
|
your funciton is limited to two arguments, use `reduce-binary'
|
|
instead." (apply fun seq))
|
|
|
|
(define (reduce-binary fun seq) "Takes a function and a sequence as arguments and applies the
|
|
function to the argument sequence. reduce-binary applies the
|
|
arguments `pair-wise' which means it works with binary functions
|
|
as compared to `reduce'." (if (nil? (rest seq)) (first seq) (fun (first seq) (reduce-binary fun (rest seq)))))
|
|
|
|
(define (filter fun seq) "Takes a function and a sequence as arguments and applies the
|
|
function to every value in the sequence. If the result of that
|
|
funciton application returns a truthy value, the original value is
|
|
added to a list, which in the end is returned." (if seq ([C-function] (if (fun (first seq)) (pair (first seq) (filter fun (rest seq))) (filter fun (rest seq)))) nil))
|
|
|
|
(define (zip l1 l2) (if (and (nil? l1) (nil? l2)) nil (pair (list (first l1) (first l2)) (zip (rest l1) (rest l2)))))
|
|
|
|
(define (printf :keys sep :defaults-to " " end :defaults-to "
|
|
" :rest args) "A wrapper for the built-in (print) that accepts a variable number
|
|
of arguments and also provides keywords for specifying the printed
|
|
separators between the arguments and what should be printed after the
|
|
las argument." (define printf-quoted (special-lambda (:keys @sep @end :rest @args) (if (nil? @args) (prog (print (eval @end)) nil) (prog (print (first @args)) (if (nil? (rest @args)) nil ([C-function] (print (eval @sep)))) (eval (pair printf-quoted (extend (list :@sep (eval @sep) :@end (eval @end)) (rest @args)))))))) (eval (pair printf-quoted (extend (list :@sep (eval sep) :@end (eval end)) args))))
|
|
|