Ключевое слово V/var



Данное ключевое слово используется для того, чтобы объявить переменную в текущем блоке кода:
V variable_name = value

Можно объявить группу переменных, инициализированных кортежем:
F get_row_column() // функция, возвращающая кортеж
   ...
   R (row, col)
...
V (row, col) = get_row_column() // аналогично такой записи: `V rc = get_row_column(); V row = rc[0]; V col = rc[1]`

Также допустимо частичное объявление:
(V row2, col) = get_row_column() // `col` уже объявлена выше, `row2` создаётся/объявляется в этой строке
или:
(row, V col2) = get_row_column() // `row` уже объявлена выше, `col2` создаётся/объявляется в этой строке

Чтобы объявить и назначить некоторое значение сразу нескольким переменным используйте такую запись ({…}):
V a = V b = 0

Для объявления константы используйте 
-V
/
-var
:
-V constant_name = value
[{…}]

Чтобы сократить количество ключевых слов 
V
/
var
, можно использовать дополнительный scope. Например, такой код:
-V
   n_rows = 10
   n_cols = 10
   grid_size = n_rows * n_cols
   min_words = 25
эквивалентен такому:
-V n_rows = 10
-V n_cols = 10
-V grid_size = n_rows * n_cols
-V min_words = 25


V?
и 
V&


V? i = ‘str’.find(‘s’)

F print_set(DefaultDict[Int, Set[Int]] ↦ key)
   V& s = map[key] // `V s = map[key]` писать нельзя (но можно `V s = copy(map[key])`)


I V


I (V&? sheep = Sheep?(animal)) != N
   print(sheep.some_sheep_prop)
можно сократить {…} до:
I V sheep = Sheep?(animal)
   ...
т.к. в 11l нет скрытого/неявного копирования.

И также как в Swift {…} запись 
I (V sheep = Sheep?(animal)) {...}
запрещена.

Однако, в 11l также можно писать так:
I T(animal) == Sheep // или `I T(animal) >= Sheep`
   print(animal.some_sheep_prop)

Также обратите внимание:
I V v = ... // `v` ведёт себя как константная ссылка, поэтому
   v = ...  // так писать нельзя

// А если хочется иметь возможность писать `v = ...`, тогда:
I V& v = ...   // пишите так
I V v = copy(...) // или так
[Это/‘такое поведение’ может показаться странным, но подобный прецедент в 11l уже есть: 
L(el)
vs 
L(&el)
, а также аргументы функций (которые неизменяемы ‘по умолчанию’/‘без квалификаторов’).
Впрочем, несмотря на запрет 
v = ...
вызывать неконстантные методы 
v
допускается (в целях удобства).]

V E


Вместо:
V&? el = map.get(key)
I el == N
   print(‘Key <’key‘> is not found!’)
   R
лучше писать:
V& el = map.get(key) E
   print(‘Key <’key‘> is not found!’)
   R
Данный синтаксис был навеян 
guard let
{…} из Swift, но он достаточно логичный, т.к.
V& el = map.get(key)!
то же самое, что
V& el = map.get(key) E
   X.throw NullPointerException()