Table of contents
=================

- BASIC
- Pascal
- Fortran
- Go
- Python
- C++
- BCPL
- Common Lisp
- J
- Scheme
- Manufactoria
- Piet
- Forth
- INTERCAL
- LLVM IR
- 1+
- Erlang
- Prolog
- Befunge
- Thue
- Whenever


BASIC
=====

SUB <name> ... END SUB

... = ...
... <> ...

IF <cond> THEN ... ELSEIF <cond> THEN ... ELSE ... END IF

DO ... LOOP
DO WHILE <cond> ... LOOP
DO UNTIL <cond> ... LOOP
DO ... LOOP WHILE <cond>
DO ... LOOP UNTIL <cond>

EXIT DO

END
EXIT SUB

GOTO


Pascal
======

begin ... end

procedure <name> ...

nil

true
... = ...
... <> ...

if ... then ... else ...

while <cond> ... do ...
repeat ... until <cond>

break
continue

exit

label <label>
goto <label>


Fortran
=======

SUBROUTINE <name> ... END SUBROUTINE

CALL ...

... == ...
... /= ...

IF <cond> ...
IF <cond> THEN ... ELSE IF <cond> THEN ... ELSE ... END IF

DO ... END DO
DO WHILE <cond> ... END DO
<label> DO ... END DO <label>
<label> DO WHILE <cond> ... END DO <label>

EXIT
CYCLE
EXIT <label>
CYCLE <label>

STOP
RETURN

GO TO <label>


Go
==

func <name> ...

nil

... = ...
new ...
& ...

... == ...
... != ...

_

if <cond> ... else if <cond> ... else ...

for ...
for <cond> ...

break
continue
break <label>
continue <label>

return

goto <label>


Python
======

def <name> ...

None

True
not <cond>

if <cond> ... elif <cond> ... else ...

while <cond> ...
while <cond> pass

break
continue

return

(label .<label>)
(goto .<label>)


C++
===

void <name> ...

nullptr

... = ...
new ...

true
... == ...
... != ...
! <cond>

if <cond> ... else ...

while <cond> ...
do ... while <cond>

break
continue

return

goto <label>


BCPL
====

LET <name> BE ...

@ ...

... = ...
... ~= ...
~ <cond>

IF <cond> DO ...
UNLESS <cond> DO ...
TEST <cond> THEN ... ELSE ...

... REPEAT
WHILE <cond> DO ...
UNTIL <cond> DO ...
... REPEATWHILE <cond>
... REPEATUNTIL <cond>

BREAK
LOOP

FINISH
RETURN

GOTO


Common Lisp
===========

progn ...

defun <name> ...

nil

t
equal ... ...
not <cond>

when <cond> ...
unless <cond> ...
if <cond> ... ...
cond <cond> ... <cond> ...

iter ...
iter <label> ...
while <cond>
until <cond>

finish
next-iteration
return-from <label>

return-from <name>

tagbody ... <label> ...
go <label>


J
=

NB. ...

<name> =: verb define ...

... ^: <n>

-. <cond>

if. <cond> do. ... else. ... end.
if. <cond> do. ... elseif. <cond> do. ... end.
if. <cond> do. ... elseif. <cond> do. ... elseif. do. ... end.

while. do. ... end.
while. ... <cond> do. ... end.
whilst. <cond> do. ... end.

break.
continue.

return.

label_<label>.
goto_<label>.


Scheme
======

define <name> ...
let <name> () ...

not <cond>

when <cond> ...
unless <cond> ...
if <cond> ... ...
cond <cond> ... <cond> ... else ...


Manufactoria
============

R
B
Y
G

Pusher

Puller

Exit

Conveyor


Piet
====

push

... duplicate
... pop
... ... roll

... ... add
... ... subtract
... ... multiply

... not

... pointer


Forth
=====

\ ...

: <name> ... ;

... dup
... drop

... ... =
... ... <>
<cond> 0=

<cond> IF ... ELSE ... THEN

BEGIN ... AGAIN
BEGIN ... <cond> UNTIL
BEGIN ... <cond> WHILE ... REPEAT

EXIT

AHEAD ... THEN

[ <n> CS-ROLL ]

REPEAT <==> AGAIN THEN
WHILE <==> IF [ 1 CS-ROLL ]
ELSE <==> AHEAD [ 1 CS-ROLL ] THEN


INTERCAL
========

DO NOT ...
PLEASE NOT ...

DO ...
PLEASE ...

<label> NEXT ... <label> NEXT ... RESUME <var>

COME FROM <label>

GIVE UP
RESUME #<n>

<label> NEXT ... FORGET


LLVM IR
=======

i32*

define void <name> ...

call void ...

br label <label>

<cond> = call i1 ...
br i1 <cond>, label <label>, label <label>

ret void


1+
==

1

... "

... ... +
... ... *

... ... <

... #


Erlang
======

<name> -> ...
<name> = fun() ... end

true
false
_

case <cond> of <value> -> ... ; <value> -> ... end


Prolog
======

<name> :- ...

!

true

<cond> -> ... ; ...

repeat ... fail


Befunge
=======

... !

... _
... |

@

> v < ^
#


Thue
====

<name> ::= ...

:::

~ ...


Whenever
========

defer <cond>
again <cond>

... - ...

N <line>

read

! <cond>
<cond> && <cond>
<cond> || <cond>

print ...


( c )   2 0 2 1 - 2 0 2 6   A d i   K a r o l