axion-lang/axion

Experimental programming metalanguage, targeting on intertranspiling with other languages.

Welcome to Axion programming language toolset

🚧 Under construction 🚧

📂 Distribution

Entire codebase is implemented in .NET 6 (+ .NET Standard 2.1)

Directory	Contents
Axion	User interface for compiler: CLI, ScriptBench editor, interpreter
Axion.Core	Language core, lexer, parser, frontend interface, compiler API
Axion.Emitter.Axion	Extension to translate Axion syntax tree back into Axion source code
Axion.Emitter.CSharp	Extension to translate Axion AST into C# source code
Axion.Emitter.Python	Extension to translate Axion AST into Python source code
Axion.Testing	NUnit-based unit tests for the toolset
CodeConsole	Sub-repo for ScriptBench - console code editor (still unstable)
misc	Code examples, arts, etc.

🎯 Key features

• Expressiveness

  Maintaining the "perfect balance" (© Thanos) between usage of expressive symbols and readable names.
  Support for language-oriented programming (LOP) and macros system allows you to:

  • Add new language syntax of almost any complexity
  • Implement common design patterns quickly and simply

• Inter-transpiling to other popular languages

  At the moment Axon targets C# and Python code output. More languages are planned!

• Static typing with less annotations

  Support for full type soundness and type inferring (in design).

• High-performance

  Compile-time computations, macros expansion, and transpiling to fastest target language's code.

💹 Progress

• Lexical analyzer
• Syntax parser
• Interpreter (based on C# transpiling)
• Console code editor with syntax highlighting & error reporting
• C#, Python transpilers

🚀 Launching

You can launch compiler with dotnet run in Axion.csproj folder and type -h in console to get support about arguments for compiler interface.

At the moment toolset supports interpretation of the Axion source with -i CLI argument (through console code editor) and file processing with -f "<path>.ax" -m <output lang> arguments.

Interpretation is performed by transpiling Axion to C# and running it through Roslyn (still incomplete and doesn't support some syntax).

📜 You can take a look at the language syntax in project wiki

axion's Issues

Various styles of block declaration

C-style:
class A { x: int; y: int; }
1-Expression style:
fn (x: int) x * x * x
Indentation-style:

class A
    x: int
    y: int

Generic functions syntax

Example:
fn makemap[T](g: T, seq: List[T]

`BlockExpression.ToCSharp` - invalid `;` placing

https://github.com/F1uctus/Axion/blob/a4e33355a629f7ea6c3ebc9428a596b23f94355b/Axion.Core/Processing/Syntactic/Ast.cs#L150-L159

When block has function/class/struct/other top level expression, then C# doesn't allow semicolons to be placed after that expressions.

for example:
Axion:

fn Hello
    Console.WriteLine("Hello, world!")

C#:

void Hello() {
    Console.WriteLine("Hello, world!");
}; // semicolon here is not permitted
// (results in 'error CS1597: Semicolon after method or accessor block is not valid')

Implement modules import statements

Related to #13.

Syntax:

import
  system
    io
    collections.generic
    reflection
  axion
    core { specification, compiler }
  

Functions syntax

fn sum (a: int, b: int) -> int
    return a + b

Note: Regular/anonymous functions are implemented as FunctionDef class.

`LangException` rendering

Render exception like:

Error: Unknown operator.

8| someInt $= 340
           ^^

src\main.ax,
line 8, column 9.

Feature is already partially implemented.

for comprehension on new line inside collection

https://github.com/F1uctus/Axion/blob/a4e33355a629f7ea6c3ebc9428a596b23f94355b/Axion.Core/Processing/Syntactic/Expression.cs#L424-L429

There is a check, that for keyword is not placed at new line, to resolve that code:
Axion:

<expression>
for x in y
    code()

not to be parsed as for comprehension (<expression> for x in y).

But also, for is allowed to be placed in that context:

(float(f)
   for a in l
     ...
       for f in e
         unless e.length == 0)

and, because of newline check, we must write it like:

(float(f) for a in l
            ...
              for f in e
                unless e.length == 0)

so, for allowed to be placed on new line if it's invoked by function, that parses
collection expression embraced in (), {} or [].

Implement modules system

Modules should be organized by nesting directories.

Definitions from one module should have straight accessibility from other module's parts.
e.g: examine the hierarchy:

app1
- frontend
  - button.ax
  - list-view.ax
- backend
  - converter.ax
  - parser.ax

Here, parts of module frontend should have access to each other without imports.
Same goes for backend.

Format syntax documentation comments for `Expr` parsing functions

Doc-comment for every function-expression builder and every expression constructor should contain valid ANTLR grammar rule, describing syntax of constructing expression.
Doc-comment format:

<summary>
    <c>
        expression: syntax;
    </c>
</summary>

Every expression rule should end with expr (except for comprehension, name, definition and type expressions).

Number literals (radix 1-36)

bin = 2::100101
oct = 8::523521
hex = 16::C0FFEE
tri = 36::V13HZ
doz = 12::138A3B

Indentation bug

In cases with equal line indentation, like:

use:
   System: Module1;
   Axion: Module2;
   Etc;

Lexer products Unknown token instead of nothing.
Should be fixed to v. 0.2.9.5.

Invalid computation of lines in SyntaxError.cs

Found an exception occurring when trying to render error/warning.

https://github.com/F1uctus/Axion/blob/41a7b091dc9ed2084dc6b6fb787407042ad5df3d/Axion.Core/Processing/SyntaxError.cs#L58-L67

This can be done simpler.

`match` construction

Example:

count = x match
    1: "one"
    2: "two"
    3: "three"
    _: "?"

Note: Implemented as a macro.

Invalid placement of unary operators with input from left

Transpiler converts any x++ - like expression to ++ (x) one.
Invalid code is here:

https://github.com/F1uctus/Axion/blob/156f68a5081c6c4957b4fbdbcdf5aed6c81d5373/Axion.Core/Processing/Syntactic/Expressions/Common/PostfixExpr.cs#L49-L53

Implement automatic span marking for expressions

At the moment compiler logic enforces explicit span (start/end location) marking for expressions.
Idea is in marking the span while binding expression part to it's parent.
This is achieved by usage of Bind(Node) and InitIfNull(NodeList<Node>) in Node-based properties.

Dataclasses

class Point (x: Int, y: Int)

Note: Implemented as a NodeList<Expr> DataMembers property of ClassDef.

Unsuccessful macro match reports false-error

Consider the following macros definition snippet:

macro for-in-statement ('for', item: Atom, 'in', iterable: Infix, scope: Scope)

macro for-index-statement ('for', init: Any, ',', condition: Infix, ',', step: Infix, scope: Scope)
    return {{
        $init
        while $condition {
            $scope
            $step
        }
    }}

And piece of code that uses it:

for (x, y) in zip(1..9, 9..1) Console.print(x, y)

First macro will try to match it, but it'll fail and report error.
Then, 2-nd macro will match successfully, but error will remain.

Move wiki to 'Read the Docs'

Add `Token` bindings to expressions

Variables syntax

a: int = 1 # immediate assignment (type can be omitted)
b = 2      # type is inferred
c: int     # type required without initializer

let a: int = 1 # immediate assignment
let b = 2      # type is inferred
let c: int     # type required without initializer
c = 3          # deferred assignment (now type of `let c` can be omitted)

Still Alive?

Is this project still alive? I love the idea of language orientatet programming. I am the developer of backlang and I want to make axion a full robsu language that can be compiled to il, like backlang does.

Use latest nullability features from C# 8

Pipeline operator `|>` (like in F#)

messages =
   friends
   |> Seq.map(fn (x): x.Messages)
   |> Seq.concat

Note: Implemented as infix operator, converted to regular FuncCallExpr through traversing.

Multiple arguments usage still unimplemented.

Multiline strings (""" & ```) parsed incorrectly

End of multiple line strings, like:

string1 = f"""Multiline
string literal"""

string2 = f```Multiline
string literal```

is missed by Lexer due to invalid algorithm here:

https://github.com/F1uctus/Axion/blob/e6cce4b25facc68ef8b73b552e41b75bf237c498/Axion/Processing/Lexer.cs#L384-L408

Build a dsl

How would you build a dsl with this?
like only expand macros in a certain context:

mydsl { do x on after y unless z }