LispPad
  • Home
  • Applications
    • 🖥️LispPad
      • Sessions
      • Editor
      • Preferences
    • 📱LispPad Go
    • 📜Language
    • 📖Libraries
  • Libraries
    • ⚙️LispKit
      • (lispkit archive tar)
      • (lispkit archive zip)
      • (lispkit base)
      • (lispkit bitset)
      • (lispkit box)
      • (lispkit bytevector)
      • (lispkit char)
      • (lispkit char-set)
      • (lispkit combinator)
      • (lispkit comparator)
      • (lispkit control)
      • (lispkit core)
      • (lispkit crypto)
      • (lispkit csv)
      • (lispkit datatype)
      • (lispkit date-time)
      • (lispkit debug)
      • (lispkit disjoint-set)
      • (lispkit draw)
      • (lispkit draw turtle)
      • (lispkit draw barcode)
      • (lispkit draw chart bar)
      • (lispkit dynamic)
      • (lispkit enum)
      • (lispkit format)
      • (lispkit graph)
      • (lispkit gvector)
      • (lispkit hashtable)
      • (lispkit heap)
      • (lispkit http)
      • (lispkit http oauth)
      • (lispkit http server)
      • (lispkit iterate)
      • (lispkit json)
      • (lispkit json schema)
      • (lispkit list)
      • (lispkit list set)
      • (lispkit log)
      • (lispkit markdown)
      • (lispkit match)
      • (lispkit math)
      • (lispkit math matrix)
      • (lispkit math stats)
      • (lispkit math util)
      • (lispkit object)
      • (lispkit port)
      • (lispkit prolog)
      • (lispkit queue)
      • (lispkit record)
      • (lispkit regexp)
      • (lispkit serialize)
      • (lispkit set)
      • (lispkit sqlite)
      • (lispkit stack)
      • (lispkit stream)
      • (lispkit string)
      • (lispkit styled-text)
      • (lispkit system)
      • (lispkit system call)
      • (lispkit system keychain)
      • (lispkit system pasteboard)
      • (lispkit test)
      • (lispkit text-table)
      • (lispkit thread)
      • (lispkit thread channel)
      • (lispkit-thread-future)
      • (lispkit thread shared-queue)
      • (lispkit type)
      • (lispkit url)
      • (lispkit vector)
    • ⚙️LispPad
      • (lisppad applescript)
      • (lisppad draw map)
      • (lisppad location)
      • (lisppad speech)
      • (lisppad system)
      • (lisppad turtle)
    • ⚙️SRFI
  • Examples
    • 📝LispKit
    • 📝LispPad
    • 📝LispPad Go
  • Releases
    • 🖥️LispPad
    • 📱LispPad Go
  • Downloads
  • Privacy Policy
  • Contact
Powered by GitBook
On this page
  1. Libraries
  2. LispKit

(lispkit combinator)

Last updated 6 months ago

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 ...) ...).

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 ...) ...).

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.

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.

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))

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 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))))))))

(disjoin f ...)

(list-of? f)

(each f ...)

(cut f) (cut f <...>) (cut f arg ...) (cut f arg ... <...>)

(cute f) (cute f <...>) (cute f arg ...) (cute f arg ... <...>)

(Y f)

⚙️