IN: recursive
USING: kernel io math ;

: dip ( x y quot -- y )
  #! Showing my Joy roots...
  swap >r call r> ; inline

: dipd ( x y z quot -- y z )
  #! Showing my Joy roots...
  -rot >r >r call r> r> ; inline  

: dipdd ( w x y z quot -- x y z )
  #! Showing my Joy roots...
  swap >r -rot >r >r call r> r> r> ; inline 

! int Ack(int x, int y) {
!     if (x == 0)
!         return y+1;
!     if (y == 0)
!         return Ack(x-1, 1);
!     return Ack(x-1, Ack(x, y-1));
! }

: ack ( x y -- z )
  over 0 = [
    nip 1 +     
  ] [
    dup 0 = [
      drop 1 - 1 ack      
    ] [
      dupd 1 - ack >r 1 - r> ack 
    ] if
  ] if ;

GENERIC: one ( v -- 1 )
M: float one drop 1.0 ;
M: integer one drop 1 ;

: fib ( n -- n )
    dup 2 < [ one ] [ 1- dup fib swap 1- fib + ] if ;

! int Tak(int x, int y, int z) {
!    if (y < x)
!        return Tak( Tak(x-1, y, z), Tak(y-1, z, x), Tak(z-1, x, y) );
!    return z;
! }

: tak ( x y z -- x ) 
  pick pick swap < [
    3dup 1- -rot tak >r
    3dup >r 1- r> rot tak >r
    >r >r 1- r> r> tak 
    r> r> tak
  ] [
    2nip
  ] if ;

USE: prettyprint
: run
  3 11 ack . flush
  38.0 fib . flush
  30 20 10 tak . flush
  3 fib . flush
  3.0 2.0 1.0 tak . flush ;