Як зробити мову гомоніконічною

Згідно з цією статтею, наступний рядок коду Lisp друкує "Hello world" на стандартний вихід.

(format t "hello, world")

Lisp, що є гомоніконімічною мовою , може розглядати код як дані таким чином:

А тепер уявіть, що ми написали такий макрос:

(defmacro backwards (expr) (reverse expr))

назад - це назва макросу, який приймає вираз (представлений у вигляді списку) і повертає його назад. Ось знову "Привіт, світ", на цей раз за допомогою макросу:

(backwards ("hello, world" t format))

Коли компілятор Lisp бачить цей рядок коду, він переглядає перший атом у списку ( backwards) і помічає, що він називає макрос. Він передає неоцінений список ("hello, world" t format)макросу, який переставляє список у (format t "hello, world"). Отриманий список замінює вираз макросу, і саме це буде оцінено під час виконання. Середовище Лісп побачить, що його перший атом ( format) є функцією, і оцінить його, передавши йому решту аргументів.

У Lisp досягти цього завдання досить просто (виправте мене, якщо я помиляюся), оскільки код реалізований як список ( s-вирази ?).

Тепер погляньте на цей фрагмент OCaml (який не є гомоніконічною мовою):

let print () =
    let message = "Hello world" in
    print_endline message
;;

Уявіть, що ви хочете додати гомонікості OCaml, який використовує набагато складніший синтаксис порівняно з Lisp. Як би ти це зробив? Чи має мова володіти особливо легким синтаксисом для досягнення гомонікості?

EDIT : з цієї теми я знайшов інший спосіб досягти гомоконічності, який відрізняється від Lisp: той, що реалізований мовою io . Це може частково відповісти на це питання.

Тут почнемо з простого блоку:

Io> plus := block(a, b, a + b)
==> method(a, b, 
        a + b
    )
Io> plus call(2, 3)
==> 5

Гаразд, тому блок працює. Блок плюс додав два числа.

Тепер давайте зробимо трохи самоаналізу цього маленького хлопця.

Io> plus argumentNames
==> list("a", "b")
Io> plus code
==> block(a, b, a +(b))
Io> plus message name
==> a
Io> plus message next
==> +(b)
Io> plus message next name
==> +

Гаряча свята холодна цвіль. Мало того, що ви можете отримати імена блок-парам. І не тільки ви можете отримати рядок повного вихідного коду блоку. Ви можете прокрастись до коду та пересувати повідомлення всередині. І найдивовижніше з усіх: це жахливо просто і природно. Вірно шукає Іо. Дзеркало Рубі нічого з цього не бачить.

Але, чекайте, ей зараз, не торкайся цього циферблата.

Io> plus message next setName("-")
==> -(b)
Io> plus
==> method(a, b, 
        a - b
    )
Io> plus call(2, 3)
==> -1

Ви можете зробити будь-яку мову гомоніконічною. По суті, ви робите це шляхом "дзеркального відображення" мови (тобто для будь-якого конструктора мови ви додаєте відповідне представлення цього конструктора як даних, подумайте AST). Вам також потрібно додати пару додаткових операцій, таких як цитування та відмітка даних. Це більш-менш це.

У Lisp це було рано через його легкий синтаксис, але сімейство мов В. Таха MetaML показало, що це можливо зробити для будь-якої мови.

Весь процес окреслений в Моделюванні однорідного генеративного метапрограмування . Більш легкий вступ до того ж матеріалу тут .

Компілятор Ocaml написаний в самому Ocaml, тому, безумовно , є спосіб маніпулювати ASTs Ocaml в Ocaml.

Можна уявити додавання вбудованого типу ocaml_syntaxдо мови та defmacroвбудовану функцію, яка приймає введення типу, скажімо

f : ocaml_syntax -> ocaml_syntax

Тепер то , що це тип з defmacro? Добре, що насправді залежить від введення даних, так як навіть якщо fфункція ідентичності, тип отриманого фрагмента коду залежить від переданого в ньому фрагмента синтаксису.

Ця проблема не виникає у простому режимі, оскільки мова динамічно набирається, і жоден тип не повинен бути приписаний макросу під час компіляції. Одне рішення було б мати

defmacro : (ocaml_syntax -> ocaml_syntax) -> 'a

що дозволило б використовувати макрос у будь-якому контексті. Але це небезпечно, звичайно, це дозволить використовувати a boolзамість а string, збій програми під час виконання.

Єдиним принциповим рішенням в мові статичного типу буде мати залежні типи, в яких тип результату defmacroбуде залежати від введення. На сьогодні цей момент стає досить складним, і я б почав із того, щоб вказати на приємну дисертацію Девіда Реймонда Крістіансена.

На закінчення: складний синтаксис не є проблемою, оскільки існує багато способів представити синтаксис всередині мови та, можливо, використовувати метапрограмування як quoteоперацію для вбудовування "простого" синтаксису у внутрішнє ocaml_syntax.

Проблема полягає в тому, щоб це було добре набрано, зокрема, макро механізм запуску, який не допускає помилок типу.

Маючи час компіляції механізм макросів на мові , як OCaml можна, звичайно, дивись , наприклад , MetaOcaml .

Також можливо корисна: Джейн-стріт на метапрограмуванні в Окамлі

Як приклад розглянемо F # (на основі OCaml). F # не є повністю гомонічним, але підтримує отримання коду функції як AST за певних обставин.

У F # ваш файл printбуде представлений як Exprдрук:

Let (message, Value ("Hello world"), Call (None, print_endline, [message]))

Щоб краще виділити структуру, ось альтернативний спосіб, як можна створити ту саму Expr:

let messageVar = Var("message", typeof<string>)
let expr = Expr.Let(messageVar,
                    Expr.Value("Hello world"),
                    Expr.Call(print_endline_method, [Expr.Var(messageVar)]))