nyuuzyou/wikis huggingface dataset:
Church numeral

A Church numeral is a natural number encoded into lambda calculus using Church encoding. Church numerals are one of two popular ways to encode natural numbers as functions, the other being Scott numerals. Quoting Corbin 2023:
The natural numbers are initial Church numerals, which is a way of formalizing the intuition that the natural numbers are: do nothing, do it once, do it twice, …
== Definition ==
We'll start with simply-typed lambda calculus. A Church numeral is a function with type (X → X) → (X → X), for all types X. This is a polymorphic type signature; in e.g. wikipedia:System F, it would be written as:
 ΛX. (X → X) → (X → X)
We can think of functions with this signature as taking unary operations X → X on some type X, chosen by the caller, and either returning the identity function on X or repeating the unary operation some number of times.
In the untyped lambda calculus, a Church numeral no longer needs to be well-typed as long as it is extensionally equivalent to one of the simply-typed functions. It can be useful, when writing untyped lambda calculus, to write Church numerals and other combinators in simply-typed lambda calculus first.
== Examples ==
The first few numbers can be written with out as:
 0: λfr.r
 1: λfr.fr
 2: λfr.f(fr)
 3: λfr.f(f(fr))
That is, the number n is a function of f and r, specifically f applied to r n times. A number can be incremented using λxfr.f(xfr). This works by simulating the number x, but applying f one more time.
== Arithmetic ==
Addition of Church numerals is performed by applying the first term to the successor function, and then to the second number to be added. If the successor function is called +, and Church numerals are notated by the integers they represent, then this resembles standard mathematical notation (adding 3 to 5 can be written as 3+5, which expands to +(+(+5)).
Multiplication is essentially function composition:
 mul: λxyf.x(yf)
Exponentiation is achieved by simply applying the exponent to the base:
 exp: λxy.yx
There are many ways to define a predecessor function,and the following is one of the ways to use church pairs.
 pair: λabx.xab
 left: λp.p(λab.a)
 right: λp.p(λab.b)
 pred: λn.left(n(λp.pair(right p)(succ(right p)))(pair 0 0))
Subtraction just like addition,but replace successor function into predecessor function.
 sub: λxy.y pred x
Need a fixed point combinator to define partial division function.
 fix: (λx.xx)(λfx.x(ffx))
 div: fix(λfxy.(succ(sub x y))(λn.succ(f(sub x y)y))0)
== Contrast with Scott numerals ==
Church numerals are the initial encoding of the natural numbers. Scott numerals are the final encoding.
Fast operations in Church numerals include multiplication and exponentiation, including wikipedia:exponentiation by squaring. In contrast, Scott numerals have fast decrement, including decrement-or-zero tests.
== See also ==
Other approaches to encoding natural numbers in lambda calculus:
* Parigot numeral
* Scott numeral
Category: Concepts
Cipher

Cipher is an programing language by User:ChuckEsoteric08.
==Description==
The Code is any number. 5 substracted from it and result is divided by 17. Then it is reads every 2-digit number, multiply it by 3 and execute it:
Result	Operation
33 	Push 1 to the stack
42 	Pop a and b. Push a+b
51 	Pop a and b. Push b-a
66 	Pop a and b. Push a*b
87 	Pop a and b. Push b/a
90 	Duplicate element on top of the stack.
96 	Start loop while top is not 0
99 	End loop
3 	Output top of the stack
==Examples==
===Addition===
This program pushes the number one (1) twice onto the stack, pops and adds these items, pushes the sum, and prints the same.
 188893822
===Countdown===
The following program prints the numbers from four (4) down to inclusive one (1) by employing a loop in conjunction with subtraction:
 1888939893989434418899466
==Interpreter==
* Common Lisp implementation of the Cipher programming language.
Category:Languages Category:Stack-based Category:Implemented Category:Turing complete Category:Output only
CipherScribe

= CipherScribe =
== Overview ==
CipherScribe is an esoteric programming language where commands are hidden within encoded messages. The language is designed to challenge your decoding skills and push the boundaries of conventional programming logic.
== Basic Commands ==
* `α` (U+03B1) - Print "a"
* `β` (U+03B2) - Print "b"
* `γ` (U+03B3) - Print "c"
* `δ` (U+03B4) - Move to the next position
* `ε` (U+03B5) - Move to the previous position
* `ζ` (U+03B6) - Increment the value at the current position
* `η` (U+03B7) - Decrement the value at the current position
* `θ` (U+03B8) - Input a value
* `ι` (U+03B9) - Output the value at the current position
* `κ` (U+03BA) - Begin a loop (continues until the value at the current position is zero)
* `λ` (U+03BB) - End a loop
== Example Programs ==
=== Hello World ===
 
δ ζ ζ ζ ζ ζ ζ ζ ζ ζ ζ κ ε ε ε ε ε ε ε ε ε ε ε ι δ ζ ζ ζ ζ ζ δ ι δ ζ ζ ζ ζ ζ ζ ζ ζ ζ ζ ζ ι δ ζ ζ δ ι ζ δ ι δ ι ε ε ε ι δ ζ ζ ι δ ι δ ζ ζ ζ ζ ζ ι
 
=== Addition with Input ===
 
θ δ ζ δ θ ζ ζ δ ι
 
=== Looping ===
 
δ ζ κ θ ι λ
 
CipherScribe adds a cryptographic twist to programming, making every line a puzzle to decode. CodePhantom (talk)
Circles

Circles is an esolang by User:PythonshellDebugwindow. It works by moving from circle to circle and performing operations on them.
==Documentation==
The documentation is available on GitHub.
==Implementation==
An implementation written in Python by User:Photon_Niko is also available on GitHub.
Category:Languages Category:Non-textual Category:Low-level Category:2020 Category:Unknown computational class Category:Implemented Category:Usability unknown Category:Two-dimensional languages
Circuitrite

Circuitrite is a Bully/Cellular automaton and esolang developed by Moon in his freetime. It is a cellular automa style esoteric language, based on a table of symbols in a 2d grid. It uses a active movement structure to allow complex designs, it also may be turing complete.
==Symbols==
Symbol	Meaning
> 	Enforces the direction of a signal or particle to where it its pointing. Twin: <
< 	Enforces the direction of a signal or particle to where it its pointing. Twin: >
_ 	Horizontal wire, transports #s
 	Diagonal wire, transports #s
[ 	Junction wire, transports #s, mixes the signals from separate directions
( 	Junction wire, transports #s, does NOT mix the signals from seperate directions
1-9 	Signals, the different numbers represent the id of the signal, signal ids wrap.
+ 	Increases the signal id or state of dust
- 	Decreases the signal id or state of dust
S 	‘Captures’ a signal and doesn’t let signals pass unless they have the same id
s 	Spawner, spawns in dust in state 1
o 	State one dust, active element (it falls) Twin: O
O 	State two dust, active element (it falls) Twin: o
p 	is the arm), 1’s expand, 2’s retract
e 	Eater, destroys active objects
# 	Wall
^ 	Enforces the direction of a signal or particle to where it its pointing. Twin: v
b 	Battery, constantly outputs a signal
v 	Enforces the direction of a signal or particle to where it its pointing. Twin: ^
N 	Nand gate, nands identical signals
==Sample programs==
1
[N[ #S#
[[ # #
 | [_[ # #
 [___[ [_+[# #+#
 | PP #
 [________[# # #
 #e#e#
==External resources==
* Google Doc
Category:Languages Category:Unimplemented Category:Cellular automata
Circute

Circute is a cellular automaton (and quite arguably an esoteric programming language) developed by Chris Pressey in 2005 as a test of the wire-crossing problem. It consists of nothing but logical NAND gates connected by wires. It was designed to be implementable in ALPACA.
== Syntax ==
*= - wire. Sparks pass through.
*- - tail, used to make sparks act more like snakes.
*# - spark. These spread across wires.
*N - NAND gate. If there's a free wire directly along the left or the right, send a message along any wire directly above or below.
== Examples ==
Note: those marked with a * must be replaced with either a wire (=) or a spark(#). These just indicate where everything goes.
===AND gate===
 *== ==*
 = =
 ===N===
 =
 =
 =====
 = =
 =#N#=
 =
===OR gate===
 *== ==*
 = =
 ===== =====
 = = = =
 ==N== ==N==
 = =
 ==#N#==
 =
 =
===One-fire switch(OSC->OFF)===
 ===#N=========
 = = =
 ==N== ===== =
 = = = = =
 ===== ==N== =
 = = =
 * ===== 
===Tiny oscillator===
Note: The tails mark the direction.
 #N=
 ==---------
===Fast oscillator===
 =N#
 #N=
 =-----
Has a period of three steps.
===NOT gate===
 *
 =
 =====
 = =
 ==N==
 =
 =
===Tiny NOT gate===
 *
 =
 =N#
 =
 =
==External resources==
* 
Category:Languages
Category:2005
Category:Unknown computational class
Category:Low-level
Category:Two-dimensional languages
Category:Implemented
Category:Cellular automata
Cixl

Cixl is a minimal, decently typed scripting language for embedding in and extending from C. Cixl shares many ideas with C, Forth, Common Lisp, Perl and Lua; as well as the hacker mindset that unites them. The language is implemented as a straight forward 3-stage (parse/compile/eval) interpreter that is designed to be as fast as possible without compromising on simplicity, transparency and flexibility; combined with a C code generator for compiling native executables.
==See Also==
*Snigl, a project based on Cixl
Category:Languages
Category:Stack-based
Category:2017
Category:Implemented
Category:Turing complete
Class Diseases

Class Diseases are an esoteric programming concept intended to make programming in OO even more of a pain in the ass then it already is.
== Concept ==
Class Diseases are generally malicious, unavoidable mandatory mixins that certain classes are infected with at declaration. When other classes interact with these classes, or in some cases with things which these classes have interacted with (e.g. variables), the disease is transmitted to the new class. Class diseases affect the class that they have infected in unfavorable and annoying ways (unless hijacked to do otherwise) and are generally not fun.
== Class Disease Behavior ==
=== Infection ===
Class diseases can infect either classes or instances. Classes that are infected pass the disease on to all instances of them.
Some instance diseases are limited to objects with a specific trait: A certain member, implementing a certain interface, or even just being a member of a certain class.
=== Contamination ===
A class or instance contracts a class disease either by being randomly given it at declaration during execution time, by being declared with it, or by coming in contact with a contaminated object. Infection can be passed in the following ways:
* For hereditary diseases, any subclass of an infected class has a good chance of catching it
* Classes or instances in the same data structure can pass diseases between each other.
** Ordered data structures increase the chance as distance between an infected body and an uninfected body decreases
* When instances are operated on, the output of that operation is likely to catch the disease (e.g. an infected instance complex(1, 5) when added to 3, will produce a similarly infected complex(4, 5).
* Airborne diseases can leave contamination on scalar variables, e.g. if x is added to a contaminated instance of something y, then x can start to carry it and infect other interacting instance variables.
== Examples of Diseases ==
None yet! (Feel free to add some)
Category:Concepts Category:2013
Classical CT

==Commands==
This is an extension of CT.
 {class_name[function_name ...] [function_name ...] lots of other functions...}
It defines a class with a lot of functions, which reads the CT instructions.
To run it, do this:
 class_name{function_name[]}
==String extensions==
for numbers containing only 2~9, they are treated as strings.
*=
This is the assign statement.
It changes the string to another string.
Category:Object-oriented paradigm
Category:Functional paradigm
Category:Declarative paradigm
Category:String-rewriting paradigm
Category: Languages
Clementine

: This language is a work in progress. There may be changes in the future.
Clementine (CLM) is a four command simple translation of Underload (excluding output) discovered by User:Orby during May 2020.
==Commands==
CLM is similar to Underload, but uses a different basis. CLM is composed of 4 commands: [, ], e and k. 
The symbols e, k and the empty string are concatenative combinators. If a and b are concatenative combinators then [a] and ab are concatenative combinators.
===CLM as a term rewriting language===
CLM uses two rewrite rules. They are applied from left to right.
Pattern 	Rewrite
[b] [a] e	[[b]a] [a[b]] [ba]
[b] [a] k	a
where a and b are concatenative combinators.
===CLM as a stack based language===
Command	Action
[ 	Begin a quote. To enclose a combinator in quotes means to push it onto the stack.
] 	End a quote. To enclose a combinator in quotes means to push it onto the stack.
e 	Pop a. Pop b. Push [b]a. Push a[b]. Push ba.
k 	Pop a. Pop b. Execute a.
===Simple translation to Underload===
Note that this is proof of Turing-completeness.
Underload	CLM
! 	[]k
a 	[]e!!
~ 	ae!k
^ 	[]~k
* 	e~!~!
: 	[]e!*^
( 	[
) 	]
CLM	Underload
e 	a~a*:(a~*)*~:(a*)*~(~*)***^
k 	~!^
[ 	(
] 	)
==Restricted CLM==
A restricted version of CLM that is quote free consists of the combinators [], [e], [k] and k. It is Turing-complete by the following reduction to Underload.
Underload	CLM
! 	[]k
a 	[][][e]k!!
~ 	a[][e]k!k
^ 	[]~k
* 	[][e]k~!~!
: 	[][][e]k!*^
(!) 	[]a[k]*
(a) 	[]a[e]*(!)*(!)*
(~) 	(a)[e]*(!)*[k]*
(^) 	[]a(~)*[k]*
(*) 	[e](~)*(!)*(~)*(!)*
(:) 	[]a[e]*(!)*(*)*(^)*
==Open questions==
* Is there a single concatenative combinator f with a single rewrite rule such that f combined with quoting is Turing-complete? What about "restricted f" with (), (f) and f?
* Does a three command simple translation of CLM exist?
* Does a two command simple translation of CLM exist?
==See also==
* Underload was the first esoteric programming language of this sort.
* The Theory of Concatenative Combinators was a major inspiration for this language.
Category:LanguagesCategory:Functional paradigmCategory:Low-levelCategory:2020Category:Turing completeCategory:No IO
Cliff L. Biffle

Cliff L. Biffle is the creator of the languages 4DL, Beatnik and HQ9+.
From 1998 to 2003 he attended Arizona State University, where he earned his Bachelor of Science in Psychology.
2011, he worked at Google. Since 2017, he is working at X, an organisation, founded by Google.
==External resources==
* His website
* His LinkedIn
* Cliffle's Esoterica
Category:People
Clip/Examples

Examples for the Clip programming language.
==Hello world==
 "Hello world
Self-explanatory, but note that the closing quotation mark is not needed.
==Cat==
 ‌
When compiled, this is expanded to:
 [M ]
Thus, the main supplier hits the end of the program, so it asks the user for the next line of input.
==Quine==
 -12.3
A less trivial quine:
 F"[Fx{'F\xx`"[Fx{'F\xx`
Or just:
 [t+t\t]"[t+t\t]"
==Factorial==
 r*`,On
 r .- reduce -.
 *` .- with multiplication -.
 , .- the list of numbers from -.
 O .- 1 to -.
 n .- the number represented by -.
 
 [implicit] the next line of input.
==Fibonacci (inefficient)==
 Fn[Fx?<x3O]+F(xF((x
 F .- apply the function F to -.
 n .- the number represented by -.
 
 [implicit] the next line of input
 
 [Fx .- define F as a function of x -.
 ? .- if -.
 <x3 .- x is less than 3 -.
 O .- then 1 -.
 ] .- else -.
 + .- the sum of -.
 F .- the function F applied to -.
 (x .- one less than x -.
 F .- the function F applied to -.
 ( .- one less than -.
 (x .- one less than x -.
==Fibonacci (efficient)==
 FZOn[Fx[y[z?zFy+xy(z]x]}}
 F .- apply the function F to -.
 Z .- 0 -.
 O .- 1 -.
 n .- the number represented by -.
 
 [implicit] the next line of input
 
 [Fx .- define F as a function of x -.
 [y .- a function of y -.
 [z .- a function of z -.
 ? .- if -.
 z .- z isn't zero -.
 F .- then apply F to -.
 y .- y -.
 +xy .- the sum of x and y -.
 (z .- one less than z -.
 ] .- else -.
 x .- x -.
 ] .- end if statement -.
 } .- return function of z -.
 } .- return function of y -.
Category:Examples
Clml

CLML (Crazy Layerd Master Language, .clml) is the main language for a :CLUVM. It was created by MasterWoodie in 2023
== Overview ==
The language is made up of mainly single-character commands, but also contains a few control structures.
The language was created for CLUVM, a Virtual Machine that uses CLM to store data.
== Features ==
Clml commands are centered around modifying data of elements, as thats all there is to do.
In order to achieve this, data can be moved around between the current element, the active element of the storage layer ("accumulator"), the active element of the pointer layer ("active pointer"), and the cell pointed to by the active pointer ("target element").
Command	Description
> 	move to next element of the current layer
< 	move to the previous element of the current layer
v 	if current element is a layer, enter that layer
^ 	if there is an above layer, exit current layer
# 	set current path to the value of the accumulator
+ 	increment current cell
- 	decrement current cell
~ 	add the value of the accumulator layer to the current cell
i 	insert new cell after current element
I 	insert new layer after current element
p 	store the current path in the accumulator
P 	store the value of the active pointer in the accumulator
s 	store the value of the current element in the accumulator
S 	store the value of the target element in the accumulator
== Examples ==
Category:Languages Category:2023 Category:Unknown computational class
Clockwise

Clockwise is a two-dimensional esolang by User:PythonshellDebugwindow where the only turns are 90° clockwise.
==Syntax==
Clockwise code is two-dimensional. It uses an instruction pointer (IP), which can point north, east, south, or west, to keep track of the current position in the code; it starts out in the northwesternmost corner facing east. If the IP ever returns to the northwesternmost character, the program halts. Each character is one command.
==Memory==
Clockwise uses an unbounded signed accumulator, initialized to zero.
==I/O format==
Input is pushed bit-by-bit to an input queue at the start of the program. The MSB is pushed first. Output must be pushed bit-by-bit to an output queue. Once 7 bits have been pushed, they are output as an ASCII character, whose MSB is the first bit pushed, and the queue is emptied.
==Commands==
Command	Effect
R 	Rotate the IP 90° clockwise
? 	If the accumulator is not 0, rotate the IP 90° clockwise, else do nothing
! 	If the accumulator is 0, rotate the IP 90° clockwise, else do nothing
+ 	Increment the accumulator
- 	Decrement the accumulator
. 	Dequeue a bit from the input queue, set the LSB of the accumulator to the bit, and enqueue the bit back to the input queue
; 	Push the LSB of the accumulator to the output queue
S 	Set the accumulator to zero
(space)	Nop
==Examples==
===Hello World===
+;-;;+;-;;;+;;-;;+;-;+;;;-;+;;-;;R
 +
 ;
 ;
 -
 ;
 +
 ;
 ;
 -
; ;
; ;
- +
; ;
+ ;
; -
; ;
- +
; ;
; ;
+ ;
; ;
; -
- ;
; +
; ;
+ -
; ;
- ;
; ;
; ;
+ ;
R ;-;+;;-;;;;;;;+;-;;;;;+;-;+;-;+R
===Truth-machine===
+-?.;.;.;.;.;.;.;?R
 R R
R R
===Cat program===
+-?++.;R
 R R
== Implementations ==
A Python interpreter by User:Bangyen.
Category:Languages Category:2020 Category:Implemented Category:Two-dimensional languages Category:Unknown computational class
Clue (Keymaker)

:You may be looking for the other language named Clue (by oklopol).
Clue is a simple, cyclic esoteric programming language, created in 2009 by User:Keymaker. The computational class of the language is unknown but the author thinks it is not Turing-complete. A Clue program is a string consisting only of 0s and 1s. There is no separate memory; the program string modifies itself every time an instruction is executed. There is a program pointer that initially starts in the beginning of the string, moving forward after every instruction, returning to the beginning when reaching the end of the string. One executed instruction is one cycle in Clue terminology. The program halts if it becomes the empty string.
* 0 removes the last character of the string.
* 1 takes the next two characters, NANDs them (resulting 0 if both inputs 1, otherwise 1), and adds the result in the beginning of the string. The program pointer then moves to just beyond the second input that was read for NAND.
For example, the program 110 (nothing to do with the famous cellular automata rule 110) would work the following way (x marks where the program pointer is currently):
 1x 1 0 (1 and 0 is NANDed, the resulting 1 is placed in the beginning)
 1x 1 1 0 (1 NAND 1, 0 added in the beginning)
 0 1 1 1 0x (the last character is removed, thus the 0 removes itself)
 0x 1 1 1 (the last character, 1, is removed)
 0 1x 1 (1 NAND 0, 1 is added in the beginning -- and so forth...)
The visualization of the state of the program string for the first 5000 cycles is seen on right. The white cells mark 0s, the black cells mark 1s.
==Finite formations==
Finite formations, in Clue, are programs that end. Using a program to comb through some 20000 first programs (0, 1, 00, 01, 10, 11, 000, 001, ...), each allowed to run for 100000 cycles, reveals a relatively small amount of such programs. Most such programs are simple, not reaching 30 cycles. Occasionally, however, there are programs that start growing, yet at a certain point the growth reversals, then reversals again but the growth is feebler, until it stagnates again. Here are some of the longer ones (the program / on which cycle it ends):
* 101111101 / 557
* 0100010111 / 572
* 1011111010 / 558
* 1101000100 / 568
* 01000100000 / 573
* 10111110100 / 559
* 11011011010 / 609
* 010001001000 / 574
* 101101111101 / 554
* 101111101000 / 560
* 101111101001 / 560
* 110100001000 / 570
* 1101101101001 / 613
Some formations grow only once and stagnate fast towards their end:
* 0100011011111 / 289
* 0110110010100 / 283
* 1111010111001 / 137
* 0110100101101 / 69
Then there are the simplest formations that never grow any:
* 000000010000 / 12
Needless to say, there may well be finite formations among the first programs that only reveal themselves after they are run more than 100000 cycles.
==External resources==
* Clue page (the specs, very simple programs, visualizations, an interpreter, a graphical viewer)
Category: Unknown computational class
Category: Self-modifying
Category: Low-level 
Category: Languages
Category: No IO
Category: Implemented 
Category: 2009