"Try 2" of the SLUL programming language
========================================

Notes:

* This programming language is in a very early design phase!
* Currently has the beginnings of a bootstrap compiler, that compiles to C.
* To implement all of the features below, it will probably be necessary
  to write a more powerful compiler (e.g. in SLUL), with a custom code
  generator / linker.

SLUL is programming language that...

Will be safe:

* [ ] Type safe, statically typed
* [ ] Memory safe
* [ ] Null safe
* [ ] Integer range safe
* [ ] Capabilities
* [ ] Pure/immutable by default
* [ ] Safe to build (no unrestricted build-time execution)
* [ ] Safe upgrades of libraries (without possibly violating constraints above)

```
    ?Thing t = get_thing 123
    assert t <> none # t can be accessed after this.
    assert b <= 254  # assuming that the range of b is 0-255,
    b += 1           # this addition is now allowed.
```

Will be lightweight:

* [ ] Small runtime
* [ ] Native code compilation
* [ ] Arena allocation, with optional garbage collection
* [ ] Compile-time generics using type erasure (avoids duplication)

Will be usable:

* [ ] Minimal surprises
* [x] Minimal punctuation
* [ ] Maybe name-based type inferrence

Will be "modules first":

* [ ] API compatibility enforced by compiler
  (cryptographically hashed interfaces)
* [ ] Dynamic linking
* [ ] Link to minimal version of dependencies
* [ ] Build environment needs only interface files of (direct) dependencies
* [ ] Easily build and replace any program of library, without having to
  rebuild any another components.

Will be platform-independent / portable:

* [ ] SLUL code will be fully platform independent
  (assuming that dependencies exist/work on the target platform).
* [ ] Trivial cross-compilation (not in the bootstrap compiler, which compiles to C)

Building it
-----------

Requirements:

* C89+ compiler with 64-bit types (such as GCC, Clang, TCC, ...)
* GNU Make or BSD Make

```
    cd bootstrap
    make
```

SLUL "try2" vs. original SLUL
-----------------------------

This an attempt to make my previous experimental progamming language
simpler and easier to use. Main changes:

* Less punctuation (no `(` around simple function calls)
* Function definitions have one parameter definition per line, which
  allows documentation to appear in a comment on the line before.
* Implicit namespace/class per file
  (this way "globals" are actually instance variables).
* Probably won't have hard-coded integers (int8, int16...)
* Generic types might use `of`, `from`, and `to` keywords.
  For example, `List of Int` or `Map from Int to String`. Not decided yet.

License
-------

EUPL 1.2 or later.

The runtime library will most likely be dual-licensed under the EUPL and MIT-0 licenses.