replace [catch_statement]

'catch '( _ [repeat modifier] _ [type_specifier] _ [variable_name] ') '{ '}

Z>>Я постоянно дописываю всякую фигню и переписываю старую. Просветления все нет

// Hyper Expressions:
  implicit def Compile(o:ExprHyper):Expr = o match {
    case ShortLambda(formals_list, body) =>  {
      def loop(formals:Formals):Lambda = formals match {
        case Nil             => Lambda(Nil, false, body)
        case (ids,dots)::Nil => Lambda(ids, dots, body)
        case (ids,dots)::xs  =>
          Lambda(ids, dots, Block(Nil,Some(Return(loop(xs)::Nil))))
      }
      loop(formals_list)
    }
    case Infix(lhs, id, rhs) => Call(id, lhs::rhs::Nil)
    case Dollar(rator,rand)  => Call(rator,rand::Nil)
    case Prefix(id,rhs)      => Call(id,rhs::Nil)
    case ConsList(exps)      => {
      val arr = Table(for(exp <- exps)yield(RecArray(exp)))
      Call(Id(zoon.lua.Const.K_array2list),arr::Nil)
    }
    case LambdaPM(clauses,dots,src) => {
      val(arity,root_obj,block) = PMCompile.make(None,dots,clauses,src)
      Lambda(root_obj,dots,block)
    }
  }

Z>Правильно. Знаете сколько таких паттерн матчингов в компиляторе? Ровно 1 Там вызываются тысячи строк кода, чтобы преобразовать одно дерево в другое, но сам паттерн матчер 1, и занимает 20 строк. Все остальные прогоны(типа алфа-ренейминга и кой каких оптимизаций) я делаю по дереву оригинального языка, который не меняется. Компилятор паттерн матчинга вообще работает со своим представлением дерева(даже не одним) и сразу выдает дерево оригинального языка. Все остальные расширения знать о нем не знают, просто вызывают по необходимости.

for (int i : [0..10]) {}

LazyList lst = new LazyList(0,10);
while (lst.hasMore()) {
  int i = ((Integer)lst.next()).intValue();
  {}
}

for (int i=0; i <= 10; i++) {}

M>for (int i : [0..10]) {}
M>

val ii = fresh("u$")
val for_ = VanillaFor(Id(ii),Int(0),BinOp(Le,Id(ii),Num(10),PostOp(Id(ii),PlusPlus)))
val block = Block(for_::body::Nil)
      ||| pretty printing
      VVV
for(int u$0123 = 0, u$0123 <= 10, u$0123++) {
    /* body */
}

-- Hyperlua
fun foo
  | 1,2,_ -> 111
  | 2,_,_ -> 222
end

-- Parse Tree
(block
  [(FunPM
     (FunctionName
       (Id "foo") RNone)
     (PatMatch
       [(PatClause
          [(GuardedPattern
             [(Number "1"),(Number "2"),(WILDpat)] RNone)]
          (ExpressionList
            [(Number "111")]))
       ,(PatClause
          [(GuardedPattern
             [(Number "2"),(WILDpat),(WILDpat)] RNone)]
          (ExpressionList
            [(Number "222")]))]))]

-- Pattern Tree
! arity: 3
! (ConPat(LTop(3)[ConPat(LNum("1")[])
              ,ConPat(LNum("2")[])
              ,WildPat]),(Vars: []
,Guard: None
,RHS: return 111))
! (ConPat(LTop(3)[ConPat(LNum("2")[]),WildPat,WildPat]),(Vars: []
,Guard: None
,RHS: return 222))

-- Decision Tree
IfEq (Obj[1] == LNum("1"))
    IfEq (Obj[2] == LNum("2"))
        Success((Vars: []
                ,Guard: None
                ,RHS: return 111))
        Failure
    IfEq (Obj[1] == LNum("2"))
        Success((Vars: []
                ,Guard: None
                ,RHS: return 222))
        Failure

-- lua
function foo(_u0,_u1,_u2)
  if _u0 == 1 then
    if _u1 == 2 then return 111
    else error'pattern-match error';
    end;
  else
    if _u0 == 2 then return 222
    else error'pattern-match error';
    end;
  end;
end;
-- + warning
foo.hlua:1:1: warning: this pattern-matching is not exhaustive:
fun foo
  | 1,2,_ -> 111
  | 2,_,_ -> 222
end

засосал parsing-tree в Scala, преобразовал там в типизированное AST, по которому ходил паттерн-матчингом. Преимущества терм-рерайтинга (как в TXL или Stratego) перед паттерн-матчингом мне до сих пор непонятны.

Знаете сколько таких паттерн матчингов в компиляторе? Ровно 1 Там вызываются тысячи строк кода, чтобы преобразовать одно дерево в другое, но сам паттерн матчер 1, и занимает 20 строк. Все остальные прогоны(типа алфа-ренейминга и кой каких оптимизаций) я делаю по дереву оригинального языка, который не меняется.

Компилятор паттерн матчинга вообще работает со своим представлением дерева(даже не одним) и сразу выдает дерево оригинального языка

Я компилирую в дерево, не в парсере, а после того, как использовал всю интересную информацию.

A pattern is either a variable, or a constructor applied to a possibly 
empty sequence of patterns. Patterns must be linear : no variable may occur 
more than once in a pattern. 
A (proper) term is a pattern not containing variables. Constructors 
and patterns can be modelled as follows:
 
    type con = { name : string, arity : int, span : int } 
    datatype pat = PVar of string | PCon of con * pat list
 
Example 1. For instance, the three constructors Null, Leaf, and Node declared 
by the Standard ML declaration 

   datatype 'a tree = 
         Null | Leaf of 'a | Node of 'a tree * 'a * 'a tree

can be represented as follows: 
   val Nullc = {name = "Null", arity = 0, span = 3} 
   val Leafc = {name = "Leaf", arity = 1, span = 3} 
   val Nodec = {name = "Node", arity = 3, span = 3}

datatype access = Obj | Sel of int * access 

datatype 'rhs decision =  
     Failure  
   | Success of 'rhs  
   | IfEq of access * con * 'rhs decision * 'rhs decision