Whereas all other [note: should be 'most other'] functional programming languages are based on the application of functions to arguments, Joy is based on the composition of functions. All such functions take a stack as argument and produce a stack as value.

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

At this point, I am still exploring the possibilities of using some dialect of Joy for different purposes. Here are some ideas:

• Joy could possible be used as a virtual machine language, perhaps as a target for Heron, which itself can be easily retargetted
• Maybe a Joy dialect could be useful as a pre-processor language for defining macros.
• The Joy syntax itself could probably be significantly improved by using a sufficiently powerful pre-processor (implemented itself in Joy?!? Now I have a headache)

#include <list>
#include <iostream>
using namespace std;

enum type_t {
    type_integer,
    type_function
};

typedef void (*function_t)();

union elem_t {
    type_t type;
    int val;
    function_t fun;
    elem_t(int v) : type(type_integer), val(v) {}
    elem_t(function_t f) : type(type_function), fun(f) {}
    operator int() const { return val; }
};

typedef list<elem_t> stack_t;

stack_t stack;

stack_t &operator << (stack_t &st, int v) {
    st.push_front(v);
    return st;
}

stack_t &operator << (stack_t &st, function_t f) {
    st.push_front(f);
    return st;
}

void pop() {
    stack.pop_front();
}

void popd() {
    stack.erase(++stack.begin());
}

void popop() {
    stack.pop_front();
    stack.pop_front();
}

void dup() {
    stack.push_front(stack.front());
}

void dupd() {
    stack.push_front(*++stack.begin());
}

void swap() {
    swap(*stack.begin(), *++stack.begin());
}

void swapd() {
    swap(*++stack.begin(), *++++stack.begin());
}

void rollup() {
    stack.insert(++++stack.begin(), stack.front());
    stack.pop_front();
}

void rolldown() {
    stack.push_front(*++++stack.begin());
    stack.erase(++++++stack.begin());
}

void choice() {
    elem_t e = *++++stack.begin();
    if (e) {
        stack.erase(++++stack.begin());
        pop();
    }
    else {
        popop();        
    }
}

void put() {
    elem_t e = stack.front();
    stack.pop_front();
    cout << e.val;
}

void get() {
    int i;
    cin >> i;
    stack.push_front(i);
}

void add() {
    stack.push_front(*stack.begin() + *++stack.begin());
}

void sub() {
    stack.push_front(*stack.begin() - *++stack.begin());
}

void mul() {
    stack.push_front(*stack.begin() * *++stack.begin());
}

void div() {
    stack.push_front(*stack.begin() / *++stack.begin());
}

void mod() {
    stack.push_front(*stack.begin() % *++stack.begin());
}

void min() {
    int v1 = *stack.begin();
    int v2 = *++stack.begin();
    stack.push_front(v1 < v2 ? v1 : v2);
}

void max() {
    int v1 = *stack.begin();
    int v2 = *++stack.begin();
    stack.push_front(v1 > v2 ? v1 : v2);
}

void succ() {
    stack.push_front(stack.front() + 1);
}

void pred() {
    stack.push_front(stack.front() - 1);
}

int main()
{
    stack << 1 << 2 << add << mul << put;
    getchar();
    return 0;    
}

define dupd == [dup] dip;

#include "unimperative.hpp"

def dupd = (q(dup), dip);

def<int> square = (dup, multiply);

namespace standard
{  
  def<any, any> 
    popd = (q(pop), dip);
  
  def<any, any> 
    dupd = (q(dup), dip);
  
  def<any, any> 
    swapd = (q(swap), dip);
  
  def<any, any, any> 
    rollup = (swap, q(swap), dip);
  
  def<any, any, any> 
    rolldown = (q(swap), dip, swap);  
    
  def<any, any, any> 
    rotate = (swap, q(swap), dip, swap);  
    
  def<any> 
    unitlist = (emptylist, cons);
  
  def<list> 
    unitlistlist = (emptylist, cons);

  def<list, list>
    pairlist = (emptylist, cons, cons);
    
  def<list> 
    unpair = (uncons, uncons, pop);        
    
  def<list> 
    second = (rest, first);
  
  def<list> 
    third = (rest, rest, first);
    
  def<list> 
    uncons2 = (q(uncons), dip, uncons, swapd);
    
  def<list> 
    unswons2 = (q(unswons), dip, unswons, swapd);
}

def dupd = (!dup, dip);
def dupd = (~dup, dip);
def dup3 = (&(dup, dup), dip);

> def<int> square = (dup, multiply);
> 

> namespace standard
> {  
>   def<any, any> 
>     popd = (q(pop), dip);
>   
>   def<any, any> 
>     dupd = (q(dup), dip);
>   
>   def<any, any> 
>     swapd = (q(swap), dip);
>   
>   def<any, any, any> 
>     rollup = (swap, q(swap), dip);
>   
>   def<any, any, any> 
>     rolldown = (q(swap), dip, swap);  
>     
>   def<any, any, any> 
>     rotate = (swap, q(swap), dip, swap);  
>     
>   def<any> 
>     unitlist = (emptylist, cons);
>   
>   def<list> 
>     unitlistlist = (emptylist, cons);
> 
>   def<list, list>
>     pairlist = (emptylist, cons, cons);
>     
>   def<list> 
>     unpair = (uncons, uncons, pop);        
>     
>   def<list> 
>     second = (rest, first);
>   
>   def<list> 
>     third = (rest, rest, first);
>     
>   def<list> 
>     uncons2 = (q(uncons), dip, uncons, swapd);
>     
>   def<list> 
>     unswons2 = (q(unswons), dip, unswons, swapd);
> }
> 

let three = (1, 2, add);

let three = (add, 1, 2);

let add3 = (add <int>(), add<int>());

let add3 = (add<double>(), add<double>());

def<int, int> add3 = (add, add);
def<double, double> add3 = (add, add);

(add3<int>(), 1, 2, 3);
(add3<double>(), 1, 2, 3);