index<--

Eve Syntax

Page bookmarks

In this article you will learn about:

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

Hello World

Example:

#demo: hello world
driver hello:

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

Syntax Elements

# main script in Eve is called: "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);

** define local variables
process
  ** main process has access to parameters
  print "param1: #{a}, param2: #{b}";

  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:

Comments

• 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:

# 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 aredy 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_

Prefix & Sigil

Indetifier 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.

System Variables

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

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 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 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.

Fragment

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

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

  ** one Double variable
  set $d = 0.5 :Double;

Globals are also called "state variables" because they are staticly defined in module scope. We use "set" keyword to create new states. If the state alredy exist, it can be modified using "let". Compiler will signal an error if you set a variable two times.

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 Double = 0.0 and for String = "" (empty string). Composite data types are initialized to "Null", 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 "=" has a result. So it can be chained.

Fragment

# multiple variables
process
  new a = b = 1 :Integer;
  new x = y = z = 0.5 :Double;
  ...
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 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 ()
  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

To assign result of an expression to a variable you can use assign operator: ":=". This operator has a strange behavior that you must understand to avoid unintended side-effects. When a boxed variable is used as an expression, the operator transfer a value "by sharing" a reference, so it does not "copy" the value but the reference to that value. When the type is native, the value is transfered and not the reference.

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 
  new identifier5 := native_var;      -- copy value
  ...

Assign: by value:

To make a clone/copy of an Object attributes you must use clone operator that is (::) instead of (:=). This will transfer values not references. After cloning, we can modify one value without affecting the original.

Syntax:

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

Note: Native types are exceptions. 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.

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;

Statements

One statement can be declarative or imperative. We use both but mostly declarative statements. Thoug many times the statements are imperative. I guess Eve is hybrid then.

• A statement is usually a single line of code,
• A statement can extend on several lines and finalize with ";"
• A group of several statements is called a code block,
• A block is finalized with one of thes: {"return", "repeat", "done"},
• A statement end with symbol ";", that is mandatory;

Single line statement

The most simple statements are definitely single line statements:

Fragment:

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;

Multi-line statements

One expression can span multiple lines.

• The expression may be enclosed in parenthesis or quotation marks;
• Arithmetic expressions can use an operator to continue on next line;

Example:

# 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;

Reserved keywords

Computer was invented in England during WW2, so we prefer English keywords, even though a computer language could be created using keywords from other spoken languages. Eve is using about 100 reserved keywords.

Definition regions

Semantic keywords

Blocks of code/sections

Operator keywords

Assign keywords

For any kind of assignment or modification you must us a specific keyword. This is why we use keywords like: {set, new, let}. User must read what's going on and will understand much better the code by using keywords.

Interruption statements

Delimiters

Operators

Eve us ASCII symbols for operators. One operator can be single character or two characters with no space between tem. Sometimes we use the same character twice for example "==" or ">>". This convention is well known in many other computer languages.

Single symbol:

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

Two symbols:

== !=  => <= >= :> <: .. !. !~ 

Three symbols:

""" .|. .&. .+. 

Modifiers:

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

Delimiters:

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

Single symbols

Eve use al single symbols found on a standard keyboard.

Double symbols

Eve use two symbols to create supplementary operators.

String concatenation

Numeric operators

Relation Operators

Eve use two symbols to create a additional operators.

Modifiers

Each modifier is created with pattern "?=", where "?" is a symbol, haiving one of these values: {:, +, -, *, /, %, ^}. Also the symbol "::" is a modifier.

Logical operators

These operators are expected logical values T = True, F = False

Unary operator: not

• not False = True
• not True = False

Table of truth

Bitwise operators

These operators are working for natural numbers ≥ 0

Binary operators

Unary operators

Quick Format

For printing output using a format we use operator as that is the "quick format" operator. We can use system constant templates that are available for making different formats for different data types. This operator is a bit smarter than the "?" operator that we can use for "string templates".

Date Format

Time Format

Numeric Format

Read next: Structure