;; описываем как парсить объявления типов
(defgeneric parse-type-decl (context type-id args))

;; объявления структур
(defmethod parse-type-decl (context (type-id (eql :struct)) args)
 (destructuring-bind (name members) args
   ;; further impl...
   ))

;; typedef объявления
(defmethod parse-type-decl (context (type-id (eql :typedef)) args)
 (destructuring-bind (source-name aliased-name) args
   ;; further impl...
   ))

;; и т.д.

  macro whenmacro (cond, body)
  syntax ("when", "(", cond, ")", body) 
  {
    def res1 = match (cond)
    {
      | <[ $subCond is $pattren ]> with guard = null
      | <[ $subCond is $pattren when $guard ]> =>
        def res2 = match (pattren)
        {
          | PT.PExpr.Call when guard != null => 
            <[ match ($subCond) { | $pattren when $guard => $body : void | _ => () } ]>
          | PT.PExpr.Call => 
            <[ match ($subCond) { | $pattren => $body : void | _ => () } ]>
          | _ => <[ match ($cond) { | true => $body : void | _ => () } ]>
        }
        res2
      | _ => <[ match ($cond) { | true => $body : void | _ => () } ]>
    }
    res1
  }

(defmacro when (condition &rest body)
  `(if ,condition (progn ,@body)))

  macro @while (cond, body)
  syntax ("while", "(", cond, ")", body) 
  {
    def loop = Nemerle.Macros.Symbol (Util.tmpname ("while_"));

    <[ 
      $("_N_break" : global) : {
        def $(loop : name) () : void {
          when ($cond) {
            $("_N_continue" : global) : {
              $body 
            } 
            $(loop : name) ()
          }
        } 
        $(loop : name) (); 
      }
    ]>
  }

(defun while-function (predicate block)
  (if (not (funcall predicate)) (return))
  (funcall block)
  (while-function predicate block))  

(defmacro while (expression &body body)
  `(while-function (lambda () ,expression)
     (lambda () ,@body)))

(defmacro while (expression &body body)
  `(tagbody
     start (if (not ,expression) (go end))
           ,@body
           (go start)
     end))

     (method :my-method (return-type :string (doc "Return value.")) (public)
      (doc "This method does strange things.")

  grammar
  {
    any           = ['\u0000' .. '\uFFFF'];
    letter        = ['a' .. 'z'] / ['A' .. 'Z'] / '_';
    digit         = ['0' .. '9'];
    spaces        = ' '*;
    id     : Expr = (letter (digit / letter)*) spaces;
    num    : Expr = digit+ spaces;
    expr'  : Expr = '(' spaces sum ')' spaces;
    expr   : Expr = num / id / expr';
    sum    : Expr = expr ('+' spaces expr)* spaces;
    start  : Expr = spaces sum spaces !any;
  }

  macro whenmacro (cond, body)
  syntax ("when", "(", cond, ")", body) 
  {
    <[ match ($cond) { | true => $body : void | _ => () } ]>
  }

Y>(defmacro when (condition &rest body)
Y>  `(if ,condition (progn ,@body)))
Y>

    macro @while (cond, body)
    syntax ("while", "(", cond, ")", body) 
    {
        <[ 
            def loop() : void {
                when ($cond) {
                    $body;
                    loop()
                }
            } 
            loop(); 
        ]>
    }

Y>(defun while-function (predicate block)
Y>  (if (not (funcall predicate)) (return))
Y>  (funcall block)
Y>  (while-function predicate block))  

Y>(defmacro while (expression &body body)
Y>  `(while-function (lambda () ,expression)
Y>     (lambda () ,@body)))
Y>

Y>(defmacro while (expression &body body)
Y>  `(tagbody
Y>     start (if (not ,expression) (go end))
Y>           ,@body
Y>           (go start)
Y>     end))
Y>

Y>Теперь все фен-шую А что это за аццкие синтаксические штучки были? Какой функционал они добавляют?

  macro @while (cond, body)
  syntax ("while", "(", cond, ")", body) 
  {
    <[ 
      ($("_N_break" : global) : {
        def loop () : void
        {
          when ($cond)
          {
            ($("_N_continue" : global) : {
              $body
            }) : void;
            loop ()
          }
        } 
        
        loop (); 
      }) : void
    ]>
  }

  macro Break ()  syntax ("break")
  {
    <[ $("_N_break" : global) () ]>
  }
  
  macro Continue ()  syntax ("continue")
  {
    <[ $("_N_continue" : global) () ]>
  }

when (asdasd is SomeType when blah-blah)
{
    ...
}

Y>  macro whenmacro (cond, body)
Y>  syntax ("when", "(", cond, ")", body) 
Y>  {
Y>    def res1 = match (cond)
Y>    {
Y>      | <[ $subCond is $pattren ]> with guard = null
Y>      | <[ $subCond is $pattren when $guard ]> =>
Y>        def res2 = match (pattren)
Y>        {
Y>          | PT.PExpr.Call when guard != null => 
Y>            <[ match ($subCond) { | $pattren when $guard => $body : void | _ => () } ]>
Y>          | PT.PExpr.Call => 
Y>            <[ match ($subCond) { | $pattren => $body : void | _ => () } ]>
Y>          | _ => <[ match ($cond) { | true => $body : void | _ => () } ]>
Y>        }
Y>        res2
Y>      | _ => <[ match ($cond) { | true => $body : void | _ => () } ]>
Y>    }
Y>    res1
Y>  }
Y>

Y>(defmacro when (condition &rest body)
Y>  `(if ,condition (progn ,@body)))
Y>

public macro When(condition, body)
syntax ("when", "(", condition, ")", body)
{
  <[ match ($condition)
     {
       | true  => $body
       | false => ()
     }
  ]>
}

Тип                 Comon Lisp             Nemerle

Цитата кода         `( цитируемый код )    <[ цитируемый код ]>

Вставка кода        ,переменная            $переменная
из переменной
(unquote)

Вставка кода        ,@переменная           ..$переменная
из списка 
(unquote списка)

Y>  macro @while (cond, body)
Y>  syntax ("while", "(", cond, ")", body) 
Y>  {
Y>    def loop = Nemerle.Macros.Symbol (Util.tmpname ("while_"));

Y>    <[ 
Y>      $("_N_break" : global) : {
Y>        def $(loop : name) () : void {
Y>          when ($cond) {
Y>            $("_N_continue" : global) : {
Y>              $body 
Y>            } 
Y>            $(loop : name) ()
Y>          }
Y>        } 
Y>        $(loop : name) (); 
Y>      }
Y>    ]>
Y>  }
Y>

Y>(defun while-function (predicate block)
Y>  (if (not (funcall predicate)) (return))
Y>  (funcall block)
Y>  (while-function predicate block))  

Y>(defmacro while (expression &body body)
Y>  `(while-function (lambda () ,expression)
Y>     (lambda () ,@body)))
Y>

  macro @while (cond, body)
  syntax ("while", "(", cond, ")", body) 
  {
    <[ 
      ($("_N_break" : global) : {
        def loop () : void
        {
          when ($cond)
          {
            ($("_N_continue" : global) : {
              $body
            }) : void;
            loop ()
          }
        } 
        
        loop (); 
      }) : void
    ]>
  }

Y>(defmacro while (expression &body body)
Y>  `(tagbody
Y>     start (if (not ,expression) (go end))
Y>           ,@body
Y>           (go start)
Y>     end))
Y>

  macro @while (cond, body)
  syntax ("while", "(", cond, ")", body) 
  {
    <[ 
        def loop() 
        {
          when ($cond)
            $body

          loop();
        } 
        
        loop();
      }
    ]>
  }

WH>when (asdasd is SomeType when blah-blah)
WH>{
WH>    ...
WH>}
WH>

def o : option[strint] = Some("строка");

when (o is Some(value))
  doStaf(value);

def o : option[strint] = Some("строка");

match (o)
{
  | Some(value) => doStaf(value);
  | _ => () // ничего не делаем!
}