Miscellaneous Functions

Here are a couple of miscellaneous functions that don’t really fit in anywhere. See if you can guess their intended functionality.

(fun {flip f a b} {f b a})
(fun {ghost & xs} {eval xs})
(fun {comp f g x} {f (g x)})

The flip function takes a function f and two arguments a and b. It then applies f to a and b in the reversed order. This might be useful when we want a function to be partially evaluated. If we want to partially evaluate a function by only passing it in it’s second argument we can use flip to give us a new function that takes the first two arguments in reversed order.

This means if you want to apply the second argument of a function you can just apply the first argument to the flip of this function.

lispy> (flip def) 1 {x}
()
lispy> x
1
lispy> def {define-one} ((flip def) 1)
()
lispy> define-one {y}
()
lispy> y
1
lispy>

I couldn’t think of a use for the ghost function, but it seemed interesting. It simply takes in any number of arguments and evaluates them as if they were the expression itself. So it just sits at the front of an expression like a ghost, not interacting with or changing the behaviour of the program at all. If you can think of a use for it I’d love to hear.

lispy> ghost + 2 2
4

The comp function is used to compose two functions. It takes as input f, g, and an argument to g. It then applies this argument to g and applies the result again to f. This can be used to compose two functions together into a new function that applies both of them in series. Like before, we can use this in combination with partial evaluation to build up complex functions from simpler ones.

For example we can compose two functions. One negates a number and another unpacks a list of numbers for multiplying together with *.

lispy> (unpack *) {2 2}
4
lispy> - ((unpack *) {2 2})
-4
lispy> comp - (unpack *)
(\ {x} {f (g x)})
lispy> def {mul-neg} (comp - (unpack *))
()
lispy> mul-neg {2 8}
-16
lispy>