airlang 0.3.0

The Air Programming Language
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57

# The Air Programming Language

The [Air](https://github.com/LambdaAlpha/airlang) programming language is carefully designed to solve programming problems once and for all.

## Goals

The Air language seeks to solve programming problems once and for all.

- It can express any describable information, such as requirements and implementations, problems and solutions, propositions and proofs.
- It can provide any information about the language and the program itself.
- It can implement any theoretically possible information processing requirement, such as implementing requirements, answering questions, and proving propositions.
- It can use information about the language and the program itself to perform property proofs and performance optimizations, achieving the best properties and optimal performance.
- It provides stable syntax and semantics, allowing users to learn the programming language once and for all.

## Non-Goals

- No design choices are taken for granted, and language features are not copied from other languages without review.
- Suboptimal designs are not chosen to accommodate user habits.
- Solutions that only solve most but not all problems are not satisfactory.
- Impossible tasks are not attempted to be implemented.
- The language is not constantly updated to implement more requirements.

## Design

- Decouple syntax from semantics, making syntax available as a general data exchange format.
- Build a concise semantic core and provide rich initial context.
- Allow functions to access context, which means that control statements are just functions that can access context.
- Implement a universal logical framework based on computability theory, replacing type systems based on type theory.
- Implement a universal problem framework based on reverse computation theory, used to express any describable requirement or problem, replacing interface/trait systems.
- Implement a universal algorithm framework based on complexity theory, attempting to achieve artificial general intelligence.

## Demo

```Air
"Demonstration of the gcd algorithm" @ ; ! [
    ctx = . context {
        : ;,
        : =,
        : while,
        : <>,
        : %,
    },
    gcd = function ! {
        body : ; ! [
            (x : y) = input,
            (y <> 0) while [
                z = y,
                y = x % y,
                x = z,
            ],
            x
        ],
        context : move ! ctx,
    },
    42 gcd 24
]
```