mattc (что сопостоавляем)
    | паттерн => вывод/действие
    | другой паттерн => вывод/действие

8 Typing during execution of macro

Some more advanced techniques are also possible. They involve a closer interaction with the compiler, using its methods and data structures or even interweaving with internal compilation stages.
For example, we can ask the compiler to type some of object programs, which are passed to the macro, retrieve and compare their types, etc. This means that we can plug between many important actions performed by the compiler, adding our own code there. It might be just a nicer bug reporting (especially for macros defining complex syntax extensions), making code generation dependent on input program types or improving code analysis with additional information.

8.1 Example

Let us consider the following translation of the if condition to the standard ML
matching:

macro @if (cond, e1, e2)
syntax ("if", "(", cond, ")", e1, "else", e1)
{
    <[
        match ($cond)
        {    | true => $e1
            | false => $e2
        }
    ]>
}

When if ("bar") true else false was written, the compiler would complain that type of matched expression is not bool. Such an error message could be very confusing, because the programmer may not know, that his if statement is being transformed to the match statement. Thus, we would like to check such errors during the execution of the macro, so we can generate a more verbose message.

8.2 Usage

Instead of directly passing object expressions to the result of the macro, we can
first make the compiler type them and then find out if they have the proper
type. The body of the above if macro should be

def tcond = TypedExpr (cond);
def te1 = TypedExpr (e1);
def te2 = TypedExpr (e2);
if (tcond.Type == <[ ttype: bool ]> )
{
    <[
        match ($(tcond : typed))
        { | true => $(te1 : typed)
            | false => $(te2 : typed)
        }
    ]>
}
else
    FailWith("`if' condition must have type bool, "
        + "while it has " + tcond.Type.ToString())

Note that typed expressions are used again in the quotation, but with a
special splicing tag \typed". This means that the compiler does not have to
perform the typing (in fact, it cannot do this from now on) on the provided
syntax trees. Such a notation introduces some kind of laziness in typing, which
is guided directly by a programmer of the macro.

VD>def tcond = TypedExpr (cond);
VD>def te1 = TypedExpr (e1);
VD>def te2 = TypedExpr (e2);
VD>if (tcond.Type == <[ ttype: bool ]> )
VD>{
VD>    <[
VD>        match ($(tcond : typed))
VD>        { | true => $(te1 : typed)
VD>            | false => $(te2 : typed)
VD>        }
VD>    ]>
VD>}
VD>else
VD>    FailWith("`if' condition must have type bool, "
VD>        + "while it has " + tcond.Type.ToString())
VD>

(awhen (compr x y)
   (blah it))

(let (it (compr x y))
  (when it
   (blah it))

VD>А я вообще-то не говорил о CL. А говорил о Лиспе вообще. Между прочим когда его на этоам форуме рекомендуют, то в первую очередь тыкают на Схему. И это разумно. Дейсвтиельно чистно функциональный язык, да еще и простой. А когда о производительности разговор заходит, то бурем значит самый узасный CL и используем в нем то, за что ругаем другие языки. Здорово!

(set! <name> <new-value>) -- присваивание

CP>Незнаю. Один небольшой авто-рефакторин я заметил. Если сохарнять модуль обазначенный одним именем в файл с дургим именем, емакс спрашивает, "а не поменять ли нам, дружок, имя модуля?"

using System;

class Program
{
    static void Main()
    {
        Console.WriteLine(Sum(10, 300));
    }

    static int Sum(int val, int count)
    {
        if (count <= 1)
            return val;

        return val + Sum(val, count - 1);
    }
}

.method private hidebysig static int32  Sum(int32 val,
                                            int32 count) cil managed
{
  // Code size       18 (0x12)
  .maxstack  8
  IL_0000:  ldarg.1
  IL_0001:  ldc.i4.1
  IL_0002:  bgt.s      IL_0006
  IL_0004:  ldarg.0
  IL_0005:  ret
  IL_0006:  ldarg.0
  IL_0007:  ldarg.0
  IL_0008:  ldarg.1
  IL_0009:  ldc.i4.1
  IL_000a:  sub
  IL_000b:  call       int32 Program::Sum(int32,
                                          int32)
  IL_0010:  add
  IL_0011:  ret
} // end of method Program::Sum

VD>using System;

VD>class Program
VD>{
VD>    static void Main()
VD>    {
VD>        Console.WriteLine(Sum(10, 300));
VD>    }

VD>    static int Sum(int val, int count)
VD>    {
VD>        if (count <= 1)
VD>            return val;

VD>        return val + Sum(val, count - 1);
VD>    }
VD>}
VD>

using System;

class Program
{
    static void Main()
    {
        Console.WriteLine(Sum(10, 300, 0));
    }

    static int Sum(int val, int count, int acc)
    {
        if (count <= 0)
            return acc;

          return Sum(val, count - 1, acc + val);
    }
}

MK>using System;

MK>class Program
MK>{
MK>    static void Main()
MK>    {
MK>        Console.WriteLine(Sum(10, 300, 0));
MK>    }

MK>    static int Sum(int val, int count, int acc)
MK>    {
MK>        if (count <= 0)
MK>            return acc;

MK>          return Sum(val, count - 1, acc + val);
MK>    }
MK>}
MK>

.method private hidebysig static int32  Sum(int32 val,
                                            int32 count,
                                            int32 acc) cil managed
{
  // Code size       19 (0x13)
  .maxstack  8
  IL_0000:  ldarg.1
  IL_0001:  ldc.i4.0
  IL_0002:  bgt.s      IL_0006
  IL_0004:  ldarg.2
  IL_0005:  ret
  IL_0006:  ldarg.0
  IL_0007:  ldarg.1
  IL_0008:  ldc.i4.1
  IL_0009:  sub
  IL_000a:  ldarg.2
  IL_000b:  ldarg.0
  IL_000c:  add
  IL_000d:  call       int32 Program::Sum(int32,
                                          int32,
                                          int32)
  IL_0012:  ret
} // end of method Program::Sum

using System;

class Program
{
    static Main() :  void
    {
        Console.WriteLine(Sum(10, 300, 0));
    }

    static Sum(mutable  val : int, mutable  count :  int, mutable  acc :  int) :  int
    {
        if (count <= 0)
             acc;
        else
         Sum(val, count - 1, acc + val);
    }
}

.method private hidebysig static int32  Sum(int32 val,
                                            int32 count,
                                            int32 acc) cil managed
{
  // Code size       32 (0x20)
  .maxstack  6
  IL_0000:  ldarg.1
  IL_0001:  ldc.i4.0
  IL_0002:  bgt        IL_000d
  IL_0007:  ldarg.2
  IL_0008:  br         IL_001f
  IL_000d:  ldarg.0
  IL_000e:  ldarg.1
  IL_000f:  ldc.i4.1
  IL_0010:  sub.ovf
  IL_0011:  ldarg.2
  IL_0012:  ldarg.0
  IL_0013:  add.ovf
  IL_0014:  starg.s    acc
  IL_0016:  starg.s    count
  IL_0018:  starg.s    val
  IL_001a:  br         IL_0000
  IL_001f:  ret
} // end of method Program::Sum

using System;
using System.Diagnostics;

class Ackermann
{
    public static int Ack(int m, int n)
    {
        if (m == 0)
            return n + 1;
        if (n == 0)
            return Ack(m - 1, 1);
        else
            return Ack(m - 1, Ack(m, n - 1));
    }

    static void Main(string[] args)
    {
        int n = 11;

        if (args.Length > 0)
            n = Int32.Parse(args[0]);

        Stopwatch timer = Stopwatch.StartNew();

        int res = Ack(3, n);

        Console.WriteLine("Ack(3,{0}): {1}   {2}", n, res, timer.Elapsed);
    }
}

using System;
using System.Diagnostics;

class Ackermann
{
    public static Ack(mutable  m : int,mutable  n :  int) :  int
    {
        if (m == 0)
             n + 1;
        else     if (n == 0)
             Ack(m - 1, 1);
        else
             Ack(m - 1, Ack(m, n - 1));
    }

    static Main(mutable  args :  array [string]) :  void
    {
        mutable  n = 11;

        when (args.Length > 0)
            n = Int32.Parse(args[0]);

        mutable  timer = Stopwatch.StartNew();

        mutable  res = Ack(3, n);

        Console.WriteLine("Ack(3,{0}): {1}   {2}", n, res, timer.Elapsed);
    }
}

C:\VS\Nemerle>Ackermann-n.exe
Ack(3,11): 16381   00:00:00.8386434

C:\VS\Nemerle>Ackermann-cs.exe
Ack(3,11): 16381   00:00:01.5771912

c:\Temp\007>Ackermann-n.exe
Ack(3,11): 16381   00:00:00.6920116

c:\Temp\007>Ackermann-cs.exe
Ack(3,11): 16381   00:00:01.3395087

.method public hidebysig static int32  Ack(int32 m,
                                           int32 n) cil managed
{
  // Code size       38 (0x26)
  .maxstack  8
  IL_0000:  ldarg.0
  IL_0001:  brtrue.s   IL_0007
  IL_0003:  ldarg.1
  IL_0004:  ldc.i4.1
  IL_0005:  add
  IL_0006:  ret
  IL_0007:  ldarg.1
  IL_0008:  brtrue.s   IL_0014
  IL_000a:  ldarg.0
  IL_000b:  ldc.i4.1
  IL_000c:  sub
  IL_000d:  ldc.i4.1
  IL_000e:  call       int32 Ackermann::Ack(int32,
                                            int32)
  IL_0013:  ret
  IL_0014:  ldarg.0
  IL_0015:  ldc.i4.1
  IL_0016:  sub
  IL_0017:  ldarg.0
  IL_0018:  ldarg.1
  IL_0019:  ldc.i4.1
  IL_001a:  sub
  IL_001b:  call       int32 Ackermann::Ack(int32,
                                            int32)
  IL_0020:  call       int32 Ackermann::Ack(int32,
                                            int32)
  IL_0025:  ret
} // end of method Ackermann::Ack

.method public hidebysig static int32  Ack(int32 m,
                                           int32 n) cil managed
{
  // Code size       57 (0x39)
  .maxstack  8
  IL_0000:  ldarg.0
  IL_0001:  ldc.i4.0
  IL_0002:  bne.un     IL_000f
  IL_0007:  ldarg.1
  IL_0008:  ldc.i4.1
  IL_0009:  add.ovf
  IL_000a:  br         IL_0038
  IL_000f:  ldarg.1
  IL_0010:  ldc.i4.0
  IL_0011:  bne.un     IL_0023
  IL_0016:  ldarg.0
  IL_0017:  ldc.i4.1
  IL_0018:  sub.ovf
  IL_0019:  ldc.i4.1
  IL_001a:  starg.s    n
  IL_001c:  starg.s    m
  IL_001e:  br         IL_0000
  IL_0023:  ldarg.0
  IL_0024:  ldc.i4.1
  IL_0025:  sub.ovf
  IL_0026:  ldarg.0
  IL_0027:  ldarg.1
  IL_0028:  ldc.i4.1
  IL_0029:  sub.ovf
  IL_002a:  call       int32 Ackermann::Ack(int32,
                                            int32)
  IL_002f:  starg.s    n
  IL_0031:  starg.s    m
  IL_0033:  br         IL_0000
  IL_0038:  ret
} // end of method Ackermann::Ack