yes

bin/pre.slime.expanded

@@ -0,0 +1,71 @@
+(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))))
+