# Joy (programming language)

Jump to: navigation, search
Paradigm multi-paradigm: functional, stack-oriented 2001 Manfred von Thun Manfred von Thun, John Cowan March 17, 2003 (March 17, 2003) strong, dynamic Joy0, Joy1, "Current Joy", "John Cowan's Joy", "JoyJ (Joy in jvmm)" Scheme, C Factor, Cat, V

The Joy programming language is a purely functional programming language that was produced by Manfred von Thun of La Trobe University in Melbourne, Australia. Joy is based on composition of functions rather than lambda calculus. It has turned out to have many similarities to Forth, due not to design but to a sort of parallel evolution and convergence.

## How it works

Joy is unusual (except for function-level programming languages and some esoteric ones, such as unlambda) in its lack of a lambda operator, and therefore lack of formal parameters. To illustrate this with a common example, here is how the square function might be defined in an imperative programming language (C):

```int square(int x) {
return x*x;
}
```

The variable x is a formal parameter which is replaced by the actual value to be squared when the function is called. Now here's how the same function would be defined in a functional language (Scheme):

```(define (square x)
(* x x))
```

This is different in many ways, but it still uses the formal parameter x in the same way. Now here is how the square function would be defined in Joy:

```DEFINE square == dup * .
```

To explain: In Joy, everything is a function that takes a stack as an argument and returns a stack as a result. For instance, the numeral '5' does not represent an integer constant, but instead a short program that pushes the number 5 onto the stack.

• The dup operator simply duplicates the top element of the stack by pushing a copy of it.
• The * operator pops two numbers off the stack and pushes their product.

So this definition of the square function says to make a copy of the top element and then multiply the two top elements, leaving the square of the original top element on top of the stack. There is no need for a formal parameter at all. This design gives Joy conciseness and power, as illustrated by this definition of quicksort:

```
DEFINE qsort ==
[small]
[]
[uncons [>] split]
[[swap] dip cons concat]
binrec .

```

"binrec" is one of Joy's many recursive combinators, implementing binary recursion. It expects four quoted programs on top of the stack which represent:

• the termination condition (if a list is "small" (1 or 0 elements) it is already sorted),
• what to do if the termination condition is met (in this case nothing),
• what to do by default (split the list into two halves by comparing each element with the pivot), and finally
• what to do at the end (insert the pivot between the two sorted halves).

## Mathematical purity

In Joy, the meaning function is a homomorphism from the syntactic monoid onto the semantic monoid. That is, the syntactic relation of concatenation of symbols maps directly onto the semantic relation of composition of functions. It is a homomorphism instead of an isomorphism because it is onto but not one-to-one, that is, some sequences of symbols have the same meaning (e.g. "dup +" and "2 *") but no symbol has more than one meaning.

Joy manages to be practical and potentially useful, unlike the otherwise similar Unlambda. Its library routines mirror those of ISO C, though the current implementation is not easily extensible with functions written in C.

## External links

##### Main Categories

Served in 0.544 secs.