gs2
gs2 is a a concatenative language designed by User:nooodl, inspired by GolfScript and J, designed to be as efficient as possible at code golf. gs2 code uses a binary format in which most bytes represent a single high-level stack operation. The code is run over stdin token by token, just like GolfScript.
The documentation that used to be here is mostly out of date now, and until the author gets around to writing up something more thorough, careful reading of the source code is your best bet, as with FlogScript. An old revision can be found here: [1]
Contents
Syntax
Code is tokenized as follows:
# string hack: programs can omit starting \x04 and save a byte if re.match('^[^\x04]*[\x05\x06]', prog): prog = '\x04' + prog token_re = [ '\x01.', # unsigned byte '\x02..', # signed short '\x03....', # signed long '\x04[^\x05\x06]*[\x05\x06]', # string (array) '\x07.', # 1 char string '.', # regular token ] tokens = re.findall('|'.join(token_re), prog, re.DOTALL)
Tokens starting with \x01 through \x03 push little-endian binary integers to the stack. Sequences of strings are delimited by \x04 and \x05, and split by \x07. The final \x05 byte can be replaced by \x06 in which case the strings are wrapped in an array. Some examples:
04 'a' 'b' 'c' 05 => "abc" 04 'a' 'b' 'c' 07 'd' 'e' 'f' 05 => "abc" "def" 04 'a' 'b' 'c' 06 => ["abc"] 04 'a' 'b' 'c' 07 'd' 'e' 'f' 06 => ["abc" "def"]
The following tokens are all "special" syntactically, i.e. not just a stack operation:
- \x08 opens a block, \x09 closes it. (These function like GolfScript's curly braces.) The mnemonics are { and }.
- \x4d __ pushes a 1-byte block. Mnemonic: ' (as in a Lisp quote.)
- \x4e __ maps a 1-byte block over the top of the stack. Mnemonic: m.
- \x4f __ filters a 1-byte block over the top of the stack. Mnemonic: f.
- \x5c __ maps a 2-byte block over the top of the stack. Mnemonic: mm.
- \x5d __ filters a 2-byte block over the top of the stack. Mnemonic: ff.
- \x5e opens a map block that lasts until the end of the program (or the next }). Mnemonic: m:.
- \x5f opens a filter block that lasts until the end of the program (or the next }). Mnemonic: f:.
Commands
In the "from" and "to" columns, following variables are used:
- α, β, γ represent any stack value, κ represents a constant
- f, g, h represent blocks
- a through z otherwise represent integers
- [α], [β] represent lists.
Dec | Hex | Mnemonic | From | To | Description |
---|---|---|---|---|---|
10 | \x0a | new-line | κ | Push a string containing a newline ([10]) to the stack. | |
11 | \x0b | empty-list | κ | Push an empty list ([]) to the stack. | |
12 | \x0c | empty-block | κ | Push an empty block ({}) to the stack. | |
13 | \x0d | space | κ | Push a string containing a space ([32]) to the stack. | |
14 | \x0e | make-array | α_{1} α_{2} ... α_{n} n | [α] | Wrap top n elements in an array. |
15 | \x0f | exit | Stop program execution. | ||
32 | \x20 | negate | x | -x | Negate a number. |
32 | \x20 | reverse | [α] | [α] | Reverse a list. |
33 | \x21 | bnot | x | ~x | One's complement. |
33 | \x21 | head | [α] | α | Extract first element from a list. |
34 | \x22 | not | α | x | Return 1 if α is zero or empty. 0 otherwise. |
34 | \x22 | tail | [α] | [α] | Drop the first element from a list. |
35 | \x23 | abs | x | |x| | Absolute value. |
35 | \x23 | init | [α] | [α] | Drop the last element from a list. |
36 | \x24 | digits | x | [x] | Return a list of digits in x, e.g. 123 → [1 2 3] |
36 | \x24 | last | [α] | α | Extract the last element of a list. |
37 | \x25 | random | [α] or x | α or x' | Pick a random element from a list or [0 1 ... x-1]. |
38 | \x26 | dec | x | x-1 | Subtract one. |
38 | \x26 | left-uncons | [α] | [α] α | Cut the first element off a list and place it on top of the stack. |
39 | \x27 | inc | x | x+1 | Add one. |
39 | \x27 | right-uncons | [α] | [α] α | Cut the last element off a list and place it on top of the stack. |
40 | \x28 | sign | x | sgn(x) | Signum. |
40 | \x28 | min | [α] | α | Minimum value of list. |
41 | \x29 | thousand | x | 1000x | Multiply by 1000. |
41 | \x29 | max | [α] | α | Maximum value of list. |
42 | \x2a | double | x | 2x | Multiply by 2. |
42 | \x2a | lines | [c] | [[c]] | Split over newlines. |
43 | \x2b | half | x | x/2 | Divide by 2. |
43 | \x2b | unlines | [[c]] | [c] | Join with newlines. |
44 | \x2c | square | x | x^{2} | Square. |
44 | \x2c | words | [c] | [[c]] | Split over spaces. |
45 | \x2d | sqrt | x | sqrt(x) | Calculate square root (rounded down.) |
45 | \x2d | unwords | [[c]] | [c] | Join by spaces. |
46 | \x2e | range | x | [x] | Push list of [0 1 ... x-1]. |
46 | \x2e | length | [α] | x | Push length of list |
47 | \x2f | range1 | x | [x] | Push list of [1 2 ... x]. |
47 | \x2f | sort | [α] | [α] | Sort list. |
48 | \x30 | add, + | x y | x+y | Add the top two numbers on the stack. |
48 | \x30 | cat | [α] [β] | [α β] | Concatenate top two lists on stack. |
49 | \x31 | sub, - | x y | x-y | Subtract the top two numbers on the stack. |
49 | \x31 | diff | [α] [β] | [γ] | Collect elements in [α] that are not in [β]. |
50 | \x32 | mul, * | x y | x*y | Multiply the top two numbers on the stack. |
50 | \x32 | join | [[α]] [β] | [γ] | Joins the lists in [[α]], splicing [β] between them. |
50 | \x32 | times | f n | Pops a number, then runs the block on top of the stack that many times. | |
50 | \x32 | fold | [α] f | β | Push the first element of [α], then alternate between pushing the next element of the list and running f. |
51 | \x33 | div, / | x y | x/y | Divide the top two numbers on the stack. |
51 | \x33 | group | [α] n | [[α]] | Group [α] into chunks of size n. |
51 | \x33 | split | [α] [β] | [[α]] | Split [α] over occurrences of sublist [β]. |
51 | \x33 | each | [α] f | Alternate between pushing elements of the list (from left to right) and running f. | |
52 | \x34 | mod, % | x y | x mod y | Modulo. |
52 | \x34 | step | [α] n | [α] | Take every nth element of [α] (like Python's a[::n].) |
52 | \x34 | clean-split | [α] [β] | [[α]] | Like split but remove empty results. |
52 | \x34 | map | [α] f | [β] | Apply f to each element in the list. |
53 | \x35 | and, & | x y | x AND y | Bitwise AND. |
53 | \x35 | get | [α] i | α | Get the i'th element of a list. |
53 | \x35 | when | f p | Run f only if p is true. | |
53 | \x35 | filter | [α] f | [α] | Collect elements in [α] for which evaluating f returns a truth value. |
54 | \x36 | or, | | x y | x OR y | Bitwise OR. |
54 | \x36 | unless | f p | Run f only if p is false. | description |
55 | \x37 | xor, ^ | x y | x XOR y | Binary XOR. |
55 | \x37 | concatmap | [α] f | [β] | Equivalent to map empty-list join. |
56 | \x38 | smallest | x y | min(x,y) | Smallest of x and y. |
57 | \x39 | biggest | x y | max(x,y) | Biggest of x and y. |
58 | \x3a | clamp | l h x | clamp(x,l,h) | Clamp x between l and h. |
60 | \x3c | gcd | x y | gcd(x,y) | Greatest common divisor. |
60 | \x3c | take | [α] i | [α] | First i elements. |
61 | \x3d | lcm | x y | lcm(x,y) | Least common multiple. |
61 | \x3d | drop | [α] i | [α] | All but first i elements. |
62 | \x3e | pow | x y | x^{y} | Exponentiation. |
62 | \x3e | index | [α] β | i | Return first index of β in the list (-1 if not found.) |
63 | \x3f | log | x y | floor(log(x,y)) | Floor of logarithm to base y. |
63 | \x3f | member | [α] β | p | Return 1 if β is in the list, else 0. |
64 | \x40 | dup | α | α | Duplicate stack top. |
65 | \x41 | dup2 | α | α α α | Duplicate stack top twice. |
66 | \x42 | swap | α β | β α | Swap top two stack elements. |
67 | \x43 | rot | α β γ | β γ α | Rotate top three stack elements leftwards. |
68 | \x44 | rrot | α β γ | γ α β | Rotate top three stack elements rightwards. |
69 | \x45 | over | α β | α β α | Copy penultimate stack element. |
70 | \x46 | nip | α β | β | Pop penultimate stack element. |
71 | \x47 | tuck | α β | β α β | Copy stack top before penultimate. |
72 | \x48 | 2dup | α β | α β α β | Duplicate top two stack elements. |
73 | \x49 | pick | α_{n} ... α_{1} n | α_{n} ... α_{1} α_{n} | Copy the n'th stack element counting from the top. |
74 | \x4a | roll | α_{n} ... α_{1} n | α_{n-1} ... α_{1} α_{n} | Move the n'th stack element counting from the top. |
75 | \x4b | get-stack | [σ] | Push the current stack as a list. | |
76 | \x4c | leave-top | α β ... ω | ω | Remove all but the top element from the stack. |
80 | \x50 | printf | [c] x or x [c] | [c] | Format x according to a printf specifier. |
81 | \x51 | lprintf | [c] [x] | [c] | Format [x] according to a printf specifier. |
82 | \x52 | show | α | [c] | Convert to string. |
83 | \x53 | map-show | [α] | [[c]] | Equivalent to m show. |
84 | \x54 | show-lines | [α] | [c] | Equivalent to m show unlines. |
85 | \x55 | show-words | [α] | [c] | Equivalent to m show unwords. |
86 | \x56 | read-num | [c] | x | Find first number (/-?\d+/) in string. |
87 | \x57 | read-nums | [c] | [x] | Find all numbers in string. |
88 | \x58 | show-line | α | [c] | Equivalent to show new-line cat |
96 | \x60 | logical-and | α β | x | Return 1 if both α and β are truthy, else 0. |
97 | \x61 | logical-or | α β | x | Return 1 if both α or β (or both) are truthy, else 0. |
98 | \x62 | divides | x y | p | Return 1 if x is a multiple of y, else 0. |
99 | \x63 | divmod | x y | q r | Return int(x/y) and (x mod y). |
100 | \x64 | sum | [x] | sum([x]) | Sum of list |
100 | \x64 | even | x | p | Is x even? |
101 | \x65 | product | [x] | product([x]) | Product of list |
101 | \x65 | odd | x | p | Is x odd? |
102 | \x66 | fizzbuzz | κ | Push "1\n2\nFizz\n4\nBuzz..." | |
103 | \x67 | popcnt | x | popcnt(x) | Count number of 1 bits in binary repr. of x |
104 | \x68 | base | α b | β | Convert α to/from base b |
105 | \x69 | binary | α | β | 2 base |
106 | \x6a | is-prime | x | p | |
107 | \x6b | nth-prime | n | p | |
108 | \x6c | n-primes | n | [p] | |
109 | \x6d | primes-below | n | [p] | |
110 | \x6e | next-prime | n | p | |
111 | \x6f | totient | n | p | Euler's totient function |
112 | \x70 | lt | α β | α < β | |
113 | \x71 | eq | α β | α = β | |
114 | \x72 | gt | α β | α > β | |
115 | \x73 | ge | α β | α ≥ β | |
116 | \x74 | ne | α β | α ≠ β | |
117 | \x75 | le | α β | α ≤ β | |
118 | \x76 | cmp | α β | cmp(α,β) | -1 if α<β, 0 if α=β, 1 if α>β |
119 | \x77 | sorted | [α] | b | 1 if [α] is sorted, else 0 |
Examples
(TODO)