From Esolang
Jump to navigation Jump to search

SyL is an esoteric language by Abraham Karplus designed to use no punctuation and pronounceable names. The syllables from which the language gets its name are all of the form CV. The extension .syl is used for SyL program files. Program file names are required to use the syntax for variable names.


The SyL consonants are

p b f v m t d s z n
k g y w l r h

The top row are normal consonants for use in variable names, while the bottom row consonants have special uses (syntax, numbers, built-in commands).


The SyL vowels are

a e i o u


All letters are pronounced with their IPA values, except that ‹y› should be pronounced /j/, to match normal English pronunciation. (Additionally, ‹l› and ‹r› can be pronounced as any lateral approximant and any rhotic, respectively.) If needed for clarity, newlines can be pronounced with any click.


The wihu keyword begins a comment and wihe ends it.

Variable names

Variable names are 1 or more syllables, each consisting of a normal consonant followed by a vowel.


Numbers are written in base 10 with these digits:

0       la
1       le
2       li
3       lo
4       lu
5       ra
6       re
7       ri
8       ro
9       ru

The decimal point is written hi. Nonnegative numbers must be followed ha and negative numbers by hu.

The decimal point cannot go at the beginning or end of a number—put a zero next to it.

For example, -13 is lelohu and 71.06 is rilehilareha. Booleans are not specially represented—they are just numbers, with 0 false and everything else true.

Variable creation / assignment

Variables are created and assigned to by the ke statement. It functions like so:

ke pabi wu luroha          wihu Variable pabi with value luroha (48) wihe
ke no wu laha              wihu Variable no with value laha (0)      wihe

Enhanced assignment is supported by putting the operator name between ke and the variable name.


The arithmetic operators are prefix. Operators separate their operands with wu.

Plus       gahaha
Minus      gahahe
Times      gahiha
Divide     gahihe
Exponent   gahoha
Root       gahohi
Logarithm  gahohu
Modulo     gaheha
Truncate   gahuho
Floor      gahuhe
Ceiling    gahuhi

Division does not truncate. Root(x, y) is equivalent to Exponent(y, 1/x). Logarithm takes the base before the main argument.

For example, pabi plus raha (5) is written gahaha pabi wu raha.


The comparison operators are also prefix, and function on lists and the special value yuhi as well.

Equal         goho
Less Than     gohi
Greater Than  gohu

For objects of different types, only goho is defined, and it is always false. On lists and maps, the comparisons function element-by-element.


The keyword we begins a block, which is a set of statements. The keyword wo ends it. It is standard practice to put each of these keywords on their own line, and to indent four spaces within a block. For a single-statement block, the keywords are still required, but it is customary to put them on the same line as the statement. These block keywords are also used in function definition and calling, with a different meaning in the latter.


The conditional keyword is ki, used like this:

ki zabo                    wihu If zabo                        wihe
we                         wihu Begin block                        wihe
    ke gahe pune wu leha   wihu Decrement pune by leha (1) wihe
    ke mana rohu           wihu Set mana to rohu (-8)      wihe
wo                         wihu End block                          wihe


The while keyword is ku, used in the same manner as the conditional.


Lists are created by assigning the keyword yuhe, representing the empty list, to a variable using the standard ke syntax.

Lists may contain objects of any type.

Iterations over a list is supported by the keyword ko, used similar to while as follows:

ko tazo wu di              wihu For di in tazo            wihe
we ke gaha pune wu di wo   wihu Increment pune by di      wihe
                           wihu The block keywords were placed on the
                                same line as the single statement wihe

Membership in a list may be tested by the geho operator which takes a list and an item and returns a boolean. An item may be added to a list by the geha operator which takes a list and an item and returns a new list with the item appended. The gehu operator takes a list, an index, and a value and returns a new list with the item at the given index replaced by the given value. Recreate a list to clear it. The gehi operator takes a list and an index and returns the item of the list at that index. The gehe operator takes a list and returns its length.

Two of the arithmetic operations work on lists: Plus and Times. Plus concatenates two lists. Times repeats a list a number of times given in the second argument.

Strings and I/O

Strings are represented as lists of characters, which are just integers.

To output a list as a string, use the giho command followed by the name of a list. To input a line, use gihe, which returns a list of the line read. To input a character, use gihi, which returns an integer representing the character read. EOF has the value lehu (-1).


A map is a variable type, similar to a list, which maps keys to values. Keys and values may be of any type. The keyword for an empty map is yuhu. Maps are also created by imports.

Most of the list functions work on maps, specifically geho, which checks if the map contains a key, gehu and gehi, which allow a generic key instead of only an index, and gehe.


The keyword wa imports a program file named following the keyword.

To import from the standard library (when there is one), add hi between wa and the filename. To import from a lower-level folder, use he as a folder separator. Folder names must be valid variable names. To import from a higher-level folder, ho can be used to go up one level from the current folder.

The file name should not have the .syl extension, that will be added by the program.

The result of the import is a new map variable, named as the file (though without the extension, of course), that has the defined variables and functions of the file as entries, with their names as string keys.


A function definition uses the syntax

ya {arguments} we
wo {return} ya

which can be written on one line as

ya {arguments} we {body} wo {return} ya

where {arguments} is a set of variable names separated by wu, {body} a set of commands, and {return} the expression that the function returns.

The syntax is used by assigning the function to a variable, which then holds the function. Functions are first-class and can be passed around, etc.

If {arguments} is omitted, the function takes no arguments. If {return} is omitted, the function returns the special value yuhi. Note that {body} may contain zero statements.

To call a function, use the syntax

yo {name} we {arguments} wo

where {name} is an expression that evaluates to a function, and {arguments} is a set of expressions separated by wu to pass to the function.

Note that arguments are only accessible from within their function, and are passed by value, so changing them inside a function does not affect the outside values.


Please comment on the talk page if you notice any bugs in these examples.

Hello World

Prints 'Hello World' (using no punctuation to better fit the spirit of the language).

ke ta wu yuhe             wihu Create a list ta                      wihe
wihu Append to the list numbers for characters wihe
ke geha ta wu riliha      wihu H        wihe
ke geha ta wu lelaleha    wihu e        wihe
ke geha ta wu lelaroha    wihu l        wihe
ke geha ta wu lelaroha    wihu l        wihe
ke geha ta wu leleleha    wihu o        wihe
ke geha ta wu loliha      wihu space    wihe
ke geha ta wu roriha      wihu W        wihe
ke geha ta wu leleleha    wihu o        wihe
ke geha ta wu leleluha    wihu r        wihe
ke geha ta wu lelaroha    wihu l        wihe
ke geha ta wu lelalaha    wihu d        wihe

giho ta     wihu Output the list as a string               wihe


Copies input to output a line at a time

ke notadone wu leha          wihu Create a variable notadone
                                 (not done) with value 1      wihe

ku notadone                 wihu While notadone           wihe
we                          wihu Begin block                  wihe
    ke ta gihe      wihu Read a line to ta        wihe
    giho ta        wihu Output ta                wihe
    ki geho ta wu luha        wihu If EOF in ta             wihe
    we ke notadone wu laha wo  wihu Set notadone to 0 (done) wihe
wo                          wihu End block                    wihe

Successor Function

Function that returns one more than its argument

ke suseso wu ya nu we wo gaha nu wu leha ya
wihu Create a function suseso
     that takes one argument, nu
     doesn't do anything
     then returns nu plus 1           wihe

ke ta wu yo suseso we reliha wo
wihu Calls suseso on reliha (62)
     and stores the result (63) in ta wihe


  • Add more examples
  • Classes
  • OS interfaces

If you have more ideas, please post on the talk page.