SyL

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.
== Consonants == 
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).
== Vowels ==
The SyL vowels are
 a e i o u
== Pronunciation ==
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.
== Comments ==
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 ==
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.
== Arithmetic ==
The arithmetic operators are prefix. Operators separate their operands with wu.
 Binary
 Plus gahaha
 Minus gahahe
 Times gahiha
 Divide gahihe
 Exponent gahoha
 Root gahohi
 Logarithm gahohu
 Modulo gaheha
 Unary
 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.
== Comparisons ==
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.
== Blocks ==
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.
== Conditional ==
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
== While ==
The while keyword is ku, used in the same manner as the conditional.
== Lists ==
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).
== Maps ==
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. 
== Imports ==
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.
== Functions ==
A function definition uses the syntax
 ya {arguments} we
 {body}
 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.
== Examples ==
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
=== Cat ===
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
== To-Do ==
* Add more examples
* Classes
* OS interfaces
If you have more ideas, please post on the talk page.
Category:Languages
Category:2011
Category:Turing complete
Category:Unimplemented
Category:High-level