This module will discuss some gates-that-work-on-gates and other assorted operators that are commonly recognized as functional programming tools.
Given a gate, you can manipulate it to accept a different number of values than its sample formally requires, or otherwise modify its behavior. These techniques mirror some of the common tasks used in other functional programming languages like Haskell, Clojure, and OCaml.
Functional programming, as a paradigm, tends to prefer rather mathematical expressions with explicit modification of function behavior. It works as a formal system of symbolic expressions manipulated according to given rules and properties. FP was derived from the lambda calculus, a cousin of combinator calculi like Nock. (See also APL.)
If a gate accepts only two values in its sample, for instance, you can chain together multiple calls automatically using the
;: miccol rune.
> (add 3 (add 4 5))12> :(add 3 4 5)12> (mul 3 (mul 4 5))60> :(mul 3 4 5)60
This is called changing the arity of the gate. (Does this work on
Binding the Sample
Currying describes taking a function of multiple arguments and reducing it to a set of functions that each take only one argument. Binding, an allied process, is used to set the value of some of those arguments permanently.
Consider calculating a x² + b x + c, a situation we earlier resolved using a door. We can resolve the situation differently using currying:
> =full |=([x=@ud a=@ud b=@ud c=@ud] (add (add (mul (mul x x) a) (mul x b)) c))> (full 5 4 3 2)117> =one (curr full [4 3 2])> (one 5)117
One can also
++cork a gate, or arrange it such that it applies to the result of the next gate. This pairs well with
;: miccol. (There is also
++corl, which composes backwards rather than forwards.) This example converts a value to
@ux then decrements it by corking two molds:
> ((cork dec @ux) 20)0x13
Exercise: Bind Gate Arguments
- Create a gate
++incwhich increments a value in one step, analogous to
Exercise: Chain Gate Values
- Write an expression which yields the parent galaxy of a planet's sponsoring star by composing two gates.
turn The turn function takes a list and a gate, and returns a list of the products of applying each item of the input list to the gate. For example, to add 1 to each item in a list of atoms:
(list @)~[11 22 33 44] |=([email protected] +(a))) ~[12 23 34 45] Or to double each item in a list of atoms:
(list @)~[11 22 33 44] |=([email protected] (mul 2 a))) ~[22 44 66 88] turn is Hoon's version of Haskell's map.
We can rewrite the Caesar cipher program using turn:
|= [[email protected] b=tape] ^- tape ?: (gth a 25) $(a (sub a 26)) %+ turn b |= [email protected] ?: &((gte c 'A') (lte c 'Z')) =. c (add c a) ?. (gth c 'Z') c (sub c 26) ?: &((gte c 'a') (lte c 'z')) =. c (add c a) ?. (gth c 'z') c (sub c 26) c
++reel are used to left-fold and right-fold a list, respectively. To fold a list is similar to
++turn, except that instead of yielding a
list with the values having had each applied,
++reel produce an accumulated value.
> (roll `(list @)`[1 2 3 4 5 ~] add)q=15> (reel `(list @)`[1 2 3 4 5 ~] mul)120
Exercise: Calculate a Factorial
++reelto produce a gate which calculates the factorial of a number.