Elara is incomplete! Only basic variable declaration is supported right now
Elara is a multi-paradigm (although primarily functional) language with a clean syntax with little "noise"
Elara's key focus is freedom. Developers should be able to write code without the language getting in the way.
This is acomplished with a minimal syntax, containing as little "noise" as possible, and being highly flexible:
Type inference for variables (and planned to be added for parameters)
A type system that allows developers to specify exactly what types they want
Infix and prefix function calling, with or without parentheses
Identifiers for things like functions and variables can be almost any unicode character (inspired by Julia)
Unlike most functional languages, Elara will not restrict the programmer for the sake of it, and prioritises developer freedom wherever possible. As such, it is not a "pure" functional language like Haskell and can effectively be procedural or object oriented too.
Simple Example
let fib = (Int n) => {
if n <= 1 => return n
return fib(n - 1) + fib(n - 2)
}
let num = fib 10
Basic Syntax
(all syntax is subject to change)
Variable Declaration
Variables are declared with the syntax
let [name] = [value] with type inference
Explicit type specification:
let [name]: [Type] = [value]
By default, variables are reference immutable. For mutability, the syntax let mut [name] = [value] should be used
Function Declaration
Functions are first class types, and are declared in a near identical way to variables:
let print-hello = () => {
print "Hello World!"
}
Functions with a single expression can be declared with a more concise syntax:
Elara supports a wide range of function calling syntax to try and make programming more natural and less restrictive:
Simple Calling
print-twice("Hello")
print-hello()
Calling without parentheses (does not work for no-arg functions)
print-twice "Hello"
OOP style calling on a receiver function
"Hello" print-twice
This feature works with multiple parameters:
let add-to = (Int a, Int b) => {
a + b
}
3 add-to 4
add-to 3 4
the 2 calls are identical
Structs
Structs in Elara are Data Only They are declared with the following syntax:
struct Person {
String name
mut Int age
Int height = 110
}
And can be instantiated like so: let mark = Person("Mark", 32, 160)
OOP Structs
Structs can easily replicate objects with extension syntax, which is the most idiomatic way of adding functionality to structs:
struct Person {
//blah
}
extend Person {
let celebrate-birthday = () => {
print "Happy Birthday " + name + "!"
age += 1
}
}
from here we can do somePerson.celebrate-birthday() as if it was a method.
The extend syntax works with any type and can be done from any file
Inheritance
The extend syntax effectively adds inheritance too:
struct Person {
//blah
}
extend Person {
struct Student {
Topic major
}
}
This is not true "inheritance". Instead, the Student struct will copy all the properties of Person. Because the type system is contract based (that is, type B can be assigned to type A if it has the same contract in its members), this is effectively inheritance - we can use an instance of Student wherever we use a Person.
Type System
Elara features a simple, linear type system. Any is the root of the type hierarchy, with subtypes such as Int, String and Person.
However, there are also a few quirks that aim to make the type system more flexible:
Types are maps Similar to Clojure, every type can be expressed as a map with a union of all of its members.
Contract based type parameters
Type parameters for generics support contract based boundary. Take for example the simple generic function, ignoring the unnecessary generic (since T can be any type):
<T>
let print-and-return = (T data) => T {
print data
return data
}
We cannot guarantee that every type will give a user-friendly value for print.
To work around this, we can add a boundary to T, that only accepts types that define a to-string function:
<T { to-string() => String } >
let print-and-return = (T data) => T {
print data.to-string()
return data
}
This gives programmers extra flexibility in that they can program to a specific contract, rather than a type
Namespaces and Importing
The namespace system in Elara is simple
Declaring a namespace is usually done at the top of the file: namespace elara/core
Namespaces follow the format base/module, similar to languages like Clojure
Importing a namespace is simple: import elara/core
The files will now have access to the contents of all files in that namespace
Functional Features
Lambdas are defined identically to functions: let lambda = (Type name) => {} Parameter types can be omitted if possible to infer from context
Functions are first class
let add-1 = (Int a) => a + 1
let added-1-list = some-list map add-1
some-list.map(add-1).filter(is-even).forEach((it) => { print it })
Conclusion
Elara is in very early stages, with the evaluator being nowhere near finished.
The eventual plan includes: Static typing Compiling to native code, but also supporting other backends such as JavaScript or JVM Bytecode A proper standard library Allowing type inference for function parameters
Usage
The runtime / evaluator is very limited at the moment, but a simple demo application along with the source code can be found here:
Hello there, the jam required you to work as a team, and I see you did. Could you please edit the post to mention your team members who worked alongside you to make this language?
Elara - A primarily functional language with a focus on developer freedom
Elara
Elara is incomplete! Only basic variable declaration is supported right now
Elara is a multi-paradigm (although primarily functional) language with a clean syntax with little "noise"
Elara's key focus is freedom. Developers should be able to write code without the language getting in the way.
This is acomplished with a minimal syntax, containing as little "noise" as possible, and being highly flexible:
Identifiers for things like functions and variables can be almost any unicode character (inspired by Julia)
Unlike most functional languages, Elara will not restrict the programmer for the sake of it,
and prioritises developer freedom wherever possible. As such, it is not a "pure" functional language like Haskell and can effectively be procedural or object oriented too.
Simple Example
Basic Syntax
(all syntax is subject to change)
Variable Declaration
Variables are declared with the syntax
let [name] = [value]
with type inferenceExplicit type specification:
let [name]: [Type] = [value]
By default, variables are reference immutable.
For mutability, the syntax
let mut [name] = [value]
should be usedFunction Declaration
Functions are first class types, and are declared in a near identical way to variables:
Functions with a single expression can be declared with a more concise syntax:
Functions with parameters:
Functions with a clearly defined return type:
Function Calling
Elara supports a wide range of function calling syntax to try and make programming more natural and less restrictive:
Simple Calling
print-twice("Hello")
print-hello()
Calling without parentheses (does not work for no-arg functions)
print-twice "Hello"
OOP style calling on a receiver function
"Hello" print-twice
This feature works with multiple parameters:
the 2 calls are identical
Structs
Structs in Elara are Data Only
They are declared with the following syntax:
And can be instantiated like so:
let mark = Person("Mark", 32, 160)
OOP Structs
Structs can easily replicate objects with extension syntax, which is the most idiomatic way of adding functionality to structs:
from here we can do
somePerson.celebrate-birthday()
as if it was a method.The
extend
syntax works with any type and can be done from any fileInheritance
The
extend
syntax effectively adds inheritance too:This is not true "inheritance". Instead, the
Student
struct will copy all the properties ofPerson
.Because the type system is contract based (that is, type
B
can be assigned to typeA
if it has the same contract in its members),this is effectively inheritance - we can use an instance of
Student
wherever we use aPerson
.Type System
Elara features a simple, linear type system.
Any
is the root of the type hierarchy, with subtypes such asInt
,String
andPerson
.However, there are also a few quirks that aim to make the type system more flexible:
Types are maps
Similar to Clojure, every type can be expressed as a map with a union of all of its members.
Contract based type parameters
Type parameters for generics support contract based boundary.
Take for example the simple generic function, ignoring the unnecessary generic (since T can be any type):
We cannot guarantee that every type will give a user-friendly value for
print
.To work around this, we can add a boundary to
T
, that only accepts types that define ato-string
function:This gives programmers extra flexibility in that they can program to a specific contract, rather than a type
Namespaces and Importing
The namespace system in Elara is simple
Declaring a namespace is usually done at the top of the file:
namespace elara/core
Namespaces follow the format
base/module
, similar to languages like ClojureImporting a namespace is simple:
import elara/core
The files will now have access to the contents of all files in that namespace
Functional Features
Lambdas are defined identically to functions:
let lambda = (Type name) => {}
Parameter types can be omitted if possible to infer from context
Functions are first class
is directly equivalent to
Conclusion
Elara is in very early stages, with the evaluator being nowhere near finished.
The eventual plan includes:
Static typing
Compiling to native code, but also supporting other backends such as JavaScript or JVM Bytecode
A proper standard library
Allowing type inference for function parameters
Usage
The runtime / evaluator is very limited at the moment, but a simple demo application along with the source code can be found here:
https://repl.it/@Elara/Elara
Team Members:
Hello there, the jam required you to work as a team, and I see you did. Could you please edit the post to mention your team members who worked alongside you to make this language?
Thank you.
@TheDrone7 done :)
@AlexWood4 Thanks again.