Самостоятельное изучение Рефала-5. Взгляд студента. [Dynamical Refal. Динамический Рефал.]

Отредактируйте страницу и нажмите Сохранить. Прочтите syntax для ознакомления с синтаксисом вики. Пожалуйста, редактируйте только в том случае, если планируете улучшить содержимое. Если Вы просто хотите потестировать что-либо, воспользуйтесь специальной страницей: playground.

====== Самостоятельное изучение Рефала-5. Взгляд студента. ======

== Рефал-5. Учебное пособие. ==

Васильева Екатерина, 
  студент УдГУ,
  2009-2010г.

===== Содержание =====
   - Структура программы
    - Переменные    
    - Предложения   
    - функции
   - Рекурсия
   - Рефал-машина
   - Взаимодействие функций
   - Стандартные функции
    - Функции ввода/вывода
    - Функции обработки символов и строк
    - Арифметические функции
   - Рефал-условия
   - Глоссарий
   - Ответы к упражнениям
   ===== Структура программы =====
Как правило, чем серьёзнее задачи, для которых создавался язык, тем сложнее «костяк» программы для него. Однако хоть Рефал и создан для решения серьёзных задач, структура его программ довольно проста.

$ENTRY Go 
  {
      = <Функция1 аргумент_для_передачи> ;
  }
  Функция1 
  {
      Предложение1; /* комментарий */
      Предложение2;
      Предложение3;
      Предложение4;
  }

$ENTRY это служебное слово, значение которого для нас пока не важно и мы просто будем всегда писать его перед функцией Go и не обращать внимания

Программа состоит из функций. 
Вызов функции выглядит так: \\
<Имя_функции  аргумент_функции>
На место своего вызова функция всегда возвращает некоторое значение, возможно пустое.

Функции состоят из предложений. Список предложений помещается в фигурные скобки:
  Имя_функции
  { 
    список предложений
  }
Предложения состоят из левой и правой части, которые разделены знаком равенства: \\
  левая часть =  правая часть;
Левая часть предложения содержит некий образец, а правая часть – результат.  \\
  образец = результат;
Обе части предложения могут содержать переменные. \\
После каждого предложения ставится точка с запятой.

Работа программы на Рефале происходит за счёт двух механизмов:
  - Сопоставление
  - Подстановка

Механизм сопоставления можно представить следующим образом: возьмём  лист бумаги формата А4, это будет наш «образец». Попробуем приложить (сопоставить) его к папке для бумаг, сопоставление будет успешным. Если приложить (сопоставить) этот лист к пачке бумаги, из которой его достали, то сопоставление снова будет успешным. Если же приложить этот лист к круглой мишени для дартса, то сопоставление будет неудачным, так как у них разная форма.

По аналогии можно работать и с текстами. Самым простым примером является кроссворд. Допустим, у нас есть пять пустых клеточек (образец). \\

^ ° ^ ° ^ ° ^ ° ^ ° ^

Берём слов «Рефал» и сопоставляем с образцом. Сопоставление успешно, так как в слове «Рефал» ровно пять букв и для каждой есть место (клеточка).

^ Р ^ е  ^ ф ^ а ^ л ^

Берём слово «Паскаль» и сопоставляем с образцом.

^ П  ^ а ^ с ^ к ^ а ^

Сопоставление неудачно, в слове «Паскаль» семь букв, клеточек не хватает.

Механизм подстановки – это замена переменных, содержащихся в левой или правой части предложения на их значения. \\
Продолжая аналогию с кроссвордами, это, по сути, занесение каждой буквы в свою клеточку \\
То есть ДО подстановки:

^ ° ^ ° ^ ° ^ ° ^ ° ^
 ⇑  ⇑  ⇑  ⇑  ⇑  \\
 **Р е ф а л**

а ПОСЛЕ подстановки:

^ Р ^ е  ^ ф ^ а ^ л ^

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

В программе обязательно должна присутствовать функция Go, с неё интерпретатор начинает исполнять программу. У функции Go в качестве аргумента пустое выражение, поэтому в списке предложений функции Go обязательно должно быть предложение с пустой левой частью (образцом).

Помимо пользовательских функций (которые описывает сам пользователь) в Рефале есть много стандартных функций, в том числе для ввода/вывода, для арифметических функций и т.п. Подробное их описание приведено ниже (раздел Стандартные функции).

Теперь попробуем понять, как написать Hello World, используя наши знания:
  $ENTRY Go 
  {
       = <Prout 'Hello World!'>;
  }
При запуске этой программы, интерпретатор вызовет функцию Go с аргументом «пустое выражение», найдет в списке предложений функции Go такое, чтобы его образец успешно сопоставился с аргументом (в нашем случае только одно предложение и его образец как раз представляет собой «пустое выражение») и выполнит правую часть найденного предложения. Стандартная функция вывода <Prout> возвращает на место своего вызова пустое значение, по сути, она только лишь производит вывод на экран своего аргумента. То есть с помощью стандартной функции на экране появится желанный Hello World!

==== Переменные ====

Те, кто изучал Паскаль, наверняка привыкли, что тип переменной задается в начале программы, а дальше используется только её имя. В языке Си, переменные уже можно вводить в разных местах программы, но тип переменной снова указывается лишь один раз. В Рефале у переменных так же есть типы и имена, но их представление отличается от Паскаля и С.

Переменная всегда указывается вместе с её типом:
  * Тип_переменной . Имя_переменной

pascal: 
  var i : char
  i = 'a'   // i - переменная типа char для одного байта

С: 
  char i
  i = 'b'  //  i - переменная типа char для одного байта

Refal:
  s.i    //  i - переменная типа s для одного Рефал-символа (например, текстового символа)

Само назначение переменных в Рефале отличается от Паскаля, Си и им подобных языков. В них переменные используются, например, для прохождения цикла (переменная подсчета итераций i в циклах for и while). В Рефале же переменные используются для сопоставления  образца (в левой части предложения) с аргументом функции.

В языке Рефал  всего три типа переменных
  * s – для обозначения символов
  * t –  для обозначения термов
  * e – для обозначения объектного выражения
//Символ// в Рефале – неделимый элемент, атом. Символами являются символы-имена (например названия функций), натуральные числа, действительные числа и знаки клавиатуры.

Символ-имя (идентификатор, термальное слово, текстовый терм) – последовательность текстовых символов, начинающаяся с буквы и которая может включать буквы, цифры, дефисы - и подчеркивания _. \\
Примеры правильных идентификаторов: 
   * **A** 
   * **A1** 
   * **Y1x2Y3**
   * **Tom_Jerry**
Чтобы использовать в идентификаторах другие символы, кроме букв и цифр, нужно обязательно использовать двойные кавычки: **”Идентификатор+1”**. Если идентификатор заключен в двойные кавычки, то он может начинаться с любого символа.
(Если необходимо использовать двойные кавычки как символ, то их нужно экранировать слешем: 'Это двойная кавычка: \” и мы её видим).

Все печатные знаки клавиатуры могут использоваться в качестве символов. Текстовые символы необходимо заключать в одинарные кавычки: 
  * **'a'** 
Для удобства, текстовые символы можно соединить в цепочку: 
  * **'abcdefg'**  – последовательность из семи текстовых символов 
(Чтобы использовать кавычку как текстовый символ, её нужно экранировать слешем: 'Это кавычка: \' и мы её видим'.) \\
Следует помнить, что **A** и **'A'** – это не одно и то же, **A** – идентификатор, **'A'** – текстовый символ.

Натуральные числа также являются символами. Они представляют собой положительные целые числа в диапазоне от 0 до 232-1. Чтобы сделать число отрицательным, нужно поместить перед ним текстовый символ **'-'** (обязательно в одинарных кавычках). 
  * **'-'23**  – правильная запись отрицательного числа 
Наверное, вы уже поняли, что **'1'** и **1** – это также не одно и то же? Первый – текстовый символ, а второй – натуральное число.
Более подробно использование целых и действительных чисел будет описано в разделе «Для продолжающих».

Все символы можно сопоставлять с переменными **s**-типа. \\
Например, если аргумент функции это символ **'А'**, и в одном из предложений функции есть образец (вспомните лист бумаги формата А4) 
  * **s.symbol**
то **'А'** успешно сопоставится с переменной **s.symbol** и эта переменная приобретёт значение

**'А'**.

Если же аргумент функции это  **'ab'**, то с образцом **s.symbol** он уже не сопоставится, для успешного сопоставления будет необходим образец 
  * **s.symbol1 s.symbol2** 
после сопоставления (слева направо, помним об этом), значение переменной **s.symbol1** будет

равно  **'a'** а значение переменной  **s.symbol2** равно **'b'**.

Если аргумент функции это символ  **”Термальное слово”**, то при сопоставлении с образцом 
  * **s.symbol** 
переменная **s.symbol** приобретёт значение **”Термальное слово”**.

//Терм// – это либо символ, либо выражение в структурных скобках.
Цепочка символов термом является, только если она заключена в структурные скобки.

Все термы можно сопоставлять с переменными **t**-типа.

Структурные скобки являются специальными знаками Рефала. Это круглые скобки: **( )**.

Структурные скобки обязательно должны быть сбалансированы.
Нужны они для того, чтобы выделять в строке, которую надо обработать, некоторые структуры. \\
Например, у нас есть два слова. И мы хотим проверить, чтобы количество букв во втором слове было равно пяти. Но, если мы просто передадим два слова как аргумент функции, то они слипнутся в одну строку. Чтобы этого не случилось, мы каждое слово поместим в структурные скобки: 
  * **('Изучаю')( 'Рефал')**
Для проверки условия, что во втором слове пять букв, нам нужен следующий образец:
  * **t.word1 (s.1 s.2 s.3 s.4 s.5)** 
При сопоставлении **t.word1** приобретёт значение **('Изучаю')**, а s-переменные: **'Р' 'е' 'ф'

'а' 'л'** соответственно.

Если аргумент функции это символ  **”Слово”**, то он сопоставим с образцом
  * **t.symbol** 
и после сопоставления переменная **t.symbol** приобретёт значение **”Слово”**.

//Объектное выражение// – произвольная последовательность //символов//, сбалансированная по скобкам, но без  переменных. Иными словами – последовательность //термов//, возможно пустая (буквально ничего не содержащая).
Примеры объектных выражений:
  - **ABCDEFGH**
  - **(A ' - ' C)(B ' - ' D)**
  - **( Hello world ' (' and Good bye ' )')**
Примеры последовательностей, не являющихся объектными выражениями:
  - **((((**  – не сбалансирована по скобкам
  - **( ABC ') '**  – так же не сбалансирована по скобкам, поскольку закрывающая скобка обозначена одинарными кавычками и следовательно является текстовым символом.

С переменными e-типа может быть сопоставлено любое объектное выражение.

Например, если аргумент функции это цепочка символов **'Refal'**, и есть образец
  * **e.string**
то **'Refal'** сопоставится с переменной **e.string** и эта переменная приобретёт значение

**'Refal'**.

Если аргумент функции это **('I') 'know it'**, то он сопоставим со следующими образцами:
  * **(s.symb) e.string**   – **s.symb** примет значение **'I'**, **e.string** – **'know it'**
  * **t.symb e.string**   – **t.symb** примет значение **('I')**, **e.string** – **'know it'**
  * **(e.symb) e.string**  – **e.symb** примет значение **'I'**, **e.string** – **'know it'**
  * **(t.symb) e.string**   – **t.symb** примет значение **'I'**, **e.string** – **'know it'**
  * **e.symb e.string**    – **e.symb** будет пустым, **e.string** – **('I') 'know it'**

__Упражнения:__
  - С какими образцами сопоставимо выражение **('Кто') ”сказал” 'мяу?'**?
  - Какие значения приобретут переменные после сопоставления выражения  **'Я' ”изучаю”

('Рефал')** с образцом **t.symb s.symb2 e.string**?

==== Предложения ====
Рефал-предложения это та «канва», по которой «вышивается» программа. Описывая нужный образец в левой части, и результат в правой, мы определяем дальнейший ход программы. То, что функция содержит целый список предложений, позволяет создать огромную сеть возможных ходов. Именно поэтому язык Рефал так удобен при обработке текстов. Не обязательно писать кучу условий, каждое Рефал-предложение – это маленькое условие, которое описано в образце и дальнейшие указания, 
которые описаны в результате.

Однако чтобы использовать этот мощный инструмент, необходимы теоретические знания. 
Поэтому введём несколько новых определений. Они очень пригодятся для дальнейшего описания языка, поэтому их лучше запомнить.

//Рефал-образец// – отличается от объектных выражений тем, что может включать переменные.
Примеры Рефал-образцов:
  - **s.symb 'word'** 
  - **(e.word) t.letter ”TERM”**

//Результатное выражение// – объектное выражение, содержащее переменные и вызовы функций.
Примеры результатных выражений:
  - **s.symb <Function1 'word' >**
  - **'Refal' e.string <Function2 e.string>(e.word) t.letter ”TERM”**

//Открытые переменные// – переменные, которым ещё НЕ задано значение.

//Закрытые переменные// – переменные, которые не сами получают значения, а ссылаются на значения открытых. Можно сказать, что закрытые переменные – это ссылки на открытые переменные.

Не забываем, сопоставление производится слева направо. \\
Пример: 
  * **ABCD s.1 F e.2 XW s.1**
Первая слева переменная **s.1** и переменная **e.2** являются открытыми,  тогда как вторая переменная **s.1** закрытая, её значение должно совпадать со значением первой переменной **s.1**. И все последующие переменные, которые будут совпадать по типу и имени с уже использованными в предложении, являются закрытыми.

Пример: 
  * **s.1 s.1 s.1 s.1 s.1**
Первая переменная **s.1** открытая, остальные 4 переменных закрытые.

Рефал-переменная «живёт» в том предложении, в котором используется. В другом предложении можно снова использовать переменную такого же типа и с таким же именем, но к переменной в предыдущем предложении она не будет иметь никакого отношения.

//Рефал-предложение// – структура вида //левая-часть// = //правая-часть// \\
где левая часть – выражение-образец, а правая часть – результатное выражение, причём правая часть может включать только такие переменные, которые входят также и в левую часть, то есть только закрытые переменные.

Понять суть Рефал-предложений может помочь аналогия с Паскалем:
  * Рефал:  образец1 = результат1;
  * Паскаль: **if** сопоставляется(образец1 , аргумент_функции) **then** результат1

Примеры Рефал-предложений:
  - **s.symb e.other = s.symb <Function1 e.other >;**
  - **'Здравствуйте' e.string  'До свидания' = <Prout e.string>;**

Примеры ошибочно составленных Рефал-предложений:
  - ** s.symb1 s.symb2 = <Function1 e.other >;** – переменной **e.other** нет в левой части, следовательно её использование в правой части запрещено
  - **'Refal' e.string  <Prout e.string> = ;** – левая часть предложения должна быть выражением-образцом, а выражение-образец не может включать в себя вызовы функций.

Рассмотрим пример программы, которая меняет местами слова во введенной строке.

$ENTRY Go 
  {
        = <Function  "Мама" "мыла" "раму" > ;
  }
  Function 
  {
         t.word1 t.word2 t.word3 = <Prout t.word3 t.word1 t.word2>;
  }

Предложение
  * **t.word1 t.word2 t.word3 = <Prout t.word3 t.word1 t.word2>;**
можно прочитать как: 
  * «Если аргумент это три терма, то меняем их местами и выводим на экран»

Если запустить данную программу на интерпретаторе, то произойдёт следующее:

1. Вызовется стандартная функция **Go** с пустым выражением в качестве аргумента

2.  Пустое выражение сопоставится с образцом предложения 
  *** = <Function  ”Мама” ”мыла” ”раму” > ;**
И произойдёт вызов функции Function с аргументом ”Мама” ”мыла” ”раму”

3. Аргумент **”Мама” ”мыла” ”раму”** сопоставится с образцом предложения
   * **t.word1 t.word2 t.word3 = <Prout t.word3 t.word1 t.word2>;**
**t.word1** приобретёт значение **”Мама”** \\
**t.word2** приобретёт значение **”мыла”** \\
**t.word3** приобретёт значение **”раму”**

4. Переменные в правой части предложения заменятся на их значения, то есть теперь правая часть будет выглядеть как 
   * **<Prout ”раму” ”Мама” ”мыла” >;**
5. Стандартная функция Prout выведет на экран свой аргумент **”раму” ”Мама” ”мыла”**

__Упражнения:__
  - Напишите программу, которая выводит первые пять символов, разделяя их пробелами.
  - Запустите программу из последнего примера. В каком виде функция **Prout** выдаст результат на экран?

==== Функции ====
Функция, как Вам уже известно, состоит из списка Рефал-предложений. Этот список необходим для того, чтобы предусмотреть для входных данных различные сценарии обработки.

Порядок предложений в функции играет огромную роль. Потому что предложения обрабатываются последовательно: сначала первое, если его образец не сопоставим с аргументом, то проверяется второе и так далее, пока не найдется сопоставимый образец.
  Функция
  {
     образец1 = результат1;
     образец2 = результат2;
     образец3 = результат3;
     образец4 = результат4;
  }

Если снова провести аналогию с Паскалем, то это будет выглядеть примерно так:
  if сопоставляется(образец1 , аргумент) then результат1
  else if сопоставляется(образец2 , аргумент) then результат2
  else if сопоставляется(образец3 , аргумент) then результат3
  else if сопоставляется(образец4 , аргумент) then результат4
  else ошибка_программы

Рассмотрим пример функции, которая в зависимости от введенного ответа выдает различные сообщения. 
В данном примере будет использована стандартная функция ввода **<Card>**, она возвращает на место своего вызова введённое с помощью клавиатуры значение.

$ENTRY Go 
  {
     = <Answer <Card>>;
  }
  Answer 
  {
     'yes' = <Prout 'Отлично!'>;
     'no' = <Prout 'Очень жаль…'>;
     e.other = <Prout 'Некорректный ответ'>;
  }

При запуске этой программы на интерпретаторе

1.  Вызовется стандартная функция **Go** с пустым выражением в качестве аргумента

2.  Пустое выражение сопоставится с образцом предложения
  * **= <Answer <Card>>;**
И произойдёт вызов функции **Answer** с введенным с терминала значением в качестве аргумента.

3. Если мы ввели **'yes'**, то стандартная функция **Prout** выведет на экран свой аргумент 
  * **'Отлично!'** \\
Если мы ввели **'no'**, то стандартная функция **Prout** выведет на экран свой аргумент 
  * **'Очень жаль…'** \\
Если мы ввели что-то другое, то стандартная функция **Prout** выведет на экран свой аргумент 
  * **'Некорректный ответ'**

А теперь попробуем поменять порядок предложений в функции **Answer**:
  Answer 
  {
     e.other = <Prout 'Некорректный ответ'>;   
     'yes' = <Prout 'Отлично!'>;
     'no' = <Prout 'Очень жаль…'>;
  }

Если мы запустим программу с такой функцией, то каким бы ни был передаваемый аргумент, в ответ всегда будет выводиться фраза «Некорректный ответ», потому что при сопоставление с образцом первого в списке предложения
  * e.other = <Prout 'Некорректный ответ'>;   
будет успешно при любом аргументе.

===== Рекурсия =====

//Рекурсия// – это вызов функции из неё же самой (прямая рекурсия) или через другие функции (сложная рекурсия), например функция **F1** вызывает функцию **F2**, а **F2** вызывает функцию **F1**.

Обычно в языках программирования (Паскаль, Си) рекурсия организована с помощью механизма «стек вызовов». Каждый рекурсивный вызов функции записывается в этот стек. Однако каждый вызов требует определенного количества памяти, и когда вызовов слишком много, может произойти переполнение стека.
 
В функциональных языках (Рефал – это функциональный язык) рекурсия организована по-другому. 
Рекурсия в Рефале это не обязательно рекурсия как в Паскале. Например, если 
  F 
  {
      образецN = <F ...>; 
  }
то в терминах Паскаля это итерация, потому что первый вызов функции **F** не откладывается, а заменяется вызовом функции **F** с другим аргументом. Все как в итерациях Паскаля: вызов функции просто повторяется несколько раз, изменяется только аргумент.

Рассмотрим пример рекурсивной программы. 
Задача: определить, является ли строка палиндромом (палиндром – строка, которая читается одинаково слева направо и справа налево).

Проверка будет осуществляться по следующему алгоритму:
  - Пустая строка – палиндром
  - Строка из одного символа – палиндром
  - Если первый и последний символы строки совпадают, то строка палиндром, если после удаления первого и последнего символа она является палиндромом
  - Если ничего из вышеперечисленного не подходит, то строка не палиндром.
Предложения в функции проверки будут соответствовать алгориму

$ENTRY Go 
  {
     = <Palindrom <Card>>;
  }
  Palindrom 
  {
      = <Prout 'Да'>; /* Пустая строка – палиндром */
     s.symb = <Prout 'Да'>; /* Строка из одного символа – палиндром */
     s.symb e.string s.symb = <Palindrom e.string>; /* и последний символы строки совпадают, откусываем их и снова отдаем на проверку функции Palindrom*/
     e.other = <Prout 'Нет'>; /* ничего из вышеперечисленного не подходит, строка не палиндром  */
  }

Основное рабочее предложение в этой функции:
  * **s.symb e.string s.symb = <Palindrom e.string>;**
Постепенно «откусывая» одинаковые символы, мы придём либо к пустой строке (если количество символов было чётным), либо к единичному символу (если количество символов было нечётным). Оба этих случая указаны в предложениях
  * **= <Prout 'Да'>;**
и
  * **s.symb = <Prout 'Да'>;**
Предложение 
  * **e.other = <Prout 'Нет'>;**
указано в самом конце, чтобы не ломать работу функции, если его указать в начале, то функция не дойдёт до рекурсии.

__Упражнения:__
  - Изменить функцию Answer таким образом, чтобы запрашивала ответ, до тех пор, пока он не станет корректным.

===== Рефал-машина =====
Чтобы писать программы на Рефале нужно понимать, как они исполняются интерпретатором. Поэтому в данном разделе мы рассмотрим принцип работы Рефал-машины. 
Для описания этого принципа введём новое определение

//Активное выражение// – отличается от объектных выражений тем, что может включать вызовы функций.

Примеры:
  - <Function <Card> >
  - 'text' <Function e.string>

Чтобы было понятнее, все эти выражения можно представить так:
  * Результатное выражение = активное выражение, содержащее переменные
  * Активное выражение = объектное выражение, содержащее вызовы функций
  * Рефал- образец = объектное выражение, содержащее переменные

//Рефал-машина// – это такое абстрактное устройство, которое пошагово выполняет программу. \\
Она состоит из двух хранилищ информации: поля программы и поля зрения. \\
В поле программы перед началом работы помещается описание всех функций, и в процессе работы оно уже не меняется. \\
В поле зрения находится активное выражение, которое в процессе работы изменяется. \\
Возьмём в качестве примера программу про палиндромы
  $ENTRY Go 
  {
     = <Palindrom <Card>>;
  }
  Palindrom 
  {
      = <Prout 'Да'>; 
     s.symb = <Prout 'Да'>; 
     s.symb e.string s.symb = <Palindrom e.string>; 
     e.other = <Prout 'Нет'>;  
  }

Работает Рефал-машина пошагово.

1.  Первый шаг

Сначала в поле зрения попадает:
  * **<Palindrom <Card> >**
На каждом шаге Рефал-машина выбирает крайнее левое активное подвыражение, не содержащее внутри себя других вызовов функций (самая левая пара угловых скобок, внутри которых угловых скобок больше нет). В нашем случае это
  * **<Card>**
Это стандартная функция, её вызов просто заменяется на введённое с помощью клавиатуры значение, например **'казак'**

2. Второй шаг

В поле зрения теперь находится 
  * **<Palindrom 'казак'>**
Рефал-машина выбирает крайнее левое активное подвыражение, не содержащее внутри себя других вызовов функций (самая левая пара угловых скобок, внутри которых угловых скобок больше нет). Сейчас это всё содержимое поле зрения целиком
  * **<Palindrom 'казак'>**
При вызове функции в виде **<имя_функции   аргумент>**, в поле программы находится описание функции (в данном случае **Palindrom**) и  аргумент (**'казак'**) сравнивается последовательно с образцами предложений функции, начиная с первого. \\
Первое предложение из функции  **Palindrom** не подходит
  * **= <Prout 'Да'>;** 
так как его образец это пустое выражение \\
Поскольку сопоставление неудачно, Рефал-машина переходит ко второму. И так пока не найдется предложение, образец которого можно сопоставить с аргументом.
  * ** s.symb e.string s.symb = <Palindrom e.string>;** 
После нахождения подходящего предложения, остальные предложения функции остаются без внимания.

Далее работа с найденным предложением такова: переменные заменяются соответствующими значениями 
  * **s.symb = 'к'**
  * **e.string = 'аза'**
в левой части предложения из образцового выражения получается объектное выражение
  * **'к'  'аза'  'к'**
все переменные правой части предложения принимают соответствующие значения и результатное выражение становится активным выражением:
  * **<Palindrom 'аза'>**
Теперь вызов функции, с которым работала Рефал-машина удаляется из поля зрения и на его место ставится полученное активное выражение. 
  * **<Palindrom 'аза'>**
На этом шаг заканчивается, и начинается следующий.

Нетрудно догадаться, что работа Рефал-машины продолжается до тех пор, пока в поле зрения не окажется объектное выражение (то есть не содержащее больше вызовов функций). Это объектное выражение является результатом работы Рефал-машины.
В примере результатом работы Рефал-машины будет пустое выражение, возвращенное стандартной функцией **Prout**.

Теперь, основываясь на теории, рассмотрим пример:

Во введенной пользователем строке заменить все буквы b на bb

$ENTRY Go 
  {
         = <Prout <Change <Card>>> ;
  }
   Change 
  {
          e.left_part 'b' e.right_part = e.left_part 'bb' <Change e.right_part >;
          /*вынося e.left_part 'bb'   за пределы повторного вызова функции Change, мы не теряем это выражение, оно остается в поле зрения благодаря тому, 
           что является  частью аргумента функции <Prout>, а эта функция выполнится только когда функция Change вернет не свой очередной вызов, 
           а объектное выражение*/
          e.other = e.other;
  }

Наглядно работу поля зрения для этой задачи можно представить в виде таблицы:

В данном примере функция **Change** рекурсивная, т.к. в процессе выполнения вызывает саму себя.
 
Работа Рефал-машины осуществляется следующим образом:

В поле зрения попадает  
  * **<Prout <Change <Card> > >**,
 выполняется крайнее левое активное выражение – **<Card>**, которое возвращает введённую пользователем строку, например **'aaabcccbddd'**.

Далее в поле зрения находится 
  * **<Prout <Change 'aaabcccbddd'> >**, 
выполняется вызов функции **Change**, в поле программы находится описание этой функции и выбирается первое подходящее предложение
  * ** e.left_part 'b' e.right_part = e.left_part 'bb' <Change e.right_part >;** 
**'aaabcccbddd'** сопоставляется с образцом, переменная **e.right_part** приобретает значение **'aaa'**, переменная **e.right_part** – **'cccbddd'**.

Правая часть предложения преобразуется в 
  * **'aaa' 'bb' <Change 'cccbddd '>** 
и передается в поле зрения в качестве результата

Поле зрения теперь содержит:
  * **<Prout 'aaa' 'bb' <Change 'cccbddd '> >**
Из поля зрения выбирается крайнее левое активное выражение, не содержащее в аргументе вызовов функций – **<Change 'cccbddd '>**

И так далее, пока в поле зрения не окажется 
  * **<Prout 'aaa' 'bb' 'ccc' bb' 'ddd ' >**
Результат выведется на экран, а в поле зрения вернётся пустое выражение. Работа Рефал-машины пришла к нормальному останову.

Теперь, когда Вы будете писать программы, рисуйте для себя табличку и пошагово разбирайте, как работает Рефал-машина. Глубокое понимание принципа, по которому исполняется программа, позволит писать более эффективные алгоритмы.

__Упражнения:__
  - Нарисовать таблицы работы поля зрения для программы про палиндромы при вводе строки 'казак' или строки 'револьвер'
  - Написать программу, которая заменяет все буквы «a» на «b». К этой программе составить таблицу работы поля зрения при вводе строки 'ararar'

===== Взаимодействие функций =====

Взаимодействие между функциями в Рефал-программе может производиться различными способами.

1. Вложенные вызовы функций.
  * **F {  e.X = <F3 <F2 <F1 e.X> > >  }**

Каждая из трех функций, F1 и т.д., ничего не знает о других. Она оставляет свое значение в поле зрения, а следующая функция принимает его.

Пример.
Задача: Во введенной строке заменить: **'a'** на **'aa'**, **'b'** на **'bbb'**, **'с'** на **'cccc'**

Для каждой замены удобно написать отдельную функцию
  $ENTRY Go 
  {
       = <Prout <Change3<Change2 <Change1 <Card>>>> >;
  }
  Change1 
  {
       e.1 'a' e.2 = e.1 'aa' <Change1 e.2>;
       e.other = e.other;
  }
  Change2 
  {
       e.1 'b' e.2 = e.1 'bbb' <Change2 e.2>;
       e.other = e.other;
  }
  Change3 
  {
       e.1 'c' e.2 = e.1 'cccc' <Change3 e.2>;
       e.other =  e.other;
  }

Функция **Change1** получит введённую с терминала строку, заменит в ней все буквы **'a'** на **'aa'**, полученный результат через поле зрения попадёт к функции **Change2**, которая произведёт замену **'b'** на **'bbb'** и через поле зрения результат попадёт к функции **Change3**.
Функция **Change3** заменит все буквы **'с'** на **'cccc'** и окончательный результат через поле зрения попадёт к функции **Prout**, которая выведет его на экран.

Этот способ имеет то преимущество, что функции не зависят от их содержимого, то есть их можно использовать и в других частях программы, не опасаясь увидеть неожиданный результат.

2.  Приведённый выше пример можно изменить так, чтобы результат передавался следующей функции через одно из предложений. \\
Результат для передачи мы будем собирать в функциях в структурные скобки.

$ENTRY Go 
  {
      = <Prout <Change1 () <Card>>> ;
  }
  Change1 
  {
      (e.string) e.1 'a' e.2 = <Change1 (e.string e.1 'aa') e.2>;
      (e.string) e.other = <Change2 () e.string e.other>;
  }
  Change2 
  {
      (e.string) e.1 'b' e.2 =  <Change2 (e.string e.1 'bbb') e.2>;
      (e.string) e.other = <Change3 () e.string e.other>;
  }
  Change3 
  {
      (e.string) e.1 'c' e.2 =  <Change3 (e.string e.1 'cccc') e.2>;
      (e.string) e.other =  (e.string e.other);
  }

Теперь, результат работы функции **Change1** передается непосредственно функции **Change2**. 
Результат работы **Change2** передается непосредственно **Change3**. А результат работы **Change3** отправляется на экран.

Этот способ удобен, когда функция имеет различных преемников в различных предложениях.

Но самый простой (и самый правильный) способ решения этой задачи – простая рекурсия:

$ENTRY Go 
  {
       =  <Prout<Change <Card>> >;
  }
  Change 
  {
      'a' e.e = 'aa' <Change e.e>;
      'b' e.e = 'bbb' <Change e.e>;
      'c' e.e = 'cccc' <Change e.e>;
       s.s e.e = s.s <Change e.e>;
       /*пусто*/ =  /*пусто*/;
  }

3.  Функции можно вызывать и последовательно:
  * **<F1> <F2> <F3>**
Каждая из трех функций, **F1** и т.д., ничего не знает о других и не передаёт им значений.
Пример:
Задача: Запросить у пользователя две строки. В первой строке заменить все запятые на **', блин,'**. Во второй строке заменить все запятые на **', нуууу,'**. Вывести изменённые строки на экран.

$ENTRY Go 
  {
       =  <Prout<Change1 <Card>> '   ' <Change2 <Card>>>;
  }
  Change1 
  {    
     e.left ',' e.right = e.left ', блин,' <Change1 e.right>;    
     e.other = e.other;    
  }
  Change2 
  {    
     e.left ',' e.right = e.left ', нууу,' <Change2 e.right>;    
     e.other = e.other;    
  }

Функция **Change1** заменяет запятые в первом предложении, функция **Change2** заменяет запятые во втором предложении.

===== Стандартные функции =====

Рефал содержит библиотеку стандартных встроенных функций.

Она включает:
  * Функции ввода/вывода
  * Функции обработки символов и строк
  * Арифметические функции

Это те функции, которые не могут быть заданы на самом языке Рефал.

Подробное описание встроенных функций приведено в руководстве В.Ф. Турчина:
[[http://www.refal.net/refer_r5.html#C]]

==== Функции ввода/вывода  ====

Ввод/вывод с терминала – это использование функций <Card> и <Prout>, которые вы уже освоили, поэтому рассмотрим ввод/вывод через файлы

Задача:
На основании файла file1.txt создать файл file2.txt, в котором все строки file1.txt повторяются

2 раза

$ENTRY Go 
  {
          = <Open 'r' 1 'file1.txt'> <Open 'w' 2 'file2.txt'> <Create <Get 1>> ;
  }
  Create  
  {
          0 = ;   /* признак конца файла */
          e.other = <Putout 2 e.other> <Putout 2 e.other> <Create <Get 1>>; /* считываем строку из файла 1 и дважды записываем её в файл 2 */
  }

__Упражнения:__
  - Записывать в файл строки, введенные с терминала, пока не будет введено слово 'stop'
  - Написать программу, создающую копию файла.

==== Функции обработки символов и строк ====

Задача: сосчитать количество символов в строке

$ENTRY Go 
  {
        = <Prout <Result  <Lenw <Card>> >> ;
        /* сразу отправляем входную строку текстовых символов функции Lenw */
  }
  Result 
  {
        s.A e.1 = 'V stroke "' e.1 '"  simvolov: ' s.A; 
        /* функции Result был передан результат работы функции Lenw:  число и исходная строка*/
         e.other = <Prout 'Error'>;
  }

==== Арифметические функции ====

Стандартно арифметические функции вызываются так: 
  * **<Имя_функции (число1) (число2)>**
Структурные скобки ставить не обязательно. \\
Если Вы передадите функции не натуральное число, а текстовый символ, то программа выдаст ошибку. Поэтому не забывайте преобразовывать текстовые символы в числа.

Задача:
Подсчитать количество символов в строке (НЕ используя функцию <Lenw>)

$ENTRY Go 
  {
      = <Prout <Get_number  <Card> >> ;
  }
  Get_number 
  {
      s.A e.1 = <Add 1 <Get_number e.1>>; 
      /* «откусываем» от строки по одному символу, одновременно формируя цепочку вызовов функции Add:
      <Add 1 <Add 1 <Add 1 ….>…>> */
      e.other = 0; 
      /*  когда символов в строке не останется, то цепочка вызовов функции Add станет такой:
      <Add 1 <Add 1 <Add 1 … <Add 1 0>…>>  и далее спокойно вычислится*/
  }

__Упражнения:__
  - В файле находится список чисел, каждая строка содержит одно число. Найти сумму всех чисел и вывести её на экран.
  - Игра "Угадай число". Один пользователь вводит число, а второй должен его угадать, программа выводит «больше», «меньше» или «угадал!».
  - Найти сумму цифр введённого числа, дописав одну строчку в программе:

$ENTRY Go 
  {
       = <Prout <Summ  <Card>>> ;
  }
  Summ 
  {
        ????????=   ?????????;
        e.other = 0;
   }

===== Рефал-условия =====

Прежде чем рассказывать про Рефал-условия, решим уже изученными методами задачу:

«Задана строка. Определить, является ли эта строка записью натурального числа.
(натуральное число может содержать незначащие нули: 000123)»

Большинство новичков решает данную задачу так

$ENTRY Go 
  {
       = <Prout <Comparing <Card> >> ;
  }
  Comparing 
  {
       '0' = 'yes';
       '1' = 'yes';
       '2' = 'yes';
       '3' = 'yes';
       '4' = 'yes';
       '5' = 'yes';
       '6' = 'yes';
       '7' = 'yes';
       '8' = 'yes';
       '9' = 'yes';
       '0' e.string = <Comparing e.string >;
       '1' e.string = <Comparing e.string >;
       '2' e.string = <Comparing e.string >;
       '3' e.string = <Comparing e.string >;
       '4' e.string = <Comparing e.string >;
       '5' e.string = <Comparing e.string >;
       '6' e.string = <Comparing e.string >;
       '7' e.string = <Comparing e.string >;
       '8' e.string = <Comparing e.string >;
       '9' e.string = <Comparing e.string >;
        e.other = 'It is not digit';
  }

Данная программа выглядит очень просто, но что делать, если мы не ограничиваемся только цифрами, а используем какой-то другой набор символов, например латинские буквы. Переделывать программу, добавляя новые и новые предложения, будет сложно и нерационально, поэтому лучше ее изменить. Например, так:

$ENTRY Go 
  {
       = <Prout <Comparing <Card> >> ;
  }
  Comparing 
  {
       T = 'True!';
       F e.string = 'It is not digit';
       T e.string = <Comparing e.string>; 
       s.symb e.string = <Comparing <In_Digits s.symb In <Digits>> e.string>;  
       e.other  = 'It is not digit';
  }
  In_Digits 
  {
       s.symb In e.left_part s.symb e.right_part = T;
       e.other = F;
  }
  Digits 
  {
       ='1234567890';
  }

Она работает аналогично, только для проверки каждого символа создана специальная фунция **In_Digits**, а для хранения нужных символов – функция **Digits**.
Конечно, теперь мы можем определить и проверить сколько угодно символов, но для этого нам пришлось описывать дополнительные функции, да и программа выглядит уже не так просто. Решить эту проблему можно с помощью Рефал-условий:

$ENTRY Go 
  {
       = <Prout <Comparing <Card> >> ;
  }
  Comparing 
  {
       s.symb, <Digits>: e.A s.symb e.B  = True;
       s.symb e.string, 
                       <Digits>: e.left_part s.symb e.right_part  
                                                                 =  <Comparing e.string>;
       e.other  = 'It is not digit';
  }
  Digits  
  {
       ='1234567890';
  }

Теперь проверка символов осуществляется внутри Рефал-предложений, без вызова дополнительной функции **In_Digits**.

Если проводить аналогию с другими языками, то Рефал-условия напоминают WHERE конструкцию языка SQL.

Рефал-условие это конструкция, которая записывается после образца, в левой части Рефал-предложения в виде:
  * **, РВ : ПО**
где **РВ** – результатное выражение, а **ПО** – произвольный Рефал-образец.

Пример: \\
  * **' Привет,' e.name '  ' e.secondname, e.name: 'Иван' = <Prout e.secondname>;**
Если значение переменной **e.name** совпадет с **'Иван'**, то на экран выведется фамилия

Единственным ограничением для результатного выражения является то, что оно должно включать только те переменные, которые имеют определенные значения на момент проверки условия (закрытые переменные). Выражение-образец в правой части условия может включать как закрытые переменные, так и  открытые переменные, которые еще не были определены и получают значения в процессе проверки условия (вычисления условия).

При проверке условия Рефал-машиной, **РВ** сопоставляется с **ПО**, так же как аргумент функции сопоставляется с образцом  Рефал предложения.

В предложении могут встретиться несколько Рефал-условий. В этом случае условия будут вычисляться (проверяться) по очереди.

Вычисление условия  происходит следующим образом:
  * Рефал-машина порождает новое поле зрения, в которое помещает результатное выражение условия, заменив переменные в этом выражении на их значения. Далее Рефал-машина работает над этим полем зрения как обычно, пока его содержимое не станет объектным выражением.
  * Полученный результат сопоставляется с образцом условия. \\
Если сопоставление успешно, то проверяется следующее условие. \\ 
Если все условия выполнены, то предложение применимо. \\
Если сопоставление одного из условий терпит неудачу, то Рефал-машина возвращается к предыдущему условию (либо образцу Рефал-предложения, если это первое по очередности) и продолжает перебирать варианты сопоставления начиная от прошлого состояния. \\
Если больше не остается вариантов сопоставления, то предложение неприменимо и Рефал-машина переходит к следующему предложению функции.
  * После того как проверка условия завершается успехом либо неудачей, временное поле зрения, созданное для аргумента условия уничтожается, и Рефал-машина возвращается  к полю зрения, из которого вызывался аргумент.

Пример использования Рефал-условий.

Задача: Для студентов организовано N кружков. Имеются списки студентов, подавших заявления на вступление в каждый кружок. Однако в деканате решили, что один студент может вступить не более чем в два кружка. Проверить списки заявлений и выдать список студентов, подавших заявления в 3 и больше кружков. Список каждого кружка - это файл, а один член кружка – строка в файле.

$ENTRY Go 
  {
       =  <Select>;
  }
  Select 
  {    
      = <Prout <Select1 <ReadAllFile 'list1.txt'><ReadAllFile 'list2.txt'><ReadAllFile 'list3.txt'><ReadAllFile 'list4.txt'>>>;        
  }
  ReadAllFile 
  {
     ( e.text  ( e.e 0 ) ) = e.text ( e.e );
     ( e.text ) = <ReadAllFile  ( e.text ( <Get 1> ) )>;
     e.filename = <Open 'r' 1 e.filename><ReadAllFile  ( ( <Get 1> ) ) >;
  }
  Select1
  {    
       (e.result) e.left_part t.A e.right_part,
                                              <Oneof t.A  e.right_part>: T e.string1, 
                                                                                     <Oneof t.A e.string1>: T e.string2 
                                                                                                                        = <Select1 (e.result t.A)  e.string2>;
       () e.other = 'No';
       (e.result) e.other =(e.result);
  }
  Oneof 
  {
      t.A  e.left_part t.A e.right_part =  T e.left_part e.right_part;
      t.A e.other = F;
  }

Функция **ReadAllFile**  считывает строки всех файлов, заключая каждую строку в структурные скобки. Функция **Select** создает общий список студентов и сохраняет его в переменную **e.N**. Далее из этого списка выбираются фамилии, встречающиеся 3 и более раз. Для этого дважды используется условие с функцией **Oneof**. \\
Функция **<Oneof t.A  e.2>** проверяет наличие терма **t.A** в **e.2**.

__Упражнения:__
  - В файле1 находится список предложений. Выбрать те из них, которые являются палиндромами (используя Рефал-условия) и записать в файл2.
  - В файле находится список студентов. Каждый студент – отдельная строка в файле в формате 'Фамилия Имя Отчество'. Найти однофамильцев и вывести на экран их список.
  - Файл представляет собой записную книжку. Каждая строка содержит дату в формате ДД/ММ/ГГГГ и список дел на эту дату. Пользователь вводит с терминала нужную ему дату. На экране должен появиться список дел на этот день.

===== Глоссарий =====
**//Активное выражение//** – последовательность термов, сбалансированная по скобкам, может включать в себя вызовы функций.

**//Выражение-образец//** – последовательность термов, сбалансированная по скобкам, может включать в себя переменные.

**//Закрытая переменная//** – переменная, ссылающаяся на значение открытой переменной.

**//Объектное выражение//** – последовательность термов, сбалансированная по скобкам (возможно пустая).

**//Открытая переменная//** – переменная без значения; переменная, впервые встречающаяся в предложении.

**//Подстановка//** – замена переменных, содержащихся в левой или правой части предложения на их значения.

**//Поле зрения//** – часть Рефал-машины, хранилище данных, в котором находятся пошагово изменяющиеся активные выражения.

**//Поле программы//** – часть Рефал-машины, хранилище данных, в которое помещаются определения всех функций программы.

**//Пользовательская функция//** – функция, определённая пользователем.

**//Рекурсия//** – это вызов функции из неё же самой (прямая рекурсия) или через другие функции (сложная рекурсия).

**//Результатное выражение//** – последовательность термов, сбалансированная по скобкам, может включать в себя переменные и вызовы функций.

**//Рефал//** – Рекурсивных Функций Алгоритмический Язык – функциональный язык программирования.

**//Рефал-машина//** – абстрактное устройство, выполняющее Рефал-программу.

**//Сопоставление//** – проверка соответствия выражения некоторому образцу.

**//Стандартная функция//** – функция, входящая в библиотеку стандартных встроенных функций Рефала.

**//Терм//** – Рефал-символ, либо выражение в структурных скобках.

**//Терминал//** – устройство ввода/вывода (монитор с клавиатурой).

===== Ответы к упражнениям =====

Раздел "Структура программы", подраздел "Переменные"

1. 
  * **(s.1 s.2 s.3)  t.word s.4 s.5 s.6**
  * **t.1 t.2 e.other**
  * **t.1 e.other**
  * **e.other**
  * **(e.word) s.word2 e.other**
  * **t.word s.1 s.2 s.3 s.4** 
2.
  * **t.symb –  'Я'** 
  * **s.symb2 – ”изучаю”**
  * **e.string –  ('Рефал')**

Раздел "Структура программы", подраздел "Предложения"

1.
  $ENTRY Go 
  {
        = <Function  'строка символов' > ;
  }
  Function 
  {
         s.1 s.2 s.3 s.4 s.5 e.other = <Prout s.1 ' ' s.2 ' ' s.3 ' ' s.4 ' ' s.5>;
  }

2. **раму Мама мыла**

Раздел "Рекурсия"

1.
  $ENTRY Go 
  {
     = <Answer <Card>>;
  }
  Answer 
  {
     'yes' = <Prout 'Отлично!'>;
     'no' = <Prout 'Очень жаль…'>;
     e.other = <Prout 'Некорректный ответ'><Answer <Card>>;
  }

Раздел "Рефал-машина"

1.1

1.2

2.

Раздел "Стандартные функции", подраздел "Функции ввода/вывода"

1. 
  $ENTRY Go 
  {
      = <Open 'w' 1 'text.txt'>  <Write_in_file  <Card>>;
  }
  Write_in_file 
  {
     'stop' = ; 
     e.string = <Putout 1 e.string > <Write_in_file  <Card>>; 
  }
2.

$ENTRY Go 
  {
      = <Open 'r' 1 'data1.txt'> <Open 'w' 2 'data2.txt'> <File_copy <Get 1>>;
  }
  File_copy 
  {
     0 = ;
     e.string 0 = <Putout 2 e.string>; /*если в файле нет пустых строк*/
     e.string = <Putout 2 e.string><File_copy <Get 1>>;
  }

Раздел "Стандартные функции", подраздел "Арифметические функции"

1. 
  $ENTRY Go 
  {
     = <Open 'r' 1 'digits.txt'> <Prout <Summ <Get 1>>>;
  }
  Summ 
  {
    0 = 0; /* если достигнут конец файла*/
    s.digit 0 = <Numb s.digit>; /* если в конце файла нет пустых строк */
    s.digit = <Add <Numb s.digit> <Summ <Get 1>>>;
  }

2.
  $ENTRY Go 
  {
      =  <Prout <Get_number <Numb<Card>>>> ;
  }
  Get_number 
  {
      e.1 = <Comparing  e.1  <Numb<Card>>>;
  }
  Comparing 
  {
      s.1 s.2 = <Result s.1 <Compare s.1 s.2>>;
  }
  Result 
  {
      s.1 '-' = <Prout 'Menshe'>  <Comparing s.1  <Numb<Card>>>;
      s.1 '+' = <Prout 'Bolshe'> <Comparing s.1 <Numb<Card>>>;
      s.1 '0' =  'Ugadal!';
  }
 
3.  s.A e.2 =   <Add  <Numb s.A> <Comparing e.2> >;

Раздел "Рефал-условия"

1.

$ENTRY Go 
  {
       = <Open 'r' 1 'pal.txt'><Open 'w' 2 'pal1.txt'><Prout<Select <Get 1>>> ;
  }
  Select 
  {
      0 = ;
      e.string, <Pal e.string>: T = <Putout 2 e.string><Select <Get 1>>;
      e.other = <Select <Get 1>>;
  }
  Pal 
  {
       = T;
      s.1 = T;
      s.1 e.2 s.1 = <Pal e.2>;
      e.1 = F;  
  }

2.

$ENTRY Go 
  {
       =  <Select>;
  }
  Select 
  {    
      = <Prout <Select1 () <ReadAllFile 'list1.txt'>>>;        
  }
  ReadAllFile 
  {
      ( e.text  ( e.e 0 ) ) = e.text (e.e);
      (e.text ) = <ReadAllFile  (e.text (<Get 1>) )>;
       e.filename = <Open 'r' 1 e.filename><ReadAllFile  ( (<Get 1>) )>;
  }
  Select1
  {    
       (e.result) (e.surname ' ' e.name) e.other,
                                               <Oneof (e.surname) e.result e.other> : T
                                                                                       = <Select1 (e.result (e.surname ' ' e.name) )  e.other>;
       (e.result) (e.other) e.other2 =<Select1 (e.result) e.other2>;
       () e.other = 'No';
       (e.result) e.other =(e.result);
  }
  Oneof 
  {
       (e.surname)  e.left (e.surname ' ' e.name) e.right=  T;
       (e.A) e.other = F;
  }

3.

$ENTRY Go 
  {
       =  <Open 'r' 1 'list2.txt'><Prout 'Date?'><Select <Card>>;
  }
  Select 
  {    
      s.d1 s.d2 '/' s.m1 s.m2 '/' s.y1 s.y2 s.y3 s.y4 = <Prout <Select1 (s.d1 s.d2 '/' s.m1 s.m2 '/' s.y1 s.y2 s.y3 s.y4) <Get 1>>>;        
      e.other = 'Incorrect format';
  }
  Select1
  { 
       (e.date) 0 = 'No such date';   
       (e.date) e.date  e.string = e.string;
       (e.date) e.string = <Select1 (e.date) <Get 1>>;
  }

Please fill all the letters into the box to prove you're human.

Сводка изменений