Zerionyx Documentation & Libraries

Getting Started

• Install Zerionyx: git clone https://github.com/memecoder12345678/Zerionyx
• Run a file: python ./interpreter/Zerionyx.py yourfile.zer
• Open interactive shell: python ./interpreter/Zerionyx.py
• See homepage for more info.

Language Grammar

PROGRAM            ::= (STATEMENT NEWLINE*)*

STATEMENT          ::= SIMPLE_STATEMENT | COMPOUND_STATEMENT

SIMPLE_STATEMENT   ::=
      "load" STRING
    | "return" EXPR
    | "continue"
    | "break"
    | EXPR

COMPOUND_STATEMENT ::=
      IF_EXPR
    | FOR_EXPR
    | WHILE_EXPR
    | DEF_FUNC

EXPR               ::= 
      "let" IDENTIFIER "=" EXPR
    | IDENTIFIER "=" EXPR
      "let" IDENTIFIER "as" EXPR
    | IDENTIFIER "as" EXPR
    | IDENTIFIER ("+=" | "-=" | "*=" | "/=" | "//=" | "%=" | "^=") EXPR
    | COMP_EXPR (("and" | "or") COMP_EXPR)*

COMP_EXPR          ::= 
      ARITH_EXPR (("==" | "<" | ">" | "<=" | ">=" | "!=") ARITH_EXPR)*
    | "not" COMP_EXPR

ARITH_EXPR         ::= TERM (("+" | "-") TERM)*

TERM               ::= FACTOR (("*" | "/" | "//" | "%") FACTOR)*

FACTOR             ::= ("+" | "-") FACTOR | POWER

POWER              ::= CALL ("^" FACTOR)*

CALL               ::= ATOM ("(" (EXPR ("," EXPR)*)? ")")?

ATOM               ::= 
      INT | FLOAT | STRING | IDENTIFIER
    | "(" EXPR ")"
    | LIST_EXPR
    | LIST_INDEX
    | IF_EXPR
    | FOR_EXPR
    | WHILE_EXPR
    | DEF_FUNC
    | COMMENT

GET_INDEX         ::= "(" IDENTIFIER ">" EXPR ")

GET_MEMBER        ::= IDENTIFIER  "." CALL

LIST_EXPR         ::= "[" (EXPR ("," EXPR)*)? "]"

HASHMAP_EXPR      ::= "{" (EXPR ("," STRING ":" EXPR)*)? "}"

NAMESPACE_EXPR    ::=
      "namespace" IDENTIFIER
      NEWLINE STATEMENT NEWLINE "done"

IF_EXPR           ::= 
      "if" EXPR "do" STATEMENT
      (NEWLINE "elif" EXPR "do" STATEMENT)*
      (NEWLINE "else" STATEMENT)?
      NEWLINE "done"

FOR_EXPR          ::=
      "for" IDENTIFIER "=" EXPR "to" EXPR
      ("step" EXPR)?
      "do" STATEMENT
      NEWLINE "done"

WHILE_EXPR        ::= 
      "while" EXPR "do" STATEMENT
      NEWLINE "done"

DEF_FUNC          ::= 
      "defun" IDENTIFIER "(" (IDENTIFIER ("," IDENTIFIER)*)? ")"
      ("->" EXPR)?
      NEWLINE STATEMENT NEWLINE "done"

COMMENT           ::= "#" /[^\n]*/

Zen of Zerionyx

The Zen of Zerionyx, by MemeCoder.

Clarity is better than cleverness.
Consistency is better than chaos.
Freedom in syntax, but not in structure.
Parentheses are for math, backslashes are for flow.
The caret (^) means power — and nothing else.
Blocks should be explicit: do...done says it all.
if is a command, not a value.
let or =, pick one — but be clear.
Whitespace is free; newlines are not.
Write like a poet, execute like a machine.
Code is for humans first, machines second.
elif is enough — no need for else if.
load means include — not magic.
Indentation is rhythm, not restriction.
When in doubt, don't guess — define it.
Simplicity comes first.
If it's hard to explain, it's probably wrong.
If it's easy to explain, it might be right.
Weirdness is not a feature.
Zerionyx may be magical, but its syntax must be real.

Built-in Functions

• append(obj, val) → list — Add val to end of obj return val
• catch(func, args) → list — Run func with args return [result, none] if ok or [none, err] if error
• clear() → none — Clear terminal
• extend(a, b) → none — Add all in b to a both must be list
• finally(f, a, final_f, final_a) → list — Run f with a then always run final_f with final_a return like catch
• input(prompt) → string — Show prompt get user input
• get_password(prompt) → string — Show prompt get user password
• insert(lst, i, val) → none — insert val to lst at index i
• is_func(x) → bool — Check if x is func
• is_list(x) → bool — Check if x is list
• is_none(x) → bool — Check if x is none
• is_num(x) → bool — Check if x is number
• is_str(x) → bool — Check if x is string
• is_bool(x) → bool — Check if x is boolean
• is_thread(x) → bool — Check if x is thread
• keys(hm) → list — Return list of all keys in hm (a hashmap)
• values(hm) → list — Return list of all values in hm
• items(hm) → list — Return list of [key, value] pairs in hm
• has(hm, key) → bool — Return true if key exists in hm
• get(hm, key, default) → any — Return value for key or default if not found
• set(hm, key, value) → none — Add or update key in hm with value
• del(hm, key) → none — Delete key and its value from hm
• len(x) → number — Get length of x
• panic(msg, type) — Stop with err msg and type ('RT': 'Runtime Error', 'M': 'Math Error', 'IO': 'IO Error' or 'T': 'Type Error')
• pop(lst, i) → any — Remove and return item at i in lst
• print(text) → none — Prints text to the standard output with no newline
• println(text) → none — Same as print but adds a newline
• to_float(x, silent) → float/none — Convert x to float return none if fail and silent true else raise
• to_int(x, silent) → int/none — Convert x to int return none if fail and silent true else raise
• to_str(x) → string — Convert x to string
• type(x) → string/none — Return type of x as string or none
• pyexec(code) → any — Executes embedded Python code and returns its result (use with caution)
• slice(l, from, to, step) → list/string/hashmap — Slice list/string/hashmap l from from to to step step (exclusive)

Standard Libraries

How to Use Libraries

• To use a library, add load "libs.<name>" at the top of your .zer file.
• Example: load "libs.math"
• Then call functions as documented above.

Zerionyx Editor