nyuuzyou/wikis huggingface dataset:
Calligulan Assembly

Calligulan Assembly is an esoteric programming language created by User:ArthroStar11 that is written entirely in Roman Numerals
== Data Structure and Syntax ==
*Commands and arguments in Calligulan Assembly are represented as roman numerals separated by newlines
**capital letters represent the numerals we all know and love
**the values of lower case letters are multiplied by 1000
*data structure
**hold cell (32-bit unsigned integer)
**boolean cell (boolean value, duh)
**variables [array of 30000, 1-index] (32-bit unsigned integer)
== Command List ==
* I (Label)
** defines a label for goto statements, 30000 labels may be used (I - xxx) as specified in <line + 1>
* II (go to)
** jumps to the corresponding label as specified in <line + 1> if the boolean cell is true
* III (less than)
** sets the boolean cell to true if <variable[line + 1]> is less than <variable[line + 2]> else false
* IV (equal to)
** sets the boolean cell to true if <variable[line + 1]> is equal to <variable[line + 2]> else false
* V (not)
** inverts the boolean cell
* VI (input)
** takes console input as an ASCII character if <line + 1> == I
** takes console input as a number if <line + 1> == II
** stored in hold cell
* VII (output)
** outputs an ASCII character to the console if <line + 1> == I
** outputs a number to the console if <line + 1> == II
** printed from hold cell
* VIII (store)
** stores the value of the hold cell into the variable specified in <line + 1>
* IX (retrieve)
** retrieves value of the variable specified in <line + 1> and stores it in the hold cell
* X (add)
** hold cell = <variable[line + 1]> + <variable[line + 2]>
* XI (subtract)
** hold cell = <variable[line + 1]> - <variable[line + 2]>
* XII (constant)
** stores the number specified by <line + 1> into the hold cell
== sample programs ==
print "HI"
 XII
 LXXII
 VII
 I
 XII
 LXXIII
 VII
 I
truth machine
 VI
 II
 VIII
 I
 XII
 I
 VIII
 II
 I
 I
 III
 I
 II
 V
 IX
 I
 VII
 II
 II
 I
print 99 to 0
 XII
 XCIX
 VIII
 I
 XII
 I
 VIII
 II
 I
 I
 III
 I
 II
 V
 IX
 I
 VII
 II
 XI
 I
 II
 VIII
 I
 II
 I
== Implementation ==
ArthroStar11's Interpreter (C++ source)
Category:Implemented
Category:Languages
Category:2021
Category:Low-level
Category:Unknown computational class
Cammy/Bikeshed

This page is an appendix for research done for Cammy which is too long and boring to be included on the main page.
== Nomenclature ==
Most categorical objects are each a presentation of some wikipedia:universal property, but the current practice of mathematics does not have unambiguous symbols for most of them. Worse, most arrows do not have standard names, and sometimes not even standard titles.
The following table's rows are categorical arrows, and the columns are category theorists who have named them; each cell is a name. Our columns are:
* Curien 1986
* Hagino 1987
* Von Thun 2001
* Kerby 2002
* Baez & Stay 2009
* Elliott 2017
* Patterson 2017
In addition, we have three extra columns. Two are for the communities of Wikipedia and nLab respectively, and one is for Cammy.
=== Kerby's Category ===
Kerby gives a broad argument that their `i` combinator, which unquotes a
single quotation and executes its stack effect, is a homomorphism. Indeed, we
will imagine an entire category which routes quotations opaquely without
executing them; to execute any expression in Kerby's category, simply suffix
it with `i`. However, Kerby also gives a persuasive argument that lambda
calculus is best understood with the identity arrow being the expression
`A\A`, which corresponds precisely to `i`. We thus will use `i` for identity
and reason from there.
=== Delta ===
One might expect that the usage of the Greek capital wikipedia:delta (letter) is definitely the Unicode codepoint U+0394 GREEK CAPITAL LETTER DELTA. However, Baez & Stay and Patterson use U+2206 INCREMENT, and Elliott uses U+25b3 WHITE UP-POINTING TRIANGLE. This is almost certainly a typesetting issue. The table uses U+0394 (Δ) exclusively, for screen readers.
WP 	nLab	Cammy 	Curien	Hagino	Von Thun	Kerby	Baez & Stay	Elliott	Patterson
wikipedia:morphism#Identity 	 	id 	id 	- 	id 	i 	id 	id 	1
- 	 	comp 	◦ 	- 	- 	b 	◦ 	◦ 	-
wikipedia:initial and terminal objects	 	ignore 	1 	! 	drop 	zap 	! 	it 	I
wikipedia:product (category theory) 	 	fst 	Fst 	pi1 	pop 	k 	p 	exl 	-
… 	… 	snd 	Snd 	pi2 	popd 	z 	p' 	exr 	-
… 	… 	pair 	<,> 	pair 	- 	c 	- 	Δ 	-
… 	… 	pair/tensor	- 	prod 	- 	- 	⊗ 	- 	⊗
wikipedia:diagonal morphism 	 	pair/dup 	- 	- 	dup 	dup 	Δ 	- 	Δ
wikipedia:coproduct 	 	left 	- 	in1 	- 	- 	- 	inl 	-
… 	… 	right 	- 	in2 	- 	- 	- 	inr 	-
… 	… 	case 	- 	case 	- 	- 	- 	jam 	-
wikipedia:monoidal category 	 	assl 	- 	- 	- 	- 	assoc 	- 	-
… 	… 	assr 	- 	- 	- 	- 	- 	- 	-
wikipedia:free monoid 	 	nil 	- 	nil 	[] 	- 	- 	- 	-
… 	… 	cons 	- 	cons 	cons 	- 	- 	- 	-
… 	… 	fold 	- 	prl 	fold 	- 	- 	- 	-
wikipedia:symmetric monoidal category 	 	swap 	- 	- 	swap 	swap 	braid 	- 	σ
wikipedia:Cartesian closed category 	 	curry 	Λ 	curry 	- 	- 	~ 	curry 	-
… 	… 	uncurry 	- 	- 	- 	- 	- 	uncurry	-
… 	… 	app 	App 	eval 	b 	- 	eval 	apply 	-
wikipedia:natural numbers object 	 	zero 	- 	zero 	0 	z0 	- 	- 	-
… 	… 	succ 	- 	succ 	succ 	- 	- 	- 	-
… 	… 	pr 	- 	pr 	primrec 	- 	- 	- 	-
Category:Languages
Camouflage

Camouflage is a language designed by Benedict Roeser, based on the idea of "disguises" which change the mode of interpreting commands.
There are five types of disguises.
1. security guard
2. slot machine
3. ghost
4. tax collector
5. playwright
Several disguises can be added resulting in more than one active command mode.
In 'security guard mode' each command is plausability checked.
No errors are thrown, but default values are used on error.
In 'slot machine mode' there is a fity-fifty chance that a command is executed. 'slot machine mode' has no effect
if 'security guard mode' is active.
In 'ghost mode' commands are executed without visible traces. No text is outputted, no graphical interface changes, ...
Nevertheless, side effects are computed. E. g. if you have commands in ghost mode, that store the current screen resolution
in a variable and change the screen resolution to 1024x768 the resolution will NOT CHANGE, but the variable will be set.
In 'playwright mode' everything is ultra-verbose and the return value of every command is displayed after the execution of
the command.
'playwright mode' has no effect if 'ghost mode' is active.
In 'tax collector mode' all variable or constant values are substituted by user input.
If 'security guard mode' is active and impossible values are entered by the user, default values are taken.
If 'ghost mode' is active, the urge for user input will not be shown in any way (No popup windows with
'Please enter something:', no blinking cursor on the console, ...)
==Implementations==
At University of Ulm, Germany, at least two interpreters for the Camouflage programming language have been implemented. One of them, written by Manfred Sauter in Ruby, is publicly available: An interpreter for the Camouflage programming language. In addition to an implementation to 99 bottles and hello world this webpage also features a quine in Camouflage.
==External resources==
*Camouflage Draft
*Official Page (in German)
Category:Languages
Category:Implemented
Category:2005
Category:High-level
Campbell

== Description ==
Campbell is a language inspired by Joseph Campbell's Monomyth.
All programs written in it expose the universal archetypal program.
== Example programs ==
 factorial n = foldl (*) 1 [1..n] -- calculates factorial
 (define (factorial n)
 (if (= n 1)
 1
 (* n (factorial (- n 1) ))))
 calculates factorial
== Discussion ==
In fact every program in Campbell calculates the factorial function making it possibly one of the most concise languages out there.
Category:2021
Category:Joke languages
Category:Languages
Category:Unusable for programming
Category:Total
Category:No-code esolang
CancelScript

CancelScript is an esoteric programming language some say is suggestive of the feeling of cancelling on plans with friends. It was conceived and its specification written after the author woke up in a sleep-deprived, alarm clock-induced daze the morning breakfast with a friend had been planned. Not moments after waking up, the author fell back asleep. Breakfast was cancelled.
==Specification==
Programs written in CancelScript can involve three components: the word "cancel" (case insensitive), whitespace characters, and non-whitespace characters not part of the word "cancel".
A CancelScript interpreter immediately terminates the program as soon as the word "cancel" is read. Any other non-whitespace character is unexpected input, and the program immediately terminates. Whitespace characters are ignored.
==Implementations==
The reference implementation is written in JavaScript and available on GitHub at the link given in the #External Resources section.
User:Zzo38 has written a `scanf` implementation in C, viewable on the talk page.
It is also possible that existing compilers or interpreters intended for a different purpose happen to be functionally equivalent to a CancelScript implementation.
==External resources==
* The reference CancelScript implementation; an interpreter written in JavaScript
Category:Languages
Category:Unusable for programming
Category:No IO
Category:Thematic
Category:2019
Category:Total
Category:Finite state automata
Category:Implemented
Cane Code

Cane Code is a Brainfuck like language, created by Mihail Podivilov in 2013 year. Cane Code is opensource.
==Command set==
Cane Code command set was created by Mihail Podivilov. Only numbers.
Command	Description
1 	Increment the data pointer (+ 1 in cell)
2 	Decrement the data pointer (- 1 in cell)
3 	Move the pointer to the left
4 	Move the pointer to the right
5 	If the byte at the data pointer is zero, then instead of moving the instruction pointer forward to the next command, jump it forward to the command after the matching 6 command
6 	If the byte at the data pointer is nonzero, then instead of moving the instruction pointer forward to the next command, jump it back to the command after the matching 5 command
7 	Accept one byte of input, storing its value in the byte at the data pointer
8 	Output the byte at the data pointer
9 	User custom command or clear memory
0 	User custom command or terminate programm execution
The Cane Code is cross-platform.
In the language Cane Code, you can write a full program or operating system. There are three ways to execute code: interpreter, compiler or compiler LOL LOL hex code into machine code. ANSI can be enabled or disabled by user.
==Example, print Mihail==
 1111111152411111111364111111111111183114111113641118282
 222222811111111811183
==Example, fibonacci numbers==
 1111111111141444411111111111111111111111111111111111111
 1111114111111111111111111111111111111113333335454444441
 4133333332644444445333333314444444263541111111111523254
 4141333264445333144426135452635266453354441333264452663
 3644454414133326444533314442613545263526645331445266333
 3333644444511111111111111111111111111111111111111111111
 1111852661111111111352423641111111111111111111111111111
 1111111111111111111185263333333333335444141333326444453
 3331444426325448483335266335441413332644453331444263353
 1426453142633326
==External resources==
* Cane Code website 
* 
* Download Cane Code
Category:Brainfuck derivatives
Category:Languages
Category:Implemented
Category:Turing complete
Category:Cell-based
Category:Low-level
Category:2013
Canon

:"Rule 108" redirects here. For the elementary cellular automaton, see Rule 108.
Canon is a one-dimensional cellular automaton created by User:TheCanon2.
==Rules==
Canon has a single pointer. The pointed moves based on the value of the pointer cell b and its neighbours a and c. Canon has four rules.
* If a = c != b, flip b and move the pointer two cells to the left.
* If a = b = c, flip b and move the pointer one cell to the left.
* If a != c and b = 1, flip b and move the pointer two cells to the right.
* If a != c and b = 0, flip b and move the pointer one cell to the right.
==Implementations==
The following Amtu script defines Canon as a Turing machine.
A < R < R < R
R > Z > Z > O
Z > ZZ > ZZ > ZO
O > OZ > OZ > OO
ZZ <1< A <1< A <1>> A
ZO <0<< A <0<< A <0> A
OZ <1>> A <1<< A <1<< A
OO <0> A <0> A <0< A
The following Python script performs Canon.
tape = [0] # Canon
import random
for i in range(0, 60):
 tape.append(random.randint(0, 1)) # Replace with 0 for blank input
pointer = 30
while True:
 subtape = [tape[pointer-1],tape[pointer],tape[pointer+1]]
 if subtape == [0, 0, 0]:
 tape[pointer] = (tape[pointer] + 1) % 2
 pointer -= 1
 elif subtape == [0, 0, 1]:
 tape[pointer] = (tape[pointer] + 1) % 2
 pointer += 2
 elif subtape == [0, 1, 0]:
 tape[pointer] = (tape[pointer] + 1) % 2
 pointer -= 2
 elif subtape == [0, 1, 1]:
 tape[pointer] = (tape[pointer] + 1) % 2
 pointer += 1
 elif subtape == [1, 0, 0]:
 tape[pointer] = (tape[pointer] + 1) % 2
 pointer += 2
 elif subtape == [1, 0, 1]:
 tape[pointer] = (tape[pointer] + 1) % 2
 pointer -= 2
 elif subtape == [1, 1, 0]:
 tape[pointer] = (tape[pointer] + 1) % 2
 pointer += 1
 elif subtape == [1, 1, 1]:
 tape[pointer] = (tape[pointer] + 1) % 2
 pointer -= 1
 for i in range(0, len(tape)):
 print(tape[i], end="")
 print("\n", end="")
Category:Cell-based
Category:Unknown computational class
Category:Languages
Category:Cellular automata
Category:Implemented
Canonical ingredients-oriented language

The canonical ingredients-oriented language is an ingredients-oriented language designed for the sole purpose of demonstrating the ingredients-oriented paradigm.
== Grammar ==
 // Base Things
 ingredient = NAME ;
 ingredientusage = NAME ["[" expression "]"] ;
 vessel = NAME ;
 type = NAME ;
 keyword = "unending" ;
 keywords = {keyword}
 declaration = keywords type NAME ["[" expression "]"] "=" expression ;
 
 // Expressions
 number = INT | FLOAT
 val = ingredientusage | number | STRING
 mixexpression = vessel "(" ({expression SEP} expression | "") ")" ;
 binexp1 = expression "**" expression ;
 binexp2 = expression ("*" | "/" | "%" expression ;
 binexp3 = expression ("+" | "-") expression;
 parenexp = "(" expression ")"
 expression = val | mixexpression | parenexp | binexp1 | binexp2 | binexp3 ;
 
 // Statements
 dispose = DISPOSE ingredientusage ;
 protocol = "protocol" NAME (line | "return" expression) ;
 statement = dispose | protocol;
 
 // Code
 line = (declaration | expression | statement) TERMINATOR ;
 block = BEGIN {line} END ;
 
 // Control flow
 emptyloop = "EMPTY" (declaration | expression | ingredient) block ;
Category:Languages
Cantonese

Cantonese is an esolang using syntax based on the grammar of the Cantonese language
==Syntax==
===Variable assignment===
Variables are assigned with the following syntax:
 var_name係value
The reserved variable `佢` is set by various functions in lieu of returns.
===Control flow===
Blocks use commas (，) to separate statements rather than semicolons, and end in a semicolon. This means that blocks cannot be nested within each other since their ending punctuation would conflict. If required, just create another function
If block
 如果expr，block
Else
 否則，block
If statement (can appear in blocks)
 如果expr就stmt
Else
 否則就stmt
While block
 只要expr，block
While statement (can appear in blocks)
 只要expr就stmt
===Functions===
 name：code
===Literals===
Literal	Value
堅 	true
贋 	false
===Operators===
 Binary Operators
Operator	Description
等於 	Equality
唔等於 	Inequality
大於 	Greater than
小於 	Less than
唔大於 	Not greater than (less than or equal)
唔小於 	Not less than (greater than or equal)
而且 	Logical AND
或者 	Logical OR
 Unary Operators
Operator	Description
唔 	Logical NOT
==Standard library==
Function 	Description
話「...」 	Println
問「...」 	Prompt - stores user input into 佢
完 	End / Return
==Examples==
===Hello World===
 話｢Hello World!」
 完。
===Cat Program===
 只要堅，
 問；
 話佢；
 完。
===Truth machine===
 問；
 如果佢等於零，
 　話零；
 否則只要堅，
 　話一；
 完。
===FizzBuzz===
 甲係一；
 只要甲小於一百，
 　如果甲取模十五等於零就話｢FizzBuzz」，
 　否則如果甲取模三等於零就話｢Fizz」，
 　否則如果甲取模五等於零就話｢Buzz」，
 　否則話甲，
 　甲係甲加一；
 完。
Category:Languages
Category:2022
Category:Unimplemented
Category:CJK
Category:Thematic
Category:Pseudonatural
Cantor

Cantor is an esolang created by User:Joe, in 2024, after imagining a stack based language with minimal/no stack shuffling. It is named after George Cantor for his work on infinities. 
==Overview==
Cantor consists of access to infinitely many stacks, and there are only a few operations you can do on these stacks. There is a catch though. To encourage the use of varying stacks, every stack can only store 7 items (so people just don't use the first 2 stacks).
Its basically a tape of stacks. Kinda a weird brainf***.
==Commands==
The integers can be both positive and negative. Positive numbers indication movement to the right, and negative to the left.
The number 0 can be used to refer to the current stack. For instance, >0 wont move the stack, and =0 dups the top item on the stack. 
If an item is copied or moved to a full stack, it is removed.
<TT>(...)</TT> can be used for comments.
; <TT>>n</TT> :
:moves the current stack n away.
; <TT>=n</TT> : 
:copies the value at the top of the current stack to the top of stack n away
; <TT>#m</TT> : 
:moves the value at the top of the current stack to the top of stack n away (the value on the top of the current stack is popped off)
; <TT>[...]</TT> : 
:push string (the text within the brackets) to the top of the current stack
; <TT>!</TT> : 
:include the string on the current stack into the actual program (to evaluate it) 
; <TT>+</TT> : 
:concatenate the top two strings on the current stack.
; <TT>^</TT> : 
:output the top string on the current stack, popping it (I view this as an extra command just for IO. not necessary for the spirit of cantor)
==Turing Completeness==
WARNING: NOT A CORRECT PROOF
(I am not too sure if this is a full proof yet, because it doesn't take into account that each stack can only hold 7 items)
On the Underload page, it is shown that :()^ is a Turing Complete reduction. And for Cantor, we can show that it can perform these operations.
; <TT>:</TT> = <TT>n=n</TT> 
:where n is an arbitrary stack. (n=n copies its top value to the top of the stack)
; <TT>()</TT> = <TT>[]n</TT>
; <TT>^</TT> = <TT>!n</TT>
We are done. (I think)
==Example Programs==
===Hello, world!===
 [Hello, world!]^
===Infinite Loop===
 [=0!]=0!
===Truth Machine===
(Based off of the Underload Truth Machine)
There is no input, so [] on the top of the stack represents 0, and a [#7] represents 1. There example below has an input of 1.
 [#7][[1]^=0!]#1#2>1#-1>1#-2>-2[[0]^]#1#2>1#-1>1#-2>-2!=0!
 (7 is the garbage stack)
==Implementations==
Factor implementation https://github.com/JosephOziel/cantor
Category:Stack-based Category:Cell-based Category:2024 Category:Implemented
Cappuccino

== Description ==
Cappuccino is like Java, but different. In fact, it is almost identical to Java, but with some key differences. For example, if you try to access a class that is public, you will get an error. This is because public has the behavior of protected in Java. There are other such substitutions just to throw you off.
== Substitutions ==
These are just replacing the behavior of one word with another. The item before the arrow behaves like the second one.
=== Access modifiers ===
* public -> protected
* protected -> private
* private -> (default access modifier)
* (default) -> public
=== Primitives ===
* int -> char
* char -> long
* long -> double
* double -> float
* float -> void
* void -> bool
* bool -> int
Note: when used as a function argument or return type, the arrow goes the opposite way.
=== Classes ===
* String -> Integer
* Integer -> Float
* Float -> Double
* Double -> Long
* Long -> Object
* Object -> String
The same applies here with function arguments and return types.
=== Keywords ===
* if -> else
* else -> for
* for -> while
* while -> switch
* switch -> new
* new -> case
* case -> class
* class -> if
== Examples ==
=== Hello, world! ===
case Main {
static float Main(Integer args[]) {
System.out.println("Hello, world!");
}
}
Category:Languages Category:Object-oriented paradigm Category:High-level Category:Turing complete
Capsule

Capsule is an esoteric programming language featuring an 8*8 grid of integers (named "capsules") and two stacks, the whole "gimmick" is that most commands can only move values to a capsule's neighbours. Its orignal compiler was made in C# by User:Leol22, it executes programs from a text file in command line.
==Command List==
hey, i'm too lazy to make this. use this.
==Computational Class==
Capsule was proven Turing Complete after Brainfuck Encoded Concatenative Calculus was interpreted on it by user:Olus2000
Category:Languages
Category:Implemented
Category:Stack-based
Category:Turing complete
Car

Car is a 2d Programming language
==Example==
 # # #
 # l f l #
 [ f f p f r # r f f f F #
 # l r l #
 # f #
 F
 #
Its a roundabout
That outputs 02
===Commands===
 “f” move forward until you hit a #
 if you hit a # a tow truck will help
 (tow truck also counts as a car)
 “F” move forward until you hit a #
 if you hit a # turn 180 degrees
 “r” turn right if you hit a # and 
 add 1 to car
 else keep moving forward
 “l” turn left if you hit a # and
 subtract 1 from car
 else keep moving forward
 “#” its just a wall
Category:Languages Category:Two-dimensional languages
Carevindecant

Carevindecant is a Turing complete esolang created by CreeperBomb in August 2023. It is a Turing tarpit, and, as of writing/creating this page, only has . The name comes from "CAREt", "V", "INcrement", "DECrement", "AT", & "Newline".
==Explanation==
There are only six characters used in Carevindecant code:
@ 	The register of the value of the register that comes immediately after it. If none does, it is register 0.
+ 	Increments immediately following register.
- 	Decrements immediately following register unless said register is 0.
^ 	Moves up a line if immediately following register is 0. If on the highest line, halt the program.
v 	Moves down a line if immediately following register is 0. If on the lowest line, go to top of program.
Newline	Seperates lines.
If the end of a line is reached, the line is run again.
There is a register for every nonnegative integer, and each register can store any nonegative integer.
I/O is done by writing/reading the registers.
==Examples==
Truth machine (input on register 0 before running):
^@+@@+@
Summation of registers 1 & 2 onto register 1, register 0 starting at 0:
+@+@^@@-@@-@-@@-@
Category:Languages Category:Turing complete Category:2023 Category:Turing tarpits
Carriage/Carriage.hs

:
Quick and dirty implementation of Carriage in Haskell. Program might not explode under every condition it is supposed to explode (but please do consider every error to be an explosion, not just BOOM). Runs the two examples given in the article.
 
 explode = error "BOOM"
 
 data Elem = Int Integer
 | Fn ([Elem] -> [Elem])
 | Sym Char
 instance Show Elem where
 show (Int i) = show i
 show (Fn _) = "<fn>"
 show (Sym c) = show c
 
 pop (e:s) = (e, s)
 push s e = (e:s)
 
 pick 0 ((Sym _):_) = explode
 pick 0 (e:_) = e
 pick n (_:s) = pick (n-1) s
 
 slice _ 0 _ = []
 slice p k s = slice' p (reverse s)
 where
 slice' 0 s = take (fromIntegral k) s
 slice' n (_:s) = slice' (n-1) s
 
 ci " " = id
 ci "1" = \s -> push s $ Int 1
 ci "$" = snd . pop
 ci "#" = \s -> push s $ Int $ fromIntegral $ length s
 ci "~" = (\s ->
 let
 (Int a, s') = pop(s)
 in
 push s' $ pick a s')
 ci "\\" = (\s ->
 let
 (a, s') = pop(s)
 (b, s) = pop(s')
 in
 push (push s a) b)
 ci "+" = (\s ->
 let
 (Int a, s') = pop(s)
 (Int b, s) = pop(s')
 in
 push s $ Int (a + b))
 ci "-" = (\s ->
 let
 (Int a, s') = pop(s)
 (Int b, s) = pop(s')
 in
 push s $ Int (b - a))
 ci "@" = (\s ->
 let
 (Int k, s') = pop(s)
 (Int p, s) = pop(s')
 fn = ci $ map (\(Sym c) -> c) $ slice p k s''
 in
 push s (Fn fn))
 ci "!" = \s -> let (Fn f, s') = pop(s) in f s'
 ci [] = id
 ci [_] = explode
 ci (sym:rest) = \x -> (ci rest) ((ci [sym]) x)
 
 di = reverse . map (\x -> Sym x) . filter (\x -> x /= ' ')
 
 run prog = (ci prog) (di prog)
 
==See also==
* Carriage
* Carriage/carriage.ml
Category:Implementations