Просмотр исходного текста страницы Описание Expression Graph Scripting 2019

== Классификация ==
Язык EGS - компилируемый статически типизированный (с выведением типов) язык программирования для платформы .net, на данный момент сочетающий в себе только элементы функционального и императивного программирования. Язык EGS испытал влияние следующих широко известных языков: CoffeeScript, Lua, C# и SQL.<br />

== Ключевые слова ==
Следующие ключевые слова являются полностью зарезервированными:

<pre> true, false, on, off, yes, no, null, nil, it, new, try, let, if, switch, use, with, print, from, typeof, async, await, once, const, assert, eval, error, last_error, check.</pre>

Следующие ключевые слова являются частично зарезервированными, т.е. используются только в контексте соответствующих выражений:

<pre> not, mod, and, or, like, is, as, in, then, else, do, isnt, empty, to, at, first, last, single, count, min, max, average, sum, select, many, cast, of, type, any, all, reverse, order, by, where, while, skip, take, asc, desc, array, list, concat, intersect, union, except, now, end, bind, distinct, group, when, typedef.</pre>

== Комментарии ==
Поддерживаются однострочные комментарии начинающиеся с символа #

<pre> # only single line comments supported </pre>

== Идентификаторы ==
Идентификатор состоит из буквы или знака подчеркивания, за которым следует любое количество букв, цифр или символов подчеркивания.
Чтобы ссылаться на идентификатор с тем же написанием, что и ключевое слово, идентификатор должен иметь префикс с одним символом @.<br />

Некоторые примеры идентификаторов:

<pre> x, Hello, m_1, @true, @String </pre>

== Литералы ==

Язык выражений поддерживает следующие типы литералов:
# Целочисленные литералы. Например: 0, 123, 10000:
## Целочисленный литерал состоит из последовательности цифр.
## Тип целочисленного литерала - это первый из типов Int32, UInt32, Int64 или UInt64, который может представлять заданное значение.
## Целочисленный литерал неявно преобразуется в любой другой числовой тип, если число находится в диапазоне этого типа.
# Литералы с плавающей точкой(тип double). Например:  1.0, 2.25, 10000.0, 1e0, 1e10, 1.2345E-4:
## Литерал с плавающей точкой состоит из целой части, за которой следуют дробная часть и / или экспонента.
## Целая часть представляет собой последовательность из одной или нескольких цифр.
## Дробная часть представляет собой десятичную точку, за которой следуют одна или несколько цифр.
## Показателем является буква e или E, за которой следует необязательный знак + или -, за которым следуют одна или несколько цифр.
## Литерал неявно преобразуется в любой другой числовой тип с плавающей точкой, если находится в диапазоне этого типа.
# Строковые литералы(тип string). Например: "hello", `hello`, "", """quoted""", "'":
## Строковый литерал состоит из нуля или более символов, заключенных в двойные кавычки.
## Внутри строкового литерала двойная кавычка записывается как две последовательные двойные кавычки.
# Символьные литералы(тип char). Например: 'A', '1', '''', '"':
## Символьный литерал состоит из одного символа, заключенного в одинарные кавычки.
## Внутри символьного литерала одиночная кавычка записывается как две последовательные одиночные кавычки.

== Константы ==

# Предопределенные константы true, yes, on и false, no, off обозначают два значения типа bool соответственно.
# Предопределенные константы null и nil обозначают нулевую ссылку.
# Нулевая константа имеет тип object, но также неявно преобразуется в любой ссылочный тип.

== Типы ==
=== Встроенные типы ===
# Язык выражения определяет следующие примитивные типы :
## void - см. System.Void.
## string - см. System.String.
## char - см. System.Char.
## bool - см. System.Boolean.
## sbyte - см. System.SByte.
## byte - см. System.Byte.
## short - см. System.Int16.
## ushort - см. System.UInt16.
## int - см. System.Int32.
## uint - см. System.UInt32.
## long - см. System.Int64.
## ulong - см. System.UInt64.
## float - см. System.Single.
## double - см. System.Double.
## decimal - см. System.Decimal.
## object - см. System.Object.
## function - см. System.Delegate.
## Enum - см. System.Enum.
## Guid - см. System.Guid.
## DateTime - см. System.DateTime.
## TimeSpan - см. System.TimeSpan.
## Array - см. System.Array.
## Tuple - см. System.Tuple.
## Type - см. System.Type.
# Так же доступны следующие специфические типы из пространства имен acuario2:
## Status - см. acuario2.types.Status.
## Priority - см. acuario2.types.Priority.
## Param - см. acuario2.types.Param.
## AbstractObject - см. acuario2.types.AbstractObject.
## Pin - см. acuario2.types.Pin.
## Object - см. acuario2.types.Object.
## Event - см. acuario2.types.Event.
## GraphObject - см. acuario2.types.GraphObject.
## Item - см. acuario2.types.Item.
## Link - см. acuario2.types.Link.
## Graph - см. acuario2.client.Graph.
# На обнуляемую форму типа указывает вопросительный знак после имени типа. Например, bool? Обозначает обнуляемую форму bool.
=== Дополнительные типы ===
Только зарегистрированные типы могут быть явно указаны в выражениях, а вызовы методов в языке выражений ограничены методами, объявленными в зарегистрированных типах.
Дополнительные типы могут быть зарегистрированы во время исполнения при помощи следующих языковых конструкций:

# use NameSpace.TypeName [as Alias] [from AssemblyName|"AssemblyPath"]
# use NameSpace.TypeName(GenericTypeName1, ...) as Alias [from AssemblyName|"AssemblyPath"]
# use (StringExpression) [as Alias] [from AssemblyName|"AssemblyPath"]
# use new {...} as Alias
# use typedef `...` as Alias
<pre>
Где:
[...] - квадратные скобки выделяют необязательный элемент;
| - символ разделяющий альтернативные элементы;
, ... - означает повторение предыдущего элемента 1 или более раз;
new {...} - объявление нового типа, см. оператор new;
NameSpace - полное пространство имен типа;
TypeName - имя типа;
Alias - псевдоним типа;
AssemblyName- имя сборки содержащей тип;
AssemblyPath- полный путь к сборке содержащей тип;
GenericTypeName1 - первый аргумент общего типа;
StringExpression - выражение возвращающее строку и выполняемое на этапе компиляции, см. const;
typedef `...` - объявление нового типа с сигнатурой совместимой с Dynamic Typedef, см. TypeDef 2017, вещественные типы параметров при этом приводятся к обнуляемой форме (т.е. например: int к int?).
</pre>
Например:

<pre>
use System.Random
use acuario2.types.SpatialObject from acuario2.types
use acuario2.types.SpatialObject as SObj from acuario2.types
use System.Web.Script.Serialization.JavaScriptSerializer from "C:\Program Files (x86)\Reference Assemblies\Microsoft\Framework\.NETFramework\v4.5\System.Web.Extensions.dll" 
use System.Collections.Generic.Dictionary(string, object) as Dictionary
use ("System.Random") as Random
use new { a = 0, b = false, c = new [0], d = new { t = "" } } as JSON
use typedef 
`
    <root>
        <param name="url">http://localhost:1986/axis2/services/Iv7Server</param>
        <param name="max_zoom_distance" type="real">1500</param>
        <param name="max_zoom_limit_factor" type="real">1</param>
    </root>
` as Settings
</pre>
Оператор use можно использовать только на верхнем уровне скрипта, т.е. не допускается его использование внутри блоков кода и функций.

=== Преобразование типов ===
Следующие преобразования неявно выполняются языком:
# Из нулевого литерала до любого ссылочного типа или типа, допускающего значение null.
# Из целочисленного литерала до целочисленного типа или реального типа, если номер находится в диапазоне этого типа.
# Из реального литерала до реального типа, если номер находится в диапазоне этого типа.
# Из строкового литерала до типа перечисления, если строковый литерал содержит имя члена этого типа перечисления.
# Из строкового литерала до Guid, если строковый литерал конвертируется в Guid.
# Из исходного типа, совместимого с целевым типом в соответствии с методом Type.IsAssignableFrom.
# Из типа значения, не допускающего значения null, до формы, допускающей значение null для этого типа значения.
# Из числового типа к другому числовому типу с большим диапазоном.
# Из любого типа к типу object.

Язык допускает явные преобразования с использованием следующего синтаксиса:
# TypeName(Expression).
# TypeName?(Expression).
# TypeName[](Expression).

<pre>
Где:
? - указывает на обнуляемую форму типа
[] - указывает на массив типа
Expression - какое либо выражение преобразуемое к типу TypeName
</pre>

Этот синтаксис может использоваться для выполнения следующих преобразований:
# Между двумя типами при условии, что Type.IsAssignableFrom истинно в одном или обоих направлениях.
# Между двумя типами обеспечивается один или оба типа интерфейсов.
# Между нулевыми и ненулевыми формами любого типа значения.
# Между любыми двумя примитивными типами или типами перечисления.
# Из любого типа в стоку при помощи метода Object.ToString.
# Из строки в тип имеющий статический метод Parse(string).
# Из любого "нового" типа языка EGS (см. оператор new {...}) в строку содержащую его JSON представление.
# Из строки содержащей JSON в соответствующий "новый" типа языка EGS.
# Так же язык допускает явные преобразования при помощи оператора as из C# с использованием аналогичного синтаксиса: Expression as TypeName.

== Операторы ==
; Доступ к экземпляру поля или экземпляру
<pre>
Доступ к любому общему полю или свойству.
x.m
Так же возможен безопасный доступ к полю.
x?.m
В случае нулевого экземпляра возвращается значение по умолчанию типа поля.
Так же возможен как безопасный так и обычный доступ к полю имя которого рассчитывается на этапе компиляции, см. оператор const.
const m = "m" 
x.(m)
x?.(m)
</pre>

; Вызов метода экземпляра
<pre>
Метод должен быть общедоступным и должен быть объявлен в доступном виде.
x.m(…)
Так же возможен безопасный вызов метода экземпляра.
x?.m?()
в случае нулевого экземпляра возвращается значение по умолчанию типа результата метода.
</pre>

; Доступ к массиву или индексатору
<pre>
Многомерные массивы не поддерживаются.
x[…]
Так же возможен безопасный доступ к массиву или индексатору.
x?[...]
в случае нулевого экземпляра возвращается значение по умолчанию типа индексатора.
</pre>

; Статический доступ к свойствам
<pre>
Доступ к любому общему полю или свойству.
T.m
</pre>
; Вызов статического метода
<pre>
Метод должен быть общедоступным и должен быть объявлен в доступном виде.
T.m(…)
</pre>
; Явное преобразование или вызов конструктора
<pre>
Обратите внимание, что new не требуется перед вызовом конструктора.

T(…)
T?(…)
T[](…)
</pre>

; Текущий экземпляр
<pre>
В контексте, где члены текущего объекта неявно входят в область видимости, он используется для обращения к самому объекту целиком.
it
</pre>

; Отрицание
<pre>
Поддерживаются следующие типы: int, long, decimal, float и double.
-x
</pre>

; Логическое отрицание
<pre>
Операнд должен быть типа bool.
!x
not x
</pre>

; Умножение
<pre>
Поддерживаются следующие типы: int, uint, long, ulong, decimal, float и double.
x * y
</pre>

; Деление
<pre>
Поддерживаются следующие типы: int, uint, long, ulong, decimal, float и double.
x / y
</pre>

; Остаток
<pre>
Поддерживаются следующие типы: int, uint, long, ulong, decimal, float и double.
x % y
x mod y
</pre>

; Сложение или конкатенация строк
<pre>
Выполняет конкатенацию строк, если любой из операндов имеет тип string. В противном случае выполняется сложение для поддерживаемых типов int, uint, long, ulong, decimal, float и double, DateTime и TimeSpan.
x + y
</pre>

; Вычитание
<pre>
Поддерживаются следующие типы: int, uint, long, ulong, decimal, float и double, DateTime и TimeSpan.
x – y
</pre>

; Конкатенация строк
<pre>
Операнды могут быть любого типа.
x..y
</pre>

; Равенство
<pre>
Поддерживается для ссылочных типов и примитивных типов.
x == y
x is y
</pre>

; Неравенство
<pre>
Поддерживается для ссылочных типов и примитивных типов.
x != y
x <> y
x isnt y
x is not y
</pre>

; Меньше
<pre>
Поддерживается для всех примитивных типов, кроме bool, object и Guid.
x < y
</pre>

; Больше
<pre>
Поддерживается для всех примитивных типов, кроме bool, object и Guid.
x > y
</pre>

; Меньше или равно
<pre>
Поддерживается для всех примитивных типов, кроме bool, object и Guid.
x <= y
</pre>

; Больше или равно
<pre>
Поддерживается для всех примитивных типов, кроме bool, object и Guid.
x >= y
</pre>

; Логическое И
<pre>
Операнды должны быть типа bool.
x && y
x and y
</pre>

; Логическое ИЛИ
<pre>
Операнды должны быть типа bool.
x || y
x or y
</pre>

; Множественное сравнение
<pre>
Операции сравнения, такие как ==, !=, <>, <, >, <=, >=, можно применять к операндам по цепочке.
Например:
x1 < x < x2
Эквивалентно следующему:
(x1 < x) and (x < x2)
</pre>

; Оператор ?? (null-coalescing)
<pre>
Возвращает x если оно не равно null, иначе возвращает y.
x ?? y 
эквивалентно 
if x isnt null then x else y
Для переменных обнуляемых вещественных типов (например: int?), оператор возвращает необнуляемое значение x если само x не равно null, иначе возвращает y.
Если x является массивом, то
x ?? empty
возвращает x, если оно не равно нулю, иначе возвращает пустой массив соответствующего типа.
</pre>

; Оператор ??? (empty-coalescing)
<pre>
Возвращает x если оно является коллекцией, не равно null и не пусто, иначе возвращает y.
x ??? y
эквивалентно
if x isnt empty then x else y
</pre>

; Проверка типа
<pre>
Проверяет является ли x экземпляром типа T, либо конвертируемым в тип T при помощи оператора is.
x is T
x isnt T
x is not T
</pre>

; Проверка наличия значения
<pre>
Проверяет наличие значение выражения x обнуляемого или ссылочного типа.
x is null
x isnt null
x is not null
</pre>

; Преобразование типа
<pre>
Преобразовывает x в тип T при помощи оператора as из языка C# .
x as T
</pre>

; Проверка наличия элемента в коллекции
<pre>
Проверяет наличие элемента x в коллекции y.
Коллекция должна поддерживать интерфейс IEnumerable<T> или IDictionary<K,V>.
В случае если коллекция является словарем проверяется наличие ключа.
В случае если первый операнд является строкой, а второй типом перечислимого значения проверяется наличие такого значения в типе.
x in y
x is in y
x isnt in y
x is not in y
"EnumItem" in EnumType
</pre>

; Проверка пустоты коллекции
<pre>
Проверяет коллекцию x на существование и наличие в ней элементов.
x is empty
x isnt empty
x is not empty
</pre>

; Проверка подобия
<pre>
Проверяет соответствие x шаблону y при помощи оператора Like из языка Visual Basic .
x like y
x is like y
x isnt like y
x is not like y
Шаблон оператора поддерживает следующие контрольные символы:
? - Любой одиночный символ
* - Ноль или более символов
# - Любая цифра от 0 до 9
[ charlist ] - Любой одиночный символ в charlist
[! charlist ] - Любой одиночный символ, не включенный в charlist
</pre>

; Создание массивов
<pre>
Создает массив из элементов x1, x2, ..., xn.
Тип массива вычисляется из типов его элементов.
Если элементы имеют разный тип, то типом массива будет object[].
new [ x1, x2, ..., xn ]
Для создания типизированного но не заполненного массива любой длинны можно воспользоваться обычным вызовом конструктора.
string[](0)
int[](10)
</pre>

; Создание новых классов и их экземпляров
<pre>
Создает новый тип со свойствами x, y и т.д. и экземпляр этого типа.
Свойствам экземпляра присваиваются начальные значения X, Y, и т.д.
При регистрации нового типа оператором use константные значения из X, Y, и т.д. становятся значениями свойств по умолчанию.
new { x = X, y = Y, ... }
</pre>

; Создание наборов значений
<pre>
Создает набор из элементов x1, x2, ..., xn.
Набор соответствует типу Tuple платформы .net и таким образом его элементы могут иметь разный тип.
new ( x1, x2, ..., xn )
</pre>

; Присвоение
<pre>
Присваивает переменной, свойству или индексатору x значение выражения X и возвращает это значение.
x = X
y.x = X
y[x] = X
</pre>

; Обработка исключений
<pre>
Выполняет выражения x1,..., xn, в случае удачи возвращает xn, а в случае ошибки выполняет выражения y1,..., yn и возвращает yn.
xn и yn должны иметь конвертируемые типы.
При отсутствии оператора else, в случае ошибки возвращается значение по умолчанию типа выражения xn.
try x1; ...; xn else y1; ...; yn
try x1; ...; xn else y1; ...; yn
try x else y
try x
try x1; ...; xn 
Глобальная переменная last_error (типа System.Excetpion) содержит ссылку на последнюю произошедшую ошибку. Переменная доступна в любом месте кода.
</pre>

; Установка текущего экземпляра
<pre>
Устанавливает в качестве оператора it результат x и выполняет с ним блок операций y1,..., yn
with x do y1; ...; yn
with x do y1; ...; yn 
with x do y
Например:
x.p1 = y1; x.p2 = y2; x.p3 = y3
Эквивалентно следующему:
with x do p1 = y1; p2 = y2; p3 = y3
Члены объекта it имеют меньший приоритет нежели параметры скрипта, переданные ему при запуске и переменные объявленные во время исполнения скрипта видимые в текущем блоке кода.
Обращаться к членам it перекрытым параметрами и переменными можно следующим образом:
let p2 = 1
with x do 
  p1 = y1
  it.p2 = y2
end
</pre>

; Объявление переменных
<pre>
Объявляет переменную x типа выражения справа от = и присваивает ей результат этого выражения.
let x = 0
let x = false
let x = X
let x = T()
let x = null as T
Объявленная переменная видима во всем блоке, в котором она объявлена, начиная с места объявления.
Возможно повторное объявление переменных с тем же именем в том же блоке.
</pre>

; Объявление набора переменных
<pre>
Объявляет переменные с именами указанными в скобках и присваивает им соответствующие их месту элементы набора справа от знака равенства.

let (x, y) = new (1, true)
let (x, y) = new (1, 2, 3)
let (, x, y) = new (1, 2, 3) # элементы можно пропускать
let (x, y) = new (y, x)     # можно использовать для обмена значениями
</pre>

; Объявление переменных сохраняющих значение между вызовами
<pre>
Так же как и предыдущее, объявляет переменную x типа выражения справа от = и присваивает ей результат этого выражения, но делает это только при первом выполнении скрипта после компиляции. При последующих выполнениях переменная содержит тоже значение, однако может быть изменена при помощи присвоения.
once ticks = Environment.TickCount # присвоит при первом запуске и сохранит значение при последующих
Обращение к таким переменным потокобезопасно.
</pre>

; Объявление констант
<pre>
Объявляет константу x типа выражения справа от = и присваивает ей результат этого выражения, вычисляемого на этапе компиляции.
const x = 2
const xx = x * x
Следует помнить, что в отличии от других языков, EGS не поддерживает констант времени исполнения, выражения после const вычисляются на этапе компиляции, и таким образом ключевое слово const (равно как и use) являются директивами компилятора языка.
</pre>

; Объявление функций
<pre>
Объявляет функцию x с аргументами p1,..., pn заданных типов.
Тип результата вычисляется по типу последнего выражения в ее теле.

let f(p1 as T1, ..., pn as Tn) = x1; ...; xn
let f(p1 as T1, ..., pn as Tn) = x1; ...; xn 
let f() = x
f(p1, ..., pn)
f()
Параметры такой функции перекрывают внутри блока кода функции возможные имена внешних параметров скрипта и переменных объявленных ранее.
Альтернативный синтаксис позволяет создавать функции с именованными параметрами имеющими значения по умолчанию.
let f{p1 = X1, ..., pn = Xn} = x1; ...; xn
f{p1 = X1, ..., pn = Xn}
f{p1 = X1}
Функция с именованными параметрами, по сути, представляет собой обычную функцию с одним параметром установленным в качестве текущего экземпляра it.
Следовательно к именованным параметрам можно обращаться так же через it, что может быть необходимо так, как внешние параметры скрипта и переменные объявленных ранее перекрывают доступ к членам it.
Так же возможно расширение функционала оператора is при помощи объявления предикатов с одним или двумя параметрами.

let even(x as int) = x % 2 is 0
if even(x) then ...
if x is even then ...
let square(x as int, y as int) = x is y * y
if square(x, y) then ...
if x is square y then ...
</pre>

; Объявление обобщенных функций
<pre>
Обобщенные функции объявляются так же как обычные, но без указания типов аргументов.
Для определения типов аргументов, компиляция обобщенной функции откладывается то того момента в коде, когда она реально будет вызвана. Повторный вызов функции с отличными типами аргументов вызывает компиляцию еще одного ее варианта. Таким образом обобщенные функции похожи на макросы в других языках и компилируются в контексте вызова, а не определения.

let f(p1, ..., pn) = x1; ...; xn
let f(p1, ..., pn) = x1; ...; xn 
f(p1, ..., pn)
Параметры обобщенной функции перекрывают внутри блока кода функции возможные имена внешних параметров скрипта и переменных объявленных ранее.
Из-за отложенной компиляции в обобщенной функции видны не только определения сделанные раньше нее (как для обычных функций), но и те которые были сделаны вплоть первого вызова этой обобщенной функции с данным набором типов аргументов.
Таким образом для обобщенных функций возможен взаимный рекурсивный вызов.
</pre>

; Условный оператор
</pre>
В случае выполнения условия x выполняет выражения x1,..., xn, иначе в случае выполнения условия y выполняет выражения y1,..., yn, иначе выполняет выражения z1,..., zn.
В случае отсутствия последнего оператора else возвращает значение по умолчанию типа результата предыдущей условной ветки.
Если результаты веток оператора не возможно привести к общему типу, то ко всем веткам автоматически добавляется результат по умолчанию void().

if x then x1; ...; xn else if y then y1; ...; yn else z1; ...; zn
if x then x1; ...; xn else if y then y1; ...; yn else z1; ...; zn 
if x then x1 else y1
if x then x1
Если условием является простая проверка типа оператором is, то после имени типа можно указать имя переменной, которая в случае успеха проверки будет содержать значение приведенное к нужному типу например:

if x is Item i then print i.." is item" 
if x is Link l then print l.." is link"
</pre>

; Оператор множественного выбора
<pre>
В случае выполнения условия x is x1 выполняет выражение или блок y1, иначе в случае выполнения условия x is xN выполняет выражение или блок yN, иначе выполняет выражение или блок z.
В случае отсутствия последнего else возвращает значение по умолчанию типа результата предыдущей условной ветки.
Если результаты веток оператора не возможно привести к общему типу, то ко всем веткам автоматически добавляется результат по умолчанию void().

  switch x
    when x1 then y1
    ...
    when xN then yN
    else z
В качестве вариантов для выбора можно использовать любые конструкции языка, которые доступны оператору is, например:

  switch x
    when in new [1,2,3] then y1
    when in new [4,5,6] then y2
    ...
    else z

  switch x
    when like "begin*" then y1
    when like "*end"   then y2
    ...
    else z

  switch x
    when Item then x.." is item" 
    when Link then x.." is link" 
    when Pin  then x.." is pin" 
    else x.." is unknown" 

  switch x
    when Item i then i.." is item" 
    when Link l then l.." is link" 
    when Pin  p then p.." is pin" 
    else             x.." is unknown" 

  let even(x) = x % 2 is 0
  let odd(x)  = x isnt even

  switch x
    when even then x.." is even" 
    when odd  then x.." is odd"
</pre>

; Тип выражения
<pre>
Заменяет выражение константой содержащей его тип.
typeof x
typeof x.a
</pre>

; Асинхронное выполнение
<pre>
Выполняет выражение следующее после ключевого слова async асинхронно т.е. в другом потоке.

  let f(x as T) = ...
  async f(x)
  f(x)
</pre>

; Ожидание асинхронное результата
<pre>
Ожидает выполнения асинхронного выражения и возвращает его значение.

  let f(x as T) = ...
  await async f(x)
</pre>

; Печать
<pre>
Печатает в отладочный поток значение выражения x.
Печатает в отладочный поток значения выражений x1,..., xn через пробел.

print x
print(x)
print(x1, ..., xn)
</pre>

; Ошибка времени исполнения
<pre>
Вызывает исключение времени исполнения с текстом msg.
error msg
error(msg)
</pre>

; Проверка условия во времени компиляции
<pre>
Проверяет условие x во время компиляции, и в случае false вызывает ошибку компиляции со стандартным текстом (если специфический текст не указан вторым параметром).

assert x
assert(x)
assert(x, msg)
</pre>

; Выполнение выражения во времени компиляции
<pre>
Выполняет выражение во время компиляции и заменяет его на результат.
eval x
</pre>

; Помещение выражения в рамки
<pre>
Выражение должно состоять из одного или двух условий сравнения на <, <=, >, >= или !=, константных операндов и одного неконстантного операнда. Если выражение выполняется, то возвращается неконстантный операнд, иначе возвращается тот операнд который первым привел к невыполнению выражения, либо выражение после else, если указанно.

check x > 0
check 0 <= x <= 1
check (0 <= x/y <= 1)
check 0 < x < 1 else -1
</pre>

; Диапазон
<pre>
Создает коллекцию чисел типа int начиная с x и до y

from x to y
</pre>

== Операции над перечисляемыми типами ==
Поддерживаются следующие монадические операции над перечисляемыми типами:

<pre>
of type - фильтрует элементы IEnumerable на основе указанного типа.
from seq of type TypeName
</pre>

<pre>
cast to - преобразует элементы IEnumerable в указанный тип.
from seq cast to TypeName
</pre>

<pre>
select - проецирует каждый элемент последовательности в новую форму.
from seq select Selector
</pre>

<pre>
select many - проецирует каждый элемент последовательности в IEnumerable и выравнивает полученные последовательности в одну последовательность.
from seq select many Selector
</pre>

<pre>
where - фильтрует последовательность значений на основе предиката.
from seq where Predicate
</pre>

<pre>
any - определяет, удовлетворяет ли какой-либо элемент последовательности условию.
from seq any Predicate
</pre>

<pre>
all - определяет, удовлетворяют ли все элементы последовательности условию.
from seq all Predicate
</pre>

<pre>
count - возвращает количество элементов в последовательности. Возвращает число, которое представляет, сколько элементов в указанной последовательности удовлетворяют условию.
from seq count all
from seq count Predicate
</pre>

<pre>
min - вызывает функцию преобразования для каждого элемента общей последовательности и возвращает минимальное результирующее значение.
from seq min
</pre>

<pre>
max - вызывает функцию преобразования для каждого элемента общей последовательности и возвращает максимальное результирующее значение.
from seq max
</pre>

<pre>
sum - вычисляет сумму последовательности значений, которая получается при вызове функции преобразования для каждого элемента входной последовательности.
from seq sum
</pre>

<pre>
average - вычисляет среднее значение последовательности значений, которое получается при вызове функции преобразования для каждого элемента входной последовательности.
from seq average
</pre>

<pre>
distinct - возвращает уникальные элементы из последовательности с использованием сравнения по умолчанию.
from seq distinct
</pre>

<pre>
reverse инвертирует порядок элементов в последовательности.
from seq reverse
</pre>

<pre>
skip - обходит заданное количество элементов в последовательности, а затем возвращает остальные элементы.
from seq skip Count
</pre>

<pre>
skip while - обходит элементы последовательности, если указанное условие истинно, а затем возвращает остальные элементы.
from seq skip while Predicate
</pre>

<pre>
take - возвращает указанное количество смежных элементов с начала последовательности.
from seq take Count
</pre>

<pre>
take while или while - возвращает элементы последовательности пока указанное условие истинно.
from seq take while Predicate
from seq while Predicate
</pre>

<pre>
single и try single - возвращает единственный элемент последовательности. В случае отсутствия элементов либо наличия более одного элемента single генерирует исключение, тогда как try single возвращает значение по умолчанию.
from seq single
from seq try single
</pre>

<pre>
first и try first - возвращает первый элемент последовательности. В случае отсутствия элементов first генерирует исключение, тогда как try first возвращает значение по умолчанию.
from seq first
from seq try first
</pre>

<pre>
last и try last  - возвращает последний элемент последовательности. В случае отсутствия элементов last генерирует исключение, тогда как try last возвращает значение по умолчанию.
from seq last
from seq try last
</pre>

<pre>
at и try at - возвращает элемент по указанному индексу в последовательности. В случае отсутствия элемента по данному индексу at генерирует исключение, тогда как try at возвращает значение по умолчанию.
from seq at Index
from seq try at Index
</pre>

<pre>
order by - сортирует элементы последовательности в указанном порядке в соответствии с ключом.
from seq order by Selector
from seq order by Selector asc
from seq order by Selector desc
</pre>

<pre>
to array  -преобразует последовательность в массив.
from seq to array
</pre>

<pre>
to list - преобразует последовательность в список.
from seq to list
</pre>

<pre>
bind to - преобразует последовательность в словарь ключ/значение.
from seq bind KeySelector to ValueSelector
</pre>

<pre>
group by - группирует последовательность по ключу.
from seq group by KeySelector
</pre>

<pre>
concat - добавляет элементы второй последовательности в конец первой.
from seq1 concat seq2
from seq concat elem
</pre>

<pre>
intersect - вычисляет пересечение последовательностей.
from seq1 intersect seq2
from seq intersect elem
</pre>

<pre>
union - вычисляет объединение последовательностей.
from seq1 union seq2
from seq union elem
</pre>

<pre>
except - вычисляет разницу последовательностей.
from seq1 except seq2
from seq except elem
</pre>

<pre>
do - выполняет блок выражений expr1, ..., exprN для каждого элемента последовательности и возвращает it.
from seq do expr1; ...; exprN
from seq do expr
</pre>

<pre>
now  - Создает цикл и перебирает все элементы коллекции. Не имеет результата.
from seq do expr now
from a to b do expr1; ...; exprN now
</pre>
Все операции возвращающие другую последовательность кроме to array и to list являются ленивыми, т.е. реально выполняются только в момент когда начинается обращение к их элементам.

== Блоки кода ==
После ключевых слов then, else, do, try, а так же после символа = при описании функции может следовать как одно выражение так и блок выражений, при этом результатом блока становится результат последнего выражения.<br />
Если первое выражение блока начинается на той же строке, то остальные выражения блока следует разделять точкой-запятой. Блок считается завершенным, если после очередного выражения не следует точка-запятая.<br />
Если же первое выражение блока начинается на следующей строке или далее, то все выражения тела блока должны иметь большие отступы нежели строка породившая блок. Если отступ текущего выражения меньше или равен отступу этой строки, блок считается завершенным. При этом находящиеся на одной строке выражения блока следует разделять точкой-запятой, а для находящихся на разных строках разделение точкой-запятой необязательно. Конец блока можно пометить опциональным ключевым словом end.
<pre>
let a = 1

if a > 0 then print a 

if a > 0 then print a + 1; print a + 1

if a > 0 then
    print a + 2
    print a + 2
    print a + 2
end

if a > 0 then
    print a + 6;
    print a + 6
    print a + 6; print a + 6
    print a + 6; print a + 6;
    print a + 6
</pre>

== Граф ==
Все элементы графа унаследованные от базового Trigger имеют следующие внешние переменные:
# tigger - ссылка на сам триггер, тип Trigger.
# graph - ссылка на граф, тип Graph.
# firefly - ссылка на объект типа Firefly приложения Acuario Manager (доступно только при запуске в Acuario Manager).
Триггеры типа ObjectCreated и ObjectUpdated имеют следующие дополнительные внешние параметры:
# @object - добавленный или изменившийся объект, тип AbstractObject.
# changes - список имен измененных параметров объекта, тип string[].
Триггеры типа ObjectDeleted имеют следующие дополнительные внешние параметры:
# @object - удаленный объект, тип AbstractObject.