LOLCODE

LOLCODE is an esoteric programming language created under the influence of a meme lolcat.

The language was created in 2007 by Adam Lindsay. The original description of the language was rather vague, so the existing implementations (quite numerous, by the way) differ a lot. Several implementations of the language, like LOLCode.NET and loljs, are proven to be Turing-complete by creating a Brainfuck interpreter in it.

The language is based on elements of Internet slang, so anybody who knows it can figure out what the programs do even without deep knowledge of the language.

Language constructs:

• The program is enclosed in keywords HAI and KTHXBYE. HAI can be followed by the version of language specification implemented, but it’s unclear how the interpreter should process it.

• Comments are provided as BTW (a comment till the end of line) and OBTW ... TLDR (a multi-line comment).

• I HAS A <varname> declares a variable. LOLCODE is dynamically typed, so there’s no need to declare the variable type explicitly.

• <varname> R <value> assigns a value to a variable. LOLCODE supports the following data types: NOOB (untyped — this value is help by a variable before it is initialized), NUMBR (integer), NUMBAR (floating-point), YARN (string) и TROOF (boolean). BUKKIT type is reserved for arrays. Types can be cast implicitly.

• functions and operators use prefix notation. If the number of function arguments can vary, their list must be delimited with MKAY keyword. Idividual arguments can be separated with an optional AN keyword.

• math operators (work with NUMBR and NUMBAR data types, if needed, can convert from YARN):

  SUM OF — addition
  DIFF OF — subtraction
  PRODUKT OF — multiplication
  QUOSHUNT OF — division
  MOD OF — division remainder
  BIGGR OF — maximum
  SMALLR OF — minimum
  

• boolean operators (work with TROOF data type which can have values WIN and FAIL):

  BOTH OF — logical "and"
  EITHER OF — logical "or"
  WON OF — xor
  NOT — logical "not"
  ALL OF ... MKAY — logical "and" for arbitrary number of arguments
  ANY OF ... MKAY — logical "or" for arbitrary number of arguments
  

• comparison operators: BOTH SAEM for equality and DIFFRINT for inaquality. The current version of language specification provides no support for other types of comparison, so they have to be constructed using BIGGR OF and SMALLR OF.

• SMOOSH … MKAY is string concatenation.

• MAEK <expression> [A] <type> converts the value of the given expression to the given data type. To change type of a variable, use <variable> IS NOW A <type>.

• VISIBLE prints an arbitrary number of arguments, which are converted to YARN data type and concatenated. By default each output ends with a newline; to avoid this, one has to add ! to the end of the list of arguments.

• GIMMEH reads a string from input stream.

• implicit variable IT is used to store the value of the last expression mentioned and to process it in flow control statements.

• basic if-then-else construct looks as follows:

  <expression>
  O RLY?
    YA RLY
      <code block>
    NO WAI
      <code block>
  OIC
  

• case construct looks like this:

  <expression>
  WTF?
    OMG <value literal>
      <code block>
   [OMG <value literal>
      <code block> …]
   [OMGWTF
      <code block>]
  OIC
  

  Comparisons use the IT variable and a constant. OMG block can contain any number of commands and might end with GTFO. If there is no GTFO command, the next comparison is done, and so on.

• infinite loop:

  IM IN YR <label>
    <code block>
  IM OUTTA YR <label>
  

• while loop:

  IM IN YR <label> <operation> YR <variable> [TIL|WILE <expression>]
    <code block>
  IM OUTTA YR <label>
  

  The loop uses a temporary local variable and any unary operation that changes it, including UPPIN and NERFIN (increment and decrement). The expression is used as a condition of end of loop: TIL stops as soon as it becomes true (WIN), WILE — false (FAIL).

• function declaration:

  HOW DUZ I <function name> [YR <argument1> [AN YR <argument2> …]]
    <code block>
  IF U SAY SO
  

  There are three ways to return from a function. FOUND YR <expression> returns the value of this expression. GTFO returns NOOB. If the execution flow reached the end of the function without returning, the return value is the value of IT variable.

• GTFO is an equivalent of break in other languages; it is used to break out from loops, case statement and functions.