using System;
using System.Linq;
using System.Text;
using System.Console;
using System.Reflection;
using System.Reflection.BindingFlags;
using Nemerle.Compiler;
using Nemerle.Compiler.Parsetree;

class Helper
{
    public static Render(this exprs : list[PExpr]) : String
    {
        def buf = StringBuilder();
        buf.Append("[");

        mutable first = true;
        foreach (expr in exprs)
        {
            if (first) { first = false; }
            else { buf.Append(", "); }

            buf.Append(expr.Render());
        }
                                                             
        buf.Append("]");
        buf.ToString();    
    }

    public static Render(this expr : PExpr) : String 
    {
        def buf = StringBuilder();
        def t = expr.GetType();
        buf.Append(t.Name);
        buf.Append("(");

        mutable first = true;
        foreach (f in t.GetFields(Public | Instance | DeclaredOnly))
        {
            if (first) { first = false; }
            else { buf.Append(", "); }

            buf.Append(f.Name);
            buf.Append(" = ");

            def v = f.GetValue(expr);
            if (v is PExpr) buf.Append((v :> PExpr).Render());
            else if (v is list[PExpr]) buf.Append((v :> list[PExpr]).Render()); 
            else buf.Append(v.ToString());
        }
                                                             
        buf.Append(")");
        buf.ToString();
    }

    public static Dump(this exprs : list[PExpr]) : void
    {
        WriteLine(exprs.Render());
    }

    public static Dump(this expr : PExpr) : void
    {
        WriteLine(expr.Render());
    }
}

XB>    public static Render(this exprs : list[PExpr]) : String
XB>    {
XB>        def buf = StringBuilder();
XB>        buf.Append("[");

XB>        mutable first = true;
XB>        foreach (expr in exprs)
XB>        {
XB>            if (first) { first = false; }
XB>            else { buf.Append(", "); }

XB>            buf.Append(expr.Render());
XB>        }
                                                             
XB>        buf.Append("]");
XB>        buf.ToString();    
XB>    }

    public static Render(this exprs : list[PExpr]) : String
    {
      $<#..$(exprs; ", "; expr.Render())#>
    }

$<#..$(exprs; ", "; _.Render())#>

$<#..$(exprs; ", "; expr => expr.Render(a, b, c))#>

def convert(expr)
{
  делаем что хотим... и возвращаем строку
}
$<#..$(exprs; ", "; convert)#>

Cut: This adds support for cuts to Erlang. These are inspired by the Scheme form of cuts.
Cuts can be thought of as a light-weight form of abstraction, with similarities to partial application (or currying).