(lispkit combinator)
Library (lispkit combinator)
defines abstractions for combinator-style programming. It provides means to create and compose functions.
(const c ...)
Returns a function accepting any number of arguments and returning the values c
... .
(flip f)
Takes a function with two parameters and returns an equivalent function where the two parameters are swapped.
(define snoc (flip cons))
(snoc (snoc (snoc '() 3) 2) 1) ⟹ (1 2 3)
(negate f)
Returns a function which invokes f
and returns the logical negation.
(define gvector-has-elements? (negate gvector-empty?))
(gvector-has-elements? #g(1 2 3)) ⟹ #t
(partial f arg ...)
Applies arguments arg ... partially to f and returns a new function accepting the remaining arguments. For a function (f a1 a2 a3 ... an)
, (partial f a1 a2)
will return a function (lambda (a3 ... an) (f a1 a2 a3 ... an))
.
(compose f ...)
Composes the given functions f ... such that ((compose f1 f2 ... fn) x)
is equivalent to (f1 (f2 (... (fn x))))
. compose
supports functions returning multiple arguments.
(o f ...)
Composes the given functions f ... such that ((o f1 f2 ... fn) x)
is equivalent to (f1 (f2 (... (fn x))))
. o
is a more efficient version of compose
which only works if the involved functions only return a single argument. compose
is more general and supports functions returning multiple arguments.
(conjoin f ...)
Returns a function invoking all functions f ... and combining the results with and
. ((conjoin f1 f2 ...) x ...)
is equivalent to (and (f1 x ...) (f2 x ...) ...)
.
(disjoin f ...)
Returns a function invoking all functions f ... and combining the results with or
. ((disjoin f1 f2 ...) x ...)
is equivalent to (or (f1 x ...) (f2 x ...) ...)
.
(list-of? f)
Returns a predicate which takes a list as its argument and returns #t
if for every element x of the list (f x) returns true.
(each f ...)
Returns a function which applies the functions f
... each individually to its arguments in the given order, returning the result of the last function application.
(cut f)
(cut f <...>)
(cut f arg ...)
(cut f arg ... <...>)
Special form cut
transforms an expression (f arg ...) into a lambda expression with as many formal variables as there are slots <>
in the expression (f arg ...). The body of the resulting lambda expression calls procedure f with arguments arg ... in the order they appear. In case there is a rest symbol <...>
at the end, the resulting procedure is of variable arity, and the body calls f with all arguments provided to the actual call of the specialized procedure.
(cut cons (+ a 1) <>) ⟹ (lambda (x2) (cons (+ a 1) x2))
(cut list 1 <> 3 <> 5) ⟹ (lambda (x2 x4) (list 1 x2 3 x4 5))
(cut list 1 <> 3 <...>) ⟹ (lambda (x2 . xs) (apply list 1 x2 3 xs))
(cute f)
(cute f <...>)
(cute f arg ...)
(cute f arg ... <...>)
Special form cute
is similar to cut
, except that it first binds new variables to the result of evaluating the non-slot expressions (in an unspecific order) and then substituting the variables for the non-slot expressions. In effect, cut
evaluates non-slot expressions at the time the resulting procedure is called, whereas cute
evaluates the non-slot expressions at the time the procedure is constructed.
(cute cons (+ a 1) <>)
⟹ (let ((a1 (+ a 1))) (lambda (x2) (cons a1 x2)))
(Y f)
Y combinator for computing a fixed point of a function f. This is a value that is mapped to itself.
; factorial function
(define fac
(Y (lambda (r)
(lambda (x) (if (< x 2) 1 (* x (r (- x 1))))))))
; fibonacci numbers
(define fib
(Y (lambda (f)
(lambda (x)
(if (< x 2) x (+ (f (- x 1)) (f (- x 2))))))))
Last updated