Пример работы:

var a := Arr(1, 2, 3, 4, 5, 6);
foreach var group in a.NWise(3) do
  Println(group); 
// Результат: [1, 2, 3], [2, 3, 4], [3, 4, 5], [4, 5, 6]

📝 Примеры задач для анализа временных рядов:

1️⃣ Скользящее среднее температуры
Вычислим средние значения температуры за последние 3 дня:

var temperatures := Arr(22.1, 23.4, 21.8, 24.2, 22.9, 23.7);
foreach var window in temperatures.NWise(3) do
  Println(window.Average.Round(4)); 
// Результат: 22.4333, 23.1333, 22.9667, 23.6

2️⃣ Обнаружение резких изменений
Найдем периоды, где изменения потребления электроэнергии превышают 50 кВт⋅ч:

var consumption := Arr(120, 180, 150, 200, 260, 220);
foreach var window in consumption.NWise(2) do
  if Abs(window[1] - window[0]) > 50 then
    Println(window);
// Результат: [120, 180], [200, 260]

3️⃣ Максимальная скорость ветра
Определим максимальную скорость ветра за каждые 3 часа:

var windSpeeds := Arr(5, 8, 6, 10, 12, 9, 7);
foreach var window in windSpeeds.NWise(3) do
  Println(window.Max); 
// Результат: 8, 10, 12, 12, 12

4️⃣ Суммирование данных в окнах
Подсчитаем общее количество запросов к серверу за каждые 4 часа:

var requests := Arr(50, 60, 70, 80, 90, 100, 110);
foreach var window in requests.NWise(4) do
  Println(window.Sum);
// Результат: 260, 300, 340, 380

5️⃣ Выявление стабильных периодов
Найдем периоды, где изменения курса валют минимальны (разница между максимумом и минимумом в окне ≤ 1):

var exchangeRates := Arr(74.5, 74.6, 74.8, 74.7, 74.5, 74.4, 74.6);
foreach var window in exchangeRates.NWise(3) do
  if window.Max - window.Min <= 1 then
    Println(window);
// Результат: [74.6, 74.8, 74.7], [74.5, 74.4, 74.6]

6️⃣ Выявление трендов
Определим окна, где значения постоянно растут:

var sales := Arr(100, 120, 140, 130, 150, 160, 170);
foreach var window in sales.NWise(3) do
  if (window[0] < window[1]) and (window[1] < window[2]) then
    Println(window);
// Результат: [100, 120, 140], [130, 150, 160], [150, 160, 170]

Вывод

В настоящей статье представлены различные примеры использования метода NWise в прикладных задачах.

<nlog xmlns="http://www.nlog-project.org/schemas/NLog.xsd"
      xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
  <targets>
    <target xsi:type="File" name="logfile" fileName="log.txt" />
  </targets>
  <rules>
    <logger name="*" minlevel="Info" writeTo="logfile" />
  </rules>
</nlog>

✦ Пишем программу для логирования:

{$reference 'NLog.dll'}
uses NLog;
begin
  // Инициализация логгера
  LogManager.LoadConfiguration('nlog.config');
  var log := LogManager.GetCurrentClassLogger;
  
  // Запись логов
  log.Info('Программа запущена');
  
  try
    var a := 10;
    var b := 0;
    var c := a div b; // Это вызовет исключение
  except
    on e: Exception do
      log.Error('Ошибка: ' + e.Message);
  end;
  
  log.Info('Программа завершена');
end.

Готово!

🔹 Присваивание динамических массивов

Когда вы присваиваете один динамический массив другому через оператор :=, происходит ссылочное присваивание. Это означает, что обе переменные ссылаются на один и тот же массив в памяти. Любые изменения в одном массиве автоматически отразятся на другом.

Пример:
var a := new integer[5]; // Создаём массив
var b := a; // b ссылается на тот же массив,что и a
b[0] := 10; // Теперь и a[0], и b[0] равны 10

Чтобы создать независимую копию массива, следует использовать встроенную функцию Copy(a).

Пример:
var a := new integer[5]; // Создаём массив
var b := Copy(a);        // b — это копия массива a
b[0] := 10;  // Изменение b не затрагивает a

🔹 Сравнение массивов

✦ Прямое сравнение массивов через оператор = проверяет ссылки, а не содержимое массивов. Даже если два массива содержат одинаковые элементы, они будут считаться неравными, если ссылаются на разные объекты в памяти.

Пример
var a := new integer[5];
var b := new integer[5];
if a = b then // это сравнение вернёт False
  Println('Массивы равны')
else Println('Массивы не равны');

✦ Для корректного сравнения содержимого массивов в PascalABC.NET нужно использовать метод ArrEqual, который проверяет, равны ли все элементы двух массивов.

Пример:
var a := new integer[5];
var b := new integer[5];
if a.ArrEqual(b) then  // Проверяет равенство всех элементов массива
  Println('Массивы равны')
else Println('Массивы не равны');

🔹 Итоги:

✦ Для копирования массива используйте функцию Copy(a), чтобы избежать ссылочного присваивания.
✦ Для сравнения содержимого массивов используйте метод ArrEqual.

Чтобы задания проверялись автоматически, необходимо создать Урок с заданиями. Урок представляет собой папку, в которой находятся .pas-файлы - заготовки с формулировками заданий, модуль проверки Tasks.pas, который будет проверять все выполненные задания в уроке, а также специальный файл lightpt.dat. Этот файл может быть пустым или содержать название урока (в кодировке Windows 1251). Название урока не должно содержать пробелов.

Именно файл lightpt.dat является маркером того, что все задания в этой папке будут проходить через невидимую проверяющую систему.

Названия .pas-файлов с заданиями могут содержать в начале имени числа с последующим знаком подчёркивания, которые игнорируются. Например, 01_Пример1.pas и Пример1.pas это одинаковые имена для системы проверки.

Итак, создадим папку Lesson1 и в ней файл lightpt.dat, в котором напишем одну строчку в кодировке Windows 1251: Урок-1. Задания на массивы

Создание задания

Теперь создадим в этой папке первый файл с заданием ArrTask1.pas со следующим содержимым:

Заметим, что в заготовке задания уже массив заполнен и выведен. Позже рассмотрим ситуацию решения с нуля.

Создание модуля проверки заданий

Теперь создадим модуль, который будет проверять все выполненные задания в уроке (в олимпиадном программировании такие подпрограммы называются чекерами). Для этого в той же папке создадим файл Tasks.pas со следующим содержимым (важно использовать именно это имя файла):

Вот полный текст проверяющего модуля Tasks:

unit Tasks;

uses LightPT;

procedure CheckTaskT(name: string);
begin
  ClearOutputListFromSpaces; 
  case name of
    'ArrTask1': begin

    end;
  end;
end;

initialization
  CheckTask := CheckTaskT;
end.

Здесь ClearOutputListFromSpaces надо писать всегда - оно удаляет пробелы из вывода, которые добавляет при выводе Print, a.Print и ему подобные.

Теперь в ветви 'ArrTask1' оператора case напишем чекер, проверяющий выполнение задания ArrTask1.

Написание чекера

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

• Проверка типов, введенных пользователем (процедура CheckData)
• Считывание ввода пользователя в локальные переменные
• Решение задания в чекере и получение ответа
• Проверка соответствия ответа тому, который вывел пользователь (процедура CheckOutput)

Рассмотрим каждый из этих пунктов по-отдельности

Проверка типов, введенных пользователем

Проверка типов, введенных пользователем, осуществляется с помощью процедуры CheckData. Простейшая форма вызова CheckData имеет вид:

var n := 10; 
CheckData(Input := [cInt] * n);

или

var n := 10; 
CheckData([cInt] * n);

Это говорит о том, что мы проверяем, что пользователь ввёл 10 целых чисел (каждое целое число задаётся здесь маркером типа cInt).

Какие ещё варианты задания входных данных могут быть? Их всего пять:

cInt, cRe, cStr, cBool, cChar

Они должны быть объединены в массив типов тем или иным способом, например, с помощью операций сложения массивов и умножения массива на число. Например, выражение

[cInt] * n

задаёт массив из n целых типов, а выражение

[cStr] + [cInt] * n + [cRe] * 2

задаёт массив из одного строкового типа, после которого идёт n целых типов и 2 вещественных.

Если маркер типа умножается на число, его необязательно окаймлять в ||, например:

[cStr] + cInt * n + cRe * 2

Считывание ввода пользователя

Итак, пусть мы написали

var n := 10; 
CheckData(cInt * n);

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

Теперь чтобы проверить задание, мы должны те n значений, которые ввёл ученик, считать во внутренние переменные. Мы это сделаем таким способом:

var a := IntArr(n);

Функция IntArr(n) считывает следующие n данных, которые ввёл пользователь, в массив, рассматривая их как целые. Таким образом, она возвращает массив из n целых.

Какие еще функции можно использовать для считывания ввода пользователя?

Это простейшие:

Int
Re
Boo
Chr
Str

которые считывают один элемент данных и продвигаются вперёд, пары

Int2
Re2

которые возвращают кортежи (пар другого типа нет поскольку это - редкость), а также массивы одного типа из n элементов:

IntArr(n)
ReArr(n)
BooArr(n)
ChrArr(n)
StrArr(n)

Решение задания в чекере и получение ответа

Теперь когда мы считали все данные, которые ввёл пользователь, в переменные, решим задачу так, как должен решать ученик. В данном случае это просто:

var cnt := a.Count(x -> x mod 2 = 0);

Проверка ответа

Теперь необходимо понять, что в заготовке задания мы уже вывели сгенерированный случайный массив и нам лишь надо вывести найденное значение cnt. Для этого воспользуемся процедурой CheckOutput:

CheckOutput(a,cnt);

Всё, текст проверки полностью готов:

procedure CheckTaskT(name: string);
begin
  ClearOutputListFromSpaces;
  case name of
    'ArrTask1': begin
      var n := 10;
      CheckData(Input := cInt * n); // проверка типов
      var a := IntArr(n);                   // считывание ввода
      var cnt := a.Count(x -> x mod 2 = 0); // решение задания
      CheckOutput(a,cnt);                   // проверка ответа
    end;
  end;
end;

Как видим, он совсем простой - состоит из 5 строк.

Как это выглядит со стороны ученика

Ученик, решая ArrTask1, вначале просто запустит заготовку и увидит

Далее он попытается решить неправильно:

И наконец

он решит задание правильно.

Добавление тестов (не дописано)

К этому может добавляться вызов процедуры генерации тестов. Дело в том, что пользователь может попытаться обмануть систему проверки LightPT и ввести данные, на которых задача решается просто.

Итог - очень впечатляющая работа нейросети. Например, новый метод IndexMinBy из соседнего диалога был сразу задействован нейросетью в текущем диалоге.

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

Несколько вопросов было по переработке алгоритма. Например, нейросеть инициализировала центроиды кластеров уже имеющимися точками, что могло приводить к ошибке общего алгоритма. Ей было предложено изменить алгоритм генерации центроидов на случайные точки в прямоугольнике - она сразу поняла, что прямоугольник, о котором идет речь, - это минимумы-максимумы координат точек. И предложила алгоритм GenerateRandomCentroids.

Руками правились части кода, где надо было генерировать точки с помощью нового модуля Coords, а также с помощью библиотеки Mathnet.Numerics.dll - нейросеть конечно этого не знала.

Но основная канва кода в крупных командах близка к идеальной.

Итак, перед нами алгоритм KMeans выделения кластеров. Задаётся набор точек, количество кластеров, максимальное число итераций и минимальное расстояние между первоначальными центроидами.

Код:

{$reference Mathnet.Numerics.dll}
uses Mathnet.Numerics;
uses Coords;

function GenerateCluster(X, Y, deviation: real; count: integer): array of Point;
begin
  var xx := Generate.Normal(count, X, deviation);
  var yy := Generate.Normal(count, Y, deviation);
  Result := ArrGen(count, i -> Pnt(xx[i],yy[i]));
end;

function Distance(p1, p2: Point): real := Sqrt(Sqr(p1.x - p2.x) + Sqr(p1.y - p2.y));

function GenerateRandomCentroids(k: integer; points: array of Point; minDistance: real): array of Point;
begin
  var minX := points.Min(p -> p.x);
  var maxX := points.Max(p -> p.x);
  var minY := points.Min(p -> p.y);
  var maxY := points.Max(p -> p.y);
  var centroids := new List<Point>();
  while centroids.Count < k do
  begin
    // Случайная точка в пределах прямоугольника
    var candidate := new Point(
      RandomReal(minX, maxX),
      RandomReal(minY, maxY)
    );
    // Проверяем, что расстояние до всех ранее выбранных центроидов больше minDistance
    var isFarEnough := centroids.All(c -> Distance(c,candidate) >= minDistance);
    if isFarEnough then
      centroids.Add(candidate);
  end;
  Result := centroids.ToArray();
end;

function KMeans(points: array of Point; k: integer; maxIterations: integer; minDistance: real): (array of List<Point>, array of Point);
begin
  var n := points.Length;
  if k > n then
    raise new System.ArgumentException('Число кластеров не может быть больше числа точек');
  // Генерируем начальные центроиды случайно в пределах прямоугольника
  var centroids := GenerateRandomCentroids(k, points, minDistance);
  // Инициализация кластеров как массив списков с помощью ArrGen
  var clusters := ArrGen(k, i -> new List<Point>);
  for var iteration := 1 to maxIterations do
  begin
    // Шаг 1: Назначаем каждую точку ближайшему центроиду
    foreach var cluster in clusters do
      cluster.Clear(); // Очищаем списки на каждой итерации
    foreach var point in points do
    begin
      var nearestCentroidIndex := centroids.IndexMinBy(c -> Distance(point,c));
      clusters[nearestCentroidIndex].Add(point); // Добавляем точку в ближайший кластер
    end;
    // Шаг 2: Обновляем центроиды как средние точки своих кластеров
    var newCentroids := Copy(centroids); // Копируем центроиды
    for var i := 0 to k - 1 do
      if clusters[i].Count > 0 then
        newCentroids[i] := new Point(
          clusters[i].Average(p -> p.x),
          clusters[i].Average(p -> p.y)
        );
    // Проверяем, если центроиды не изменились, то завершаем
    if newCentroids.SequenceEqual(centroids) then
      break;
    centroids := newCentroids;
  end;
  Result := (clusters, centroids);
end;

begin
  // Сгенерируем исходные кластеры точек
  var cluster1 := GenerateCluster(5, 3, 2.5, 50);
  var cluster2 := GenerateCluster(7, -6, 1.5, 25);
  var cluster3 := GenerateCluster(-7, 2, 1, 44);
  
  var allPoints := cluster1 + cluster2 + cluster3;
  
  // Применяем алгоритм K-means для кластеризации
  var (clusters, centroids) := KMeans(allPoints, 3, 100, 2);
  
  DrawPoints(clusters[0].ToArray,3);
  DrawPoints(clusters[1].ToArray,3);
  DrawPoints(clusters[2].ToArray,PointRadius := 3);
  
  DrawPoint(centroids[0].x,centroids[0].y,PointRadius := 5);
  DrawPoint(centroids[1].x,centroids[1].y,PointRadius := 5);
  DrawPoint(centroids[2].x,centroids[2].y,PointRadius := 5);
end.

Вывод в графическом окне:

Немного не нравится необходимость преобразовывать списки к массивам с помощью ToArray. В Distance можно брать квадрат расстояния для ускорения, но оставил как есть.

Решение о моделировании кластеров пополняемыми списками нейросеть принимала сама. А вычисление nearestCentroidIndex с помощью indexMinBy просто красиво.

Вопрос 1:

О великий могучий ChatGPT! Предложи синтаксис нового современного языка программирования, который сразу понравится всем :)

ChatGPT:

Создание синтаксиса нового языка программирования, который сразу понравится всем, — это сложная задача, так как предпочтения разработчиков сильно разнятся. Однако можно предложить нечто, что могло бы объединить лучшие черты популярных языков и учесть современные тенденции. Ниже я предложу синтаксис и концепции для такого гипотетического языка.

Имя языка: "Fluent"

1. Простота и Лаконичность

• Минимальное количество ключевых слов.
• Краткость и выразительность как в Python.
• Чистота и строгая типизация как в TypeScript.

2. Консистентная и Универсальная Система Типов

• Типизация, подобная Rust, с возможностью автоматического выведения типов.
• Безопасность типов с возможностью применения как статической, так и динамической типизации.

3. Функциональность и Модульность

• Поддержка чистых функций и функционального программирования.
• Явная поддержка модульной архитектуры.

4. Асинхронность и Параллелизм

• Встроенная поддержка асинхронности с простым синтаксисом, как в JavaScript (async/await).
• Возможность простого создания параллельных вычислений без необходимости управления потоками вручную.

5. Единый Стиль Форматирования и Поддержка

• Автоматический форматтер в стиле Go, но с возможностью кастомизации.
• Встроенный линтер с гибкой настройкой.

Пример синтаксиса:

// Комментарии поддерживаются в стиле C++

// Модульное объявление
module MyApp.Utils

// Импорт других модулей
import MyApp.Core.Math as Math

// Определение функции
fn square(x: Number) -> Number {
    return x * x
}

// Функции могут быть асинхронными
async fn fetchData(url: String) -> Response {
    let response = await http.get(url)
    return response
}

// Структуры и типы данных
struct User {
    name: String
    age: Option<Number>
}

// Работа с коллекциями и выражениями
fn getUserNames(users: List<User>) -> List<String> {
    return users.filter(user -> user.age > 18)
                .map(user -> user.name)
}

// Использование опциональных типов с безопасной распаковкой
let age: Number = user.age.unwrap_or(0)

// Параллельные вычисления
fn processData(data: List<Number>) -> List<Number> {
    return data.parallel_map(x -> square(x))
}

// Обработка ошибок через Result тип
fn divide(a: Number, b: Number) -> Result<Number, String> {
    if b == 0 {
        return Err("Division by zero")
    }
    return Ok(a / b)
}

Ключевые концепции:

• Модульность и Простота: Основное внимание уделяется простоте и читаемости кода. Отсутствие сложных конструкций, которые легко ошибочно интерпретировать.
• Безопасность типов: Строгая типизация предотвращает ошибки на этапе компиляции, при этом поддерживается удобная система типов с возможностью опциональных значений и типами Result.
• Асинхронность и Параллелизм: Интуитивно понятная асинхронность и встроенные возможности параллелизма делают язык мощным и современным.

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

Вопрос 2:

Предложи другой синтаксис языка программирования с теми же параметрами.

ChatGPT сказал:

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

Имя языка: "Streamline"

Основные особенности:

• Сильная типизация с автоматическим выводом типов.
• Краткий и понятный синтаксис.
• Интуитивное функциональное программирование.
• Мощная система модулей и асинхронного кода.

Пример синтаксиса:

// Определение модуля
module App.Utilities

// Импортирование модулей
import App.Network.Http as Http

// Функции с кратким определением типов
func square(x: Number) -> Number = x * x

// Асинхронные функции с простым синтаксисом
async func fetchData(url: String): Response {
    let response = await Http.get(url)
    return response
}

// Структуры и типы данных
type User {
    name: String
    age?: Number  // Опциональный тип с вопросительным знаком
}

// Работа с коллекциями и функциональными операциями
func adultNames(users: List<User>): List<String> =
    users.filter(|user| user.age > 18)
         .map(|user| user.name)

// Опциональные типы с безопасным доступом через `?`
let age: Number = user.age ? 0  // Если `age` пусто, то вернется 0

// Параллельные вычисления с встроенной поддержкой
func processData(data: List<Number>): List<Number> =
    data.parallel_map(|x| square(x))

// Обработка ошибок через `Result` и `try-catch` блоки
func divide(a: Number, b: Number): Result<Number, String> =
    if b == 0 {
        return Err("Division by zero")
    } else {
        return Ok(a / b)
    }

// Пример использования обработки ошибок
try {
    let result = divide(10, 0)
    print(result)
} catch (error: String) {
    print("Error: $error")
}

Ключевые концепции:

• Простота и Минимализм: Максимально лаконичный и читабельный код. Простые конструкции, которые легко понимаются и поддерживаются.
• Мощная Типизация: Вывод типов, строгая типизация с поддержкой опциональных значений и возможностей для обработки ошибок.
• Асинхронность и Параллелизм: Интеграция асинхронного программирования и параллельных вычислений с минимальными усилиями со стороны разработчика.
• Чистота и Структурированность: Чистый и компактный синтаксис, который легко структурировать и масштабировать.

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

Вопрос 3:

Отлично! И предложи третий вариант языка, ещё более лаконичный и привлекательный

ChatGPT сказал:

Рад, что вам понравилось! Вот третий вариант языка программирования, который будет еще более лаконичным и интуитивным.

Имя языка: "Swiftly"

Основные особенности:

• Экстремальная лаконичность и выразительность.
• Интуитивный синтаксис с минимальным количеством операторов.
• Мощная система типов с простым выводом.
• Фокус на чистоту кода и функциональный стиль.

Пример синтаксиса:

// Модули и импорты
module Utils
import Net.Http

// Определение функции с неявным выводом типа
fn square(x) = x * x

// Асинхронные функции с неявным возвратом
async fn fetch(url) {
    response = await Http.get(url)
    response
}

// Структуры и типы данных
type User {
    name: String
    age?: Int  // Опциональный тип через `?`
}

// Функциональные коллекции
fn adult_names(users) = 
    users.filter(|u| u.age > 18).map(|u| u.name)

// Опциональные типы с безопасным доступом через `?`
age = user.age ? 0  // Если `age` пусто, возвращаем 0

// Параллельные вычисления, встроенные в функциональные методы
fn process(data) = 
    data.parallel_map(square)

// Простая обработка ошибок через `?` и `catch`
fn divide(a, b) = 
    b == 0 ? "Error: Division by zero" : a / b

// Пример использования
result = divide(10, 0) 
print(result)  // "Error: Division by zero"

Ключевые концепции:

• Минимум Синтаксиса: Минимум символов и конструкций, простой и понятный код. Вывод типов автоматически, где это возможно.
• Лаконичность: Синтаксис оптимизирован для краткости без потери выразительности. Операторы и ключевые слова сведены к минимуму.
• Простая Асинхронность и Параллелизм: Асинхронные и параллельные операции интегрированы прямо в язык, используя простые и лаконичные конструкции.
• Функциональная Чистота: Лямбда-выражения и функции высшего порядка легко читаются и пишутся, что поощряет функциональный подход.

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

Вопрос 4. К чему ты больше склоняешься для языка для обучения - к статической типизации с мощным автовыведением типов или к динамической типизации?

ChatGPT:

Я склоняюсь к статической типизации с мощным автовыведением типов для образовательного языка программирования. Вот почему:

Основные Аргументы:

1. Раннее Обнаружение Ошибок:
• Статическая типизация позволяет выявлять ошибки типов на этапе компиляции, что особенно важно для начинающих. Это помогает ученикам избегать распространенных ошибок и учит их лучше понимать, как типы данных влияют на выполнение программы.
2. Автовыведение Типов:
• Автовыведение типов упрощает процесс написания кода, поскольку ученикам не нужно явно указывать типы данных везде. Это снижает когнитивную нагрузку и позволяет сосредоточиться на логике программирования. Например, ученику не нужно думать о том, какой тип у переменной x, если компилятор может это сделать за него.
3. Гибкость и Чистота Кода:
• Код остаётся лаконичным и чистым, что важно для обучения. Ученики могут писать простые функции и выражения, не беспокоясь о типах данных, при этом получая все преимущества статической типизации, такие как проверка корректности на этапе компиляции.
4. Переход к Более Сложным Концепциям:
• Такой подход обеспечивает плавный переход к более сложным аспектам программирования. Начинающие программисты со временем начнут понимать, как работают типы, и смогут начать использовать явные аннотации типов для более сложных задач.
5. Снижение Риска Ошибок во Время Выполнения:
• Динамическая типизация может привести к ошибкам, которые возникают только во время выполнения программы, что усложняет отладку. Статическая типизация предотвращает такие проблемы, давая ученикам уверенность в правильности их кода ещё до запуска.

Заключение:

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

Вопрос 5:

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

ChatGPT сказал:

Конечно! Вот пример синтаксиса языка программирования, основанного на статической типизации с автовыведением типов, который охватывает широкий спектр конструкций и возможностей.

Имя языка: "EduFlex"

Основные конструкции

1. Присваивания и стандартные типы

# Переменные и типы
num = 42               # Тип 'Int' выводится автоматически
pi = 3.14              # Тип 'Float'
name = "Alice"         # Тип 'String'
is_valid = true        # Тип 'Bool'
colors = ["red", "blue", "green"]  # Тип 'List<String>'

# Кортежи
person = ("John", 30, true)  # Тип '(String, Int, Bool)'

# Словари (ассоциативные массивы)
scores = {"Alice": 95, "Bob": 88}  # Тип 'Dict<String, Int>'

# Срезы массивов
sub_colors = colors[1:3]  # Срез списка: ["blue", "green"]

# Множественное присваивание через кортежи
x, y = 10, 20
name, age, is_student = person

2. Условные конструкции

# Условные конструкции
if num > 50:
    print("Число больше 50")
elif num == 42:
    print("Число равно 42")
else:
    print("Число меньше 50")

3. Циклы

# Цикл for по списку
for color in colors:
    print(color)

# Цикл for с диапазоном
for i in 1..5:  # Диапазон от 1 до 5 включительно
    print("Итерация", i)

# Цикл while
counter = 0
while counter < 5:
    print("Счётчик =", counter)
    counter += 1

4. Функции

# Функции с автоматическим выводом типов
fn greet(name):
    return "Привет, " + name

message = greet("Alice")  # "Привет, Alice"

# Функции с аннотациями типов (по желанию)
fn add(a: Int, b: Int) -> Int:
    return a + b

result = add(10, 20)  # 30

# Лямбда-выражения
squared_numbers = [1, 2, 3, 4].map(|x| x * 2)  # [2, 4, 6, 8]

# Функции высшего порядка
fn apply_twice(fn, x):
    return fn(fn(x))

result = apply_twice(|n| n + 2, 5)  # 9

5. Составные типы

# Структуры
type User {
    name: String
    age: Int
    is_active: Bool
}

# Создание объекта структуры
user = User("Alice", 25, true)

# Доступ к полям структуры
print(user.name)  # "Alice"
user.age += 1

# Деструктуризация структуры
name, age, is_active = user

# Параметры по умолчанию в функциях
fn create_user(name: String, age: Int = 18, is_active: Bool = true) -> User:
    return User(name, age, is_active)

user2 = create_user("Bob")

6. Модули и импорт

# Объявление модуля
module MathUtils

fn square(x: Int) -> Int:
    return x * x

fn cube(x: Int) -> Int:
    return x * x * x

# Импорт и использование функций модуля
import MathUtils

result = MathUtils.square(4)  # 16

7. Современные возможности

# Кортежи и их использование в функциях
fn swap(a, b) -> (Int, Int):
    return (b, a)

x, y = swap(10, 20)  # x = 20, y = 10

# Срезы списков и строк
slice = "Hello, World"[0:5]  # "Hello"

# Цепочки методов
numbers = [5, 3, 8, 6]
result = numbers.filter(|x| x > 5).map(|x| x * 2).sort()  # [12, 16]

8. Обработка ошибок

# Простейшая обработка ошибок с использованием типа Result
fn safe_divide(a: Int, b: Int) -> Result<Int, String>:
    if b == 0:
        return Err("Деление на ноль")
    return Ok(a / b)

# Пример использования
result = safe_divide(10, 0)
if result.is_err():
    print("Ошибка:", result.unwrap_err())
else:
    print("Результат:", result.unwrap())

Заключение

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

Вопрос 6:

Здорово! А как по-твоему, нужен ли в таком языке отдельный цикл "повторить n раз" или достаточно цикла for, который ты предложил?

ChatGPT сказал:

Отдельный цикл "повторить n раз" (например, repeat n times) может быть полезен в образовательном языке, особенно для начинающих программистов. Хотя цикл for вполне может выполнять эту задачу, добавление специального цикла "повторить n раз" делает код более интуитивным и понятным, особенно на ранних этапах обучения.

Преимущества отдельного цикла "повторить n раз":

1. Простота и Ясность:
• Команда repeat n times более интуитивно отражает намерение программиста, особенно для начинающих, которые могут ещё не быть знакомы с концепцией диапазонов в циклах for.
2. Читабельность:
• Такой цикл делает код более самодокументированным. Читая repeat 5 times, сразу понятно, что операция повторяется 5 раз, без необходимости вникать в детали диапазона или начального значения счётчика.
3. Фокус на Логике:
• Учащиеся могут сосредоточиться на логике программы, не отвлекаясь на настройку диапазонов и счётчиков. Это упрощает обучение и позволяет быстрее перейти к более интересным и сложным задачам.

Пример использования:

# Цикл "повторить n раз"
repeat 5 times:
    print("Это сообщение будет напечатано 5 раз")

Вариант с циклом for:

# Цикл "повторить n раз"
repeat 5 times:
    print("Это сообщение будет напечатано 5 раз")

Итог:

Хотя цикл for технически может заменить цикл "повторить n раз", отдельная конструкция repeat n times добавляет простоту и читабельность, что делает язык более доступным для начинающих программистов. В образовательном контексте это может быть важным фактором, способствующим лучшему пониманию и более плавному погружению в программирование. Поэтому такой цикл имеет смысл включить в язык, ориентированный на обучение.

Вопрос 7:

А цикл типа "loop 5 do" подойдёт для этих целей?

ChatGPT сказал:

Да, цикл вида loop 5 do отлично подойдёт для этих целей. Он является лаконичным и интуитивным, что особенно важно для начинающих программистов. Такой синтаксис легко читается и сразу даёт понять, что код внутри блока будет выполнен 5 раз.

Преимущества синтаксиса loop n do:

1. Лаконичность:
• Синтаксис короткий и понятный, что уменьшает количество кода, который нужно писать и читать. Это особенно полезно в образовательных целях, где важно минимизировать отвлекающие детали.
2. Ясность:
• Команда loop 5 do ясно указывает намерение — повторить действия внутри цикла 5 раз. Это делает код доступным и понятным даже для тех, кто только начинает изучать программирование.

Пример использования:

# Цикл "loop n do"
loop 5 do:
    print("Сообщение будет выведено 5 раз")

Варианты циклов:

• Если нужно просто повторить действие несколько раз, loop n do выглядит как естественный выбор.
• Для более сложных сценариев, где требуется счётчик или диапазон значений, можно использовать цикл for.

Итог:

Синтаксис loop 5 do является отличным выбором для реализации простого цикла с повторением фиксированного количества раз. Он сочетает в себе лаконичность и простоту, что идеально подходит для языка, ориентированного на обучение. Такой цикл сделает код более читаемым и интуитивно понятным для школьников и других начинающих программистов.

Ошибка 1. Имя переменной не определено к моменту использования.

Если мы пытаемся использовать какую-то переменную в вычислениях, но еще не присваивали ей значение, то возникает данная ошибка. Например, в программе

a = int(input())
print(b + 1)

мы вначале введем значение переменной a, и только потом при выполнении второй строки будет выведено «NameError: name 'b' is not defined». Таким образом, данная проблема будет диагностирована слишком поздно – уже когда программа выполнялась достаточно долго. При этом программа будет прервана на этом месте и все данные будут потеряны.

Сравним это поведение с аналогичной программой на PascalABC.NET:

begin
  var a := ReadInteger;
  Print(b);
end.

При запуске такой программы мы получаем ошибку компиляции

Вывод. Компилятор PascalABC.NET контролирует все семантические ошибки и не даст запустить программу, которая содержит хотя бы одну такую ошибку. Это – огромное преимущество компиляторов, которе отсутствует у интерпретаторов.

Ошибка 2. Имя функции записано неправильно.

a = int(input())
Print(a)

В этой программе имя функции Print неправильно записано с большой буквы. Программа по-прежнему после запуска выполнит первую строку – ввод данных, и только после этого выведет ошибку: «NameError: name 'Print' is not defined».

Ошибка 3. Несоответствие типов при вызове функции.

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

from math import *
print(sqrt('Python'))

возникнет ошибка «TypeError: must be real number, not str». Это означает, что функция sqrt не может быть применена к строкам – только к вещественным числам.

Ошибка 4. Несоответствие типов при выполнении операции.

Бывают ситуации, когда мы пытаемся делать какие-то операции над типами, которые для этого не предназначены. При запуске следующей программы

s = input()
print(s + 1)

мы вначале введём строку в переменную s, а при выполнении второй строки получим ошибку «TypeError: can only concatenate str (not "int") to str», что означает, что строку нельзя складывать с числом.

Вывод. Семантические ошибки на Python диагностируются поздно, что приводит к программам, которые заведомо содержат ошибку, но могут быть запущены и успешно проработают какое-то время. Такие программы более опасны чем те, которые сразу не запускаются из-за ошибок синтаксиса, потому что, если программа запускается, это создаёт ложное ощущение её безопасности.

Во всех задачах на массивы требуется уметь описывать массивы, вводить их, заполнять случайными числами, выводить. Очень часто требуется цикл по массиву с перебором всех элементов.

Описание массива и выделение памяти

var a: array of integer := new integer[10];

Можно без указания типа:

var a := new integer[10];

Если в задаче требуется создать массив из N элементов, то N надо предварительно ввести:

var N := ReadInteger;
var a := new integer[N];

Цикл по массиву

for var i:=1 to a.Length-1 do
Print(a[i])

или

foreach var x in a do
Print(x)

В случае foreach невозможно изменение элементов.

Ввод массива с клавиатуры

Массив можно ввести циклом

var N := ReadInteger;
var a := new integer[N];
for var i:=1 to a.Length-1 do
a[i] := ReadInteger;

или методом

var N := ReadInteger;
var a := ReadArrInteger(N);

Вывод массива

a.Println;

Поиск в массиве элементов и их индексов

Для проверки, есть ли элемент в массиве, используется операция in:

3 in a
(3 in a) or (4 in a)

Найти индекс первого элемента, равного чему то:

var ind := a.IndexOf(3); // индекс первой 3 или -1 если не найдено

Найти индекс первого элемента, удовлетворяющего условию:

var ind := a.FindIndex(x -> x mod 2 = 0); // индекс первого четного или -1 если не найдено

FindIndex можно также использовать для проверки, есть ли элементы, удовлетворяющие условию:

var Has := a.FindIndex(x -> x in 3..5) <> -1; // есть ли элементы от 3 до 5

Генерация массива по заданному правилу

var a := ArrFill(N,1); // заполнить N элементов значением 1

Для заполнения каждого элемента по правилу a[i] := i + 1 пользуемся функцией ArrGen:

var a := ArrGen(N, i -> i+1);

Но можно и циклом:

var a := new integer[N];
for var i:=1 to a.Length-1 do
a[i] := i + 1;

Для заполнения массива, в котором задан первый элемент, а каждый следующий определяется по предыдущему, пользуемся

var a := ArrGen(N, 1, x -> следующий);

Здесь N - количество элементов, 1 – первый элемент.

Например, если каждый следующий больше предыдущего на 2:

var a := ArrGen(N, 1, x -> x + 2);

Если же каждый следующий больше предыдущего в 2 раза:

var a := ArrGen(N, 1, x -> x * 2);

Преобразование элементов по заданному правилу

Будем считать массив a заданным (например, введенным с клавиатуры).

Чтобы увеличить все элементы массива на 1, пользуемся методом-процедурой Transform:

a.Transform(x -> x + 1)

Иногда удобно преобразовывать элементы массива, используя цепочку методов. В этом случае следует использовать метод Select. Возможно потребуется преобразование назад к массиву, тогда используем дополнительно метод ToArray:

a := a.Select(x -> x + 1).ToArray;

Если некоторые элементы надо преобразовать по одному правилу, а остальные – по другому или не преобразовывать вовсе, то лучше воспользоваться циклом. Например, для обнуления нечетных:

for var i:=1 to a.Length-1 do
if a[i] mod 2 <> 0 then
a[i] := 0;

Если нечетные надо уменьшить на 1, а четные увеличить на 1:

for var i:=1 to a.Length-1 do
if a[i] mod 2 <> 0 then
a[i] -= 1
else a[i] += 1;

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

a.Transform(x -> x mod 2 = 0 ? x - 1 : x + 1);

Фильтрация элементов по условию

Если в массиве надо отобрать элементы, удовлетворяющие определенному условию, это называется фильтрацией. Фильтрацию проще всего выполнять с помощью метода Where. Например, если требуется отфильтровать и вывести элементы массива, меньшие 5, то вот код:

a.Where(x -> x < 5).Println;

Если надо отфильтровать данные и записать результат в тот же массив, то используем преобразование к массиву методом ToArray:

a := a.Where(x -> x < 5).ToArray;

Бывает так, что после фильтрации надо вычислить какую-то характеристику отфильтрованных элементов – например, найти их сумму, среднее или минимум-максимум:

a.Where(x -> x > 10).Sum.Print;
a.Where(x -> x in 2..8).Average.Print;
a.Where(x -> x mod 2 = 0).Min.Print;

С помощью

a.Where(x -> x in 2..8).Count

можно вычислять количество элементов, удовлетворяющих некоторому условию. Однако то же можно сделать с помощью метода Count с параметром (см. следующий пункт).

Кроме того, отфильтрованные элементы можно далее преобразовывать методом Select, используя цепочку методов:

a.Where(x -> x in 2..8).Select(x -> x + 10).Println;

Задачи на поиск количества элементов, удовлетворяющих некоторому условию

Если надо найти количество опеределенных элементов, то используется метод CountOf:

a.CountOf(3) – количество троек в массиве

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

a.Count(x -> x in 2..8)

Задачи на использование срезов

Срез массива – это набор элементов массива, расположенных последовательно или с некоторым шагом.

Если есть массив из 10 элементов

var a := Arr(1..10);

то a[1:5] – это срез элементов массива с индексами от 1 до 4

В срезах можно пропускать первый или последний индекс:

a[:5] – первые 5 элементов

a[5:] – срез с элемента с индексом 5 до конца

Кроме этого, есть срезы с шагом:

a[::2] – все элементы с четными индексами

a[1::2] – все элементы с нечетными индексами

a[::-1] – инвертированный массив (все элементы в обратном порядке)

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

a[::2].Sum – сумма элементов с четными индексами

a[1::2].Average – среднее элементов с нечетными индексами

a[:5].Min – минимальный среди первых 5 элементов

Можно комбинировать срезы и методы массивов:

a[:5].Where(x -> x mod 2 = 0) – отфильтровать четные элементы среди первых пяти элементов массива

Индексация с конца и срезы

В ряде задач может встречаться индексация элементов с конца:

a[^1] – это первый элемент с конца (последний)

a[^2] – это второй элемент с конца (предпоследний)

Индексация с конца может сочетаться со срезами, например,

a[:^1] – все элементы кроме последнего

a[^2:] – два последних элемента массива

a[1:^1].Sum – сумма всех элементов кроме нулевого и последнего

Рассмотрим данный процесс на примере.

Начальные действия

Чтобы задания проверялись автоматически, необходимо создать Урок с заданиями. Урок представляет собой папку, в которой находятся .pas-файлы - заготовки с формулировками заданий, а также специальный файл lightpt.dat. Этот файл может быть пустым или содержать название урока. Именно этот файл является маркером того, что все задания в этой папки будут проходить через невидимую проверяющую систем

Итак, создадим папку Lesson1 и в ней файл lightpt.dat, в котором напишем одну строчку в кодировке Windows 1251: Урок-1. Задания на массивы

Создание задания

Теперь создадим в этой папке первый файл с заданием ArrTask1.pas со следующим содержимым:

Обязательно сохраним указанный файл в папку с уроком.

Создание модуля проверки заданий

Теперь создадим модуль, который будет проверять все выполненные задания в уроке (в олимпиадном программировании такие подпрограммы называются чекерами). Для этого в той же папке создадим файл Tasks.pas со следующим содержимым (важно использовать именно это имя файла):

Вот полный текст проверяющего модуля Tasks:

unit Tasks;

uses LightPT;

procedure CheckTaskT(name: string);
begin
  case name of
    'ArrTask1': begin

    end;
  end;
end;

initialization
  CheckTask := CheckTaskT;
end.

Код проверки задания

Далее напишем самую главную часть - код проверки:

Вот полный текст модуля:

unit Tasks;

uses LightPT;

procedure CheckTaskT(name: string);
begin
  case name of
    'ArrTask1': begin
      var N := Int;
      CheckData(Input := |cInt| + |cRe| * N);
      var a := ReArr(N);
      var cnt := a.Count(x -> x > 5);
      CheckOutput(cnt);
    end;
  end;
end;

initialization
  CheckTask := CheckTaskT;
end.

Поясним отдельные строки.

1. Введенное учеником первое целоезначение, характеризующее размер массива, запоминается в переменной N

var N := Int;

2. В процедуре CheckData указывается, что входные данные Input должны состоять из целого числа (константа cInt) и N вещественных чисел (константа cRe). Все данные объединяются в массив входных данных с помощью конструктора массива |cInt| + |cRe| * N.

CheckData(Input := |cInt| + |cRe| * N);

Константы cInt, cRe, cStr, cBool, cChar хранят в себе элементарные типы значений - именно из них конструируются типы входных данных и соответствие именно этим типам проверяются чекером у входных данных.

Если мы введем неверное количество входных данных или неверно укажем их типы, система проверки выведет соответствующее сообщение об ошибке.

3. С помощью функции ReArr введенные учеником N вещественных значений заносятся в массив a

var a := ReArr(N);

4. Количество элементов, больших 5, вычисляется с помощью стандартного метода массива a.Count и заносится в переменную cnt.

var cnt := a.Count(x -> x > 5);

5. Проверка правильности вывода осуществляется с помощью процедуры CheckOutput:

CheckOutput(cnt);

Всё!

Решение задания учеником

Теперь всё готово к выполнению задания под управлением системы невидимой автоматической проверки.

Закроем среду PascalABC.NET и промоделируем действия ученика на уроке.

Ученик обязательно должен запустить PascalABC.NET из файла урока щелчком мыши на файле с заданием:

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

Наберем часть решения и запустим:

Мы видим, что система автоматической проверки начала свою работу и показала, что необходимо ввести дополнительные данные.

Введем массив N вещественных любым доступным способом:

Здесь мы ошиблись - надо ввести вещественный массив:

Это сообщение системы невидимой проверки выводится серым, что означает, что ошибки нет, и мы на верном пути.

Попытаемся обмануть систему и выведем неверное значение:

Система невидимой проверки показала, что результат неверен.

И наконец правильно решим задачу:

Система невидимой проверки зеленым вывела, что задание выполнено.

Поздравляем! Вы составили и выполнили первое задание под управлением системы невидимой автоматической проверки!

Составление нескольких тестов

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

Это означает, что проверка задания составлена некачественно.

Вернемся к заданию и добавим к проверке дополнительные тесты. Сделать это просто:

Строка

GenerateTests(10,tInt(N,N) + tRe(1,10) * N);

означает "сгенерировать 10 автоматических тестов, каждый тест в качестве входных данных будет содержать одно целое число в диапазоне от N до N (то есть, само число N) и затем N вещественных чисел в диапазоне от 1 до 10".

Здесь tInt, tRe, tChr, tBoo - это функции, которые вызываются только при генерации тестов для задания алгоритма генерации случайного тестового входного значения нужного типа в указанном диапазоне.

После этого запуск предыдущего неправильного решения ученика приведет к следующему выводу:

Итак, произошло следующее:

1. Ученик попытался обмануть систему, ввел определённые данные, не написал алгоритм и вывел результат для этих данных.
2. Система невидимой проверки проверила его решение и посчитала его верным.
3. Система невидимой проверки не поверила ученику и предложила 10 своих тестов, где в качестве входных данных сгенерировала случайные значения по спецификации tInt(N,N) + tRe(1,10) * N
4. На одном из таких тестов 3 7 8 5 (сгенерировано автоматически 3 вещественных числа 7 8 5) система "поймала" ученика, вывела данные теста, вывела неправильный ответ ученика и правильный результат, который необходимо было вывести если бы эти данные были бы введены.

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

Протокол выполнения заданий учеником

Протокол выполнения заданий учеником хранится в файле db.txt в папке урока. Он имеет вид:

Урок-1. ArrTask1 2023-11-01 11:36:05Z IOError InputCount(1,4)
Урок-1. ArrTask1 2023-11-01 11:36:59Z IOError InputCount(1,4)
Урок-1. ArrTask1 2023-11-01 11:38:05Z IOError InputCount(1,4)
Урок-1. ArrTask1 2023-11-01 11:56:53Z IOError InputCount(1,4)
Урок-1. ArrTask1 2023-11-01 11:59:13Z IOError InputType(2,real,integer)
Урок-1. ArrTask1 2023-11-01 12:00:05Z IOError OutputCount(0,2)
Урок-1. ArrTask1 2023-11-01 12:46:46Z BadSolution NoInfo
Урок-1. ArrTask1 2023-11-01 12:48:19Z Solved NoInfo

При каждом запуске в конец этого файла добавляется строка, характеризующая текущий запуск. Она содержит имя урока, имя задания, время запуска и результат запуска - степень выполнения и дополнительные параметры. По данному содержимому видно, что ученик 4 раза запустил программу, в которой было введено всего одно число, после этого он ввел неверный тип при вводе массива (ошибка InputType(2,real,integer) во втором элементе), затем он выводил неверное количество данных (ошибка OutputCount(0,2) - выведено 0, а надо вывести 2 элемента), после этого неправильно решил задание (BadSolution) и наконец решил правильно (Solved).

Разработка следующих заданий урока

Следующие задания разрабатываются существенно проще.

Скажем, мы добавляем в папку урока новое задание ArrTask2.pas с формулировкой задания в комментарии. Тогда чтобы оно стало проверяемым, мы также должны добавить в модуль Tasks.pas строки

Мы также должны добавить в модуль Tasks.pas строки

    'ArrTask2': begin
      // Здесь - текст чекера
    end;

Заключение

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

1. Разработка заданий осуществляется в той же среде, что и решение заданий учеником

2. Разработка заданий проста и для последующих задач по данной теме занимает 2-3 минуты на задание.

3. Задания проверяют типы при вводе-выводе (в системах олимпиадного тестирования из файла считываются лишь текстовые данные, что крайне бедно)

4. Решение задания учеником выполняется непосредственно в среде PascalABC.NET без каких-то дополнительных действий. Текст программы не надо копировать на интернет-страницу сетевой тестирующей системы.

5. Задание проверяется в момент запуска программы ученика - нет ожидания ответа от сервера.

В следующих статьях о системе LightPT мы рассмотрим более сложные случаи составления заданий.

Пока это последняя статья цикла.

В данной статье мы рассмотрим, как обойти полученное синтаксическое дерево AST и какие задачи с помощью этого обхода можно решать.

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

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

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

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

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

Для решения этой важнейшей задачи нам поможет так называемый паттерн проектирования Визитор (Посетитель).

Прежде всего, давайте разберемся, что такое паттерны проектирования. Паттерн проектирования - это повторяющаяся в разных проектах архитектурная конструкция кода, состоящая из нескольких взаимодействующих классов и решающая определенную задачу. Паттерны проектирования впервые были описаны в книге Э.Гаммы и др. "Приёмы объектно-ориентированного проектирования. Паттерны проектирования".

Паттерн Визитор решает следующую проблему. Узлы синтаксического дерева имеют разные типы, и в каждом узле в зависимости от его типа необходимо выполнить определенное действие. Например, в каждом узле можно вернуть строку - правильно отформатированный код части программы, представляемый этим узлом. Но таких задач может быть много. Встраивать подобные действия в узлы дерева неэффективно - для ькаждой задачи в узел потребуется добавить один метод, и количество таких методов будет разрастаться. Паттерн Визитор предлагает выделить все действия по решению определенной задачи в отдельный класс, называемый визитором. Тем самым код узлов синтаксического дерева не будет захламляться.

Рассмотрим интерфейс визитора по нашему синтаксическому дереву:

type
  IVisitor<T> = interface
    function VisitNode(bin: Node): T;
    function VisitExprNode(bin: ExprNode): T;
    function VisitStatementNode(bin: StatementNode): T;
    function VisitBinOp(bin: BinOpNode): T;
    function VisitStatementList(stl: StatementListNode): T;
    function VisitExprList(exlist: ExprListNode): T;
    function VisitInt(n: IntNode): T;
    function VisitDouble(d: DoubleNode): T;
    function VisitId(id: IdNode): T;
    function VisitAssign(ass: AssignNode): T;
    function VisitAssignPlus(ass: AssignPlusNode): T;
    function VisitIf(ifn: IfNode): T;
    function VisitWhile(whn: WhileNode): T;
    function VisitProcCall(p: ProcCallNode): T;
    function VisitFuncCall(f: FuncCallNode): T;
  end;

Он состоит из заголовков функций - каждая отвечает за свой тип узла и возвращает некоторое значение типа T. В классах, реализующих этот интерфейс, мы будем возвращать конкретные типы T. Например, в визиторе PrettyPrinter T=string и мы будем в каждой функции строковое представление части кода, связанной с этим узлом.

Обратим внимание, что мы можем создать какое угодно количество конкретных визиторов - классов, реализующих этот интерфейс для решения разных задач - код узлов дерева при этом не изменится!

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

 type
  Node = class
    pos: Position;    
  public
    function Visit<T>(v: IVisitor<T>): T; virtual := v.VisitNode(Self);
  end;
  ExprNode = class(Node)
  public
    function Visit<T>(v: IVisitor<T>): T; override := v.VisitExprNode(Self);
  end;
  StatementNode = class(Node)
  public
    function Visit<T>(v: IVisitor<T>): T; override 
      := v.VisitStatementNode(Self);
  end;
  BinOpNode = class(ExprNode)
  public
    Left,Right: ExprNode;
    Op: OpType;
    constructor (Left,Right: ExprNode; Op: OpType; pos: Position) := 
      (Self.Left,Self.Right,Self.Op,Self.pos) := (Left,Right,Op,pos);
    function Visit<T>(v: IVisitor<T>): T; override := v.VisitBinOp(Self);
  end;
  StatementListNode = class(StatementNode)
  public
    lst: List<StatementNode> := new List<StatementNode>;
    procedure Add(st: StatementNode) := lst.Add(st);    
    function Visit<T>(v: IVisitor<T>): T; override := v.VisitStatementList(Self);
  end;
  ExprListNode = class(Node)
  public
    lst: List<ExprNode> := new List<ExprNode>;
    procedure Add(ex: ExprNode) := lst.Add(ex);
    function Visit<T>(v: IVisitor<T>): T; override := v.VisitExprList(Self);
  end;
  IntNode = class(ExprNode)
  public
    Value: integer;
    constructor(Value: integer; pos: Position) 
    := (Self.Value,Self.pos) := (Value,pos);
    function Visit<T>(v: IVisitor<T>): T; override := v.VisitInt(Self);
  end;
  DoubleNode = class(ExprNode)
  public
    Value: real;
    constructor(Value: real; pos: Position) := (Self.Value,Self.pos) := (Value,pos);
    function Visit<T>(v: IVisitor<T>): T; override := v.VisitDouble(Self);
  end;
  IdNode = class(ExprNode)
  public
    Name: string;
    constructor(name: string; pos: Position) := (Self.Name,Self.pos) := (name,pos);
    function Visit<T>(v: IVisitor<T>): T; override := v.VisitId(Self);
  end;
  AssignNode = class(StatementNode)
  public
    Ident: IdNode;
    Expr: ExprNode;
    constructor(Ident: IdNode; Expr: ExprNode; pos: Position) := (Self.Ident,Self.Expr,Self.pos) := (Ident,Expr,pos);
    function Visit<T>(v: IVisitor<T>): T; override := v.VisitAssign(Self); 
  end;
  AssignPlusNode = class(StatementNode)
  public
    Ident: IdNode;
    Expr: ExprNode;
    constructor(Ident: IdNode; Expr: ExprNode; pos: Position) := (Self.Ident,Self.Expr,Self.pos) := (Ident,Expr,pos);
    function Visit<T>(v: IVisitor<T>): T; override := v.VisitAssignPlus(Self); 
  end;
  IfNode = class(StatementNode)
  public
    Condition: ExprNode;
    ThenStat,ElseStat: StatementNode;
    constructor(Condition: ExprNode; ThenStat,ElseStat: StatementNode; pos: Position) 
      := (Self.Condition,Self.ThenStat,Self.ElseStat,Self.pos) := (Condition,ThenStat,ElseStat,pos);
    function Visit<T>(v: IVisitor<T>): T; override := v.VisitIf(Self);
  end;
  WhileNode = class(StatementNode)
  public
    Condition: ExprNode;
    Stat: StatementNode;
    constructor(Condition: ExprNode; Stat: StatementNode; pos: Position) 
      := (Self.Condition,Self.Stat,Self.pos) := (Condition,Stat,pos);
    function Visit<T>(v: IVisitor<T>): T; override := v.VisitWhile(Self);
  end;
  ProcCallNode = class(StatementNode)
  public
    Name: IdNode;
    Pars: ExprListNode;
    constructor(Name: IdNode; Pars: ExprListNode; pos: Position) := (Self.Name,Self.Pars,Self.pos) := (Name,Pars,pos);
    function Visit<T>(v: IVisitor<T>): T; override := v.VisitProcCall(Self);
  end;
  FuncCallNode = class(ExprNode)
  public
    Name: IdNode;
    Pars: ExprListNode;
    constructor(Name: IdNode; Pars: ExprListNode; pos: Position) := (Self.Name,Self.Pars,Self.pos) := (Name,Pars,pos);
    function Visit<T>(v: IVisitor<T>): T; override := v.VisitFuncCall(Self);
  end;

В каждом методе Visit мы передаем единственным параметром интерфейс описанного нами визитора и в теле метода вызываем соответствующий данному синтаксическому узлу метод визитора. Например, в теле метода Visit класса BinOpNode мы вызываем метод v.VisitBinOp(Self), передавая ему в качестве параметра Self - ссылку на текущий узел синтаксического дерева.

Что мы таким образом приобретаем?

Предположим, мы написали определенный визитор MyVisitor, реализующий интерфейс IVisitor<T> и создали объект этого визитора в переменной v. Тогда вызов метода Visit например для узла BinOpNode вызовет, как мы уже отметили, метод v.VisitBinOp(Self) для нашего класса MyVisitor, тем самым, выполнится конкретное действие, которое мы предусмотрели для узла BinOpNode в классе MyVisitor.

В итоге каждый визитор реализует свой набор действий для разных типов узлов синтаксического дерева, решая какую-то конкретную задачу. А таких задач будет много.

Приведем полный код модуля ASTNodes с интерфейсом визитора:

unit ASTNodes;
uses Common;

type OpType = (opPlus, opMinus, opMultiply, opDivide, 
  opEqual, opLess, opLessEqual, opGreater, opGreaterEqual, opNotEqual, 
  opAnd, opOr, opNot, opBad);

var OpToStr := Dict(
    (opPlus,$'+'),(opMinus,$'-'),(opMultiply,$'*'),(opDivide,$'/'),
    (opEqual,$'=='),(opLess,$'<'),(opLessEqual,$'<='),(opGreater,$'>'),(opGreaterEqual,$'>='),(opNotEqual,$'!='),
    (opAnd,$'&&'),(opOr,$'||'),(opNot,$'!')
  );

type 
  Node = class;
  ExprNode = class;
  StatementNode = class;
  BinOpNode = class;
  StatementListNode = class;
  ExprListNode = class;
  IntNode = class;
  DoubleNode = class;
  IdNode = class;
  AssignNode = class;
  AssignPlusNode = class;
  IfNode = class;
  WhileNode = class;
  ProcCallNode = class;
  FuncCallNode = class;
  IVisitor<T> = interface
    function VisitNode(bin: Node): T;
    function VisitExprNode(bin: ExprNode): T;
    function VisitStatementNode(bin: StatementNode): T;
    function VisitBinOp(bin: BinOpNode): T;
    function VisitStatementList(stl: StatementListNode): T;
    function VisitExprList(exlist: ExprListNode): T;
    function VisitInt(n: IntNode): T;
    function VisitDouble(d: DoubleNode): T;
    function VisitId(id: IdNode): T;
    function VisitAssign(ass: AssignNode): T;
    function VisitAssignPlus(ass: AssignPlusNode): T;
    function VisitIf(ifn: IfNode): T;
    function VisitWhile(whn: WhileNode): T;
    function VisitProcCall(p: ProcCallNode): T;
    function VisitFuncCall(f: FuncCallNode): T;
  end;
  IVisitorP = interface
    procedure VisitNode(bin: Node);
    procedure VisitExprNode(bin: ExprNode);
    procedure VisitStatementNode(bin: StatementNode);
    procedure VisitBinOp(bin: BinOpNode);
    procedure VisitStatementList(stl: StatementListNode);
    procedure VisitExprList(exlist: ExprListNode);
    procedure VisitInt(n: IntNode);
    procedure VisitDouble(d: DoubleNode);
    procedure VisitId(id: IdNode);
    procedure VisitAssign(ass: AssignNode);
    procedure VisitAssignPlus(ass: AssignPlusNode);
    procedure VisitIf(ifn: IfNode);
    procedure VisitWhile(whn: WhileNode);
    procedure VisitProcCall(p: ProcCallNode);
    procedure VisitFuncCall(f: FuncCallNode);
  end;
  
  Node = class
    pos: Position;    
  public
    function Visit<T>(v: IVisitor<T>): T; virtual := v.VisitNode(Self);
  end;
  ExprNode = class(Node)
  public
    function Visit<T>(v: IVisitor<T>): T; override := v.VisitExprNode(Self);
  end;
  StatementNode = class(Node)
  public
    function Visit<T>(v: IVisitor<T>): T; override := v.VisitStatementNode(Self);
  end;
  BinOpNode = class(ExprNode)
  public
    Left,Right: ExprNode;
    Op: OpType;
    constructor (Left,Right: ExprNode; Op: OpType; pos: Position) := 
      (Self.Left,Self.Right,Self.Op,Self.pos) := (Left,Right,Op,pos);
    function Visit<T>(v: IVisitor<T>): T; override := v.VisitBinOp(Self);
  end;
  StatementListNode = class(StatementNode)
  public
    lst: List<StatementNode> := new List<StatementNode>;
    procedure Add(st: StatementNode) := lst.Add(st);    
    function Visit<T>(v: IVisitor<T>): T; override := v.VisitStatementList(Self);
  end;
  ExprListNode = class(Node)
  public
    lst: List<ExprNode> := new List<ExprNode>;
    procedure Add(ex: ExprNode) := lst.Add(ex);
    function Visit<T>(v: IVisitor<T>): T; override := v.VisitExprList(Self);
  end;
  IntNode = class(ExprNode)
  public
    Value: integer;
    constructor(Value: integer; pos: Position) := (Self.Value,Self.pos) := (Value,pos);
    function Visit<T>(v: IVisitor<T>): T; override := v.VisitInt(Self);
  end;
  DoubleNode = class(ExprNode)
  public
    Value: real;
    constructor(Value: real; pos: Position) := (Self.Value,Self.pos) := (Value,pos);
    function Visit<T>(v: IVisitor<T>): T; override := v.VisitDouble(Self);
  end;
  IdNode = class(ExprNode)
  public
    Name: string;
    constructor(name: string; pos: Position) := (Self.Name,Self.pos) := (name,pos);
    function Visit<T>(v: IVisitor<T>): T; override := v.VisitId(Self);
  end;
  AssignNode = class(StatementNode)
  public
    Ident: IdNode;
    Expr: ExprNode;
    constructor(Ident: IdNode; Expr: ExprNode; pos: Position) := (Self.Ident,Self.Expr,Self.pos) := (Ident,Expr,pos);
    function Visit<T>(v: IVisitor<T>): T; override := v.VisitAssign(Self); 
  end;
  AssignPlusNode = class(StatementNode)
  public
    Ident: IdNode;
    Expr: ExprNode;
    constructor(Ident: IdNode; Expr: ExprNode; pos: Position) := (Self.Ident,Self.Expr,Self.pos) := (Ident,Expr,pos);
    function Visit<T>(v: IVisitor<T>): T; override := v.VisitAssignPlus(Self); 
  end;
  IfNode = class(StatementNode)
  public
    Condition: ExprNode;
    ThenStat,ElseStat: StatementNode;
    constructor(Condition: ExprNode; ThenStat,ElseStat: StatementNode; pos: Position) 
      := (Self.Condition,Self.ThenStat,Self.ElseStat,Self.pos) := (Condition,ThenStat,ElseStat,pos);
    function Visit<T>(v: IVisitor<T>): T; override := v.VisitIf(Self);
  end;
  WhileNode = class(StatementNode)
  public
    Condition: ExprNode;
    Stat: StatementNode;
    constructor(Condition: ExprNode; Stat: StatementNode; pos: Position) 
      := (Self.Condition,Self.Stat,Self.pos) := (Condition,Stat,pos);
    function Visit<T>(v: IVisitor<T>): T; override := v.VisitWhile(Self);
  end;
  ProcCallNode = class(StatementNode)
  public
    Name: IdNode;
    Pars: ExprListNode;
    constructor(Name: IdNode; Pars: ExprListNode; pos: Position) := (Self.Name,Self.Pars,Self.pos) := (Name,Pars,pos);
    function Visit<T>(v: IVisitor<T>): T; override := v.VisitProcCall(Self);
  end;
  FuncCallNode = class(ExprNode)
  public
    Name: IdNode;
    Pars: ExprListNode;
    constructor(Name: IdNode; Pars: ExprListNode; pos: Position) := (Self.Name,Self.Pars,Self.pos) := (Name,Pars,pos);
    function Visit<T>(v: IVisitor<T>): T; override := v.VisitFuncCall(Self);
  end;
end.

Напишем простой прикладной визитор простой печати текста программы по синтаксическому дереву. Унаследуем его от IVisitor<string>. Это значит, что каждый его метод будет возвращать строку - часть текста программы, соответствующая данному узлу. Поместим этот визитор в модуль SimplePrint:

unit SimplePrint;
uses ASTNodes;
type 
  SimplePrintVisitor = class(IVisitor<string>)
  public  
    function VisitNode(n: Node): string := n.Visit(Self);
    function VisitExprNode(ex: ExprNode): string := ex.Visit(Self);
    function VisitStatementNode(st: StatementNode): string := st.Visit(Self);
    function VisitBinOp(bin: BinOpNode): string := bin.Left.Visit(Self) + OpToStr[bin.Op] + bin.Right.Visit(Self);
    function VisitStatementList(stl: StatementListNode): string := 
      stl.lst.Select(x -> x.Visit(Self)).JoinToString(NewLine);
    function VisitExprList(exlist: ExprListNode): string := exlist.lst.Select(x -> x.Visit(Self)).JoinToString(',');
    function VisitInt(n: IntNode): string := n.Value.ToString;
    function VisitDouble(d: DoubleNode): string := d.Value.ToString;
    function VisitId(id: IdNode): string := id.Name;
    function VisitAssign(ass: AssignNode): string := ass.Ident.Name + ' := ' + ass.Expr.Visit(Self);
    function VisitAssignPlus(ass: AssignPlusNode): string := ass.Ident.Name + ' += ' + ass.Expr.Visit(Self);
    function VisitIf(ifn: IfNode): string 
      := 'if ' + ifn.Condition.Visit(Self) + ' then '+ ifn.ThenStat.Visit(Self) 
        + (ifn.ElseStat = nil ? '' : ifn.ElseStat.Visit(Self));
    function VisitWhile(whn: WhileNode): string
      := 'while '+ whn.Condition.Visit(Self) + ' do '+ NewLine + whn.Stat.Visit(Self);
    function VisitProcCall(p: ProcCallNode): string := p.Name.Name + '(' + p.Pars.Visit(Self) + ')';
    function VisitFuncCall(f: FuncCallNode): string := f.Name.Name + '(' + f.Pars.Visit(Self) + ')';
  end;
end.

Воспользуемся им в основной программе:

uses LexUnit,ParseUnit,SemanticCheck,Common,SimplePrint;
begin
  var text := 'i = 1; sum = 0.0; while i<100000000 do {sum += 1/i; i += 1}; print(sum)';  
  var lex := new Lexer(text);
  try
    var par := new Parser(lex);
    var progr := par.MainProgram;
    var semcheck := new SemanticCheckVisitor;
    progr.VisitP(semcheck);
    progr.Visit(new SimplePrintVisitor).Println;
  except
    on e: LexerException do
      OutputError('Лексическая ошибка:',e,lex.Lines);
    on e: SyntaxException do
      OutputError('Синтаксическая ошибка:',e,lex.Lines);
    on e: SemanticException do
      OutputError('Семантическая ошибка:',e,lex.Lines);
  end;  
end.

Результат:

i := 1
sum := 0
while i<100000000 do 
sum += 1/i
i += 1
print(sum) 

Заключение. Мы рассмотрели важный для создания интерпретаторов и достаточно сложный паттерн проектирования Визитор, применили его к нашему синтаксическому дереву и реализовали конкретный визитор для упрощенного вывода текста программы, занимающий около 20 строк.