public macro razbor(y:PExpr)
  {
    <[y]>
  }

razbor(<[def x=1;]>)

public macro razbor(y : PExpr)
{
   <[ $y ]>
}

public macro razbor(y : PExpr)
{
   y
}

match (expr)
{
  | PExpr.Define(pat, val) => // что то сделать с выражениями pattern и value из выражения def pattern = value
}

match (expr)
{
 | <[ def $x = $v]> => // аналогично первому варианту
}

def x=1;
def y=1;

А>def x=1;
А>def y=1;
А>

def str = ["def x = 1;", "def y = 1;"]; // список строк
foreach (elem in str)
{
  def elems = elem.Split(array[" "], StringSplitOptions.RemoveEmptyEntries); // получаете список строк ["def", "x", "=", "1"]
  
  def join = string.Join(" ", str); // соединяет элементы обратно через пробелы

}

variant VariableType
{
  | Constant { val : int; }
  | Variable { name : string;}
}

variant OperatorExpression
{
 | Sum { left : VariableType; right : VariableType}
 | Other { expr : PExpr; } 
}

variant AnalyseTree
{
 | VarCreate { name : string; value : Literal; }
 | DefExpression { name : string; value : OperatorExpression; }

}

macro analyze(expr)
{

// анализируем операторы выражений
def analyse_operator(n)
{
 // смотрим сложение константы с переменной
 | <[ $(x : int) + $(y : usesite) ]> => OperatorExpression.Sum(VariableType.Constant(x), VariableType.Variable(y))
  // в другом порядке
 | <[ $(x : usesite) + $(y : int) ]> => OperatorExpression.Sum(VariableType.Variable(x), VariableType.Constant(y))
 | _                                 => OperatorExpression.Other(n)
}

def map(expr)
{
  // смотрим является ли это def определение
  | <[ def $x = $v]> =>  // можно зарегистрировать переменную с именем x и значением v, x и v тоже надо матчить чтобы докопаться до имен и их содержимого здесь можно выдать новый член дерева
                        match (v)
                        {
                          // если это обычная константа
                          | <[ $(n : int) ]> as e => AnalyseTree.VarCreate(x.ToString(), e.val) // создаем новое дерево с уже полученными значениями из выражений Н
                          | _                     => AnalyseTree.DefExpression(x.ToString(), analyse_operator(v)) // сразу анализируем операторы для их последующей обработки
                        }
}

def new_expr = match (expr)
{
 | <[ ..$seq ]> => seq.Map(map) // обходим с получением из списка выражений свое дерево
}
// обходим без результата но сохраняем в некоем промежуточном состоянии результаты обхода
 foreach (expr in new_expr)
 {
   | AnalyseTree.VarCreate(n, val) => hashtable[n] = val // регистрация переменной со значением
   | _ => ()..// 
 }

def eval(expr)
{
 | OperatorExpression.Sum(VariableType.Name(l), VariableType.Constant(r)) => def val = hashtable[l]; // получаем значение переменной зарегестрированной в хэштаблице
                                                                             val + r // выдаем значение
 | _ => ..// обработка других операторов
}

def fold_expr(expr, acc)
{
  match (expr)
  {
   | DefExpression(n, v) => eval(v)
   | _                   => acc
  }
}
 
def result = new_expr.FoldLeft(0, fold_expr); // получаем результат преобразования 
}

using Nemerle;
using Nemerle.Collections;
using Nemerle.Compiler;
using Nemerle.Text;
using Nemerle.Utility;

using System;
using System.Collections.Generic;
using System.Linq;

namespace SC
{
  public macro razbor(y)
  {
    
    def id(x){x}   
      
    match (y){
        | <[ ..$seq ]> => seq.Map(id);
        | <[  ]> => <[ ]>;
  }
}
}

using Nemerle.Collections;
using Nemerle.Text;
using Nemerle.Utility;

using System;
using System.Collections.Generic;
using System.Console;
using System.Linq;
using SC;

module Program
{
  Main() : void
  {
      
      
     SC.razbor(
    {
        def x1=1;
        def y =  2;
    
    }
    ) ;
      
    WriteLine("Hi!");
    _ = ReadLine();
  }
}

public macro razbor(y)
  {

    def id(x) { x }

    match (y)
    {
      | <[ {..$seq} ]> => def exprs = seq.Map(id);
                          <[ {..$exprs} ]> // соединение списка выражений в одно выражение
      | <[  ]> => <[ ]>;
    }
  }

А>def x=1;
А>def y=1;
А>

{
  def x = 1;
  def y = 1;
}

match (expr)
{
  | <[ { ..$exprs } ]> => Делаем что-то с exprs в котором лежат подвыражения.
  | _ => обрабатываем ошибку
}

def e = <[ { ..$exprs } ]>;