Every self-respecting hobby/student programming language should have a name - this one is called Stretch. File extensions for programs in this language are .str.
It is very much inspired (at least syntax-wise) by the Rust programming language.
This project started as a university assignment during Programming Languages and Paradigms course at University of Warsaw.
There, students are tasked with writing their own interpreter of a programming language, of their own design, meeting certain criteria. This is an attempt at statically-typed expression-based imperative programming language, heavily inspired by Rust.
Despite the language being inherently imperative, one of the main
characteristics will be an attempt to treat everything as an expression
(although it won't be Lisp!... I think). For example, if true { 1 } else { 0 }
is an expression with type int which returns value 1.
In general, blocks always return a certain value. The value returned will be the
last expression inside a given block, e.g. { [Stmt]; Exp } will return value
from evaluating the Exp expression. If no expression is present, a block
implicitly returns a unit value (), same with expressions such as if .. { .. } (without else). A unit value () is analogous to the C void type.
Additionally, since control flow constructs are expressions, expressions with
side-effects (e.g. { a = a + 2 } are obviously supported.
Furthermore, the language supports functions as typed values. An example function definition looks like this:
fn my_function(arg1: bool, arg2: int) -> int {
42
}which is a function accepting 2 arguments and returning an int value. Here,
my_function is of type Fn(bool, int) -> int. If the type is not specified,
it implicitly returns a unit value ().
Since the functions are first-class citizens, the language supports anonymous functions. An example syntax is given below:
let anon: Fn(bool, int) -> int = |arg1: bool, arg2: int| { 42 };Here, the value can be called with anon() as an ordinary function and has the
same type as the above my_function functiom.
The language will be interpreted, however it is meant to be statically typed - this means that the type-checking phase will always be resolvable before actually interpreting and running the program.
The language above should meet requirements given at the university course,
however it wouldn't be a real inspiration after Rust, at least not only
syntax-wise, if it didn't support at least a simple linear type system.
Currently the language grammar allows for a special drop Ident; statement used
to consume values, however it is not used at the moment.
Small syntax examples are inside the examples/ directory.