Макросы Python: варианты использования?

Некоторые примеры лисп-макросов:

• ITERATE — забавная и расширяемая функция циклов.
• CL-YACC/FUCC, которые являются генераторами синтаксических анализаторов, которые генерируют синтаксические анализаторы во время компиляции.
• CL-WHO, который позволяет указывать HTML-документы со статической и динамической частями.
• Parenscript, который является генератором кода javascript.
• Различные простые обёртки кода, например, обработчики ошибок (у меня есть with-gtk-error-message-handler, который выполняет код и показывает GtkMessageDialog, если возникает необработанная ошибка), исполнители (например, получив код, выполняйте его в другом потоке; я иметь макрос внутри основного потока, который выполняет код в разных потоках; библиотека PCall использует макросы для переноса кода выполняться одновременно)
• Построители графического интерфейса с макросами (например, укажите иерархию виджетов и свойства виджетов и генерируйте код макроса для создания всех виджетов)
• Генераторы кода, использующие внешние ресурсы во время компиляции. Например, макрос, обрабатывающий заголовки C и генерирующий код FFI, или макрос, генерирующий определения классов на основе схемы базы данных.
• Декларативное ИФУ. Например, указание сторонних структур, функций, типов их аргументов и наличие макросов для генерации соответствующих структур Лиспа, функций с отображением типов и кодом маршалинга.
• Веб-фреймворки на основе продолжений для Common Lisp используют макросы, которые преобразуют код в форму CPS (стиль передачи продолжения).

Я считаю, что макросы противоречат культуре Python. Макросы в Лиспе допускают подход большой ком грязи; вы можете переопределить язык, чтобы он больше подходил для вашей предметной области. И наоборот, код Pythonic использует наиболее естественную встроенную функцию Python для решения проблемы, вместо того, чтобы решать ее таким образом, который был бы более естественным на другом языке.

Макросы по своей сути не являются питоническими.

Это несколько запоздалый ответ, но MacroPy — это мой новый проект по внедрению макросов в Python. У нас есть довольно обширный список демонстраций, все из которых представляют собой варианты использования, требующие реализации макросов, например, обеспечивающие чрезвычайно краткий способ объявления классов:

@case
class Point(x, y)

p = Point(1, 2)
print p.x   # 1
print p     # Point(1, 2)

MacroPy использовался для реализации таких функций, как:

• Классы case, простые алгебраические типы данных из Scala
• Сопоставление с образцом из мира функционального программирования
• Оптимизация хвостового вызова
• Квазикавычки, быстрый способ манипулировать фрагментами программы
• Интерполяция строк, общая функция многих языков, и Pyxl.
• Трассировка и смарт-утверждения
• PINQ to SQLAlchemy, клон LINQ to SQL из C#
• Быстрые лямбда-выражения из Scala и Groovy,
• Комбинаторы парсеров, вдохновленные Scala.

Посетите связанную страницу, чтобы узнать больше; Я думаю, что могу с уверенностью сказать, что варианты использования, которые мы демонстрируем, намного превосходят все, что кто-либо предлагал до сих пор в этой теме = D

Существует публикация в списке рассылки (зеркалоarchive.org), что довольно хорошо объясняет это. Этот пост посвящен Perl, но он также применим и к Python.

В lisp макросы — это просто еще один способ абстрагировать идеи.

Это пример из незавершенного трассировщика лучей, написанного на clojure:

(defmacro per-pixel
  "Macro.
Excecutes body for every pixel. Binds i and j to the current pixel coord."
  [i j & body]
  `(dotimes [~i @width]
     (dotimes [~j @height]
       ~@body)))

Если вы хотите что-то сделать с каждым пикселем с координатами (i,j), скажем, нарисовать черный пиксель, если i четно, вы должны написать:

(per-pixel i,j
  (if (even? i)
    (draw-black i,j)))

Без макросов здесь не обойтись, потому что @body может означать что угодно внутри (попиксельно i j @body)

Что-то подобное было бы возможно и в питоне. Вам нужно использовать декораторы. Вы не можете делать все, что можете, с помощью макросов lisp, но они очень мощные.

Ознакомьтесь с этим руководством по декоратору: http://www.artima.com/weblogs/viewpost.jsp?thread=240808

Вот один реальный пример, с которым я столкнулся, который был бы тривиален с макросами или реальной поддержкой метапрограммирования, но должен быть выполнен с манипуляцией байт-кодом CPython из-за отсутствия обоих в Python:

http://www.aminus.net/dejavu/chrome/common/doc/2.0a/html/intro.html#cpython

Вот как проблема решается в Common Lisp с помощью комбинации обычных макросов и read-макросов для расширения синтаксиса (можно было бы обойтись без последних, но не с первыми):

http://clsql.b9.com/manual/csql-find.html

Та же проблема решена в Smalltalk с использованием замыканий и метапрограммирования (Smalltalk — один из немногих ОО-языков с единой диспетчеризацией, который действительно обеспечивает правильную передачу сообщений):

http://people.csail.mit.edu/gregs/ll1-discuss-archive-html/msg02096.html

Здесь я попытался реализовать подход Smalltalk в Common Lisp, что является хорошей иллюстрацией того, как плохо поддерживается метапрограммирование в последнем:

http://carcaddar.blogspot.com/2009/04/закрытие-ориентированное-метапрограммирование-via.html

Некоторые варианты использования, которые я видел ранее, включают создание фабрик классов или удаление операторов ведения журнала из производственного кода.

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

1. Создание DSL или более красноречивого синтаксиса для чего-либо (хороший пример — макрос Lisp LOOP). В данном случае философия Python преднамеренно отказалась от него. Если вам не хватает какой-то явной записи, вы всегда можете запросить PEP.

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

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

И в качестве примечания, я бы предпочел перезапуски Lisp в Python, чем макросы.

Прочтите "The Lambda Papers", чтобы понять, почему вообще можно воспользоваться макросами.

Вы должны начать с «AIM-353 Lambda: The Ultimate Imperative» и следовать за ним с «AIM-443 Lambda: Ultimate GOTO». Оба можно найти здесь:

http://library.readscheme.org/page1.html

Hy, Для собственного использования я создал модуль Python (Espy), который позволяет определять макросы с аргументами, циклами и генерацией условного кода: вы создаете файл source.espy, затем запускаете соответствующую функцию, затем генерируется source.py.

Он допускает следующий синтаксис:

macro repeat(arg1):
    for i in range(%arg1%):
        socket
    print "stop"
   ...
repeat(5):
    print "Hi everybody"
    print "See you soon"

эквивалентно:

...
for i in range(5):
    print "Hi everybody"
    print "See you soon"
print "stop"

Другой синтаксис:

macro doit(arg1):
    for i in %arg1%:
        socket suit(arg2):
            socket
            print %arg2%
        socket check(arg3):
            if %arg2%==%arg3%:
                socket
...
#use
doit(range(10)):
    suit(result):
        result=i*i
    check(result,25):
        print "I knew that 5*5 == 25"

эквивалентно:

for i in range(10):
    result=i*i
    print result
    if result==25:
        print "I knew that 5*5 == 25"

Еще у Espy есть 2 функции: "макрос для" и "макрос если". Пример:

macro for v in [6,10,12,20,23]:
    macro if 7<%v%<22:
        True:
            print "At %v%, I'm awake."
        False:
            print "At %v%, I'm sleeping."

переводится Эспи на:

print "At 6, I'm sleeping."
print "At 10, I'm awake."
print "At 12, I'm awake."
print "At 20, I'm awake."
print "At 23, I'm sleeping."

Полную документацию и бесплатную загрузку можно найти здесь: http://elp.chronocv.fr

Я использую этот модуль во многих случаях. Это позволяет использовать более структурированные и короткие коды. С его помощью я сгенерировал 65000 строк четкого и эффективного кода Python из 1000 строк шпионского кода для нового проекта шахматного движка (все еще в процессе).

Если бы Python мог включать макросы в будущую версию, это стало бы более впечатляющим.

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

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

Например, есть PEP для добавления цикла do-while. Это, вероятно, будет добавлено в Python, но PEP был создан в 2003 году. Я хотел бы написать do-while циклов сегодня, и я мог бы сделать это, если бы в Python были макросы.

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

Помимо PEP, мне также нужен макрос unless. Вместо того, чтобы писать:

if not is_superman():
    dodge_bullet()

Я мог бы написать:

unless is_superman():
    dodge_bullet()

Мне нужен макрос case (часто называемый cond в Лиспе). Вместо того, чтобы писать:

if x == FOO:
    do_stuff_with_foos()
elif x == BAR:
    do_stuff_with_bars()
elif x == BAZ:
    do_stuff_with_bazs()

Я мог бы написать:

switch x:
   case FOO:
       do_stuff_with_foos()
   case BAR:
       do_stuff_with_bars()
   case BAZ:
       do_stuff_with_bazs()

Их было бы просто реализовать в виде макросов. Более сложные и полезные макросы включают:

• Интерполяция строк в стиле Ruby, например. "hello there {user}" (вероятно, лучше всего реализовано в виде макроса для чтения)
• Сопоставление с образцом

В настоящее время это только функции на других языках. С помощью макросов я мог добавить их в Python. Я мог бы даже написать PEP, который включал бы пример реализации. (Некоторые PEP уже делают это, но они вынуждены модифицировать исходный код C самого интерпретатора.)

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

Единственный способ можно было бы придумать, чтобы сделать это в python, чтобы передать строку в eval.

Ну, я хотел бы вместо

print >> sys.stderr, "abc"

написать

err "abc"

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

я могу сделать

import sys
err = sys.stderr

а потом

print >> err, "abc"

который короче, но все равно занимает слишком много символов в строке.

Я хочу использовать макрос, чтобы включить оператор sql в коде python. - выбрать * из таблицы1

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

if logger.level > logger.DEBUG:
    logger.log('%s' % (an_expensive_call_that_gives_useful_info(),))

с макросами вместо этого можно было бы сделать что-то вроде

DEBUG('%s' % (an_expensive_call_that_gives_useful_info(),))