Lingua Indeterminatum

Lingua Indeterminatum is the successor of Septem Lingua, which is also designed by the developing team of Septem Lingua.

So far, the language is called Lingua Indeterminatum, but we’re open to other names. On July 1st, there will be a draw, and whoever's name gets chosen will have this page redirected to their page. The name I suggested is 'Lingua Filium'.

Development Team

Leader: User:PrySigneToFry(PSTF)

Co-leader: User:I am islptng

Developers: User:Yoyolin0409, User:Qazwsxplm, User:cleverxia

1st-batch members: User:Hammy, User:None1, User:Yayimhere

2nd-batch members: User:MihaiEso, User:Areallycoolusername, User:Xyzzy

Rules

1. You MUST implement it when adding a new feature, using Python. This also means that cannot add non-computable commands to this language.
2. Adding joke commands is prohibited. Lingua Indeterminatum is a serious language.
3. All commands will be treated as functions unless otherwise specified.
4. Adding built-in data storage is prohibited. We stipulate that all data in this language must be stored in variables. However, commands are allowed to access registers or memory to implement more complex programs, and it is permissible to add data types or simulate stacks, queues, deques, binary trees, hash tables, etc., through functions.
5. No memes are allowed to add in the command, nor appear in the description. The purpose of creating this language was not to become worse or more chaotic.
6. Allow a command to execute other programming languages, but only those that have been implemented, such as Python. Self-evaluation or self-interpretation is allowed, but not interpreting unimplemented languages.
7. Allow manipulation of system files, but do not allow a single command to damage the system directly. For example, this command violates this rule: death - Delete all files on the device that is running this command.

Core features

To be discussed. We(islptng & PSTF)'ll discuss on the talk page to first think about a draft, and others MUSTN'T edit after we've written the interpreter framework.

EBNF Definition

(* ----------------------------------------- *)
(* Lexical tokens (simplified)                *)
(* ----------------------------------------- *)

letter   = "A" | "B" | ... | "Z" | "a" | ... | "z" | "_" ;
digit    = "0" | "1" | ... | "9" ;
hex      = digit | "A" | "B" | "C" | "D" | "E" | "F" | "a" | "b" | "c" | "d" | "e" | "f" ;
alphanum = letter | digit ;
unicode  = (All Unicode Characters without undefined ones) ;

identifier = letter, alphanum ;

integer = digit, { digit } ;
float   = digit, { digit }, ".", digit, { digit }, [ ("e" | "E"), [ "+" | "-" ], integer ] ;
real    = integer | float ;
rune    = "@", character ;        (* @ followed by a single character, with escapes *)
string  = '"', { character | escape | ("{", expression, "}") }, '"' ;
escape  = "\", ( "n" | "t" | "r" | "\" | "'" | '"' | "0" | "x", hex, hex, hex, hex | digit, digit, digit, digit, digit ) ;

imagine = float, "i" | integer, "i" ;   (* imaginary unit, e.g., 3i, 2.5i *)
complex = real, "+", imagine ;          (* full complex literals are formed by addition: 3+4i *)

bool    = "true" | "false" ;

(* ----------------------------------------- *)
(* Comments                                   *)
(* ----------------------------------------- *)

comment = "[[!?", { unicode except "?]]" }, "?]]" ;

(* ----------------------------------------- *)
(* Types (as values)                         *)
(* ----------------------------------------- *)

type = "Int" | "Float" | "Doc" | "Rune" | "Bool" | "List" | "Pair" | "Complex"
     | identifier ;                        (* user-defined class names *)

(* ----------------------------------------- *)
(* Literals                                  *)
(* ----------------------------------------- *)

literal = integer | float | string | rune | bool | complex
        | "[", [ expression, { ",", expression } ], "]"
        | "(", expression, ",", expression, ")"
        | type ;                            (* type literals are also values *)

(* ----------------------------------------- *)
(* Expressions                               *)
(* ----------------------------------------- *)

expression = logical_or ;

logical_or  = logical_xor, { "or", logical_xor } ;
logical_xor = logical_and, { "xor", logical_and } ;
logical_and = comparison, { "and", comparison } ;

comparison = bitwise_or, { ("=" | "!=" | "<" | "<=" | ">" | ">="), bitwise_or } ;

bitwise_or  = bitwise_xor, { "|", bitwise_xor } ;
bitwise_xor = bitwise_and, { "`", bitwise_and } ;   (* backtick *)
bitwise_and = shift, { "&", shift } ;
shift       = additive, { ("<<" | ">>"), additive } ;

additive = multiplicative, { ("+" | "-"), multiplicative } ;
multiplicative = exponent, { ("*" | "/" | "//" | "%"), exponent } ;
exponent = unary, { "^", unary } ;                  (* right‑associative *)

unary = [ ("+" | "-" | "~" | "not") ], primary ;

primary = literal
        | identifier
        | "(", expression, ")"
        | call
        | member_access
        | "self"                                 (* or "this" *)
        | "(", expression, ")"                   (* grouping, distinct from pair *)
        | "input(", string, ")"                  (* User input *)
        ;

call = primary, "(", [ argument_list ], ")" ;
argument_list = expression, { ",", expression } ;

member_access = primary, ".", identifier
              | primary, ".", identifier, "(", [ argument_list ], ")" ;  (* method call *)

(* ----------------------------------------- *)
(* Statements                                *)
(* ----------------------------------------- *)

statement = import_statement
          | print_statement
          | assignment_statement
          | declaration_statement
          | if_statement
          | while_statement
          | for_statement
          | forever_statement
          | skip_statement
          | stop_statement
          | halt_statement
          | return_statement
          | block
          | expression_statement
          | empty_statement
          | nope_statement
          ;
import_statement = "import", identifier, { ".", identifier }, [ "as", identifier ] ;
print_statement = "print", [ "(", expression, ")" ] ;

block = "{", { statement, [ ";" ] }, "}" ;   (* semicolons separate statements, optional after last *)

empty_statement = ;
nope_statement = "pass" ;

(* Assignment *)
assignment_statement = identifier, "<-", expression ;   (* mutates existing variable *)

(* Declaration with visibility *)
declaration_statement = [ visibility ], ("var" | "const"), identifier, [ ":", type ], [ "<-", expression ] ;

visibility = "public" | "protected" | "private" ;

(* Conditionals *)
if_statement = "if", "(", expression, ")", block
               { "elif", "(", expression, ")", block }
               [ "else", block ] ;

(* Loops *)
while_statement = "while", "(", expression, ")", block ;
for_statement   = "for", identifier, "in", expression, block ;
forever_statement = "forever", block ; (* It's shorter than while(true) *)

skip_statement = "skip" ;
stop_statement = "stop" ;
halt_statement = "halt" ;

return_statement = "return", [ expression ] ;

expression_statement = expression ;

(* ----------------------------------------- *)
(* Functions                                 *)
(* ----------------------------------------- *)

function_definition = [ visibility ], "func", identifier,
                      "(", [ parameter_list ], ")",
                      [ "->", type ],
                      block ;

parameter_list = parameter, { ",", parameter } ;
parameter = identifier, [ ":", type ] ;

(* ----------------------------------------- *)
(* Classes                                   *)
(* ----------------------------------------- *)

class_definition = [ visibility ], "class", identifier,
                   [ "extends", identifier ],
                   "{", { class_member }, "}" ;

class_member = declaration_statement
             | function_definition
             | constructor_definition
             ;

constructor_definition = "func", "new",
                         "(", [ parameter_list ], ")",
                         [ "->", type ],   (* typically the class type *)
                         block ;

(* ----------------------------------------- *)
(* Top‑level program                         *)
(* ----------------------------------------- *)

program = { (declaration_statement | function_definition | class_definition | statement), [ ";" ] } ;