|
ELENA is a general-purpose, object-oriented, polymorphic language with late binding. It features message dispatching/manipulation, dynamic object mutation, a script engine / interpreter and mix-ins.
* ELENA on [https://github.com/ELENA-LANG/elena-lang/wiki/ Github]
== The simplest program ==
To create a simple console program we have to declare the public **program** closure in the project root namespace:
public program()
{
}
Everything in ELENA is an object. To interact with it we have to send a message. The message consists of *an action* and a *parameter list*.
The statement should be terminated by a semicolon.
public program()
{
console.writeLine("Hello!");
}
In our example the action is **writeLine** and the parameter list consists of a single string constant. The message target is **console** object (implementing input / output operations with a program console).
Several message operations can be done in a single statement:
public program()
{
console.writeLine("Hello!").writeLine("How are you?");
}
The result will be:
Hello!
How are you?
We may read a user input by sending **readLine** message without parameters:
public program()
{
console.write("What is your name:").writeLine("Hello " + console.readLine())
}
The result will be:
What is your name:Alex
Hello Alex
**Console::write** method is similar to **writeLine** except that it writes to the output screen without a new line character.
== Declaring a variable ==
A variable can be declared in an assignment statement starting with **var** attribute:
var myVariable := "A text";
where we declare a variable **myVariable** and initialize it with a string constant value.
The assigning value can be an expression itself:
public program()
{
console.writeLine("Hello!").writeLine("How are you?");
var s := console.readLine()
}
ELENA is a dynamic language and in most cases we may not specify the variable type:
public program()
{
var s := "Hello";
console.writeLine(s);
s := 2;
console.writeLine(s);
}
The output will be:
Hello
2
But it is possible to specify the variable expected type:
String s := "Hello";
console.writeLine(s);
*where system'String is a class representing text as a sequence of UTF-8 characters.*
We may use a class alias to simplify the code:
string s := "Hello"; // string is a String class alias
console.writeLine(s);
ELENA does not enforce types in compilation-time, so the following code will be successfully compiled:
string s := "Hello";
s := 2;
But it will raise an exception in the run-time:
system'IntNumber : Method #cast[0] not found
Call stack:
system'Exception#class.new[1]:exceptions.l(125)
system'MethodNotFoundException#class.new[2]:exceptions.l(236)
system'$inlineC.start[0]:win32_app.l(313)
mytest'program.#invoke[0]:test.l(5)
system'$inlineC.start[0]:win32_app.l(39)
system'#startUp:win32_app.l(52)
As you may see, the compiler injects the typecasting code, so the actual code looks like this:
string s := "Hello";
s := cast string(2);
*where* **cast string(2)** *is a construction to typecast the target expression* - **a numeric constant** - *to the expected type* - **System'String**
As a result if the object supports casting method the operation will work. For example, system'IntNumber can be implicitly converted into system'RealNumber so the following code:
public program()
{
real r := 2;
console.writeLine(r)
}
will be successfully executed with the result:
2.0
== Basic Types ==
=== The Boolean Type ===
Boolean type is used in conditional operations and may accept only two Boolean literals - **true** and **false**.
import extensions;
public program()
{
bool b1 := true;
bool b2 := false;
console.printLine(b1,"==",b1," is ",b1==b1);
console.printLine(b2,"==",b2," is ",b2==b2);
console.printLine(b1,"==",b2," is ",b1==b2);
console.printLine(b2,"==",b1," is ",b1==b2);
}
*Note that implicit extension method - **extensions'outputOp.printLine[]** - was used to simplify the output operations.*
The output is:
true==true is true
false==false is true
true==false is false
false==true is false
=== The Numeric types ===
The most used numeric types in ELENA are 32-bit signed integer number (represented by **IntNumber**), 64-bit signed integer number (represented by **LongNumber**) and 64-bit floating-point number (represented by **RealNumber**):
import extensions;
public program()
{
int n := -234;
long l := 1235456765l;
real r := 2.3456r;
console.printLine("Integer number - ",n);
console.printLine("Long integer number - ",l);
console.printLine("Real number - ",r)
}
The output is:
Integer number - -234
Long integer number - 1235456765
Real number - 2.3456
=== The String Type ===
**String** is used to store the text encoded in UTF-8. String is a read-only collection of **CharValue** classes each representing UTF-32 symbol. *Note that one character may be encoded with more than one byte!*.
import extensions;
public program()
{
var s := "Hello";
console.printLine("The first character of ",s," is ", s[0]);
console.printLine("The last character of ",s," is ", s[s.Length - 1])
}
The output is:
The first character of Hello is H
The last character of Hello is o
The same code for example with a Russian text will not work. Because every character is encoded with a two bytes and this should be taken into account.
import extensions;
public program()
{
var s := "Привет";
console.printLine("The first character of ",s," is ", s[0]);
console.printLine("The last character of ",s," is ", s[s.Length - 1])
}
The output is:
The first character of Привет is П
An index is out of range
Call stack:
system'Exception#class.new[1]:exceptions.l(125)
system'OutOfRangeException#class.new[1]:exceptions.l(156)
system'OutOfRangeException#class.new[0]:exceptions.l(156)
system'String.at[1]:memory.l(1243)
mytest'program.#invoke[0]:test.l(8)
system'$inlineC.start[0]:win32_app.l(39)
system'#startUp:win32_app.l(52)
We may use another class representing UTF-16 text (**WideString**) to solve this problem:
import extensions;
public program()
{
var s := "Привет"w. // UTF-16 string
console.printLine("The first character of ",s," is ", s[0]);
console.printLine("The last character of ",s," is ", s[s.Length - 1]);
}
The output will be correct this time:
The first character of Привет is П
The last character of Привет is т
But this code will not work with Chinese text or any other requiring more than 2 bytes per symbol. So instead we may use enumerators:
import system'routines;
import extensions;
public program()
{
var s := "Привет";
console.printLine("The first character of ",s," is ", s.FirstMember);
console.printLine("The last character of ",s," is ", s.LastMember)
}
The output will be correct for any UTF-8 text:
The first character of Привет is П
The last character of Привет is т
=== Array types ===
It is possible to declare a generic (_system'Array_) or strong-typed template-based (_system'Array#1_) array.
import extensions;
public program()
{
var strongTypedArray := new int[] {1,2,3};
var genericArray := Array.allocate(3);
genericArray[0] := 1;
genericArray[1] := "b";
genericArray[2] := 2.3r;
console.printLine("strong-typed array ",strongTypedArray.asEnumerable());
console.printLine("dynamic-typed array ",genericArray.asEnumerable());
}
The output is:
strong-typed array 1,2,3
dynamic-typed array 1,b,2.3
== Basic arithmetic operations ==
ELENA supports basic arithmetic operations with integer and floating-point numbers:
import extensions;
public program()
{
var n1 := 12;
var n2 := 5;
var n3 := -3;
var r1 := 2.3r;
console.printLine(n1, " + ", n2, " = ", n1 + n2);
console.printLine(n1, " - ", n2, " = ", n1 - n2);
console.printLine(n1, " * ", n3, " = ", n1 * n3);
console.printLine(n1, " / ", n2, " = ", n1 / n2);
console.printLine(n1, " + ", n2, " * ", r1 ," = ", n1 + n2 * r1)
}
The result is:
12 + 5 = 17
12 - 5 = 7
12 * -3 = -36
12 / 5 = 2
12 + 5 * 2.3 = 23.5
== ?? operator ==
Operator ?? is used to deal with nil.
_a ?? b_ - will return _a_ if _a_ is not _nil_ or _b_
See the following code:
import extensions;
public program()
{
var a := nil;
var b := a ?? 0 + 2;
console.printLine(a ?? "nil", " ?? 0 + 2 = ", b);
a := 1;
b := a ?? 0 + 2;
console.printLine(a ?? "nil", " ?? 0 + 2 = ", b);
}
The output is:
nil ?? 0 + 2 = 2
1 ?? 0 + 2 = 3
The operator can be used for typecasting operations as well:
_cast type(a) ?? b_ - will typecast _a_ to _type_ or return _b_ if it is not possible.
See the code:
import extensions;
public program()
{
string s := "a";
var n := 2;
console.printLine("cast int(",s,") ?? 0 = ", cast int(s) ?? 0);
console.printLine("cast int(",n,") ?? 0 = ", cast int(n) ?? 0);
}
The output is:
cast int(a) ?? 0 = 0
cast int(2) ?? 0 = 2
== Conditions, Multi-select, Loops ==
Conditional statement in ELENA are defined as follows:
if(<Boolean expression>)
{
/* doSomething if TRUE*/
}
else
{
/*doSomehting if ELSE*/
};
We could omit else part
if(<Boolean expression>)
{ /*doSomehting if TRUE*/ };
Usually Boolean expression is a result of a comparison operation:
public program()
{
console.writeLine("Hello!").writeLine("How are you?");
var s := console.readLine();
if(s == "good")
{
console.writeLine("Me too")
}
else
{
console.writeLine("What happends?")
}
}
Several conditions can be checked:
public program()
{
console.writeLine("Hello!").writeLine("How are you?");
var s := console.readLine();
if((s == "good") || (s == "fine"))
{
console.writeLine("Me too")
}
else
{
console.writeLine("What happends?")
}
}
A switch statement can be implemented using => operator:
public program()
{
console.writeLine("Hello!").writeLine("How are you?");
var s := console.readLine();
s =>
"good" { console.writeLine("Me too") }
"fine" { console.writeLine("Glad to hear") }
"bad" { console.writeLine("What's wrong?") }
"so so" { console.writeLine("It happens") }
: { console.writeLine("What happens?") };
}
We could declare *while* loop which will be repeated until the condition is true:
public program()
{
console.writeLine("Hello!").writeLine("Guess what?");
var s := console.readLine();
while (s != "nothing")
{
console.writeLine("Guess what?");
s := console.readLine();
}
}
Alternatively *until* loop is executed until the condition is met :
public program()
{
console.writeLine("Hello!").writeLine("Guess what?");
var s := console.readLine();
until (s == "nothing")
{
console.writeLine("Guess what?");
s := console.readLine();
}
}
ELENA supports C-styled *for* loop as well:
public program()
{
for(int n := 0, n < 5, n += 1)
{
console.write("*")
}
}
The output is:
*****
_Note that comma is used instead of semicolon!_
*doUntil* loop is similar to *for*, but the loop is executed at least once:
var text := new StringWriter();
doUntil(string line, line.isEmpty(), line := console.readLine())
{
text.writeLine(line)
};
== Classes, Fields Methods, Constructors ==
Everything in ELENA is a class. So to implement some tasks we will have to declare our own classes.
=== Declaring a simple class ===
Let's create a simple class :
import extensions;
class MyClass
{
// a field
string myString;
// an implicit constructor
constructor(string s)
{
myString := s
}
// an explicit constructor
constructor fromNuber(int n)
{
myString := n.toString();
}
// a method
printString()
{
console.printLine(myString)
}
}
public program()
{
// creating a class instance by sending new message to the class
var myClass := new MyClass("This is printed by my class.");
myClass.printString()
}
The output will be:
This is printed by my class.
*Note that in ELENA a class is an object itself and can be used by like any other object*
=== Class Inheritance ===
We may inherit our class. When the parent is not explicitly declared - the class inherits *system'Object* super class
import extensions;
class MyParent
{
constructor new()
{
console.printLine("Parent Constructor.")
}
printMe()
{
console.printLine("I'm a Parent Class.")
}
}
class MyChild : MyParent
{
constructor new()
<= new() // calling the parent constructor
{
console.printLine("Child Constructor.")
}
printMe()
{
// calling the parent method
super.printMe();
console.printLine("I'm a Child Class.")
}
}
public program()
{
var myClass := MyChild.new();
myClass.printMe()
}
The output is:
Parent Constructor.
Child Constructor.
I'm a Parent Class.
I'm a Child Class.
=== Private methods ===
It is possible to declare the private methods which cannot be called outside the class.
import extensions;
class MyClass
{
private printPrivate()
{
console.printLine("private print.")
}
printPublic()
{
console.print("Calling from public print - ");
// self is a reference to the current object
self.printPrivate()
}
}
public program()
{
// Note that if the constructor explicitly is not declared
// the system'Object one (without input parameters) is inherited
var myClass := new MyClass();
myClass.printPublic();
myClass.printPrivate()
}
The output is:
Calling from public print - private print.
mytest'$private'MyClass : Method printPrivate[0] not found
Call stack:
system'Exception#class.new[1]:exceptions.l(125)
system'MethodNotFoundException#class.new[2]:exceptions.l(236)
system'$inline16.start[0]:win32_app.l(313)
mytest'program.#invoke[0]:test.l(26)
system'$inline16.start[0]:win32_app.l(39)
system'#startUp:win32_app.l(52)
=== Properties ===
In normal case the class fields cannot be accessed outside the class. That's why we may declare special methods to access it:
import extensions;
class MyClass
{
int _x;
get int x() = _x; // get accessor
set x(int o) // set accessor
{
_x := o
}
}
public program()
{
var myClass := new MyClass();
myClass.x := 2;
console.printLine("MyClass.x=", myClass.x)
}
The output is:
MyClass.x=2
We may simplify our code if we will use **prop** field template:
import extensions;
class MyClass
{
int _x;
prop int x
{
get() = _x;
set(int val)
{
_x := val;
}
}
}
public program()
{
var myClass := new MyClass();
myClass.x := 2;
console.printLine("MyClass.x=", myClass.x)
}
Simple accessors can be omitted:
import extensions;
class MyClass
{
prop int x;
}
public program()
{
var myClass := new MyClass();
myClass.x := 2;
console.printLine("MyClass.x=", myClass.x)
}
== Exception Handling ==
We may use try-catch statement to handle the possible exceptions:
import extensions;
public program()
{
try
{
new Object().nonExistingMethod();
}
catch(MethodNotFoundException e)
{
console.printLine("Method not found")
}
catch(Exception e)
{
console.printLine("Unknown error")
}
}
The output is :
Method not found
== See also ==
* ELENA on [https://github.com/ELENA-LANG/elena-lang/ Github]
* ELENA on [https://www.reddit.com/r/elena_lang/ Reddit]
| 
