GolfScript

GolfScript is a concatenative programming language embedded on top of Ruby, designed to allow very short programs to be written, in order to win code-golf contests. It supports a range of datatypes including arbitrary precision integers, and a wider range of standard operations than many other esoteric programming languages.
== Overview ==
A GolfScript program is a list of items: integers, lists, strings, blocks, variables, and variable assignments.
Integers, when encountered, are simply pushed onto the stack.
Lists, strings, and blocks behave similarly. Variables are also pushed onto the stack, except when the variable contains a block. If that happens, the block is executed.
When a variable assignment is encountered, the top item on the stack is assigned to the variable, but not popped off the stack.
== Syntax and Execution ==
Lists and blocks are delimited by square brackets and curly brackets, respectively.
A block is actually just a string that has special behavior.
Variable assignment is done by placing a colon before the variable name.
Comments begin with a hash and end at the end of the line.
Strings are first evaluated by Ruby, allowing an escape to Ruby expressions and frameworks for those functions not provided by GolfScript, such as floating point and math libraries.
== Input and Output ==
Before a GolfScript program is executed, the input is pushed onto the stack as one long string, and therefore interactive input is impossible. When the program finishes execution, the stack's contents are printed, (apparently) starting from the bottom. There are also some explicit built-in methods of printing.
== Built-ins ==
Most of the golfing power of GolfScript comes from its extensive library of operators. These are actually just variables specially initialized. You can assign values to them if you want. Also, most of the operators are overloaded to provide different results if supplied with different arguments. For example, the asterisk * can mean any of:
* Multiplication, when supplied with two integers
* To execute a block a number of times, when supplied with an integer and a block
* To repeat a string or list a number of times, when supplied with an integer and a string/list
* To join the elements of a string/list together with another string/list, when supplied with two string/lists
* To reduce the elements of a string/list to one element, when supplied with a string/list and a block
=== Coercion ===
When needed, integers are coerced to arrays/strings/blocks, arrays are coerced to strings/blocks (each element is converted to a string and the results are concatenated together), and strings are coerced to blocks.
=== List of built-ins ===
Here is a list of built-ins (currently incomplete), in roughly increasing order of complexity. The arguments describe what types of objects should be on the stack, written bottom to top. A slash means that the arguments are interchangeable. 'List' means arrays or strings; 'sequence' means lists or blocks. This terminology is largely arbitrary.
Name 	Arguments 	Description
; 	any 	Pop, discard
. 	any 	Duplicate on stack
\ 	any, any 	Swap top two elements
@ 	any, any, any 	Move third element on bottom to top
! 	any 	Negation: pushes 1 if argument is 0 or empty string/array/block, 0 otherwise.
` 	any 	Converts the element to a string that, if evaluated, returns the original
~ 	int 	Bitwise not
~ 	string or block 	Evaluate
~ 	array 	Dump the elements onto the stack
, 	int 	Construct an array with elements [0, 1, ..., int - 1]
, 	list 	Find the length
, 	list, block 	Filter: select elements that return true when the block is applied to them.
& 	int, int 	Bitwise and
& 	seq, seq (coerce)	Setwise and
|	int, int 	Bitwise or
|	seq, seq (coerce)	Setwise or
^ 	int, int 	Bitwise xor
^ 	seq, seq (coerce)	Setwise xor
$ 	int 	Copy stack: copy the nth element of the stack (after popping the argument) to the top.
$ 	list 	Sort
$ 	list, block 	Sort, according to a mapping
( 	int 	Decrement
( 	seq 	Uncons: push sequence without first item, push first item
) 	int 	Increment
) 	seq 	Uncons from right: push sequence without last item, push last item
+ 	int, int 	Add two integers
+ 	seq, seq (coerce)	Concatenate two sequences
- 	int, int 	Subtract
- 	seq, seq (coerce)	Setwise difference
* 	int, int 	Multiply
* 	int/list 	Copy the sequence (int) times and concatenate them together.
* 	int/block 	Execute it (int) times.
* 	list, list 	Join. Put the elements of the second sequence in between each element of the first sequence and concatenate.
* 	list, block 	Fold. Reduce. Whatever.
/ 	int, int 	Integer division
/ 	list, list 	Split around matches with a second array
/ 	block, block 	Unfold: a while loop where the condition test is applied to the top of stack, and if the check passes the element on top of stack is collected into an array.
/ 	list, block 	Each: execute a block over each element, and push the results.
% 	int, int 	Integer modulus
% 	list, list 	Split around matches like /, but omit empty results
% 	list, int 	Select elements with index 0 mod int. If the int is negative the result is reversed, so [1 2 3]-1% reverses the array.
% 	list, block 	Map. Somewhat like Each except the results go in a list.
== Examples ==
99 bottles of beer (considerably golfed)
 [296,{3/)}%-1%["No more"]+[" bottles":b]294*[b-1<]2*+[b]+[" of beer on the wall\n".8<"\nTake one down, pass it around\n"+1$n+]99*]zip
Quines: Note that since the stack is output at termination, a program like
 5
is a quine (as long as no input is given to it). A more non-cheating example could be
 {".~"}.~
How it works: block {".~"} pushes the .~ string when evaluated. It's duplicated (blocks are printed with parentheses) and evaluated.
Random example of the golfing that can be done with this code:
 ~{..{(h{3^3%}%2,@h{2\-}%\;++}{,}if}:h~2/zip{{"ACB"=}%}%n*\;
== Computational class ==
GolfScript is Turing-complete, as it can be shown to be computationally equivalent to Underload: the GolfScript built-ins \.;+{}~ correspond to the TC subset of Underload commands ~:!*()^.
== External resources ==
* GolfScript homepage
* Examples of golfscript programs submitted with the intent of minimizing program length. (Scroll down to 'right time' or lower for ones you can view.)
Category:Languages
Category:2007
Category:Stack-based
Category:Implemented
Category:Turing complete
Category:Golfing language