Shift is an esoteric functional programming language I made a couple of years ago, but published today. It is stack-based, but also has automatic currying like Haskell.
There are two datatypes in Shift:
- Functions, which have an arbitrary positive arity (number of inputs), and which return a list of outputs. For example, a function that duplicates its only input has arity 1, and a function that swaps its two inputs has arity 2.
- Blanks, which are all identical and have no other purpose than not being functions.
A Shift program consists of zero or more commands, each of which is a single ASCII character. There are 8 commands in total:
!(apply) pops a function
fand a value
xfrom the stack, and applies
fhas arity 1, the list
f(x)is appended to the stack. If it has arity
n > 1, a new
gis pushed to the stack. It takes inputs
?(blank) pushes a blank to the stack.
+(clone) pushes to the stack a unary function that duplicates its input: any value
xis mapped to
>(shift) pushes to the stack a unary function that takes in an
f, and returns an
gthat ignores its first argument, and calls
fon the remaining ones.
/(fork) pushes to the stack a ternary function that takes three inputs
a,b,c, and returns
ais a blank, and
$(call) pushes to the stack a binary function that pops a function
fand a value
x, and applies
.(chain) pushes to the stack a binary function that pops two functions
g, and returns their composition: a function
hthat has the same arity as
f, and which takes its inputs normally, applies
fto them, and then fully applies
gto the result (calls it as many times as its arity dictates).
@(say) pushes a unary function that simply returns its input, and prints
0if it was a blank, and
1if it was a function.
Note that all commands except
! simply push a value to the stack, there is no way to perform input, and the only way to output anything is to use
A program is interpreted by evaluating the commands one by one, printing
1s whenever "say" is called, and exiting.
Any behavior not described here (applying a blank, applying a stack of length 0 or 1, calling "chain" on a blank etc.) is undefined: the interpreter may crash, silently fail, ask for input, or whatever.
Your task is to write an interpreter for Shift.
It should take from STDIN, command line, or function argument a Shift program to be interpreted, and print to STDOUT or return the resulting (possibly infinite) output of
If you write a function, you must be able to access the infinite-length outputs in some way (generator in Python, lazy list in Haskell, etc).
The lowest byte count wins, and standard loopholes are disallowed.
This Shift program prints
Starting from the left: push a blank, push say, then apply the say to the blank.
Then, push say twice, and apply the second say to the first.
This program loops forever, producing no output:
Push clone and call, then apply chain to them (we need two
!s since chain is a binary function).
Now the stack contains a function that takes one argument, duplicates it, and calls the first copy on the second.
+!!, we duplicate this function and call it on itself.
This program prints the infinite sequence
01011011101111..., where the number of
1s always increases by one:
I'm not going to explain it, mainly because I wrote it many years ago and forgot how it works. See the repository for a partial explanation.