aysìnvi

Lefngapä lì'fya

1. What is this?
2. Why this name?
3. Key goals
4. Addendum

What is this?

Aysìnvi is an esolang based on the Na'vi constructed language from Avatar. Some of the main goals of this project are:

• having the least non-alphabetic symbols possible to represent the oral culture of Na'vi (including math operators),
• making conjugation of verbs (here functions) have a purpose,
• building an actually usable standard library that interfaces with lower level APIs to make this esolang technically productive.

Why this name?

ay+ -> plural prefix, causes lenition
tìnvi -> task, errand, step (in an instruction)

Key goals

• Grammar
• Parsed AST
• Bound AST (missing recursion)
• Typed AST
• Generic AST pattern replace
• Interpreter
• Compiler
• REPL
• LSP

Grammar

• Module inclusion
• Statements
  • If construct
    • Truthy condition
    • Comparison condition
  • Loop construct
  • Function definition
    • Infix position marking
    • Arity =0 functions
    • Arity >1 functions
  • Variable definition
    • Singular variable definition
    • Dual, trial and plural variable definition
• Expressions
  • Literal parsing
    • Numbers (temporary numeric form)
    • Strings
  • Data structures
    • Arrays
  • Identifiers
  • Comparisons
  • Function calling
    • Arity =0 si form
    • Arity >1 fa form

Parsed AST

• Module inclusion
• Statements
  • If construct
  • Loop construct
  • Function declaration
  • Variable declaration
• Expressions
  • Literals
    • Numbers (temporary numeric form)
      • Octal parsing
      • Multiplier (melo/pxelo) parsing
    • Strings
  • Data structures
    • Arrays
  • Identifiers
  • Comparisons
  • Function calls

Bound AST

• Variables
  • Definition
  • Use
• Functions
  • Definition
  • Call
  • Recursion

Typed AST

• Definitions
  • Variables
  • Functions
• Expressions
  • Literals
  • Variable use
  • Function call
  • Comparisons

Generic AST pattern replace

This step aims to provide a nice API to enable advanced users to consisely define their own mini pattern finding language.
This must be generic and user-defined as modules use different types of structs and enums that rarely have the same names or components.
The general structure should be the same.
For example:

• Fd(_,_,[Vd(_, _)])/d could be a representation for
  "Match any Function definition with a single Variable definition in its body and delete its subtree from the AST".
• [Fd(name,argnames,body),Fc(name,args)]/s/[Vd(argnames,args),body] could be a representation for
  "Match any Function definition followed only by a Function call to it and substitute this match with a Variable definition of the call arg(s)uments followed by the function's body".

Addendum

I have been informed that I am forced to add that since this is made with Rust, it will obviously be 🚀 blazingly fast 🚀