1 Functions

(require (planet cce/scheme:6:1/function))

This module provides tools for higher-order programming and creating functions.

1.1 Simple Functions

Examples:

(define f (thunk (define x 1) (printf "~a\n" x)))

> (f)

1

> (f 'x)

1

> (f #:y 'z)

1

This function is reprovided from scheme/function. In versions of PLT Scheme before const was implemented, this module provides its own definition.

Examples:

(define f (const 5))

> (f)

5

> (f 'x)

5

> (f #:y 'z)

5

1.2 Higher Order Predicates

This function is reprovided from scheme/function.

Examples:

(define f (negate exact-integer?))

> (f 1)

#f

> (f 'one)

#t

Examples:

(define f (conjoin exact? integer?))

> (f 1)

#t

> (f 1.0)

#f

> (f 1/2)

#f

> (f 0.5)

#f

Examples:

(define f (disjoin exact? integer?))

> (f 1)

#t

> (f 1.0)

#t

> (f 1/2)

#t

> (f 0.5)

#f

1.3 Currying and (Partial) Application

Examples:

> (map call          (list + - * /)          (list 1 2 3 4)          (list 5 6 7 8))

(6 -4 21 1/2)

(define count 0)

(define (inc)     (set! count (+ count 1)))

(define (reset)     (set! count 0))

(define (show)     (printf "~a\n" count))

> (for-each call (list inc inc show reset show))

2   0

((papply f x ...) y ...) = (f x ... y ...)

((papplyr f x ...) y ...) = (f y ... x ...)

Examples:

(define reciprocal (papply / 1))

> (reciprocal 3)

1/3

> (reciprocal 4)

1/4

(define halve (papplyr / 2))

> (halve 3)

3/2

> (halve 4)

2

The curryn and currynr functions construct a curried version of f, specialized at x ..., that produces a result after n further applications. Arguments at any stage of application may include keyword arguments, so long as no keyword is duplicated. These curried functions obey the following equations:

(curryn 0 f x ...) = (f x ...)

((curryn (+ n 1) f x ...) y ...) = (curryn n f x ... y ...)

(currynr 0 f x ...) = (f x ...)

((currynr (+ n 1) f x ...) y ...) = (currynr n f y ... x ...)

The call, papply, and papplyr utilities are related to curryn and currynr in the following manner:

(call f x ...) = (curryn 0 f x ...) = (currynr 0 f x ...)

(papply f x ...) = (curryn 1 f x ...)

(papplyr f x ...) = (currynr 1 f x ...)

Examples:

(define reciprocal (curryn 1 / 1))

> (reciprocal 3)

1/3

> (reciprocal 4)

1/4

(define subtract-from (curryn 2 -))

(define from-10 (subtract-from 10))

> (from-10 5)

5

> (from-10 10)

0

(define from-0 (subtract-from 0))

> (from-0 5)

-5

> (from-0 10)

-10

(define halve (currynr 1 / 2))

> (halve 3)

3/2

> (halve 4)

2

(define subtract (currynr 2 -))

(define minus-10 (subtract 10))

> (minus-10 5)

-5

> (minus-10 10)

0

(define minus-0 (subtract 0))

> (minus-0 5)

5

> (minus-0 10)

10

1.4 Eta Expansion

This is useful for function expressions that may be run, but not called, before f is defined. The eta expression will produce a function without evaluating f.

Examples:

(define f (eta g))

> f

#<procedure:eta>

(define g (lambda (x) (+ x 1)))

> (f 1)

2

This macro behaves similarly to eta, but produces a function with statically known arity which may improve efficiency and error reporting.

Examples:

(define f (eta* g x))

> f

#<procedure:f>

> (procedure-arity f)

1

(define g (lambda (x) (+ x 1)))

> (f 1)

2

1.5 Parameter Arguments

Examples:

(define p (open-output-string))

(define hello-world     (lambda/parameter ([port #:param current-output-port])       (display "Hello, World!")       (newline port)))

> (hello-world p)

> (get-output-string p)

"Hello, World!\n"