- alias
- block?
- boolean?
- define
- defined
- empty?
- eval
- include
- integer?
- nil?
- small?
- string?
- type
Arithmetic operations
- abs
- add
- dec
- div
- fact
- inc
- mult
- neg
- prod
- sub
- sum
- zero?
Basic I/O
- p
- print
- read
Control flow
- call
- if
- if-else
- times
- under
- under2
- unless
- until
- while
- without
- without2
Lists
- append
- apply
- cons
- head
- prepend
- reduce
- reverse
- tail
Logical operations
- and
- compare
- eq?
- gt?
- gte?
- lt?
- lte?
- neq?
- not
- or
Stack operations
- compose
- drop
- dup
- dup2
- pop
- size
- stack
- swap
- swapp
- wrap
Strings
- concat
- join
Types
- integer
- list
- range
- string

alias

string string →

Defines an alias which when used will call the aliased function.
Example
```
'add' '+' alias
```
block?

'a → bool

Checks whether the top element is a block.
Source
```
type 'block'   =
```
boolean?

'a → bool

Checks whether the top element is boolean.
Source
```
type 'boolean' =
```
define

string block →

Defines a new function with the name given, when called the block passed will be called.
Example
```
'sq' [ dup * ] define
```
defined

→ string

Pushes a string containing all defined functions on to the stack.
empty?

→ bool

Checks whether there are no elements on the stack.
Source
```
size 0 eq?
```
eval

string →

Evaluates the string at the top of the stack as vodka source code.
Example
```
'1 2 +' eval ;=> [3]
```
include

string →

Includes the vodka file at the top of the stack.
Example
```
'test' include ; Will load the file 'test.vk'
```
Source
```
'.vk' concat read eval
```
integer?

'a → bool

Checks whether the top element is an integer.
Source
```
type 'integer' =
```
nil?

'a → bool

Checks whether the top element is nil.
Source
```
type 'nil'     =
```
small?

→ bool

Checks whether the stack contains one or less elements.
Source
```
size 1 lte?
```
string?

'a → bool

Checks whether the top element is a string.
Source
```
type 'string'  =
```
type

'a → string

Replaces the element at the top of the stack with a string describing it's type.
Example
```
123 type ;=> ['integer']
```

Arithmetic operations

abs

int → int

Replaces the number at the top of the stack with it's absolute value.
Source
```
dup 0 lt?
                :neg unless
```
add

int int → int

Adds the top two elements of the stack together.
Example
```
5 2 add ;=> [7]
```
dec

int → int

Decrements the number at the top of the stack.
Source
```
1 sub
```
div

int int → int

Divides the second element of the stack by the second. Does integer division only at the moment, this does not round to the nearest integer.
Example
```
5 2 div ;=> [2]
```
fact

int → int

Calculates the factorial of the number at the top of the stack.
Example
```
5 fact ;=> [120]
```
Source
```
1 swap range :* reduce
```
inc

int → int

Increments the number at the top of the stack.
Source
```
1 add
```
mult

int int → int

Multiples the top two elements of the stack together.
Example
```
5 2 mult ;=> [10]
```
neg

int → int

Negates the number at the top of the stack.
Example
```
5 neg ;=> [-5]
```
prod

'A → int

Multiplies all values on the stack.
Source
```
:* stack
```
sub

int int → int

Subtracts the top element of the stack from the second.
Example
```
5 2 sub ;=> [3]
```
sum

'A → int

Sums all values on the stack.
Source
```
:+ stack
```
zero?

'a → bool

Checks whether the top element is 0.
Source
```
0 eq?
```

Basic I/O

p

'a →

Prints the string representation of the element at the top of the stack.
Example
```
500 p ;=> 500
```
print

string →

Prints the string at the top of the stack to stdout.
Example
```
'Hello world' print ;=> Hello World
```
read

string → string

Reads the file at the top of the stack.
Example
```
'lorem.txt' read ;=> ["Lorem ..."]
```

Control flow

call

block → 'a

Calls the block at the top of the stack.
Example
```
300 :inc call ;=> [301]
```
if

bool block → 'a

Evaluates the block at the top of the stack if the value below it is true.
Example
```
300 300 eq? [ "300 equals 300, crazy!" print ] if
```
Source
```
. swap if-else
```
if-else

bool block block → 'a

Calls the block at the top of the stack if the condition is true, or the second if the condition is false.
Example
```
300 300 eq? [ "yes" ] [ "no" ] if-else ;=> ["yes"]
```

times

block int → 'a

Calls the second element of the stack n times, where n is the top element.

Example

300 :inc 5 times ;=> [305]

Source

swap
                wrap :dec swap compose :under compose
                :zero?
                ; 300 5 [dec :inc under] :zero? until
                until

                ; Cleanup counter
                pop nil pop

under

'a ( → 'A) → 'a 'A

Calls the top element while temporarily removing the second element.
Example
```
5 'In the way' :dec under ;=> [4 'In the way']
```
Source
```
swap without
```
under2

'a 'b ( → 'A) → 'a 'b 'A

Calls the top element while temporarily removing the second and third elements.
Source
```
swap swapp without2
```
unless

bool block → 'a

Evaluates the block at the top of the stack if the value below it is false.
Source
```
swap not swap if
```
until

block ( → bool) → 'a

Evaluates the second block while the condition at the top of the stack is false.
Example
```
5 :dec :zero? until ;=> 0
```
Source
```
:not compose while
```

while

block (block → bool) → 'a

Evalutes the second block on the third element of the stack while the condition at the top of the stack is true.

Example

5 :dec [ zero? ! ] while ;=> [0]

Source

; Evaluate the condition, while leaving copies of everything
                swapp swap dup
                swapp swap dup
                swapp call

                ; If condition is false, cleanup
                [pop swap pop]
                ; If condition is still true, ...
                [swapp swap dup
                swapp swap without2
                while]
                if-else

without

( → 'A) 'a → 'A 'a

Calls the second element while temporarily removing the top element from the stack.
Example
```
5 :dec 'In the way' without ;=> [4 'In the way']
```
without2

( → 'A) 'a 'b → 'A 'a 'b

Calls the third element while temporarily removing the top two elements from the stack.

Lists

append

list list → list

Adds the second list on the stack to the back of the first.
Example
```
(1 2 3) (4 5 6) append ;=> [(4 5 6 1 2 3)]
```
apply

list block → list

Applies the block at the top of the stack to the elements in the list below.
Example
```
(1 2 3) :swap apply ;=> [(1 3 2)]
```
cons

list 'a → list

Adds the element at the top of the stack to the end of the list below.
Example
```
(1 2 3) 4 cons ;=> [(1 2 3 4)]
```
head

list → 'a

Replaces the list with it's first element.
Example
```
(1 2 3 4) head ;=> [1]
```
prepend

list list → list

Adds the second list on the stack to the front of the first.
Example
```
(1 2 3) (4 5 6) prepend ;=> [(1 2 3 4 5 6)]
```
Source
```
swap append
```
reduce

list block → 'a

Applies the function to each pair of elements in the list.
Example
```
(1 2 3 4) :+ reduce ;=> [10]
```
Source
```
wrap :stack compose apply head
```
reverse

list → list

Reverses the elements in the list.
Example
```
(1 2 3) reverse ;=> [(3 2 1)]
```
tail

list → list

Replaces the list with a list containing all but the first of it's elements.
Example
```
(1 2 3 4) tail ;=> [(2 3 4)]
```

Logical operations

and

bool bool → bool

Calculates the value of a boolean and operation applied to the top two elements of the stack.
Example
```
true false and ;=> [false]
```
compare

'a 'b → int

Compares the top two elements of the stack, pushes -1 if the top element is less than the second, 0 if the elements are equal or 1 if the top element is greater.
Example
```
1 2 compare ;=> [1]
```
eq?

'a 'b → bool

Checks if the top two elements are equal.
Example
```
1 1 eq? ;=> [true]
```
gt?

'a 'b → bool

Checks whether the top element is greater than the second.
Example
```
1 2 gt? ;=> [true]
```
Source
```
compare  1 eq?
```
gte?

'a 'b → bool

Checks whether the top element is greater than or equal to the second.
Source
```
lt? !
```
lt?

'a 'b → bool

Checks whether the top element is less than the second.
Example
```
1 2 lt? ;=> [false]
```
Source
```
compare -1 eq?
```
lte?

'a 'b → bool

Checks whether the top element is less than or equal to the second.
Source
```
gt? !
```
neq?

'a 'b → bool

Checks whether the top element is not equal to the second. Note: this has a different meaning to `eq? not`. This will return false if the elements are lt? or gt? or eq?. Make sure you understand this properly before using, in most cases you will want to use `eq? not` instead.
Example
```
'a' 4 neq? ;=> [true]
```
Source
```
compare -2 eq?
```
not

bool → bool

Returns the opposite of the boolean value at the top of the stack.
Source
```
:true :false if-else
```
or

bool bool → bool

Calculates the value of a boolean or operation applied to the top two elements of the stack.
Example
```
true false or ;=> [true]
```

Stack operations

compose

block block → block

Composes the two blocks at the top of the stack, forming one single block.
Example
```
[ dup dec ] :mult compose ;=> [[ dup dec mult ]]
```
drop

'A →

Removes all elements from the stack.
dup

'a → 'a 'a

Pushes a copy of the top element to the stack.
dup2

'a 'b → 'a 'b 'a 'b

Duplicates the top two elements of the stack.
Source
```
swap dup swapp swap dup swapp
```
pop

'a →

Removes the element from the top of the stack.
size

→ int

Pushes the size of the stack on to the top of the stack.
stack

'A block → 'a

Calls the block on the top of the stack for each element on the stack, should be used with a reductive function.
Source
```
size 2 - times
```
swap

'a 'b → 'b 'a

Swaps the top two elements on the stack.
swapp

'a 'b 'c → 'b 'a 'c

Swaps the second and third elements on the stack.
Source
```
:swap under
```
wrap

block → ( → block)

Wraps the block in another block.
Example
```
:inc wrap [[inc]] eq? ;=> [true]
```

Strings

concat

string string → string

Joins the top two strings on the stack forming one string.
Example
```
'Hello' ' World' concat ;=> ['Hello World']
```
join

list string → string

Joins all strings in a list together using the string at the top.
Example
```
('John' 'Dave' 'Luke') ', ' join ;=> ['John, Dave, Luke']
```
Source
```
wrap [swap concat concat] compose reduce
```

Types

integer

string → int

Replaces the string at the top of the stack with an integer of the value represented by the string.
Example
```
'5' integer ;=> [5]
```
list

'a → list

Replaces the element at the top of the stack with a list containing the element.
Example
```
5 list ;=> [(5)]
```
range

int int → list

Creates a list with all the numbers from the second element to the top element.
Example
```
1 5 range ;=> [(1 2 3 4 5)]
```
string

'a → string

Converts the element at the top of the stack into a string.
Example
```
5 string ;=> ['5']
```

alias

string string →

Example

block?

'a → bool

Source

boolean?

'a → bool

Source

define

string block →

Example

defined

→ string

empty?

→ bool

Source

eval

string →

Example

include

string →

Example

Source

integer?

'a → bool

Source

nil?

'a → bool

Source

small?

→ bool

Source

string?

'a → bool

Source

type

'a → string

Example

Arithmetic operations

abs

int → int

Source

add

int int → int

Example

dec

int → int

Source

div

int int → int

Example

fact

int → int

Example

Source

inc

int → int

Source

mult

int int → int

Example

neg

int → int

Example

prod

'A → int

Source

sub

int int → int

Example

sum

'A → int

Source

zero?

'a → bool

Source

Basic I/O

p

'a →