index<--

Eve Syntax

Page bookmarks

In this article you will learn about:

• elements
• punctuation
• comments
• identifiers
• globals
• expressions
• statements
• keywords
• delimiters
• operators

Design Strategy

Eve aims to strike a balance between a verbose, explicit syntax for learning purposes and a concise, intuitive syntax for ease of use. The goal is to design a syntax that is both descriptive and readable for beginners, while also being concise and "looking right" for experienced users.

Hello World

Example:

#demo: hello world
driver hello:

process:
  ** main process:
  print "Hello World!";
return;

In example above we have a script, the file name must be hello.eve. It consist of driver with name "hello". Inside we have a single main process that print to console "Hello World!". This is basicly a small Eve program.

Syntax Elements

# Eve programs start with a "driver"
driver syntax_elements(a, b: Integer):

** define two global lambda expressions
global
  set add = (p1, p2: Integer) => (p1 + p2);
  set sub = (p1, p2: Integer) => (p1 - p2);

process:
  ** the process use arguments -a -b
  print "param1: {a}, param2: {b}";

  ** define local variables
  new v1, v2 :Integer;
  
  let v1 := add(4, 5);
  let v2 := sub(5, 3);

  ** print the result
  print ("result:", v1); -- 9
  print ("result:", v2); -- 2
return;

Punctuation:

• Hash sign "#" is used for title comments,
• Subtitle comments are using two stars: "**";
• Single line comments start with two dashes : "--"
• Boxed comments are using Bee like notation: "+-...-+"
• Block comments are inspired from Java: "/* ... */"

Examples 2:

# boxed comments in Eve language
+--------------------------------------------
| Eve boxed comments can be used on top     |
| You can create a box using this new style |
--------------------------------------------+
driver comment_demo:

# line comments in Eve language
----------------------------------------------
-- Single line comments are inspired from Ada 
-- You can use these comments at end of lines 
----------------------------------------------
process:
  ** this comment style is inspired from "md"
  new a = 0, b = 1 :Integer;

  ** next demo use end of line comments:
  let a := a + b * -- end of line comments can
          (a - 1); -- be useful in expressions
return;

# Final Notes:
/*

-- Eve also has C legacy style comments. These are
used for notes or outline large blocks of code.

-- Eve block comments can be nested over boxed 
comments. So you can comment out large sections
of code that already have some comments.
*/

Notes:

• Block comments +-...-+ do not support nesting;
• You can use C block comments /*...*/ to exclude code;
• A statement can continue after end of line comment;
• After end of script, you can add notes on many lines;
• Single line comment like "//" is not valid in Eve;

Identifiers

The name of identifiers in Eve can have a length of 30 characters. A name starts with lowercase letters (a..z) or capital letters (A..Z) followed by one or more characters or numbers. No special characters or spaces are permitted in the name except underscore ("_"). An identifier can contain underscore and can start with underscore but it can not end with underscore and can not use two consecutive underscores.

These are valid identifiers

_
x, y, z
a1, a2, a3
thisIsOK
this_is_ok
_this_is_valid

These are invalid identifiers

1st
not_valid_
_not_valid_

To summarize, Eve identifiers follow a conventional naming style similar to many programming languages, with some additional restrictions on the use of underscores at the beginning, end, and consecutive positions within the identifier name.

Prefix & Sigil

Identifier prefix is used to declare a variable, but is not required when using the variable. A sigil is part of variable name and it must be used when you use the variable.

So in summary, Eve uses specific prefixes like * and @ to denote special parameter types, and sigils like _ and $ as part of variable names to indicate their scope and accessibility (protected or system-wide). This convention helps differentiate various types of identifiers and variables within the Eve programming language.

System Variables

System variables start with sigil: "$", that is making a "system state". System states are static and public, shared in a a process.

Notes:

• System sigil "$" is reducing collision with the local scope;
• A system constant is usually represented by a data literal;
• A system variable can be an object with attributes or a base type.

Globals

In any Eve script you can define global variables. These are primitive values or references to objects. A global variable is represented by an identifier and value. Type is optional hint. Global variables do not use a sigil.

Global variables can be declared using "set" statement. Initial value is establish with operator "=" follow by a type hint. Globals can be modified during the program execution using "let" statement with modifier operators like: { :=, ::, +=, -= ... }.

Globals example:

Most of the examples are also stored on GitHub. However it is possible the one in GitHub to be different from then the one in documentation. This is due to fast evolution of the language and not by intention. We declare globals outside of any process in a "global" region. You can use global keyword multiple times in a module but all globals are in the same memory heap and must be unique regarding the region they are defined in.

...
** define global system states
global
  set s = "test" :String;

  ** two integers
  set a :Integer;
  set b :Integer;

global
  ** one Real variable
  set d = 0.5 :Real;
...

Globals are staticly defined in module scope (global) scope. We use "set" keyword to create a global state. If the state alredy exist, it can be modified using "let" in a process or subprogram. Compiler will signal an error if you "set" a variable two times or if you use "set" in a process or in a subprogram. "set" can't change value of a variable.

Initial Value

The initial value can be establish using the initializer "=" (single equal). This operator can use only data literals but no expressions. It is not able to execute the right operator. That is, the initial value can be a constant literal or an expression but the expression is not evaluated.

Zero Values

When a variable is specified, with no initializer, the variables takes default zero values. These values are different for each data type. For example zero value for Integer = 0 for Real = 0.0 and for String = "" (empty string). Composite data types are initialized to "Empty", that is (), [], {}, all equivalent to "∅" used in set theory.

Cascade Initialization

Operator "=" is used to create an expression. That means you can initialize multiple variables using a single declaration. This is different than assignment ":=" or clone "::" that create a statement and not an expression. Operator "=" create a result, so it can be chained like in Python.

Fragment

...
process:
  new a = b = 1 :Integer;    -- create and initialize a,b 
  new x = y = z = 0.5 :Real; -- create and initialize a,y,z
  ...
return;

Expressions

An expression is a syntax element that can be evaluated using mathematical rules and principles. Expressions are created using identifiers, operators, functions and constant literals. Expressions can be grouped using round paranthesis (). Multiple expressions can be used in a statement.

expressions...

• can be combined to create more complex expressions;
• have a type that is logic determined using type inference;
• can be assigned to variables using ":=" or "?" operators;
• can be printed to console using "print" or "write" methods;
• can use () to clarify and enforce order of operations;
• can use () to encapsulate different kind of expressions;

Fragment

## simple expressions
process:
  print 10;
  write "this is a test";
  ** complex expressions can use grouping: ()
  print (10 + 10 + 15); -- numeric expression
  print (10 > 5) or (2 < 3); -- logical expression
  ** list of expressions are enclosed in ()
  print (1, 2, 3); -- expect: 1 2 3
  print (10, 11, 12); -- expect: 10 11 12
  ** using write to: avoid new line and print
  write (1,2);
  write (3,4);
  ** now create a new line and output the text
  print; -- 1234
  ...
return;

Notes:

• print can receive multiple arguments separated by comma,
• print will add new line by default,
• print will separate different values using one space,
• write will output to console and do not add new line,
• write do not separate values by using one space,
• print is used to flush the buffer, after several writes,

Assign Expression

In Eve, you can assign the result of an expression to a variable using the assignment operator :=. However, this operator exhibits a behavior that you must understand to avoid unintended side effects. When assigning a non-primitive (boxed) variable as an expression, the operator transfers the value by sharing a reference, rather than copying the value itself. This means that the new variable will reference the same underlying object as the original variable. In contrast, when assigning a primitive (native) type, the operator transfers the actual value, creating a separate copy of the data.

Assign: by reference

#expressions pseudo-code
  ...
  new identifier1 := literal;         -- constant literal
  new identifier2 := expression;      -- execute expression
  new identifier3 := function_name(); -- function call
  new identifier4 := variable;        -- borrow (create a refference or copy a value) 
  new identifier5 := native_var;      -- copy value
  ...

Assign: by value:

To make a deep clone/copy of an Object you must use clone operator that is (::) instead of (:=). This will transfer values of attributes, not references. After cloning, we can modify one value without affecting the original. Making a clone is not possible for native variables, it works only with objects.

Syntax:

// making a clone
  new object :: original;
  expect object is not original;

Note: For native type, the operator "is" do not work at all. Attempting to use "is" or "is not" with a native type will always return false even if the values are equal. For native types you have to use "==" to compare the values. For objects, "==" will execute deep comparison, and will return "True" if all object attributes or data elements have also equal values.

Ternary expression

The ternary operator in Eve is the "if" keyword. This keyword has actually two roles in EVE. It can be used to create a conditional statement or an expression. It can be used to return a value or other depending on one or several logical expressions. In other languages we use ternary operator "?" and ":" but in Eve these two symbols are used for more important other purposes.

Syntax:

# ternary expression
process:
** regular style using a single line of code:
  new variable1 := (value1 if condition else value2);

** alternative style using multiple lines of code:
  new variable2 := (value1 if condition1 else
                    value2 if condition2 else
                    value3);
  ...
return;

Example:

In next example we use a ternary expression as argument.

process:
  ** create a logic variable
  new test := True;
  ...
  expect (True if test else False); -- will pass
  ...
return;

driver assign_demo:
process:
  ** initialization statements
  new a :=  2;
  new b := .0;

  ** execute expression
  let b := a + 0.5;

  ** verification statements
  expect a == 2;
  expect b == 2.5;
return;

# multiple line demo
process:
  ** multi-row expression
  new var := 1
            +2
            +3 + 4 +
             5 + 6;

  ** multi-row literal
  new map := {
      'two' :2,
      'four':4,
      'six' :6
  };
return;

# , : . ; = ~ ? % ^ * - + / < > & | ! @ $

== !=  => <= >= :> <: .. !. !~ && || &=

.|. .&. .+. 

:: := += -= *= /= %= ^= +> <+ >> << -> <- 

"_" '_' (...) [...] {...} #(...)