Синтаксис макроса Pythonic

Вы должны взглянуть на MetaPython , чтобы увидеть, достигает ли он того, что вы ищете .

Вы могли бы рассмотреть взгляд на то, как Шиканье (основанный на.NET язык с синтаксисом, в основном вдохновленным Python), реализует макросы, как описано по телефону http://boo.codehaus.org/Syntactic+Macros .

Это - новый макро-синтаксис, который я придумал на основе идей Kent Fredric. Это анализирует синтаксис в список точно так же, как код анализируется.

макрос Печати:

macro PrintMacro:
    syntax:
      print $stmts

  if not isinstance(stmts, list):
    stmts = [stmts]
  return Printnl(stmts, None)

, Если макрос:

@MultiLine
macro IfMacro:
  syntax:
    @if_ = if $cond: $body
    @elifs = ZeroOrMore(elif $cond: $body)
    Optional(else: $elseBody)

  return If(
      [(cond, Stmt(body)) for cond, body in [if_] + elifs],
      elseBody != None and Stmt(elseBody) or None
    )

X к Y [содержащему] [шаг Z] макрос:

@Partial
macro ToMacro:
  syntax:
    $start to $end Optional(inclusive) Optional(step $step)

  if step == None:
    step = quote 1
  if inclusive:
    return quote:
      xrange($start, $end+1, $step)
  else:
    return quote:
      xrange($start, $end, $step)

Кроме незначительной проблемы использования декораторов для идентификации макро-типа моей единственной реальной проблемой с этим является способ, которым можно назвать группы, например, в если случай. Я использую @name =..., но это просто сильно пахнет Perl. Я не хочу просто использовать имя =..., потому что это могло конфликтовать с макро-шаблоном для соответствия. Какие-либо идеи?

Слияние BNF

class IfMacro(Macro):
    syntax: "if" expression ":" suite ("elif" expression ":" suite )* ["else" ":" suite] 

    def handle(self, if_, elifs, elseBody):
        return If(
            [(expression, Stmt(suite)) for expression, suite in [if_] + elifs],
            elseBody != None and Stmt(elseBody) or None
            )

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

macro PrintMacro:
  syntax:  
          print $a
  rules:  
        a: list(String),  as vars
  handle:
       # do something with 'vars' 

macro IfMacro:
  syntax: 
      if $a :
          $b
      $c 
   rules: 
        a: 1 boolean  as if_cond 
        b: 1 coderef     as if_code 
        c: optional macro(ElseIf) as else_if_block 

    if( if_cond ):
          if_code();
    elsif( defined else_if_block ): 
          else_if_block(); 

стиль кавычки Perl Реализации, но в Python! (это - очень плохая реализация и примечание: пробел является значительным в правиле)

macro stringQuote:
  syntax:  
          q$open$content$close
  rules:  
        open:  anyOf('[{(/_') or anyRange('a','z') or anyRange('0','9');
        content: string
        close:  anyOf(']})/_') or anyRange('a','z') or anyRange('0','9');
  detect: 
      return 1 if open == '[' and close == ']' 
      return 1 if open == '{' and close == '}'
      return 1 if open == '(' and close  == ')'
      return 1 if open == close 
      return 0
  handle: 
      return content;

Если Вы только спрашиваете о синтаксисе (не реализация) макросов в рамках Python, то я полагаю, что ответ очевиден. Синтаксис должен тесно соответствовать тому, что Python уже имеет (т.е." def" ключевое слово).

, Реализуете ли Вы это, поскольку одно из следующего ваше дело:

def macro largest(lst):
defmac largest(lst):
macro largest(lst):

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

def twice_second(a,b):
    glob_i = glob_i + 1
    return b * 2
x = twice_second (1,7);

и

defmac twice_second(a,b):
    glob_i = glob_i + 1
    return b * 2
x = twice_second (1,7);

функционально эквивалентны.

способ, которым я реализовал бы это, с препроцессором (а-ля C), который был бы:

• замена весь defmac's с defs во входном файле.
• передача это через Python для проверки синтаксиса (подлый бит, это).
• откладывает defmac's в.
• находят все использование каждого макроса и "встраивают" их, с помощью собственных зарезервированных переменных, таких как преобразование локального var a с __macro_second_local_a.
• возвращаемое значение должно быть специальной переменной также (macro_second_retval).
• глобальные переменные сохранили бы свои настоящие имена.
• параметру можно дать имена _macro_second_param_XXX.
• , после того как все встраивание сделано, удалите defmac 'функции' полностью.
• передают результирующий файл через Python.

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

Так:

x = twice_second (1,7);

становится:

# These lines are the input params.
__macro_second_param_a = 1
__macro_second_param_b = 7

# These lines are the inlined macro.
glob_i = glob_i + 1
__macro_second_retval = __macro_second_param_b * 2

# Modified call to macro.
x = __macro_second_retval

Это - текущий механизм для определения синтаксиса при помощи стандартного класса Python.

макрос Печати:

class PrintMacro(Macro):
  syntax = 'print', Var
  def handle(self, stmts):
    if not isinstance(stmts, list):
      stmts = [stmts]
    return Printnl(stmts, None)

макро-класс If/elif/else:

class IfMacro(MLMacro):
  syntax = (
      ('if', Var, Var),
      ZeroOrMore('elif', Var, Var),
      Optional('else', Var)
    )
  def handle(self, if_, elifs, elseBody):
    return If(
        [(cond, Stmt(body)) for cond, body in [if_] + elifs],
        elseBody != None and Stmt(elseBody) or None
      )

X к Y [содержащему] [шаг Z] класс макроса:

class ToMacro(PartialMacro):
  syntax = Var, 'to', Var, Optional('inclusive'), Optional('step', Var)
  def handle(self, start, end, inclusive, step):
    if inclusive:
      end = ['(', end, '+', Number(1), ')']
    if step == None: step = Number(1)
    return ['xrange', ['(', start, end, step, ')']]

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

Это - макро-синтаксис, который я придумал для своего надмножества Python.

макрос Печати:

macro PrintMacro:
    syntax:
        stmts = 'print', Var

  if not isinstance(stmts, list):
    stmts = [stmts]
  return Printnl(stmts, None)

, Если макрос:

@MultiLine
macro IfMacro:
  syntax:
    if_ = 'if', Var, Var
    elifs = ZeroOrMore('elif', Var, Var)
    else_ = Optional('else', Var)

  return If(
      [(cond, Stmt(body)) for cond, body in [if_] + elifs],
      elseBody != None and Stmt(elseBody) or None
    )

X к Y [содержащему] [шаг Z] макрос:

@Partial
macro ToMacro:
  syntax:
    start = Var
    'to'
    end = Var
    inclusive = Optional('inclusive')
    step = Optional('step', Var)

  if step == None:
    step = quote 1
  if inclusive:
    return quote:
      xrange($start, $end+1, $step)
  else:
    return quote:
      xrange($start, $end, $step)

Моя основная проблема с этим - то, что блок синтаксиса неясен, особенно 'к' строке в последнем примере. Я - также не большой поклонник использования декораторов для дифференциации макро-типов.