Skip to content

Latest commit

 

History

History
89 lines (70 loc) · 2.81 KB

README.md

File metadata and controls

89 lines (70 loc) · 2.81 KB
Raw

cyan

An experiment in programming languages

Current features

  • variables and arrays (immutable by default)
  • structs (immutable)
  • complex expressions (parantheses, precedence, PEMDAS)
  • basic type inference for variable declarations
  • type checking for if statements and variables with type annotations
  • arithmetic (+, -, *, /, %)
  • if, else if, else
  • functions (local only)
  • stack-based interpreter
  • JS codegen
  • (WIP) WASM codegen

Goals

  • modern, flexible language
  • flexible but strong typing
  • multiple compile targets

Non-Goals

  • interop with existing languages / ecosystems

Example

let a = 1847899 + (301111 * 5)    // Complex expressions
let b = "hello"                   // Type inference
let c = ["hi", "hello", b]        // Homogeneous arrays
let d: bool = true                // Type annotations
var e = "what"                    // Mutable variables
e = "so ..."
print(c[2])                       // Array indexing
if (d) {                          // "if - else if - else" chains
    print(c)
} else if (false || d) {
    print("hi !")
} else {
    print("ho !")
}
function hi(a) {                  // Functions
    let array: i32[] = [1, 3, 42, 127, (10 % 3)]
    print("Hello world !")
    print(array)
    print(array.length)
    function hello(b) {           // Local functions
       print("heck")
       print(b)
    }
}
hi(9)
print(hi)

type Person = struct {          // Structs
    name: str,
    age: i32
}
let p: Person = { "James", 18 }
print(p.name)

Architecture

The cyan compiler (cyanc) currently works using an internal representation called FIR (Frontend Intermediate Representation).

FIR is a transformed code format on which type-checking and symbol resolution is performed. Therefore, any outputted FIR is valid code.

Here are the compilation steps :

  1. The runtime source code (resources/runtime/runtime.cy) is compiled using the same steps as normal code;
  2. A FirDocument (root node of any FIR tree) is created for the program source code, and the symbols from the compiled runtime are inserted into it;
  3. The source code is lexed and parsed (cỳan.compiler.parser) into an AST (abstract syntax tree);
  4. The AST is lowered into FIR (cyan.lower.ast2fir), using the previously mentionned FirDocument. This is where type-checking and symbol resolutioon happens;
  5. (Temporary) The FIR is turned into generated JS.

Current limitations

  • The codegen component consumes cyan FIR, which includes some pretty high-level concepts like structs and for loops. That makes some targets very difficult or impossible to implement.
  • Member access expressions only work on structs

Contributions and issues

Contributions and issues are welcomed and encouraged.

If you encounter any problem with the compiler, or wish to ask about a feature you'd like, feel free to open an issue.