Введение

При разработке Scheme упор был сделан на элегантность и простоту языка. Философия языка подчёркнуто минималистская. Его цель - не сваливать в кучу разные полезные конструкции и средства, а напротив - удалить слабости и ограничения, вызывающие необходимость добавления в язык новых возможностей. В результате, Scheme содержит минимум примитивных конструкций и позволяет выразить все, что угодно путём надстройки над ними. В качестве примера можно указать, что язык использует 2 механизма организации циклов:

1. «остаточная» или «хвостовая» рекурсия (англ. tail recursion )
2. итеративный подход (в котором используются временные переменные для сохранения промежуточного результата).

Scheme был первым диалектом Лиспа , применяющим исключительно статические (а не динамические) области видимости переменных, гарантирующим оптимизацию хвостовой рекурсии и поддерживающим данные булевского типа (#t и #f вместо традиционно неуклюжих T и NIL). Он также был одним из первых языков, непосредственно поддерживающих продолжения (англ. continuations ). Начиная со спецификации R^5RS, язык приобрел исключительно мощное и удобное средство для записи макросов на основе шаблонов синтаксического преобразования с «соблюдением гигиены» (англ. hygienic_macro ). В Scheme также реализована «сборка мусора » (англ. garbage collection ), то есть автоматическое освобождение памяти от неиспользуемых более объектов.

В качестве базовых структур данных язык использует списки и одномерные массивы («векторы»). В соответствии с декларируемым минимализмом, (пока) нет стандартного синтаксиса для поддержки структур с именованными полями, а также средств ООП - все это может быть реализовано программистом по его предпочтению, хотя большинство реализаций языка предлагают готовые механизмы.

Как курьёз, можно отметить, что первоначальное название языка Schemer было изменено на настоящее из-за тогдашнего ограничения на длину имён файлов в ITS.

Примеры

Простые математические операции

(+ 2 (* 2 2 ) ) (+ 1 2 3 4 )

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

Предикаты типа

(number? 5 ) (number? "foo" ) (string ? "foo" )

По соглашению, имена всех предикатов заканчиваются символом? .

Проверки на равенство

(eq? "foo" "bar" ) (eq? 5 (+ 2 3 ) ) (eq? (eq? 2 3 ) (eq? 3 4 ) )

Определение макросов для традиционных операций push/pop

(define-syntax push! (syntax-rules () ((push! x l ) (set! l (cons x l ) ) ) ) ) (define-syntax pop! (syntax-rules () ((pop! l ) (let ((x (car l ) ) ) (set! l (cdr l ) ) x) ) ) )

Определение функций

;; факториал в (неэффективном) рекурсивном стиле (define (fact x) (if (< x 3 ) x (* (fact (- x 1 ) ) x) ) ) ;; функция Фибоначчи - требует двойной рекурсии (define (fib n) (cond ((= n 0 ) 0 ) ((= n 1 ) 1 ) (else (+ (fib (- n 1 ) ) (fib (- n 2 ) ) ) ) ) ) ;; сумма элементов списка в характерном для Scheme стиле ;; (вспомогательная функция loop выражает цикл с помощью ;; хвостовой рекурсии и переменной-аккумулятора) (define (sum-list x) (let loop ((x x) (n 0 ) ) (if (null? x) n (loop (cdr x) (+ (car x) n) ) ) ) ) (fact 14 ) (fib 10 ) (sum "(6 6 6 100 ) ) (sum (map fib "(1 2 3 4 ) ) )

Определение функции должно соответствовать следующему прототипу:

(define имя_функции (lambda (список_аргументов) (реализация_функции) ) ) ,

хотя на практике чаще используют сокращённую форму:

(define (имя_функции аргументы) (реализация_функции) ) .

Ввод / Вывод

(write (+ (read ) (read ) ) )

Ссылки

Русскоязычные ссылки

Англоязычные ссылки

Учебники на английском

• Видео-лекции «Structure and Interpretation of Computer Programs» , Harold Abelson и Gerald Jay Sussman
• The Scheme Programming Language , R. Kent Dybvig

Wikimedia Foundation . 2010 .

Смотреть что такое "Scheme (язык программирования)" в других словарях:

Язык программирования формальная знаковая система, предназначенная для записи компьютерных программ. Язык программирования определяет набор лексических, синтаксических и семантических правил, задающих внешний вид программы и действия,… … Википедия

Scheme, также известный под именем Lisp (не путать с Common Lisp) — это современный алгоритмический язык программирования, знаменитый своей ориентацией на функциональную парадигму программирования, однако ей себя не ограничивающий.

Семейство Lisp - второе по длительности применения семейство языков (после Фортрана), основанное Джоном Маккарти в качестве инструмента написания искусственного интеллекта. Одним из активных участников разработки специализированных компьютеров для интерпретации Lisp был Ричард Столлман, впоследствии основатель Фонда Свободного Программного Обеспечения. Как следствие, одним из основных инструментов при разработке на Scheme является Emacs (+Geiser, Scheme-Complete, company-mode). Предполагается, что в какой-то момент Scheme будет внутренним языком Emacs, вместо Emacs Lisp. (Уже сейчас можно посмотреть на EdWin.)

Scheme — это Lisp, ориентированный на лёгкость портирования, функциональный подход и внедрение лучших практик теории языков программирования.

Scheme развивается двумя путями. Индивидуальные расширения формулируются согласно процессу, сходному с RFC, и называются SRFI, (Scheme Request For Implementation). В отведённые сроки выходят объединённые редакции «стандартного отчёта», формулирующие, что из себя представляет scheme «в целом». Последним завершённым изданием является Revised 7 Report on Algorithmic Language Scheme (small language), а последним экспериментальным изданием является R7RS-large Red Edition. Предполагается, что до выхода окончательной редакции R7RS-large выйдет семь или восемь промежуточных редакций, и в данный момент рассматриваются редакция 2 (Tangerine), ставящая своей целью формализовать структуры данных, коллекции и numerics и редакция 3, нацеленная на новые фичи.

Заинтересованным специалистам предлагается изучить дискуссионный материал и проголосовать согласно собственному видению вопроса, представившись перед этим заранее в [email protected]

• Строковая библиотека
• Ассоциативные массивы
• Регулярные выражения
• Генераторы/Аккумуляторы
• Целочисленные операции
• Битовые операции
• Математические операции с fixpoint
• Математические операции с floating point
• Битовые вектора
• Гомогенные вектора
• Форматирование
• Большие числа
• Дроби
• Точные числа

Вопросы, которые предлагается рассмотреть в третьем издании:

• Случайные числа
• Простые числа
• Целочисленные множества
• Дискрептивная статистика
• Диапазоны
• Битовые вектора
• Байтовые строки
• Перечисления
• Комбинаторика и перестановки

Anonymous (28.11.2018 23:36:26)

MIT/GNU Scheme - это реализация языка программирования Scheme, предоставляющая интерпретатор, компилятор, отладчик исходного кода, встроенный Emacs-образный редактор и большую библиотеку времени выполнения. MIT/GNU Scheme заточен под программирование больших приложений с быстрым циклом разработки.

Изменения:

• Сборки для Windows больше не распространяются, поскольку существовавшие 32-разрядные сборки малопригодны для современных систем, а для достижения работоспособности 64-разрядной нужны немалые усилия, в которых никто из текущих сопроводителей не заинтересован.
• Для macOS теперь выпускаются только 64-разрядные сборки, поскольку в применяемом в последних выпусках инструментарии поддержка 32-разрядной сборки объявлена устаревшей.
• Переносимая версия для C не включена в этот выпуск, поскольку её не удалось вовремя починить.
• На следующий выпуск запланировано кучу мелких улучшений; первоочерёдными задачами этого выпуска являются нововведения.

Важные нововведения:

Ещё изменения:

• начальная поддержка SMP;
• уведомления сборщика мусора;
• события нитей;
• многие другие мелкие нововведения и исправления.

Несовместимые изменения:

Экспериментальные новые возможности:

• Тип URI имеет новый синтаксис: #<...> . И читатели, и писатели работают с этим синтаксисом.

GNU Guile 2.9.1 (beta)

Guile - это реализация языка программирования Scheme от GNU, поддерживающая многие SRFI, реализующая стандарт R5RS, предоставляющая модульную систему, полный доступ к системным вызовам POSIX, поддержку сети, нитей, динамического связывания, вызовов внешних функций и мощную обработку строк. Guile может интерпретировать код интерактивно, компилировать его в байткод виртуальной машины и даже подключаться библиотекой в качестве встроенного в приложение интерпретатора.

2.9.1 - первый beta-выпуск готовящейся к стабильному выпуску 3.0 ветки. По сравнению с текущей стабильной веткой (2.2.x), в ней добавлена JIT-компиляция, ускоряющая все Guile-программы до 4-х раз. В этом выпуске JIT поддерживается только на x86-64; в будущих выпусках планируется поддержка всех платформ, поддерживаемых GNU lightning.

GNU Guile-CV 0.2.0

Guile-CV - это библиотека компьютерного зрения для языка программирования GNU Guile, являющаяся привязкой к библиотеке Vigra, написанной на C++, и работающая через прослойку Vigra C. Guile - реализация языка Scheme, диалекта Lisp.

Вышел язык программирования Racket 7.0

GNU Guile-CV 0.1.9

Guile-CV - это библиотека компьютерного зрения для языка программирования GNU Guile, являющаяся привязкой к библиотеке Vigra, написанной на C++, и работающая через прослойку Vigra C. Guile - реализация языка Scheme, диалекта Lisp.

Изменения с версии 0.1.8:

• Обновлены зависимости. Совместимость теперь поддерживается с Vigra C от коммита a2ff675f4 и выше, из-за изменений в январе этого года: в интерфейсе vigra_nonlocalmean_c переименован аргумент, в функции vigra_medianfilter_c добавлен аргумент out-of-bound strategy .
• Новые интерфейсы: im-median-filter , im-median-filter-channel , im-nl-means , im-nl-means-channel .
• Исправления: в модуле (cv support latex) , использующем latex-pdftoppm — недокументированной, но весьма полезной для подготовки текста к добавлению на изображения процедуре - опциональный аргумент с ключевым словом [#:res 72] фактически не использовался, теперь это исправлено.

Вышла новая версия 0.2.3 веб-фреймворка GNU Artanis на языке Scheme

Фреймворк написан на реализации языка Scheme — Guile Scheme и предназанчен для создания динамических веб-сайтов, веб-приложений, веб-сервисов и веб-ресурсов.

Фреймворк также предоставляет инструменты для работы с БД, шаблонами, сессиями, кэшированием, URL-remapping для RESTful и т.д.

Само название Artanis происходит от обратного Sinatra — веб-фреймворка на Ruby.

Artanis похож на такие веб-фреймворки, как Ruby Sinatra, Python Flask и Java Spark.

Имя главного разработчика — Nala Ginrut, опять же от обратного Alan Turing.

Guile-Ncurses 2.0

Состоялся релиз guile-ncurses 2.0 — библиотеки для создания текстовых пользовательских интерфейсов на GNU Guile, реализации функционального языка программирования Scheme. guile-ncurses является оберткой к библиотеке Ncurses.

Вышел GNU Guile 2.0.10

GNU Guile - это проект по развитию свободной реализации функционального языка программирования Scheme, поддерживающий возможность встраивания кода в приложения на других языках программирования.

Релиз содержит 253 коммита от 11 людей, принятые за 11 месяцев.

Помимо исправлений множества ошибок, релиз содержит новые возможности, таких как имплементация векторной библиотеки SRFI-43 и API для тестирования SRFI-64 , частичная поддержка нового стандарта языка Scheme R7RS и расширение GDB для отладки Guile.

Опубликован перевод книги «Lisp in Small Pieces»

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

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

Здесь нет откровений, невероятно эффективных оптимизаций, мощных систем типов и прочих атрибутов современной computer science (книге 20 лет всё же), но есть отличное твёрдое введение в реализацию языков программирования, призванное заинтересовать новичков, познакомить их с основными понятиями и приёмами этого дела, построив таким образом фундамент для дальнейшего развития.

Сегодня, 22 января 2013 года, состоялся новый релиз широко известного в узких кругах интерпретатора языка программирования Scheme — Scheme48, разработчиком которого является один из основных членов Руководящего комитета (Steering committee) Scheme Джонатан Риз. Релиз имеет номер 1.9 и является достаточно долгожданным, поскольку интерпретатор не обновлялся сравнительно давно.

Основные добавления таковы:

• добавлен новый механизм FFI (старый пока тоже доступен, однако, в скором времени будет удален);
• добавлен набор функций для поддержки сети (с полной поддержкой IPv6 и UDP, пока не документирован);
• записи теперь поддерживают наследование (доступно через пакет r6rs-records);
• добавлен letrec*;
• интерпретатор теперь предупреждает о циклических зависимостях и переопределениях в модулях;
• добавлен статистический профилировщик;
• если VM интерпретатора собирается компилятором, поддерживающим GNU C, то используется прямой шитый код, что позволяет ускорить выполнение;
• другие добавления, касающиеся поддержки возможностей R6RS, системы сборки и лицензирования (по ссылке «Подробности»).

Список важнейших изменений:

• переработан собственный сборщик мусора BIBOP GC, который теперь используется по умолчанию;
• переписана реализация syntax-rules;
• другие изменения, касающиеся системы сборки, лицензирования и поддержки POSIX (по ссылке «Подробности»).

Вышла новая версия реализации языка Scheme - GNU Guile 2.0.7. Несмотря на незначительное изменение номера версии, появились несколько интересных нововведений, а именно:

• Полная поддержка инфиксных выражений (curly-infix-expressions). Теперь вместо (* a (+ b c)) можно писать {a * {b + c}}.
• Поддержка разных опции чтения (read option) для разных портов.
• Поддержка вложенных директив future.
• Специальный синтаксис для добавления путей в переменные окружения GUILE_LOAD_PATH и GUILE_LOAD_COMPILED_PATH в конец списка путей, а не в начало.
• Исправлен недочет в функции load-in-vicinity, которая не сканировала директории, установленные в переменной %load-compiled-path.
• Исправлен порядок поиска расширений. Теперь Guile не изменяет для этого переменную окружения LD_LIBRARY_PATH.
• Функция make-vtable-vtable помечена устаревшей, рекомендуется использовать make-vtable и .
• Оптимизированы вызовы equal? и eqv? для случаев, когда один из аргументов - константа.
• Новые предупреждения компилятора -Wduplicate-case-datum и -Wbad-case-datum.
• Многочисленные незначительные улучшения и исправления ошибок.

GNU Guix - новый менеджер пакетов от команды GNU

Людовик Кортес (Ludovic Courtès), один из участников проекта GNU, объявил о выпуске первой альфа-версии нового менеджера пакетов для любых дистрибутивов GNU/Linux - GNU Guix, создающегося на базе менеджера пакетов Nix .

Кроме стандартных функций установки, удаления и обновления ПО GNU Guix будет поддерживать транзакционные обновления с возможностью отката на прежнюю версию, работать без привилегий root, содержать отдельные профили настроек для каждого пользователя и включать в себя сборщик мусора (для отслеживания и игнорирования неактуальных пакетов). Но самая главная особенность GNU Guix заключается в том, что его разрабатывают на функциональном языке Scheme.

Получить исходные тексты можно через Git-репозиторий .

Представлена версия 5.2 языка программирования Racket (ранее PLT Scheme).

Новое в этой версии:

• Новая библиотека `db", предоставляющая высокоуровневый интерфейс к популярным РСУБД: MySQL, SQLite, PostgreSQL, а также другим через ODBC.
• Новая коллекция XREPL, предоставлящая вспомогательные команды для цикла чтения-выполнения-печати (REPL) Racket. Она будет полезна людям, которые используют консольную версию Racket и альтернативные редакторы.
• Коллекция `plot" переписана на Racket, теперь она поддерживает вывод в PDF, логарифмические оси, гистограммы и многое другое.
• DrRacket использует традиционные сочетания клавиш: C-t создает новую вкладку, C-w закрывает вкладку, C-r выполняет определения.
• Typed Racket:
  • Typed Racket предоставляет средства для статической отладки производительности: показывается какой код будет оптимизирован, а какой нет.
  • Более интуитвные типы в выводе REPL и сообщениях об ошибках.
  • Поддерживается определение функций с необязательными аргументами с таким же синтаксисом, как в Racket.
• Исправлено несколько проблем с графическим интерфейсом, в том числе с Ubuntu 11.10 (GTK+3) и 64-битной Mac OS X.
• Внуртренние определения теперь имеют семантику `let*" если не содержат обратных ссылок, это исключает потерю проиводительности при использовании внутренних определений вместо `let" и изменяет смысл программ, которые захватывают продолжения во внутренних определениях. Использование внутренних определений теперь считается предпочтительным стилем.

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

Введение

Scheme - функциональный язык программирования, один из двух наиболее известных в наше время диалектов языка Lisp . Гай Стил (Guy L. Steele) и Джеральд Сассмен (Gerald Jay Sussman) из Массачусетского технологического института (MIT ) — создали его в середине 1970-х годов. Именно Scheme долгое время применялся в MIT для обучения программированию (сейчас заменен на Python ) и именно на Scheme написаны примеры в знаменитой книге "Структура и интерпретация компьютерных программ" - библии всякого уважающего себя программиста.

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

Плагин называется SchemeScript и является частью проекта SchemeWay . Скачать последнюю версию данного плагина можно с сайта (после скачивания достаточно скопировать jar-файл в каталог eclipse/plugins ). Проект активно развивается, последняя версия носит название 1.3.0 alpha10 и выпущена 09.05.2010 г. Исходный код доступен на GitHub . Дополнительную информацию о плагине, некоторых трюках, которые допускает SchemeScript , и его возможностях можно узнать из блога Dominique Boucher - автора данного расширения.

Стоит отметить, что даже последняя версия SchemeScript не работает в Eclipse Helios , поэтому пока для разработки на языке Scheme следует использовать Eclipse Galileo .

UPD 17.07.10: Последняя версия на GitHub работает в Eclipse Helios , но ее нужно собирать из исходников. Через некоторое время Доминик обещал пересобрать и дистрибутив.

Eclipse -перспектива Scheme

После установки плагина станет доступна Eclipse -перспектива Scheme . По-умолчанию она выглядит следующим образом:

Перспектива включает в себя вид (в терминах Eclipse ) навигатора по проектам - Navigator , вид с отображением разобранного содержимого редактируемого файла - Outline , в котором будет отображаться список определений констант и функций, а так же два свернутых вида: вид с иконкой в виде буквы лямбда - Definitions и вид Console .

В главное меню Eclipse добавлена группа команд Scheme , предназначенная прежде всего для управления интерпретатором. На панель быстрого запуска выведены три кнопки (снабжены иконками в виде буквы лямбда), слева-направо: запустить интерпретатор, перезапустить интерпретатор и остановить интерпретатор.

Прежде чем приступать к работе с редактором, необходимо создать Eclipse-проект , в котором будут храниться файлы исходного кода. Специфичного для Scheme типа проекта плагин SchemeScript не предоставляет, поэтому нужно создать обычный проект из каталога General :

Созданный проект отобразится в навигаторе:

Теперь в проекте можно выполнить New -> File и создать файл, предназначенный для хранения исходного кода на Scheme . Данный файл должен иметь расширение .ss или .scm . Файлы с данными расширениями будут редактироваться с помощью специального редактора из поставки SchemeScript .

Редактирование исходного кода

SchemeScript предоставляет редактор исходного кода на языке Scheme с довольно богатыми возможностями. Рассмотрим их подробнее.

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

Редактор содержит встроенный анализатор корректности S-выражений . Если, например, пропустить закрывающую скобку, то будет сгенерировано уведомление об ошибке:

Существует так же такая полезная вещь, как автоподстановка или автозавершение выражений . Т.е., если при наборе нажать Ctrl+Space , то всплывет окошко с доступными вариантами завершения вводимой конструкции:

При создании определений (например, с помощью ключевого слова define ) они добавляются в вид Outline , что позволяет при необходимости быстро обратиться к нужному определению:

Плагин SchemeScript добавляет две группы пунктов в контекстное меню редактора кода: Source - содержит команды редактирования исходного кода - и Eval - содержит команды его интерпретации:

Рассмотрим группу пунктов меню Source :

Find definition - осуществляет поиск определения символа в исходном коде. Т.е., например, нам нужно посмотреть как определен символ sqr . Для этого нужно поставить курсор после данного символа

и нажать F12 . Курсор будет перемещен на определение функции sqr , причем данное определение будет выделено:

Complete symbol - с данной командой мы уже познакомились, это - команда автозавершения.

Describe symbol - выводит всплывающую подсказку с описанием символа. Например, рассмотренный нами в прошлом примере символ sqr является функцией:

Insert header comment - добавляет глобальный комментарий в начало файла с исходным кодом. В настройках (см. ниже) можно определить некоторые поля такого комментария - автор, копирайт и т.д.

Insert chapter comment - добавляет комментарий к некоторому блоку кода - набору функций и определений.

Insert section comment - добавляет комментарий к конкретной функции или определению.

Toggle comment - закомментировать/раскомментировать выделенный блок кода. Если блок кода не является комментарием, то к нему добавляются лидирующие символы ";":

И, соответственно, наоборот - если какое-то выражение закомментировано, то символы комментариев убираются:

Compress spaces - убирает лишние предшествующие и последующие пробелы и символы перевода строки. Что-то вроде функции trim :

Format - осуществляет форматирование кода в соответствии с заданными настройками. Расставляет отступы, убирает лишние пробелы и переносы строки.

Код до форматирования

Код после форматирования

Swap S-expressions - меняет порядок следования S-выражений одного уровня вложенности. Например, если в предыдущем примере выполнить данную команду, то list и lambda поменяются местами:

В пункте Scheme главного меню Eclipse содержится команда Find Scheme Symbol (доступна так же по Ctrl + F12 ). При вызове данной команды появляется диалоговое окно, позволяющее быстро найти определение нужной функции. Например, у нас в файле исходного кода определена функция sqr , соответственно, если в поле Enter the symbol prefix: диалогового окна ввести sq , то в поле Matching symbols появится определенная в коде функция sqr :

Если из поля Matching symbols выбрать эту функцию, то курсор в редакторе автоматически перейдет к месту ее определения. Предположим, что у нас несколько файлов с исходным кодом и в каждом определена функция sqr . Тогда помимо самой функции нужно еще выбрать файл. Для этого служит вид Definitions , в который после выбора функции помещается информация о вариантах ее определения из разных файлов:

Интерпретация

Когда код написан, его хочется проверить, например, запустив на интерпретаторе Scheme . Плагин SchemeScript предоставляет возможности и для этого. Прежде всего, это пункт Scheme главного меню Eclipse , содержащий команды выбора нужного интерпретатора и управления им: запуск, перезапуск и останов (необходим в случае зависания приложения, например - вечного цикла. Т.к. Scheme может оптимизировать хвостовую рекурсию, вечный цикл - действительно вечный).

На рисунке видны варианты выбора интерпретатора. Прежде всего это - External Interpreter - подключает внешний интерпретатор, установленный на той же машине, что и Eclipse . Интерпретаторов Scheme сейчас много, под Windows можно использовать, например, Chez Scheme .

Embedded Kawa - входящий в поставку SchemeScript интепретатор Kawa . Представляет собой разрабатываемый под эгидой GNU на Java фреймворк для реализации высокоуровневых и динамических языков, код с которых компилируется в Java-байткод . Позволяет легко использовать в коде на Scheme Java-классы и поэтому хорош в качестве скриптового языка. Помимо интерпретатора содержит и компилятор, что позволяет использовать его в качестве полноценного языка под JVM , как используются Scala , Groovy и Clojure . Некоторые энтузиасты используют Kawa для разработки приложений, работающих на платформе Android .

Remote Interpreter - позволяет выбрать в качестве интерпретатора специальный сервер, запущенный на другой машине. Например, в институте при обучении программированию можно поднять специальный сервер, умеющий интерпретировать Scheme -код. Взаимодействие SchemeScript и данного интерпретатора будет осуществляться по сети.

SISC Interpreter - встроенный REPL от Second Interpreter of Scheme Code - написанного на Java интерпретатора Scheme .

После выбора работающего интерпретатора, например Kawa , его нужно запустить соответствующей командой меню или кнопкой с панели быстрого запуска:

Непосредственно для отправки участков кода на интерпретацию используется группа команд Eval из контекстного меню редактора кода:

Данная группа содержит следующие команды:

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

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

Eval previous expression - выполнить предыдущее относительно курсора выражение. Если в примере

выполнить данную команду, то в интерпретатор будет загружено выражение (* x x) , которое он не сможет выполнить, т.к. параметр x не определен:

Load file in Interpreter - загрузить файл в интерпретатор, т.е. выполнить в интерпретаторе все содержимое файла.

Рассмотрим пример: существует код функции, вычисляющей n- е число Фибоначчи. Мы хотим вычислить четвертое число Фибоначчи:

Если выполнить команду Eval previous expression после (fib 4) , то будет сгенерирована ошибка: интерпретатор не знает определение функции fib :

Если же выполнить команду Load file in Interpreter , а затем - Eval previous expression , то вычисление пройдет корректно:

Поддержка Kawa REPL

Read-eval-print loop (REPL) - простая интерактивная среда программирования, в данной среде пользователь может вводить выражения, которые тут же будут вычислены, а результаты вычисления - отображены пользователю.

В состав Kawa входит такая среда. Например, можно прямо в консоли с запущенным интепретатором определить функцию sum и вычислить ее значение относительно каких-то аргументов (каждая строчка трактуется как одно выражение):

Дополнительно так же существует вид Kawa Stack Trace , позволяющий следить за состоянием стека вызовов при отладке. Чтобы понять как им пользоваться - смоделируем ошибку, например вызовем функцию, вычисляющую квадрат числа, от аргумента "ss" :

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

Стектрейс при этом будет выглядеть так:

Если отжать в виде Kawa Stack Trace кнопку Show Scheme frames only , то будет отображен полный стектрейс, содержащий в том числе и ислючительные ситуации в коде, написанном на Java , а не только на Scheme :

Настройки

Плагин SchemeWay является довольно гибконастраиваемым расширением для среды разработки Eclipse . Чтобы разобраться со всеми его возможностями обязательно стоит рассмотреть настройки. Дерево настроек начинается с группы Scheme :

На странице Scheme доступны следующие настройки:
- Displayed tab with - позволяет задать ширину (в пробелах) для отображения символа табуляции. Это работает, только если в команде не принято заменять табуляции на пробелы.
- Enable structural editing - галочка отвечает за включение/выключение структурированного редактора Scheme . Структурированный редактор работает не с символами, а с S-выражениями целиком. Т.е. по backspace , например, будет удаляться сразу все S-выражение. Так же при открытии скобки будет сразу же добавляться парная закрывающая.
- Save... и Load... позволяют сохранить и наоборот - загрузить - настройки SchemeScript в/из .epf -файл/а.

Страница Appearance отвечает за внешний вид редактора. Позволяет настроить цвет, которым будет выделяться парная скобка (группа Matched parenthesis ), цвет фона редактора (группа Background ) и цвета, используемые при подсветки синтаксиса (группа Foreground ).

На рисунке выше приведен пример установки для строковых констант синего цвета.

Страница Comments отвечает за отображение комментариев. На ней представлены следующие настройки:
- Prefix for comments - префикс, с которого будет начинаться комментарий. По-умолчанию - две точки с запятой (;; ).
- Author field content - содержимое поля Автор, позволяет задать имя/фамилию автора кода.
- Copyright field content - содержимое поля Копирайт, позволяет задать информацию об авторских правах.
- Automatically continue comment from previous line - если данная галочка установлена, то при нажатии Enter после комментария на новой строке комментарий продолжиться, т.е. новая строка начнется с ;; .

Страница Fast Eval Keys позволяет задать команды (т.е. имена Scheme -функций), которые будут выполнены при нажатии соответствующих клавиатурных комбинаций. По-умолчанию каждому Fast Eval Key 0 ... 9 соответствует комбинация клавиш Alt-K, 0...9 . При активном использовании плагина у каждого разработчика формируется набор названий методов, которые он постоянно вызывает (например, метод test , для запуска какого-то тестирующего кода). Соответственно, вызов данный методов можно назначить на клавиатурные комбинации.

Страница Indentation служит для настройки отступов, добавляемых при написании/форматировании кода. Для каждого ключевого слова можно указать настройку отступов, применыемых для его аргументов. Таблица настроек устроена следующим образом: в колонке Symbol задается ключевое слово, отступы для которого настраиваются. Колонка Indentation scheme задает схему расстановки отступов. Схемы бывают следующими:
- default - все под-выражения выравниваются ниже первого символа своего обрамляющего выражения.
- definition - все подвыражения выравниваются как обрамляющее выражение + 2 пробела (похоже на оформление формы define ).
- if - все подвыражения выравниваются как обрамляющее выражение + 4 пробела (похоже на оформление формы if ).
- none - нет отступов, все подвыражения выравниваются так же как и обрамляющее выражение.
- with - наиболее сложная форма выравнивания, используется для функций с длинными именамим и/или большим списком параметров. Первые N -параметров выравниваются с отступом в 4 пробела, остальные - в 2. Столбец Hint задает величину N . Примером использования данной формы служит выравнивание ключевого слова let :

Страница Interpreter позволяет задать настройки интерпретации и разбора кода. Пока таких настроек две: - если галочка установлена, то перед отправкой на интерпретацию файл будет сохранен. Позволяет не помнить о сохранении изменений перед интерпретацией.
- Surround exressions with (begin ...) - обрамлять ли интепретируемые выражения в форму (begin ...) . Как я понимаю, данная опция необходима для работы с некоторыми интепретаторами, которые могут за раз выполнять только одно S-выражение.

Страница External Interpreter позволяет указать используемый внешний интерпретатор. Можно задать следующие параметры:
- Interpreter name - название интерпретатора
- Command line - командную строку, включающую полный путь до интепретатора и какие-то нужные ему для работы опции.
- Working directory - рабочий каталог интерпретатора - каталог, относительно которого он будет вычислять пути к файлам.
- Error Regexp - регулярное выражение для разбора ошибок. Интерпретатор выдает сообщения об ошибках в каком-то своем формате, SchemeScript должен знать как из этой строки с ошибками извлечь информацию о месте нахождения ошибки в исходном коде. Например, для Kawa данное регулярное выражение следующее: [\t ]+at [^(]+\(((.+):(+))\) .

На рисунке выше показан запущенный в консоли внешний интерпретатор chez-scheme .

Страница Remote Interpreter содержит настройки подключения к удаленному интепретатору - интерпретатору, запущенному в качестве сервера и слушающему определенный порт. Соответственно, данная страница позволяет задать имя хоста и порт, на котором этот удаленный интерпретатор работает.

Страница Lexical extensions служит для управления лексическими расширениями Scheme . Содержит два пункта:
- Treat brackets ( or {}) as parentheses - обрабатывать ли фигурные и квадратные скобки так же как и круглые. Т.е. подсвечивать ли пару и контролировать ли парность скобок.
- Accept dash (#) as identifier part - разрешать ли использовать символ решетки как часть имени идентификатора (как я понял - работает не для всех интерпретаторов Scheme ).

Последняя страница - Syntax - позволяет гибко управлять обработкой синтаксиса языка - добавлять и удалять конструкции из групп, что влияет на подсветку синтаксиса при редактировании. На данной странице определены 5 групп:
- Define - определения, содержат ключевые слова, с которых начинаются определения, например - define .
- Special names - специальные именнованые параметры, такие как #!key или #!rest .
- Special forms - специальные формы, такие как if , and , let и т.д. По сути - основная часть ключевых слов языка программирования.
- Mutator - мутаторы, т.е. функции, меняющие состояние. Подсвечиваются иначе, нежели функции, не меняющие состояние.
- Constant - константы, такие как #!eof , #!nul и др. Можно добавить так же #t и #f .

В каждую группу можно добавлять свои элементы, а также удалять существующие. Это очень удобно, при разработке собственного DSL на базе Scheme и работы с ним в редакторе. Помимо явного добавления вариантов, в каждой группе можно указать регулярное выражение, соответствующее ее членам.

Вот что будет, если добавить в группу Define ключевое слово pavel :

Заключение

Мы рассмотрели богатый возможностями и гибконастраиваемый инструмент для разработки на языке программирования Scheme в среде Eclipse . Данный инструмент позволяет редактировать исходный код, взаимодействовать с широким набором интепретаторов, в том числе встроенными и удаленными. Если сравнивать возможности данного плагина с инструментарием для разработки на Scheme , например, под Emacs , то они вполне сопоставимы (за исключением отсутствия таких мелочей, как, замена ключевого слова lambda на символ греческой буквы лямбды). Любой программист, который не хочет осваивать Emacs может использовать Eclipse для знакомства с функциональным программированием или языком Scheme , а также для решения задач и упражнений из SICP . Так же возможно кого-нибудь заинтересует тема разработки на Scheme под JVM с использованием Kawa .

Хочется сказать спасибо автору SchemeScript - Dominique Boucher , который бесплатно разрабатывает эту утилиту. Стоит отметить, что плагин SchemeScript является проектом с открытым исходным кодом и любой программист может помочь в его развитии, добавив возможности, которые ему необходимы.

З.Ы. Возникла мысль, что ту же Scheme трудно изучать, потому что не интересно - нет интересных задач. Обычные математические какие-то вычисления неинтересны, а даже для простой работы с графикой, например, нужна платформа и библиотеки. Интереснее изучать язык, прилагая его к какой-нибудь предметной области. Так вот, SchemeScript + Kawa + Eclipse могут использоваться в качестве платформы для обучения. Посмотрите примеры из SchemeScript (в jar-файле каталог examples ), там есть довольно интересные.

Как обычно вы можете оставить свои комментарии или задать вопросы Суровому челябинскому программисту.

Понравилось сообщение -

Язык Scheme традиционно имеет достаточно хорошую поддержку Emacs. Эта поддержка реализуется набором пакетов, которые могут работать как с произвольными реализациями этого языка (scheme-mode , cmuscheme , quack ), так и поддерживать только конкретные реализации (xscheme , gds , bee-mode , gambit ). Как правило, поддержка конкретных реализация имеет несколько больше возможностей по сравнению с пакетами, ориентированными на поддержку всех реализаций.

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

Scheme-mode

Scheme-mode поставляемый в поставке дистрибутивов Emacs является модификацией lisp-mode для работы с исходным кодом на языке Scheme. Данный пакет реализует следующую функциональность:

• подсветку синтаксиса
• расстановку отступов
• подсветку парных скобок

На базе scheme-mode создано несколько других пакетов — , и другие, которые расширяют его функциональность добавлением функций для выполнения кода прямо из буфера Emacs, и т.п. вещей.

Данный режим включается автоматически для файлов, использующих стандартные расширения для файлов с исходными текстами на Scheme — .scm , .ss и т.п. Чтобы включить данный режим для других файлов, добавьте в свой файл инициализации следующий код (заменив.scm на нужное расширение):

(add-to-list "auto-mode-alist "("\\.scm$" . scheme-mode))

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

Cmuscheme

Пакет cmuscheme был написан Olin Shivers много лет назад, но до сих пор является одним из основных пакетов, обеспечивающих работу со Scheme. Данный пакет реализует интерактивную работу с интерпретаторами языка Scheme. Взаимодействие с интерпретатором реализуется за счет использовании возможностей пакета comint , входящего в поставку Emacs.

Настройка пакета

Настройка пакета достаточно проста — поместите в свой файл инициализации следующий код

(autoload "run-scheme "cmuscheme" "Run an inferior Scheme" t) (setq scheme-program-name "mzscheme" )

и пакет будет автоматически загружен при первом запуске функции run-scheme . Вторая строка в этом примере используется для указания имени интерпретатора Scheme, которое вы можете заменить на свой любимый диалект. Все настройки данного пакета также доступны для интерактивной настройки через группу настройки cmuscheme .

В буфере интерпретатора, создаваемом пакетом, используется специальный режим — inferior-scheme-mode , который можно настроить используя хук inferior-scheme-mode-hook . Кроме того, если существует файл ~/.emacs_SCHEMENAME или ~/.emacs.d/init_SCHEMENAME.scm (где SCHEMENAME — название интерпретатора), то они будут выполнены сразу после загрузки интерпретатора.

Работа с пакетом

Основной функцией пакета является функция run-scheme , которая запускает выбранный интерпретатор языка Scheme и позволяет производить интерактивное выполнение кода не покидая Emacs.

При этом вы можете управлять тем, какая часть кода (выделенный блок, определение функции или отдельное выражение) будет выполнена путем использования разных функций, определенных пакетом — функция scheme-send-definition (сочетания клавиш C-c C-e или C-M-x) передает для выполнения интерпретатору текущее определение; функция scheme-send-region (C-c C-r) позволяет выполнить выделенный кусок исходного кода; функция scheme-send-last-sexp (C-x C-e) используется для вычисления выражения, которое находится перед курсором; а функция scheme-load-file (C-c C-l) позволяет загрузить в интерпретатор файл целиком (она позволяет выполнить код из любого файла, указанного пользователем, а не только из текущего буфера).

Интерпретатор Scheme выполняется в отдельном буфере с именем *scheme* , куда также выводятся и результаты вычисления выражений и функций. Для быстрого переключения в этот буфер из буфера с исходным текстом, существует отдельная функция switch-to-scheme (C-c C-z). Кроме того, поскольку часто требуется выполнить код и просмотреть результаты, то в пакете также определены две функции, которые отправляют интерпретатору код для выполнения, и переключаются в буфер *scheme* — scheme-send-definition-and-go (C-c M-e) для вычисления текущего определения и scheme-send-region-and-go (C-c M-r) для вычисления выделенного исходного кода.

Для работы с макросами пакет предоставляет функцию scheme-expand-current-form (C-c C-x), которая позволяет раскрыть определение текущего макроса в соответствующий код на Scheme. Раскрытие кода производится интерпретатором и выводится в буфер *scheme* . А при работе с реализациями Scheme, которые поддерживают компиляцию исходного кода, пользователь может воспользоваться функциями scheme-compile-file (C-c C-k) и scheme-compile-definition (C-c M-c), которые соответственно выполняют компиляцию файла или текущего определения.

Как отмечалось выше, в буфере интерпретатора действует специальный режим — inferior-scheme-mode в котором работают все команды режима comint , а также следующие команды cmuscheme — scheme-compile-file (C-c C-k), scheme-load-file (C-c C-l), scheme-send-last-sexp (C-x C-e) и scheme-send-definition (C-M-x).

Quack

Пакет Quack является расширением для пакета cmuscheme и реализует следующие дополнительные возможности (многие из них в первую очередь относятся к работе с PLT Scheme):

• меню, позволяющие получать доступ к документации по языку, интерпретатору и SRFI, а также возможность поиска описания для имени функции, находящегося в текущей позиции курсора;
• новые наборы подсветки для font-lock — для PLT Scheme и расширенная, для других реализаций;
• возможность использования греческого символа lambda для обозначения lambda-выражений (примеры приведены ниже);
• дополнительные опции и команды для вставки правильных открывающих и закрывающих скобок;
• расширения для правил расстановки отступов, с возможностью настройки для разных интерпретаторов Scheme;
• расширенная версия команды run-scheme , которая знает имена команд популярных интерпретаторов Scheme, а также запоминает последний запущенный вариант интерпретатора;
• расширенная версия команды switch-to-scheme ;
• возможность просмотра содержимого.plt коллекций и команды для открытия буфера Dired для нужной коллекции.

Установка и настройка

Пакет написан Neil Van Dyke, и доступен для загрузки с сайта автора . Пакет устанавливается путем копирования в каталог, где Emacs сможет найти его, и загружается командой:

(require "quack )

Все настройки пакета могут быть заданы используя группу настройки quack , или используя меню Quack . Эти настройки включают в себя адреса руководств и SRFI, определение префиксного сочетания клавиш, используемого пакетом и т.п.

Пользователям PLT Scheme рекомендуется скачать руководства по данному интерпретатору с сайта проекта и установить их в коллекцию doc . Нахождение коллекций PLT Scheme определяется либо переменной quack-pltcollect-dirs , в которой можно перечислить все каталоги с рабочими коллекциями, либо переменными среды PLTHOME и/или PLTCOLLECTS .

Также для работы пакета требуется наличие программы wget , которая будет использоваться для доступа к SRFI.

Работа с пакетом

После загрузки пакета, в дополнение к функциям cmuscheme и scheme-mode становятся доступными функции, определенные пакетом. Пользователь может выполнять эти функции либо используя стандартные механизмы (сочетания клавиш и/или запуск по имени функции), либо используя меню Quack .

Просмотр документации осуществляется с помощью нескольких функций. Функция quack-view-manual (C-c C-q m) используется для просмотра документации в веб-браузере. Эта команда позволяет просматривать как базовую документацию по языку Scheme, так и документацию по конкретным реализациям. Для просмотра SRFI определена отдельная команда — quack-view-srfi (C-c C-q s), которая запрашивает номер нужного документа и открывает его в браузере. А для пользователей PLT Scheme еще доступна и команда quack-view-keyword-docs (C-c C-q k), которая показывает документацию для заданного ключевого слова (работа этой команды зависит от правильной установки документации PLT Scheme ).

Как уже отмечалось выше, пакетом реализована функция run-scheme (C-c C-q r), которая позволяет запускать интерпретаторы языка Scheme, выбирая их из списка известных (включая запуск с нужными опциями), а также запоминает последний выбор пользователя.

Для пользователей PLT Scheme также определены удобные функции для работы с коллекциями. Функция quack-find-file (C-c C-q f) открывает файл, используя данные из текущего контекста для получения имени файла. Например, если вы используете эту функцию в то время как курсор находится на коде (require (lib "list.ss")) , то вам будет предложено открыть файл list.ss из коллекции mzlib . Кроме того, определена функция quack-dired-pltcollect , которая позволяет открыть буфер Dired для нужной коллекции PLT Scheme (при задании имени пользователь может использовать автодополнение имени коллекции).

Данный пакет также реализует несколько функций, которые изменяют форматирование кода, делая его более удобным для использования. Функция quack-tidy-buffer (C-c C-q t) заново расставляет отступы в коде, заменяет знаки табуляции на пробелы, удаляет лишние пустые строки, удаляет заключительные пробельные символы в строках, а также добавляет знак перевода строки в конце файла, если его нет. Функция quack-toggle-lambda (C-c C-q l) изменяет объявление текущей функции с (define (func args) ...) на (define func (lambda (args) ..)) , что позволяет показывать знак лямбда в коде (при включенной опции отображения данного символа). Например, вот так:

Пакет GCA

GCA — пакет предназначенный для эффективной работы с исходным кодом Scheme. Он разрабатывался для поддержки Gauche Scheme , но может использоваться и с другими диалектами. Как и quack , он расширяет функции пакета cmuscheme .

Данный пакет имеет следующие возможности:

• вставку кусков кода, используя механизм шаблонов
• показ описаний для функций
• дополнение имен

Данный пакет имеет некоторые архитектурные отличия от других пакетов — вместо взаимодействия с интерпретаторами используя стандартный ввод и вывод, данный пакет использует простой сетевой протокол для передачи данных. Данный подход позволяет выполнять большее количество задач, но сильно зависит от реализации интерпретатора и требует отдельного процесса Scheme (сервера gds ), который будет использоваться взаимодействия с другими процессами.

Установка и настройка

Пакет gds поставляется вместе с последними версиями Guile, так что вам необходимо лишь добавить файлы с исходными текстами Emacs Lisp в пути поиска Emacs, и вписать в файл инициализации следующую строчку:

(require "gds )

Данная команда приводит к загрузке пакета и запуска отдельного процесса, который будет отвечать за взаимодействие с интерпретаторами Scheme. Стоит отметить, что для работы пакета необходимо наличие отдельного пакета на Scheme в путях поиска Guile. Если пакет находится в нестандартном месте, то вы можете указать его расположение с помощью переменной gds-scheme-directory , иначе, при отсутствии этого пакета, загрузка пакета не будет произведена полностью.

Остальные настройки могут быть заданы используя группу настройки gds .

Работа с исходным кодом

Пакет gds для вычисления кода использует те же сочетания клавиш, что и cmuscheme . Исключением является функция gds-eval-expression (C-c C-e), которая вычисляет выражение введенное в мини-буфере.

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

Дополнение имен производится функцией gds-complete-symbol (сочетание клавиш M-TAB), которая старается найти все известные символы, чьи имена соответствуют тем буквам, которые находятся перед курсором. Если найдено одно имя, то оно вставляется сразу, но если есть несколько вариантов, то будет показано новое окно, в котором пользователь может выбрать нужное имя.

Получение справки на конкретный символ производится с помощью функции gds-help-symbol (C-h g), которая выдает те же результаты, что и запуск команды (help SYMBOL) в интерактивной среде Guile. Имя символа запрашивается у пользователя через мини-буфер, но в качестве значения по умолчанию используется имя, на котором находится курсор. Если вы не помните точное имя символа, то вы можете воспользоваться функцией gds-apropos (C-h G), которая аналогична выполнению (apropos REGEXP) в Guile, и которая выводит список символов, чьи имена соответствуют введенному регулярному выражению.

Отладка

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

(use-modules (ice-9 gds-client debugging traps)) (named-module-use! "(guile-user) "(ice-9 session)) (gds-accept-input #f)

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

(install-trap (make #:behaviour gds-debug-trap #:procedure proc_name))

и после вызова указанной процедуры, в получите в буфере gds примерно следующее:

Calling procedure: => s s --:** PID XXXXX (Guile-Debug)--All--------

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

Для перемещения по стеку вызовов функций могут использоваться следующие клавиши: u , C-p и стрелка вверх используются для перемещения вверх по стеку вызовов и выбора этого фрейма (функция gds-up), d , C-n и стрелка вниз — для перемещения вниз (gds-down), а клавиша RET используется для выбора фрейма на котором находится курсор.

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

К дополнительным функциям, работающим в буфере стека относятся следующие:

gds-evaluate (клавиша e) позволяет вычислить выражение, используя окружение, соответствующее выбранному фрейму, при этом результат отображается в эхо-области; gds-frame-info (i) показывает информацию о выбранном фрейме — строку в исходном файле, соответствующее выражение, тип фрейма и т.п.; gds-frame-args (A) показывает аргументы фрейма приложения; gds-proc-source (S) показывает исходный код вызванной процедуры. Эта функция очень полезна в тех случаях, когда процедура создана анонимным лямбда-выражением, поскольку такие процедуры показываются в стеке вызовов функций в виде Что не делает понятным, что будет выполнено дальше.

Для продолжения выполнения прерванной программы, gds реализует следующие функции:

gds-go (g , c или q) продолжает выполнение программы; gds-step-file (SPC) выполняет один шаг функций, относящихся к тому же исходному файлу, что и выбранный фрейм стека. Функции из других файлов будут выполняться, но без входа в них; gds-step-into (i) выполняет следующий шаг. Это наиболее детальный уровень выполнения программы; gds-step-over (o) выполняет программу до тех пор, пока не будет закончено выполнение выбранного фрейма стека.

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

Scheme48

scheme48 — еще один пакет основанный на cmuscheme , но реализующий расширенную поддержку реализации Scheme48. Данный пакет добавляет поддержку font-lock для ключевых слов и операторов, специфических для Scheme48, а также дополнительные привязки клавиш для команд вычисления выражений.

Процедура установки этого пакета стандартна — поместите gambit.el в место, где его найдет Emacs, и добавьте следующие строки в файл инициализации:

(autoload "gambit-inferior-mode "gambit" "Hook Gambit mode into cmuscheme." ) (autoload "gambit-mode "gambit" "Hook Gambit mode into scheme." ) (add-hook "inferior-scheme-mode-hook (function gambit-inferior-mode)) (add-hook "scheme-mode-hook (function gambit-mode)) (setq scheme-program-name "gsi -:d-" )

Интерпретатор Gambit запускается с помощью функции run-scheme , реализованной в cmuscheme , но gambit добавляет к ней процедуры фильтрации вывода, что позволяет пакету получать информацию о местоположении в исходном файле. После запуска интерпретатора, пользователь получает возможность использовать стандартные сочетания клавиш для выполнения и компиляции кода — C-x C-e , C-c C-l , C-c C-k и т.д.

В дополнение к функциям cmuscheme , пакет gambit предлагает несколько функций, предназначенных для отладки исходного кода:

gambit-continue (F8 или C-c c) продолжить выполнение кода. Аналогично команде,c интерпретатора; gambit-crawl-backtrace-newer (F9 или C-c ]) перейти к предыдущему фрейму в цепочке. Аналогично команде,- интерпретатора; gambit-crawl-backtrace-older (F10 или C-c [) перейти к следующему фрейму в цепочке. Аналогично команде,+ интерпретатора; gambit-step-continuation (F11 или C-c s) выполнить один шаг вычисления включая вхождение в вызываемую функцию. Аналогично команде,s интерпретатора; gambit-leap-continuation (F12 или C-c l) выполнить один шаг вычисления, не заходя в вызываемую функцию. Аналогично команде,l интерпретатора; gambit-kill-last-popup (C-c _) удалить окно, которое было создано для показа выражения.

Существуют и более короткие сочетания клавиш для этих команд: M-c , M-[ , M-] , M-s , M-l и M-_ , но они по умолчанию не активированы, поскольку они не совсем соответствуют соглашениям, принятым для сочетаний клавиш в Emacs. Чтобы разрешить их использование, вам необходимо выполнить следующую команду (или поместить ее в файл инициализации):

(setq gambit-repl-command-prefix "\e" )

Bee-mode (bmacs)

bmacs — это реализация интегрированной программной среды для работы с Bigloo Scheme . Данный пакет реализует следующие возможности:

• отладку кода;
• профилирование;
• автоматическое создание и обновление файлов Makefile;
• навигация по коду;
• интеграция с системами контроля версий;
• просмотр документации;
• интерактивное выполнение кода;
• раскрытие макросов;
• некоторая поддержка грамотного стиля программирования (literate programming).

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

Установка и настройка

Данный пакет поставляется в составе Bigloo Scheme и находится в подкаталоге bmacs дистрибутива. Для установки пакета надо перейти в этот каталог и там выполнить команду:

Make make install EMACSDIR =

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

(autoload "bdb "bdb" "bdb mode" t) (autoload "bee-mode "bee-mode" "bee mode" t) (setq auto-mode-alist (append "(("\\.scm$" . bee-mode) ("\\.sch$" . bee-mode) ("\\.scme$" . bee-mode) ("\\.bgl$" . bee-mode) ("\\.bee$" . bee-mode)) auto-mode-alist))

Настройки пакета могут быть установлены используя группу настройки bee , которая обеспечивает задание настроек для bee-mode , и групп dbg & bug , используемых для задания настроек отладчика.

Работа с исходным кодом

После загрузки bee-mode пользователь может выполнять основные команды используя соответствующие иконки тулбара, или выбирая нужные пункты из меню Bee , которое появляется при запуске режима.

Для расстановки отступов в соответствии с принятыми для Bigloo соглашениями, пакет bee-mode определяет несколько функций: bee-indent-sexp (C-M-q) расставляет отступы для текущего выражения, bee-indent-define (C-c TAB C-d) делает это для текущего определения функции, bee-indent-last-sexp (C-c TAB C-l) расставляет отступы для выражения перед курсором и т.д.

Очень важный набор функций, используемых при работе с исходным кодом, это функции поиска определений функций и переменных. Чтобы найти определение переменной, вы можете воспользоваться функцией bee-tags-find (C-x 5 .) или bee-tags-find-variable (C-c C-d f). А для поиска определения модуля существует функция bee-find-module (C-c C-d m). Кроме того, bee-mode переопределяет два сочетания клавиш — M-. & M-, которые привязываются к функциям bee-tag-find и bee-tags-find-next , что позволяет находить определения функций и классов.

Для упрощения работы с модулями, bee-mode определяет набор функций, которые управляют списком модулей импортируемых текущим исходным кодом — функция bee-import-binding (C-c RET i), а также списком функций и переменных, экспортируемых из текущего модуля — bee-export-function (C-c RET f) и bee-export-variable (C-c RET v). Кроме того, существует отдельная функция, которая позволяет импортировать символы из файлов на языке C — bee-import-c-file (C-c RET c), а также она обновляет Makefile , добавляя зависимость для компиляции соответствующего кода.

Пакет также обеспечивает некоторую поддержку так называемого грамотного программирования (literate programming). Реализуемая поддержка не является полной, но по крайней мере позволяет вставлять в код ссылки на описания модулей и функций. Это достигается за счет использования ключевых слов @path , @node & @deffn в комментариях для модуля и описаний функций. Ключевые слова @path & @node определяют файл и раздел документации, описывающих данный модуль и указываются в комментарии для объявления модуля. А ключевое слово @deffn указывается в комментарии для функции. Используя эти ключевые слова, разработчик получает возможность быстрого перехода к соответствующим разделам и описаниям функций, что позволяет улучшить документирование кода.

Выполнение и компиляция кода

Также как и другие пакеты, bee-mode позволяет выполнять код Scheme непосредственно из буфера Emacs. Для запуска интерпретатора необходимо выполнить функцию ude-repl-other-frame (C-c C-r C-r), выбрать соответствующую иконку тулбара (Repl ), или соответствующий пункт меню.

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

• ude-repl-send-buffer (C-c C-r b) передает для вычисления весь буфер;
• ude-repl-send-region (C-c C-r r), передает интерпретатору выделенный блок кода;
• bee-repl-send-define (C-c C-r d) используется для выполнения текущего определения (define);
• bee-repl-send-last-sexp (C-c C-r l) вычисляет значение выражения перед курсором;
• bee-repl-send-toplevel-sexp (C-c C-r t) используется для вычисления всего текущего выражения.

Очень часто при использовании макросов необходима возможность их раскрытия. Также как и для работы с обычным кодом, bee-mode реализует набор функций для раскрытия макросов в вашем коде (при этом, весь буфер будет просканирован на предмет наличия определений макросов):

• bee-expand-buffer (C-c C-e C-e) приводит к раскрытию макросов в текущем буфере;
• bee-expand-region (C-c C-e C-r) раскрывает макросы в выделенном коде;
• bee-expand-define (C-c C-e C-d) раскрывает макросы в текущем определении (define)
• bee-expand-last-sexp (C-c C-e C-l) производит раскрытие макросов в выражении перед курсором;
• bee-expand-toplevel-sexp (C-c C-e C-t) раскрывает макросы в текущем выражении.

Для компиляции программ необходимо наличие файла Makefile , который описывает зависимости между модулями и указывает флаги компиляции. Для проекта необходимо наличие так называемого корневого каталога — bee-mode пытается определить корневой каталог проекта путем поиска одного из файлов Makefile , .afile или.etags , или корневой каталог может быть установлен с помощью функции ude-user-set-root-directory (C-c C-p C-r) или соответствующей кнопки тулбара.

После того, как корневой каталог задан, Makefile может быть сгенерирован с помощью функции ude-generate-makefile (C-c C-c a или C-c C-c C-l), которая запросит у пользователя имя исполняемого модуля, в который будет скомпилирован данный исходный код. В том случае, если Makefile уже существует, то эти же сочетания клавиш обновляют его, а также перестраивают файлы.afile и.etags . Кроме того, имеется набор функций для редактирования Makefile — ude-edit-makefile (C-c C-c e), обновления Makefile — ude-update-makefile (C-c C-c u), переключения между отладочной и окончательной версиями программы — ude-makefile-debug-mode (C-c C-c C-d) & ude-makefile-final-mode (C-c C-c C-f) и другие.

Когда Makefile существует, то появляется возможность компиляции кода с помощью функции ude-mode-compile-from-menu (C-c C-c C-c) . Прервать компиляцию можно с помощью функции kill-compilation (C-c C-c k).

И после того, как компиляция закончится, можно выполнить исполняемый модуль с помощью функции ude-execute (C-c C-c C-r).

Отладка и профилирование

Вместе с пакетом Bigloo поставляется и отладчик, который позволяет производить отладку на уровне исходного кода. bee-mode поддерживает взаимодействие с этим отладчиком в Emacs. Для запуска отладчика надо выполнить функцию bee-debug (C-c C-b C-b) или выбрать соответствующую иконку тулбара, или пункт меню. Но запуск отладчика не приводит к автоматическому подключению к нему, поэтому необходимо явно выполнить функцию bee-toggle-connect-buffer (C-c C-b c) чтобы связать текущий буфер с отладчиком, что позволит устанавливать точки останова и выполнять прочие задачи находясь в буфере с исходным текстом.

Профилирование программ поддерживается автоматически, если вы пользуетесь генерацией Makefile . Чтобы провести профилирование кода, необходимо его сначала скомпилировать с поддержкой профилирования, что выполняется функцией bee-profiler-start (C-c C-p c). А после компиляции, вы можете выполнить функцию bee-profiler-inspect (C-c C-p i), что приведет к запуску программы, и затем к запуску утилиты bglprof , которая соберет данные о выполнении, и вы получите их в удобном для анализа виде.

Прочие функции

Пакет предоставляет возможности по получению справочной информации. Это может быть сделано путем запуска функции bee-doc-visit (C-c C-d i) или нажатия на иконку Info в тулбаре. Эта функция ведет себя по разному в зависимости от текущего положения курсора — если курсор находится на идентификаторе, то выдается документация для данного идентификатора, если выделен регион кода, то будет выдана документация для данного региона. В противном случае, у пользователя будет запрошено имя интересующего раздела документации, и показан выбранный раздел.

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

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

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

Поддержка Scheme в SLIME

Для использования SLIME со Scheme, вам необходимо выполнить базовую настройку пакета, как это описано в разделе посвященном этому пакету, а затем загрузить необходимые компоненты . В общем виде это делается следующим образом:

(add-hook "slime-load-hook (lambda () (require "slime-scheme )))

Эта команда установит хуки необходимые для работы со SLIME , но для каждого из поддерживамых диалектов вам может понадобиться выполнить дополнительную настройку в соответствии с инструкциями, изложенными в соответствующем файле — swank-kawa.scm или swank-mit-scheme.scm .

А все остальное, касающееся работы со SLIME , описано в соответствующем разделе .

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

Кроме того, в поставке bmacs также имеются пакеты cee , предназначенный для редактирования кода на языке C, используемого для написания расширений Bigloo, bug-mode, обеспечивающий поддержку отладчика Bigloo, и ude (Unix Development Environment), реализующий поддержку компиляции, и различных утилит, используемых в работе с Bigloo.

Стоит отметить, что если Makefile не существует, то эта функция приводит к запуску компиляции исполняемого модуля из одного файла.

Так называемый swank -модуль.

Все компоненты, относящиеся к Scheme, находятся в подкаталоге contrib дистрибутива SLIME, так что не забудьте добавить его в пути поиска.