DemonScript: Структуры данных

Строки

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

var S = "это 'простая' строка"
Строки можно складывать (конкатенация строк) и складывать с числом (оно преобразуется в строку). Метод .size() возвращает длину строки: 
out "aaa" + "bbb"                  //> aaabbb
out "aaa" + 5                      //> aaa5
out "aaa".size()                   //> 3        : длина строки

Массивы

Массив - это список констант или переменных любых базовых типов. Элементы массива заключаются в квадратные скобки и перечисляются через запятую: 

var A = [1, 2, True]
out A.type()                       //> array
out A                              //> [1, 2, True]
out A[2]                           //> True
A[0] = False                       //> меняем элемент массива
out A                              //> [False, 2, 3]
out A.size()                       //> 3   : число элементов в массиве
К элементам массива возможен индексный доступ, в котором первый элемент имеет нулевой индекс. Выше A[2] возвращает третий элемент.

Элементы массива можно добавлять в массив и убирать их из него: 

var A = []                         // пустой массив
A.push(1)                          // добавили один элемент 
A.push(2, 3)                       // ещё два в конец
out A                              //> [1,2,3]

out A.pop()                        //> 3  : выталкиваем из конца
out A                              //> [1,2]
Аналогично, при помощи методов .unshift() и .shift() можно добавлять и извлекать элементы в начале массива. Элементы можно случайно перемешивать методом .mix(). Метод .clear() очищает массив, а .empty() возвращает True, если массив пустой. Полный перечень методов см. в справочнике.

Элементами массива могут быть другие массивы. Это позволяет организовывать как двумерные массивы, так и массивы любой размерности: 

var A = [[1,2], [3,4]]             // двумерный массив
out A[0]                           //> [1,2]
out A[0][1]                        //> 2

При присваивании переменных типа array происходит не копирование данных, а передача ссылки на данные. Переменные ссылающиеся на один и тот же массив, могут одновременно менять его элементы. Чтобы скопировать данные, необходимо вызвать метод .copy(): 

var A = [1,2,3]       
var B = A                          //> это тот же массив
var C = A.copy()                   //> это другой массив (копия)
B[0] = 0
C[0] = 4
out A,B,C                          //> [0,2,3] [0,2,3] [4,2,3]

Логическое значение можно преобразовать в массив: 

var X = (0.1, 0.8).array()
out X                              //> [0.1, 0.8]
Аналогично, при помощи .logic() можно массив превратить в логическое значение.

При помощи цикла for можно перебирать элементы массива: 

for X in [1, 2, 3]:
   out X                           // 1 2 3

Хэш-таблицы

Хэш-таблица или map является коллекций данных организованных по принципу ключ-значение. В качестве ключа могут выступать любые типы, однако значение ключа должно быть уникальным. Значение, соответствующее ключу также может быть любого типа и, в отличии от ключа, может повторяться. Доступ к значениям по ключу осуществляется при помощи квадратных скобок: 

var M = { "a": 1, "b": 2};        // объявляем таблицу

out M["a"];                       //> 1 (выводим значение для ключа "a")
M["a"] = 8;                       // меняем значение ключа "a"

out M                             //> {a:8, b:2} (выводим всю таблицу)
Элементы таблицы можно переберать при помощи оператора for: 
for K in M:
   out K, M[K]                    // выводим ключ K и значение его данных M[K]
Если нужен и ключ и значение, то несколько быстрее будет работать следующая конструкция: 
for K,V in M:
   out K, V                      // выводим ключ K и значение его данных V

При помощи квадратных скобок, в хэш-таблицу можно также добавлять новые элементы: 

var M = { };                     // пустая таблица

M["a"]  = 1;                     // добавляем один ключ (строка), значение - число
M["b"]  = [1,2, 3];              // ещё один ключ (строка) - значение массив
M[3.14] = True                   // ещё один ключ (число) - значение логическая константа

out M                            //> {3.14:True, a:1, b:[1,2,3]}

Нечёткие числа

Нечёткое число это некоторое вещественное значение и его возможный диапазон. Например, если вес объекта примерно равен 50, но может также находиться в интервале от 30 до 60, пишем: 

var X = (30, 50, 60)            
out X.type()                     // fuzzy
Предполагается, что X=50 с максимальной (единичной) степенью уверенности, а вне диапазона 30...60 значение X не находится. От 50 к 30 и 60 степень уверенности спадает линейным образом (треугольное распределение).

Можно также использовать трапецевидные нечёткие числа, которые задаются четвёркой вещественных чисел: 

var Y = (30, 40, 50, 60)
В этом случае существует единичная уверенность, что число Y находится в интервале 40..50. Треугольное нечёткое число является частным случаем трапецевидного числа. Так, X эквивалентно можно записать как (30, 50, 50, 60).

На самом деле треугольные нечёткие числа хранятся как трапецевидные. Доступ к диапазонам на чтение и запись производится при помощи квадратных скобок: 

out X[0], X[1], X[2], X[3]        //> 30 50 50 60

С нечёткими числами можно проводить стандартные арифметические операции: 

out X + Y                         //> ( 60,90,100,120)
out X - Y                         //> (-30, 0, 10, 30)
out X * Y                         //> (900,2000,2500,3600)
out X / Y                         //> (0.5, 1, 1.25, 2)