Changeset 173

Show
Ignore:
Timestamp:
12/27/07 14:00:12 (4 years ago)
Author:
BCS
Message:

updates (including a fix to stabilize the order of the code in generated_rules.d)
committed the lisp code needed to generate stuff.

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved

  • trunk/backmath/backmath.d

    r134 r173  
     1/*************** 
     2    BackMath 
     3 
     4    Author: Benjamin Shropshire 
     5 
     6    Copywrite: You may used this code only if you accept all risk involved in doing so. It is highly experimental and probably contains bugs. I DON'T warrant it for any use. 
     7 
     8    Version: 0.001 
     9    Date: 12/4/2007 
     10*/ 
     11 
    112import std.stdio; 
    213 
    …… 
    4556        else 
    4657        { 
    47             static assert(is(V.DefP == Defined)); 
    48             T.set = V.get; 
     58            static if(is(V.DefP == Defined)) 
     59                T.set = V.get; 
     60            else 
     61            { 
     62//              static assert(is(typeof(*this - t)), "Can't force equality of '"~typeof(*this).stringof~"' and '"~V.stringof~\'); 
     63                (*this - t).set = 0; 
     64            } 
    4965        } 
    5066    } 
    5167} 
    5268 
     69template Val(real r){Value!(r) Val;} 
    5370struct      Value(real r)   { private alias   Defined DefP; private alias CVal  Op; static real get(){return r;}                  mixin Operate!(typeof(*this)); } 
    5471struct   DefinedT(alias _r) { private alias   Defined DefP; private alias Term  Op; static real get(){return r;}    alias _r r;   mixin Operate!(typeof(*this)); } 
    …… 
    113130    A / B  + D / B = C; // 2 = 3/B + 3/B; -> 6/2 
    114131    writef("%s == (6/2)\n", b); 
     132 
     133    B / A = (B / C) + D; // B / 3 = B / 2 + 3; -> -18 
     134    writef("%s == -18\n", b); 
     135 
     136    (B * A) = (B * C) + D; // B * 3 = B * 2 + 3; -> 3 
     137    writef("%s == 3\n", b); 
     138 
     139 
    115140} 
    116  

  • trunk/backmath/generated_rules.d

    r155 r173  
    1 template TypeOfSub(T, V) 
    2 { 
    3     static if( // (- (/> A B) (/> C (+> (/ D C) B))) -> (+> D (/> (- A C) B)) 
    4         is(T.Op == DivA) && is(T.LHS.DefP == Defined) && is(T.RHS.DefP == UnDefined) && 
    5         is(V.Op == DivA) && is(V.LHS.DefP == Defined) && is(V.RHS.LHS.LHS.DefP == Defined) && is(V.RHS.LHS.RHS.DefP == Defined) && is(V.RHS.RHS.DefP == UnDefined) 
    6          && is(T.RHS == V.RHS.RHS) && is(V.LHS == V.RHS.LHS.RHS) 
    7         )  
    8         alias OpAddA!(V.RHS.LHS.LHS, OpDivA!(OpSub!(T.LHS, V.LHS), T.RHS)) TypeOfSub; 
    9     else 
    10     static if( // (- (*> A B) (*> C (-> (* D C) B))) -> (+> D (/> (- (/ 1 A) (/ 1 C)) B)) 
    11         is(T.Op == MulA) && is(T.LHS.DefP == Defined) && is(T.RHS.DefP == UnDefined) && 
    12         is(V.Op == MulA) && is(V.LHS.DefP == Defined) && is(V.RHS.LHS.LHS.DefP == Defined) && is(V.RHS.LHS.RHS.DefP == Defined) && is(V.RHS.RHS.DefP == UnDefined) 
    13          && is(T.RHS == V.RHS.RHS) && is(V.LHS == V.RHS.LHS.RHS) 
    14         )  
    15         alias OpAddA!(V.RHS.LHS.LHS, OpDivA!(OpSub!(OpDiv!(Value!(1), T.LHS), OpDiv!(Value!(1), V.LHS)), T.RHS)) TypeOfSub; 
    16     else 
    17     static if( // (- (/R> A B) (/R> C B)) -> (/R> (- A C) B) 
    18         is(T.Op == DivAR) && is(T.LHS.DefP == Defined) && is(T.RHS.DefP == UnDefined) && 
    19         is(V.Op == DivAR) && is(V.LHS.DefP == Defined) && is(V.RHS.DefP == UnDefined) 
    20          && is(T.RHS == V.RHS) 
    21         )  
    22         alias OpDivAR!(OpSub!(T.LHS, V.LHS), T.RHS) TypeOfSub; 
    23     else 
    24     static if( // (- (/> A B) (/> C B)) -> (/> (- A C) B) 
    25         is(T.Op == DivA) && is(T.LHS.DefP == Defined) && is(T.RHS.DefP == UnDefined) && 
    26         is(V.Op == DivA) && is(V.LHS.DefP == Defined) && is(V.RHS.DefP == UnDefined) 
    27          && is(T.RHS == V.RHS) 
    28         )  
    29         alias OpDivA!(OpSub!(T.LHS, V.LHS), T.RHS) TypeOfSub; 
    30     else 
    31     static if( // (- A (-R> B X)) -> (+> (- B A) X) 
    32         is(T.DefP == Defined) && 
    33         is(V.Op == SubAR) && is(V.LHS.DefP == Defined) && is(V.RHS.DefP == UnDefined) 
    34          /+ no repeats +/ 
    35         )  
    36         alias OpAddA!(OpSub!(V.LHS, T), V.RHS) TypeOfSub; 
    37     else 
    38     static if( // (- X (-R> E X)) -> (/> 2 (+> (/ E 2) X)) 
    39         is(T.DefP == UnDefined) && 
    40         is(V.Op == SubAR) && is(V.LHS.DefP == Defined) && is(V.RHS.DefP == UnDefined) 
    41          && is(T == V.RHS) 
    42         )  
    43         alias OpDivA!(Value!(2), OpAddA!(OpDiv!(V.LHS, Value!(2)), T)) TypeOfSub; 
    44     else 
    45     static if( // (- C (*> A (-> B X))) -> (*> A (-R> (+ (* C A) B) X)) 
    46         is(T.DefP == Defined) && 
    47         is(V.Op == MulA) && is(V.LHS.DefP == Defined) && is(V.RHS.LHS.DefP == Defined) && is(V.RHS.RHS.DefP == UnDefined) 
    48          /+ no repeats +/ 
    49         )  
    50         alias OpMulA!(V.LHS, OpSubAR!(OpAdd!(OpMul!(T, V.LHS), V.RHS.LHS), V.RHS.RHS)) TypeOfSub; 
    51     else 
    52     static if( // (- A (*> B X)) -> (*> B (-R> (* A B) X)) 
    53         is(T.DefP == Defined) && 
    54         is(V.Op == MulA) && is(V.LHS.DefP == Defined) && is(V.RHS.DefP == UnDefined) 
    55          /+ no repeats +/ 
    56         )  
    57         alias OpMulA!(V.LHS, OpSubAR!(OpMul!(T, V.LHS), V.RHS)) TypeOfSub; 
    58     else 
    59     static if( // (- X (*> E X)) -> (/> (- 1 (/ 1 E)) X) 
    60         is(T.DefP == UnDefined) && 
    61         is(V.Op == MulA) && is(V.LHS.DefP == Defined) && is(V.RHS.DefP == UnDefined) 
    62          && is(T == V.RHS) 
    63         )  
    64         alias OpDivA!(OpSub!(Value!(1), OpDiv!(Value!(1), V.LHS)), T) TypeOfSub; 
    65     else 
    66     static if( // (- A (/> B X)) -> (/> B (-R> (/ A B) X)) 
    67         is(T.DefP == Defined) && 
    68         is(V.Op == DivA) && is(V.LHS.DefP == Defined) && is(V.RHS.DefP == UnDefined) 
    69          /+ no repeats +/ 
    70         )  
    71         alias OpDivA!(V.LHS, OpSubAR!(OpDiv!(T, V.LHS), V.RHS)) TypeOfSub; 
    72     else 
    73     static if( // (- X (/> E X)) -> (/> (- 1 E) X) 
    74         is(T.DefP == UnDefined) && 
    75         is(V.Op == DivA) && is(V.LHS.DefP == Defined) && is(V.RHS.DefP == UnDefined) 
    76          && is(T == V.RHS) 
    77         )  
    78         alias OpDivA!(OpSub!(Value!(1), V.LHS), T) TypeOfSub; 
    79     else 
    80     static if( // (- (-R> B X) A) -> (-R> (- B A) X) 
    81         is(T.Op == SubAR) && is(T.LHS.DefP == Defined) && is(T.RHS.DefP == UnDefined) && 
    82         is(V.DefP == Defined) 
    83          /+ no repeats +/ 
    84         )  
    85         alias OpSubAR!(OpSub!(T.LHS, V), T.RHS) TypeOfSub; 
    86     else 
    87     static if( // (- (-R> H X) X) -> (/> 2 (-R> H X)) 
    88         is(T.Op == SubAR) && is(T.LHS.DefP == Defined) && is(T.RHS.DefP == UnDefined) && 
    89         is(V.DefP == UnDefined) 
    90          && is(T.RHS == V) 
    91         )  
    92         alias OpDivA!(Value!(2), OpSubAR!(T.LHS, T.RHS)) TypeOfSub; 
    93     else 
    94     static if( // (- (*> A (-> B X)) C) -> (*> A (+> (- (* C A) B) X)) 
    95         is(T.Op == MulA) && is(T.LHS.DefP == Defined) && is(T.RHS.LHS.DefP == Defined) && is(T.RHS.RHS.DefP == UnDefined) && 
    96         is(V.DefP == Defined) 
    97          /+ no repeats +/ 
    98         )  
    99         alias OpMulA!(T.LHS, OpAddA!(OpSub!(OpMul!(V, T.LHS), T.RHS.LHS), T.RHS.RHS)) TypeOfSub; 
    100     else 
    101     static if( // (- (*> B X) A) -> (*> B (+> (* A B) X)) 
    102         is(T.Op == MulA) && is(T.LHS.DefP == Defined) && is(T.RHS.DefP == UnDefined) && 
    103         is(V.DefP == Defined) 
    104          /+ no repeats +/ 
    105         )  
    106         alias OpMulA!(T.LHS, OpAddA!(OpMul!(V, T.LHS), T.RHS)) TypeOfSub; 
    107     else 
    108     static if( // (- (*> H X) X) -> (/> (- (/ 1 H) 1) X) 
    109         is(T.Op == MulA) && is(T.LHS.DefP == Defined) && is(T.RHS.DefP == UnDefined) && 
    110         is(V.DefP == UnDefined) 
    111          && is(T.RHS == V) 
    112         )  
    113         alias OpDivA!(OpSub!(OpDiv!(Value!(1), T.LHS), Value!(1)), T.RHS) TypeOfSub; 
    114     else 
    115     static if( // (- (/> B X) A) -> (/> B (+> (/ A B) X)) 
    116         is(T.Op == DivA) && is(T.LHS.DefP == Defined) && is(T.RHS.DefP == UnDefined) && 
    117         is(V.DefP == Defined) 
    118          /+ no repeats +/ 
    119         )  
    120         alias OpDivA!(T.LHS, OpAddA!(OpDiv!(V, T.LHS), T.RHS)) TypeOfSub; 
    121     else 
    122     static if( // (- (/> H X) X) -> (/> (- H 1) X) 
    123         is(T.Op == DivA) && is(T.LHS.DefP == Defined) && is(T.RHS.DefP == UnDefined) && 
    124         is(V.DefP == UnDefined) 
    125          && is(T.RHS == V) 
    126         )  
    127         alias OpDivA!(OpSub!(T.LHS, Value!(1)), T.RHS) TypeOfSub; 
    128     else 
    129     static if( // (- (+> B X) A) -> (+> (+ A B) X) 
    130         is(T.Op == AddA) && is(T.LHS.DefP == Defined) && is(T.RHS.DefP == UnDefined) && 
    131         is(V.DefP == Defined) 
    132          /+ no repeats +/ 
    133         )  
    134         alias OpAddA!(OpAdd!(V, T.LHS), T.RHS) TypeOfSub; 
    135     else 
    136     static if( // (- A (+> B X)) -> (-R> (+ A B) X) 
    137         is(T.DefP == Defined) && 
    138         is(V.Op == AddA) && is(V.LHS.DefP == Defined) && is(V.RHS.DefP == UnDefined) 
    139          /+ no repeats +/ 
    140         )  
    141         alias OpSubAR!(OpAdd!(T, V.LHS), V.RHS) TypeOfSub; 
    142     else 
    143     static if( // (- (-> B X) A) -> (+> (- A B) X) 
    144         is(T.Op == SubA) && is(T.LHS.DefP == Defined) && is(T.RHS.DefP == UnDefined) && 
    145         is(V.DefP == Defined) 
    146          /+ no repeats +/ 
    147         )  
    148         alias OpAddA!(OpSub!(V, T.LHS), T.RHS) TypeOfSub; 
    149     else 
    150     static if( // (- A (-> B X)) -> (-R> (- A B) X) 
    151         is(T.DefP == Defined) && 
    152         is(V.Op == SubA) && is(V.LHS.DefP == Defined) && is(V.RHS.DefP == UnDefined) 
    153          /+ no repeats +/ 
    154         )  
    155         alias OpSubAR!(OpSub!(T, V.LHS), V.RHS) TypeOfSub; 
    156     else 
    157     static if( // (- A X) -> (-R> A X) 
    158         is(T.DefP == Defined) && 
    159         is(V.DefP == UnDefined) 
    160          /+ no repeats +/ 
    161         )  
    162         alias OpSubAR!(T, V) TypeOfSub; 
    163     else 
    164     static if( // (- A B) -> (- A B) 
    165         is(T.DefP == Defined) && 
    166         is(V.DefP == Defined) 
    167          /+ no repeats +/ 
    168         )  
    169         alias OpSub!(T, V) TypeOfSub; 
    170     else 
    171     static if( // (- X A) -> (+> A X) 
    172         is(T.DefP == UnDefined) && 
    173         is(V.DefP == Defined) 
    174          /+ no repeats +/ 
    175         )  
    176         alias OpAddA!(V, T) TypeOfSub; 
    177     else 
    178     static assert(false, `inavlid type used for Sub: T == ` ~ T.stringof ~ ` and V == `~ V.stringof ); 
    179 } 
    1801template TypeOfAdd(T, V) 
    1812{ 
    182     static if( // (+ (/R> A B) (/R> C B)) -> (/R> (+ A C) B) 
    183         is(T.Op == DivAR) && is(T.LHS.DefP == Defined) && is(T.RHS.DefP == UnDefined) && 
    184         is(V.Op == DivAR) && is(V.LHS.DefP == Defined) && is(V.RHS.DefP == UnDefined) 
    185          && is(T.RHS == V.RHS) 
    186         )  
    187         alias OpDivAR!(OpAdd!(T.LHS, V.LHS), T.RHS) TypeOfAdd; 
    188     else 
    1893    static if( // (+ (/> A B) (/> C B)) -> (/> (+ A C) B) 
    1904        is(T.Op == DivA) && is(T.LHS.DefP == Defined) && is(T.RHS.DefP == UnDefined) && 
    …… 
    1948        alias OpDivA!(OpAdd!(T.LHS, V.LHS), T.RHS) TypeOfAdd; 
    1959    else 
     10    static if( // (+ (/> A (-> B X)) C) -> (/> A (-> (+ (/ C A) B) X)) 
     11        is(T.Op == DivA) && is(T.LHS.DefP == Defined) && is(T.RHS.LHS.DefP == Defined) && is(T.RHS.RHS.DefP == UnDefined) && 
     12        is(V.DefP == Defined) 
     13         /+ no repeats +/ 
     14        )  
     15        alias OpDivA!(T.LHS, OpSubA!(OpAdd!(OpDiv!(V, T.LHS), T.RHS.LHS), T.RHS.RHS)) TypeOfAdd; 
     16    else 
     17    static if( // (+ (/> K (-> H X)) X) -> (/> (+ K 1) (-> (/ (* H K) (+ K 1)) X)) 
     18        is(T.Op == DivA) && is(T.LHS.DefP == Defined) && is(T.RHS.LHS.DefP == Defined) && is(T.RHS.RHS.DefP == UnDefined) && 
     19        is(V.DefP == UnDefined) 
     20         && is(T.RHS.RHS == V) 
     21        )  
     22        alias OpDivA!(OpAdd!(T.LHS, Value!(1)), OpSubA!(OpDiv!(OpMul!(T.RHS.LHS, T.LHS), OpAdd!(T.LHS, Value!(1))), T.RHS.RHS)) TypeOfAdd; 
     23    else 
     24    static if( // (+ C (*> A (-R> B X))) -> (*> A (-R> (+ B (* C A)) X)) 
     25        is(T.DefP == Defined) && 
     26        is(V.Op == MulA) && is(V.LHS.DefP == Defined) && is(V.RHS.LHS.DefP == Defined) && is(V.RHS.RHS.DefP == UnDefined) 
     27         /+ no repeats +/ 
     28        )  
     29        alias OpMulA!(V.LHS, OpSubAR!(OpAdd!(V.RHS.LHS, OpMul!(T, V.LHS)), V.RHS.RHS)) TypeOfAdd; 
     30    else 
     31    static if( // (+ C (*> A (+> B X))) -> (*> A (+> (- B (* C A)) X)) 
     32        is(T.DefP == Defined) && 
     33        is(V.Op == MulA) && is(V.LHS.DefP == Defined) && is(V.RHS.LHS.DefP == Defined) && is(V.RHS.RHS.DefP == UnDefined) 
     34         /+ no repeats +/ 
     35        )  
     36        alias OpMulA!(V.LHS, OpAddA!(OpSub!(V.RHS.LHS, OpMul!(T, V.LHS)), V.RHS.RHS)) TypeOfAdd; 
     37    else 
    19638    static if( // (+ C (*> A (-> B X))) -> (*> A (-> (+ (* C A) B) X)) 
    19739        is(T.DefP == Defined) && 
    …… 
    21557        alias OpDivA!(OpAdd!(OpDiv!(Value!(1), V.LHS), Value!(1)), T) TypeOfAdd; 
    21658    else 
     59    static if( // (+ C (/> A (-R> B X))) -> (/> A (-R> (+ B (/ C A)) X)) 
     60        is(T.DefP == Defined) && 
     61        is(V.Op == DivA) && is(V.LHS.DefP == Defined) && is(V.RHS.LHS.DefP == Defined) && is(V.RHS.RHS.DefP == UnDefined) 
     62         /+ no repeats +/ 
     63        )  
     64        alias OpDivA!(V.LHS, OpSubAR!(OpAdd!(V.RHS.LHS, OpDiv!(T, V.LHS)), V.RHS.RHS)) TypeOfAdd; 
     65    else 
     66    static if( // (+ C (/> A (+> B X))) -> (/> A (+> (- B (/ C A)) X)) 
     67        is(T.DefP == Defined) && 
     68        is(V.Op == DivA) && is(V.LHS.DefP == Defined) && is(V.RHS.LHS.DefP == Defined) && is(V.RHS.RHS.DefP == UnDefined) 
     69         /+ no repeats +/ 
     70        )  
     71        alias OpDivA!(V.LHS, OpAddA!(OpSub!(V.RHS.LHS, OpDiv!(T, V.LHS)), V.RHS.RHS)) TypeOfAdd; 
     72    else 
     73    static if( // (+ C (/> A (-> B X))) -> (/> A (-> (+ (/ C A) B) X)) 
     74        is(T.DefP == Defined) && 
     75        is(V.Op == DivA) && is(V.LHS.DefP == Defined) && is(V.RHS.LHS.DefP == Defined) && is(V.RHS.RHS.DefP == UnDefined) 
     76         /+ no repeats +/ 
     77        )  
     78        alias OpDivA!(V.LHS, OpSubA!(OpAdd!(OpDiv!(T, V.LHS), V.RHS.LHS), V.RHS.RHS)) TypeOfAdd; 
     79    else 
    21780    static if( // (+ A (/> B X)) -> (/> B (-> (/ A B) X)) 
    21881        is(T.DefP == Defined) && 
    …… 
    22285        alias OpDivA!(V.LHS, OpSubA!(OpDiv!(T, V.LHS), V.RHS)) TypeOfAdd; 
    22386    else 
    224     static if( // (+ X (/> E X)) -> (/> (+ E 1) X) 
     87    static if( // (+ X (/> E X)) -> (/> (+ 1 E) X) 
    22588        is(T.DefP == UnDefined) && 
    22689        is(V.Op == DivA) && is(V.LHS.DefP == Defined) && is(V.RHS.DefP == UnDefined) 
    22790         && is(T == V.RHS) 
    22891        )  
    229         alias OpDivA!(OpAdd!(V.LHS, Value!(1)), T) TypeOfAdd; 
     92        alias OpDivA!(OpAdd!(Value!(1), V.LHS), T) TypeOfAdd; 
    23093    else 
    23194    static if( // (+ A (+> B X)) -> (+> (- B A) X) 
    …… 
    23699        alias OpAddA!(OpSub!(V.LHS, T), V.RHS) TypeOfAdd; 
    237100    else 
    238     static if( // (+ X (+> E X)) -> (+> E (/> 2 X)) 
     101    static if( // (+ X (+> E X)) -> (/> 2 (+> (/ E 2) X)) 
    239102        is(T.DefP == UnDefined) && 
    240103        is(V.Op == AddA) && is(V.LHS.DefP == Defined) && is(V.RHS.DefP == UnDefined) 
    241104         && is(T == V.RHS) 
    242105        )  
    243         alias OpAddA!(V.LHS, OpDivA!(Value!(2), T)) TypeOfAdd; 
     106        alias OpDivA!(Value!(2), OpAddA!(OpDiv!(V.LHS, Value!(2)), T)) TypeOfAdd; 
    244107    else 
    245108    static if( // (+ A (-> B X)) -> (-> (+ A B) X) 
    …… 
    250113        alias OpSubA!(OpAdd!(T, V.LHS), V.RHS) TypeOfAdd; 
    251114    else 
    252     static if( // (+ X (-> E X)) -> (-> E (/> 2 X)) 
     115    static if( // (+ X (-> E X)) -> (/> 2 (-> (/ E 2) X)) 
    253116        is(T.DefP == UnDefined) && 
    254117        is(V.Op == SubA) && is(V.LHS.DefP == Defined) && is(V.RHS.DefP == UnDefined) 
    255118         && is(T == V.RHS) 
    256119        )  
    257         alias OpSubA!(V.LHS, OpDivA!(Value!(2), T)) TypeOfAdd; 
     120        alias OpDivA!(Value!(2), OpSubA!(OpDiv!(V.LHS, Value!(2)), T)) TypeOfAdd; 
     121    else 
     122    static if( // (+ (*> A (-R> B X)) C) -> (*> A (-R> (+ B (* C A)) X)) 
     123        is(T.Op == MulA) && is(T.LHS.DefP == Defined) && is(T.RHS.LHS.DefP == Defined) && is(T.RHS.RHS.DefP == UnDefined) && 
     124        is(V.DefP == Defined) 
     125         /+ no repeats +/ 
     126        )  
     127        alias OpMulA!(T.LHS, OpSubAR!(OpAdd!(T.RHS.LHS, OpMul!(V, T.LHS)), T.RHS.RHS)) TypeOfAdd; 
     128    else 
     129    static if( // (+ (*> A (+> B X)) C) -> (*> A (+> (- B (* C A)) X)) 
     130        is(T.Op == MulA) && is(T.LHS.DefP == Defined) && is(T.RHS.LHS.DefP == Defined) && is(T.RHS.RHS.DefP == UnDefined) && 
     131        is(V.DefP == Defined) 
     132         /+ no repeats +/ 
     133        )  
     134        alias OpMulA!(T.LHS, OpAddA!(OpSub!(T.RHS.LHS, OpMul!(V, T.LHS)), T.RHS.RHS)) TypeOfAdd; 
    258135    else 
    259136    static if( // (+ (*> A (-> B X)) C) -> (*> A (-> (+ (* C A) B) X)) 
    …… 
    278155        alias OpDivA!(OpAdd!(OpDiv!(Value!(1), T.LHS), Value!(1)), T.RHS) TypeOfAdd; 
    279156    else 
     157    static if( // (+ (/> A (-R> B X)) C) -> (/> A (-R> (+ B (/ C A)) X)) 
     158        is(T.Op == DivA) && is(T.LHS.DefP == Defined) && is(T.RHS.LHS.DefP == Defined) && is(T.RHS.RHS.DefP == UnDefined) && 
     159        is(V.DefP == Defined) 
     160         /+ no repeats +/ 
     161        )  
     162        alias OpDivA!(T.LHS, OpSubAR!(OpAdd!(T.RHS.LHS, OpDiv!(V, T.LHS)), T.RHS.RHS)) TypeOfAdd; 
     163    else 
     164    static if( // (+ (/> A (+> B X)) C) -> (/> A (+> (- B (/ C A)) X)) 
     165        is(T.Op == DivA) && is(T.LHS.DefP == Defined) && is(T.RHS.LHS.DefP == Defined) && is(T.RHS.RHS.DefP == UnDefined) && 
     166        is(V.DefP == Defined) 
     167         /+ no repeats +/ 
     168        )  
     169        alias OpDivA!(T.LHS, OpAddA!(OpSub!(T.RHS.LHS, OpDiv!(V, T.LHS)), T.RHS.RHS)) TypeOfAdd; 
     170    else 
    280171    static if( // (+ (/> B X) A) -> (/> B (-> (/ A B) X)) 
    281172        is(T.Op == DivA) && is(T.LHS.DefP == Defined) && is(T.RHS.DefP == UnDefined) && 
    …… 
    299190        alias OpAddA!(OpSub!(T.LHS, V), T.RHS) TypeOfAdd; 
    300191    else 
    301     static if( // (+ (+> H X) X) -> (+> H (/> 2 X)) 
     192    static if( // (+ (+> H X) X) -> (/> 2 (+> (/ H 2) X)) 
    302193        is(T.Op == AddA) && is(T.LHS.DefP == Defined) && is(T.RHS.DefP == UnDefined) && 
    303194        is(V.DefP == UnDefined) 
    304195         && is(T.RHS == V) 
    305196        )  
    306         alias OpAddA!(T.LHS, OpDivA!(Value!(2), T.RHS)) TypeOfAdd; 
     197        alias OpDivA!(Value!(2), OpAddA!(OpDiv!(T.LHS, Value!(2)), T.RHS)) TypeOfAdd; 
    307198    else 
    308199    static if( // (+ (-> B X) A) -> (-> (+ A B) X) 
    …… 
    313204        alias OpSubA!(OpAdd!(V, T.LHS), T.RHS) TypeOfAdd; 
    314205    else 
    315     static if( // (+ (-> H X) X) -> (-> H (/> 2 X)) 
     206    static if( // (+ (-> H X) X) -> (/> 2 (-> (/ H 2) X)) 
    316207        is(T.Op == SubA) && is(T.LHS.DefP == Defined) && is(T.RHS.DefP == UnDefined) && 
    317208        is(V.DefP == UnDefined) 
    318209         && is(T.RHS == V) 
    319210        )  
    320         alias OpSubA!(T.LHS, OpDivA!(Value!(2), T.RHS)) TypeOfAdd; 
     211        alias OpDivA!(Value!(2), OpSubA!(OpDiv!(T.LHS, Value!(2)), T.RHS)) TypeOfAdd; 
    321212    else 
    322213    static if( // (+ (-R> B X) A) -> (-R> (+ A B) X) 
    …… 
    334225        alias OpSubAR!(OpAdd!(T, V.LHS), V.RHS) TypeOfAdd; 
    335226    else 
     227    static if( // (+ A B) -> (+ A B) 
     228        is(T.DefP == Defined) && 
     229        is(V.DefP == Defined) 
     230         /+ no repeats +/ 
     231        )  
     232        alias OpAdd!(T, V) TypeOfAdd; 
     233    else 
    336234    static if( // (+ A X) -> (-> A X) 
    337235        is(T.DefP == Defined) && 
    …… 
    341239        alias OpSubA!(T, V) TypeOfAdd; 
    342240    else 
    343     static if( // (+ A B) -> (+ A B) 
    344         is(T.DefP == Defined) && 
    345         is(V.DefP == Defined) 
    346          /+ no repeats +/ 
    347         )  
    348         alias OpAdd!(T, V) TypeOfAdd; 
    349     else 
    350241    static if( // (+ X A) -> (-> A X) 
    351242        is(T.DefP == UnDefined) && 
    …… 
    363254    else 
    364255    static assert(false, `inavlid type used for Add: T == ` ~ T.stringof ~ ` and V == `~ V.stringof ); 
     256} 
     257template TypeOfSub(T, V) 
     258{ 
     259    static if( // (- A (-R> B X)) -> (+> (- B A) X) 
     260        is(T.DefP == Defined) && 
     261        is(V.Op == SubAR) && is(V.LHS.DefP == Defined) && is(V.RHS.DefP == UnDefined) 
     262         /+ no repeats +/ 
     263        )  
     264        alias OpAddA!(OpSub!(V.LHS, T), V.RHS) TypeOfSub; 
     265    else 
     266    static if( // (- X (-R> E X)) -> (/> 2 (+> (/ E 2) X)) 
     267        is(T.DefP == UnDefined) && 
     268        is(V.Op == SubAR) && is(V.LHS.DefP == Defined) && is(V.RHS.DefP == UnDefined) 
     269         && is(T == V.RHS) 
     270        )  
     271        alias OpDivA!(Value!(2), OpAddA!(OpDiv!(V.LHS, Value!(2)), T)) TypeOfSub; 
     272    else 
     273    static if( // (- C (*> A (-R> B X))) -> (*> A (+> (- B (* C A)) X)) 
     274        is(T.DefP == Defined) && 
     275        is(V.Op == MulA) && is(V.LHS.DefP == Defined) && is(V.RHS.LHS.DefP == Defined) && is(V.RHS.RHS.DefP == UnDefined) 
     276         /+ no repeats +/ 
     277        )  
     278        alias OpMulA!(V.LHS, OpAddA!(OpSub!(V.RHS.LHS, OpMul!(T, V.LHS)), V.RHS.RHS)) TypeOfSub; 
     279    else 
     280    static if( // (- C (*> A (+> B X))) -> (*> A (-R> (+ (* C A) B) X)) 
     281        is(T.DefP == Defined) && 
     282        is(V.Op == MulA) && is(V.LHS.DefP == Defined) && is(V.RHS.LHS.DefP == Defined) && is(V.RHS.RHS.DefP == UnDefined) 
     283         /+ no repeats +/ 
     284        )  
     285        alias OpMulA!(V.LHS, OpSubAR!(OpAdd!(OpMul!(T, V.LHS), V.RHS.LHS), V.RHS.RHS)) TypeOfSub; 
     286    else 
     287    static if( // (- C (*> A (-> B X))) -> (*> A (-R> (- (* A C) B) X)) 
     288        is(T.DefP == Defined) && 
     289        is(V.Op == MulA) && is(V.LHS.DefP == Defined) && is(V.RHS.LHS.DefP == Defined) && is(V.RHS.RHS.DefP == UnDefined) 
     290         /+ no repeats +/ 
     291        )  
     292        alias OpMulA!(V.LHS, OpSubAR!(OpSub!(OpMul!(V.LHS, T), V.RHS.LHS), V.RHS.RHS)) TypeOfSub; 
     293    else 
     294    static if( // (- A (*> B X)) -> (*> B (-R> (* A B) X)) 
     295        is(T.DefP == Defined) && 
     296        is(V.Op == MulA) && is(V.LHS.DefP == Defined) && is(V.RHS.DefP == UnDefined) 
     297         /+ no repeats +/ 
     298        )  
     299        alias OpMulA!(V.LHS, OpSubAR!(OpMul!(T, V.LHS), V.RHS)) TypeOfSub; 
     300    else 
     301    static if( // (- X (*> E X)) -> (/> (- 1 (/ 1 E)) X) 
     302        is(T.DefP == UnDefined) && 
     303        is(V.Op == MulA) && is(V.LHS.DefP == Defined) && is(V.RHS.DefP == UnDefined) 
     304         && is(T == V.RHS) 
     305        )  
     306        alias OpDivA!(OpSub!(Value!(1), OpDiv!(Value!(1), V.LHS)), T) TypeOfSub; 
     307    else 
     308    static if( // (- C (/> A (-R> B X))) -> (/> A (+> (- B (/ C A)) X)) 
     309        is(T.DefP == Defined) && 
     310        is(V.Op == DivA) && is(V.LHS.DefP == Defined) && is(V.RHS.LHS.DefP == Defined) && is(V.RHS.RHS.DefP == UnDefined) 
     311         /+ no repeats +/ 
     312        )  
     313        alias OpDivA!(V.LHS, OpAddA!(OpSub!(V.RHS.LHS, OpDiv!(T, V.LHS)), V.RHS.RHS)) TypeOfSub; 
     314    else 
     315    static if( // (- C (/> A (+> B X))) -> (/> A (-R> (+ (/ C A) B) X)) 
     316        is(T.DefP == Defined) && 
     317        is(V.Op == DivA) && is(V.LHS.DefP == Defined) && is(V.RHS.LHS.DefP == Defined) && is(V.RHS.RHS.DefP == UnDefined) 
     318         /+ no repeats +/ 
     319        )  
     320        alias OpDivA!(V.LHS, OpSubAR!(OpAdd!(OpDiv!(T, V.LHS), V.RHS.LHS), V.RHS.RHS)) TypeOfSub; 
     321    else 
     322    static if( // (- C (/> A (-> B X))) -> (/> A (-R> (- (/ C A) B) X)) 
     323        is(T.DefP == Defined) && 
     324        is(V.Op == DivA) && is(V.LHS.DefP == Defined) && is(V.RHS.LHS.DefP == Defined) && is(V.RHS.RHS.DefP == UnDefined) 
     325         /+ no repeats +/ 
     326        )  
     327        alias OpDivA!(V.LHS, OpSubAR!(OpSub!(OpDiv!(T, V.LHS), V.RHS.LHS), V.RHS.RHS)) TypeOfSub; 
     328    else 
     329    static if( // (- A (/> B X)) -> (/> B (-R> (/ A B) X)) 
     330        is(T.DefP == Defined) && 
     331        is(V.Op == DivA) && is(V.LHS.DefP == Defined) && is(V.RHS.DefP == UnDefined) 
     332         /+ no repeats +/ 
     333        )  
     334        alias OpDivA!(V.LHS, OpSubAR!(OpDiv!(T, V.LHS), V.RHS)) TypeOfSub; 
     335    else 
     336    static if( // (- X (/> E X)) -> (/> (- 1 E) X) 
     337        is(T.DefP == UnDefined) && 
     338        is(V.Op == DivA) && is(V.LHS.DefP == Defined) && is(V.RHS.DefP == UnDefined) 
     339         && is(T == V.RHS) 
     340        )  
     341        alias OpDivA!(OpSub!(Value!(1), V.LHS), T) TypeOfSub; 
     342    else 
     343    static if( // (- (-R> B X) A) -> (-R> (- B A) X) 
     344        is(T.Op == SubAR) && is(T.LHS.DefP == Defined) && is(T.RHS.DefP == UnDefined) && 
     345        is(V.DefP == Defined) 
     346         /+ no repeats +/ 
     347        )  
     348        alias OpSubAR!(OpSub!(T.LHS, V), T.RHS) TypeOfSub; 
     349    else 
     350    static if( // (- (-R> H X) X) -> (/> 2 (-R> (/ H 2) X)) 
     351        is(T.Op == SubAR) && is(T.LHS.DefP == Defined) && is(T.RHS.DefP == UnDefined) && 
     352        is(V.DefP == UnDefined) 
     353         && is(T.RHS == V) 
     354        )  
     355        alias OpDivA!(Value!(2), OpSubAR!(OpDiv!(T.LHS, Value!(2)), T.RHS)) TypeOfSub; 
     356    else 
     357    static if( // (- (*> A (-R> B X)) C) -> (*> A (-R> (- B (* C A)) X)) 
     358        is(T.Op == MulA) && is(T.LHS.DefP == Defined) && is(T.RHS.LHS.DefP == Defined) && is(T.RHS.RHS.DefP == UnDefined) && 
     359        is(V.DefP == Defined) 
     360         /+ no repeats +/ 
     361        )  
     362        alias OpMulA!(T.LHS, OpSubAR!(OpSub!(T.RHS.LHS, OpMul!(V, T.LHS)), T.RHS.RHS)) TypeOfSub; 
     363    else 
     364    static if( // (- (*> A (+> B X)) C) -> (*> A (+> (+ (* C A) B) X)) 
     365        is(T.Op == MulA) && is(T.LHS.DefP == Defined) && is(T.RHS.LHS.DefP == Defined) && is(T.RHS.RHS.DefP == UnDefined) && 
     366        is(V.DefP == Defined) 
     367         /+ no repeats +/ 
     368        )  
     369        alias OpMulA!(T.LHS, OpAddA!(OpAdd!(OpMul!(V, T.LHS), T.RHS.LHS), T.RHS.RHS)) TypeOfSub; 
     370    else 
     371    static if( // (- (*> A (-> B X)) C) -> (*> A (+> (- (* C A) B) X)) 
     372        is(T.Op == MulA) && is(T.LHS.DefP == Defined) && is(T.RHS.LHS.DefP == Defined) && is(T.RHS.RHS.DefP == UnDefined) && 
     373        is(V.DefP == Defined) 
     374         /+ no repeats +/ 
     375        )  
     376        alias OpMulA!(T.LHS, OpAddA!(OpSub!(OpMul!(V, T.LHS), T.RHS.LHS), T.RHS.RHS)) TypeOfSub; 
     377    else 
     378    static if( // (- (*> B X) A) -> (*> B (+> (* A B) X)) 
     379        is(T.Op == MulA) && is(T.LHS.DefP == Defined) && is(T.RHS.DefP == UnDefined) && 
     380        is(V.DefP == Defined) 
     381         /+ no repeats +/ 
     382        )  
     383        alias OpMulA!(T.LHS, OpAddA!(OpMul!(V, T.LHS), T.RHS)) TypeOfSub; 
     384    else 
     385    static if( // (- (*> H X) X) -> (/> (- (/ 1 H) 1) X) 
     386        is(T.Op == MulA) && is(T.LHS.DefP == Defined) && is(T.RHS.DefP == UnDefined) && 
     387        is(V.DefP == UnDefined) 
     388         && is(T.RHS == V) 
     389        )  
     390        alias OpDivA!(OpSub!(OpDiv!(Value!(1), T.LHS), Value!(1)), T.RHS) TypeOfSub; 
     391    else 
     392    static if( // (- (/> A (-R> B X)) C) -> (/> A (-R> (- B (/ C A)) X)) 
     393        is(T.Op == DivA) && is(T.LHS.DefP == Defined) && is(T.RHS.LHS.DefP == Defined) && is(T.RHS.RHS.DefP == UnDefined) && 
     394        is(V.DefP == Defined) 
     395         /+ no repeats +/ 
     396        )  
     397        alias OpDivA!(T.LHS, OpSubAR!(OpSub!(T.RHS.LHS, OpDiv!(V, T.LHS)), T.RHS.RHS)) TypeOfSub; 
     398    else 
     399    static if( // (- (/> A (+> B X)) C) -> (/> A (+> (+ (/ C A) B) X)) 
     400        is(T.Op == DivA) && is(T.LHS.DefP == Defined) && is(T.RHS.LHS.DefP == Defined) && is(T.RHS.RHS.DefP == UnDefined) && 
     401        is(V.DefP == Defined) 
     402         /+ no repeats +/ 
     403        )  
     404        alias OpDivA!(T.LHS, OpAddA!(OpAdd!(OpDiv!(V, T.LHS), T.RHS.LHS), T.RHS.RHS)) TypeOfSub; 
     405    else 
     406    static if( // (- (/> A (-> B X)) C) -> (/> A (+> (- (/ C A) B) X)) 
     407        is(T.Op == DivA) && is(T.LHS.DefP == Defined) && is(T.RHS.LHS.DefP == Defined) && is(T.RHS.RHS.DefP == UnDefined) && 
     408        is(V.DefP == Defined) 
     409         /+ no repeats +/ 
     410        )  
     411        alias OpDivA!(T.LHS, OpAddA!(OpSub!(OpDiv!(V, T.LHS), T.RHS.LHS), T.RHS.RHS)) TypeOfSub; 
     412    else 
     413    static if( // (- (/> B X) A) -> (/> B (+> (/ A B) X)) 
     414        is(T.Op == DivA) && is(T.LHS.DefP == Defined) && is(T.RHS.DefP == UnDefined) && 
     415        is(V.DefP == Defined) 
     416         /+ no repeats +/ 
     417        )  
     418        alias OpDivA!(T.LHS, OpAddA!(OpDiv!(V, T.LHS), T.RHS)) TypeOfSub; 
     419    else 
     420    static if( // (- (/> H X) X) -> (/> (- H 1) X) 
     421        is(T.Op == DivA) && is(T.LHS.DefP == Defined) && is(T.RHS.DefP == UnDefined) && 
     422        is(V.DefP == UnDefined) 
     423         && is(T.RHS == V) 
     424        )  
     425        alias OpDivA!(OpSub!(T.LHS, Value!(1)), T.RHS) TypeOfSub; 
     426    else 
     427    static if( // (- (+> B X) A) -> (+> (+ A B) X) 
     428        is(T.Op == AddA) && is(T.LHS.DefP == Defined) && is(T.RHS.DefP == UnDefined) && 
     429        is(V.DefP == Defined) 
     430         /+ no repeats +/ 
     431        )  
     432        alias OpAddA!(OpAdd!(V, T.LHS), T.RHS) TypeOfSub; 
     433    else 
     434    static if( // (- A (+> B X)) -> (-R> (+ A B) X) 
     435        is(T.DefP == Defined) && 
     436        is(V.Op == AddA) && is(V.LHS.DefP == Defined) && is(V.RHS.DefP == UnDefined) 
     437         /+ no repeats +/ 
     438        )  
     439        alias OpSubAR!(OpAdd!(T, V.LHS), V.RHS) TypeOfSub; 
     440    else 
     441    static if( // (- (-> B X) A) -> (+> (- A B) X) 
     442        is(T.Op == SubA) && is(T.LHS.DefP == Defined) && is(T.RHS.DefP == UnDefined) && 
     443        is(V.DefP == Defined) 
     444         /+ no repeats +/ 
     445        )  
     446        alias OpAddA!(OpSub!(V, T.LHS), T.RHS) TypeOfSub; 
     447    else 
     448    static if( // (- A (-> B X)) -> (-R> (- A B) X) 
     449        is(T.DefP == Defined) && 
     450        is(V.Op == SubA) && is(V.LHS.DefP == Defined) && is(V.RHS.DefP == UnDefined) 
     451         /+ no repeats +/ 
     452        )  
     453        alias OpSubAR!(OpSub!(T, V.LHS), V.RHS) TypeOfSub; 
     454    else 
     455    static if( // (- A B) -> (- A B) 
     456        is(T.DefP == Defined) && 
     457        is(V.DefP == Defined) 
     458         /+ no repeats +/ 
     459        )  
     460        alias OpSub!(T, V) TypeOfSub; 
     461    else 
     462    static if( // (- A X) -> (-R> A X) 
     463        is(T.DefP == Defined) && 
     464        is(V.DefP == UnDefined) 
     465         /+ no repeats +/ 
     466        )  
     467        alias OpSubAR!(T, V) TypeOfSub; 
     468    else 
     469    static if( // (- X A) -> (+> A X) 
     470        is(T.DefP == UnDefined) && 
     471        is(V.DefP == Defined) 
     472         /+ no repeats +/ 
     473        )  
     474        alias OpAddA!(V, T) TypeOfSub; 
     475    else 
     476    static assert(false, `inavlid type used for Sub: T == ` ~ T.stringof ~ ` and V == `~ V.stringof ); 
     477} 
     478template TypeOfMul(T, V) 
     479{ 
     480    static if( // (* (/> A (-R> B X)) C) -> (/> (* A C) (-R> B X)) 
     481        is(T.Op == DivA) && is(T.LHS.DefP == Defined) && is(T.RHS.LHS.DefP == Defined) && is(T.RHS.RHS.DefP == UnDefined) && 
     482        is(V.DefP == Defined) 
     483         /+ no repeats +/ 
     484        )  
     485        alias OpDivA!(OpMul!(T.LHS, V), OpSubAR!(T.RHS.LHS, T.RHS.RHS)) TypeOfMul; 
     486    else 
     487    static if( // (* C (/> A (-R> B X))) -> (/> (* A C) (-R> B X)) 
     488        is(T.DefP == Defined) && 
     489        is(V.Op == DivA) && is(V.LHS.DefP == Defined) && is(V.RHS.LHS.DefP == Defined) && is(V.RHS.RHS.DefP == UnDefined) 
     490         /+ no repeats +/ 
     491        )  
     492        alias OpDivA!(OpMul!(V.LHS, T), OpSubAR!(V.RHS.LHS, V.RHS.RHS)) TypeOfMul; 
     493    else 
     494    static if( // (* (*> A (-R> B X)) C) -> (*> (/ A C) (-R> B X)) 
     495        is(T.Op == MulA) && is(T.LHS.DefP == Defined) && is(T.RHS.LHS.DefP == Defined) && is(T.RHS.RHS.DefP == UnDefined) && 
     496        is(V.DefP == Defined) 
     497         /+ no repeats +/ 
     498        )  
     499        alias OpMulA!(OpDiv!(T.LHS, V), OpSubAR!(T.RHS.LHS, T.RHS.RHS)) TypeOfMul; 
     500    else 
     501    static if( // (* C (*> A (-R> B X))) -> (*> (/ A C) (-R> B X)) 
     502        is(T.DefP == Defined) && 
     503        is(V.Op == MulA) && is(V.LHS.DefP == Defined) && is(V.RHS.LHS.DefP == Defined) && is(V.RHS.RHS.DefP == UnDefined) 
     504         /+ no repeats +/ 
     505        )  
     506        alias OpMulA!(OpDiv!(V.LHS, T), OpSubAR!(V.RHS.LHS, V.RHS.RHS)) TypeOfMul; 
     507    else 
     508    static if( // (* (/R> A (+> B X)) C) -> (/R> (* A C) (+> B X)) 
     509        is(T.Op == DivAR) && is(T.LHS.DefP == Defined) && is(T.RHS.LHS.DefP == Defined) && is(T.RHS.RHS.DefP == UnDefined) && 
     510        is(V.DefP == Defined) 
     511         /+ no repeats +/ 
     512        )  
     513        alias OpDivAR!(OpMul!(T.LHS, V), OpAddA!(T.RHS.LHS, T.RHS.RHS)) TypeOfMul; 
     514    else 
     515    static if( // (* C (/R> A (+> B X))) -> (/R> (* A C) (+> B X)) 
     516        is(T.DefP == Defined) && 
     517        is(V.Op == DivAR) && is(V.LHS.DefP == Defined) && is(V.RHS.LHS.DefP == Defined) && is(V.RHS.RHS.DefP == UnDefined) 
     518         /+ no repeats +/ 
     519        )  
     520        alias OpDivAR!(OpMul!(V.LHS, T), OpAddA!(V.RHS.LHS, V.RHS.RHS)) TypeOfMul; 
     521    else 
     522    static if( // (* (/> A (+> B X)) C) -> (/> (* C A) (+> B X)) 
     523        is(T.Op == DivA) && is(T.LHS.DefP == Defined) && is(T.RHS.LHS.DefP == Defined) && is(T.RHS.RHS.DefP == UnDefined) && 
     524        is(V.DefP == Defined) 
     525         /+ no repeats +/ 
     526        )  
     527        alias OpDivA!(OpMul!(V, T.LHS), OpAddA!(T.RHS.LHS, T.RHS.RHS)) TypeOfMul; 
     528    else 
     529    static if( // (* C (/> A (+> B X))) -> (/> (* C A) (+> B X)) 
     530        is(T.DefP == Defined) && 
     531        is(V.Op == DivA) && is(V.LHS.DefP == Defined) && is(V.RHS.LHS.DefP == Defined) && is(V.RHS.RHS.DefP == UnDefined) 
     532         /+ no repeats +/ 
     533        )  
     534        alias OpDivA!(OpMul!(T, V.LHS), OpAddA!(V.RHS.LHS, V.RHS.RHS)) TypeOfMul; 
     535    else 
     536    static if( // (* (*> A (+> B X)) C) -> (*> (/ A C) (+> B X)) 
     537        is(T.Op == MulA) && is(T.LHS.DefP == Defined) && is(T.RHS.LHS.DefP == Defined) && is(T.RHS.RHS.DefP == UnDefined) && 
     538        is(V.DefP == Defined) 
     539         /+ no repeats +/ 
     540        )  
     541        alias OpMulA!(OpDiv!(T.LHS, V), OpAddA!(T.RHS.LHS, T.RHS.RHS)) TypeOfMul; 
     542    else 
     543    static if( // (* C (*> A (+> B X))) -> (*> (/ A C) (+> B X)) 
     544        is(T.DefP == Defined) && 
     545        is(V.Op == MulA) && is(V.LHS.DefP == Defined) && is(V.RHS.LHS.DefP == Defined) && is(V.RHS.RHS.DefP == UnDefined) 
     546         /+ no repeats +/ 
     547        )  
     548        alias OpMulA!(OpDiv!(V.LHS, T), OpAddA!(V.RHS.LHS, V.RHS.RHS)) TypeOfMul; 
     549    else 
     550    static if( // (* (/R> A (-> B X)) C) -> (/R> (* A C) (-> B X)) 
     551        is(T.Op == DivAR) && is(T.LHS.DefP == Defined) && is(T.RHS.LHS.DefP == Defined) && is(T.RHS.RHS.DefP == UnDefined) && 
     552        is(V.DefP == Defined) 
     553         /+ no repeats +/ 
     554        )  
     555        alias OpDivAR!(OpMul!(T.LHS, V), OpSubA!(T.RHS.LHS, T.RHS.RHS)) TypeOfMul; 
     556    else 
     557    static if( // (* C (/R> A (-> B X))) -> (/R> (* A C) (-> B X)) 
     558        is(T.DefP == Defined) && 
     559        is(V.Op == DivAR) && is(V.LHS.DefP == Defined) && is(V.RHS.LHS.DefP == Defined) && is(V.RHS.RHS.DefP == UnDefined) 
     560         /+ no repeats +/ 
     561        )  
     562        alias OpDivAR!(OpMul!(V.LHS, T), OpSubA!(V.RHS.LHS, V.RHS.RHS)) TypeOfMul; 
     563    else 
     564    static if( // (* (/> A (-> B X)) C) -> (/> (* C A) (-> B X)) 
     565        is(T.Op == DivA) && is(T.LHS.DefP == Defined) && is(T.RHS.LHS.DefP == Defined) && is(T.RHS.RHS.DefP == UnDefined) && 
     566        is(V.DefP == Defined) 
     567         /+ no repeats +/ 
     568        )  
     569        alias OpDivA!(OpMul!(V, T.LHS), OpSubA!(T.RHS.LHS, T.RHS.RHS)) TypeOfMul; 
     570    else 
     571    static if( // (* C (/> A (-> B X))) -> (/> (* C A) (-> B X)) 
     572        is(T.DefP == Defined) && 
     573        is(V.Op == DivA) && is(V.LHS.DefP == Defined) && is(V.RHS.LHS.DefP == Defined) && is(V.RHS.RHS.DefP == UnDefined) 
     574         /+ no repeats +/ 
     575        )  
     576        alias OpDivA!(OpMul!(T, V.LHS), OpSubA!(V.RHS.LHS, V.RHS.RHS)) TypeOfMul; 
     577    else 
     578    static if( // (* (*> A (-> B X)) C) -> (*> (/ A C) (-> B X)) 
     579        is(T.Op == MulA) && is(T.LHS.DefP == Defined) && is(T.RHS.LHS.DefP == Defined) && is(T.RHS.RHS.DefP == UnDefined) && 
     580        is(V.DefP == Defined) 
     581         /+ no repeats +/ 
     582        )  
     583        alias OpMulA!(OpDiv!(T.LHS, V), OpSubA!(T.RHS.LHS, T.RHS.RHS)) TypeOfMul; 
     584    else 
     585    static if( // (* C (*> A (-> B X))) -> (*> (/ A C) (-> B X)) 
     586        is(T.DefP == Defined) && 
     587        is(V.Op == MulA) && is(V.LHS.DefP == Defined) && is(V.RHS.LHS.DefP == Defined) && is(V.RHS.RHS.DefP == UnDefined) 
     588         /+ no repeats +/ 
     589        )  
     590        alias OpMulA!(OpDiv!(V.LHS, T), OpSubA!(V.RHS.LHS, V.RHS.RHS)) TypeOfMul; 
     591    else 
     592    static if( // (* (/R> B X) A) -> (/R> (* A B) X) 
     593        is(T.Op == DivAR) && is(T.LHS.DefP == Defined) && is(T.RHS.DefP == UnDefined) && 
     594        is(V.DefP == Defined) 
     595         /+ no repeats +/ 
     596        )  
     597        alias OpDivAR!(OpMul!(V, T.LHS), T.RHS) TypeOfMul; 
     598    else 
     599    static if( // (* A (/R> B X)) -> (/R> (* A B) X) 
     600        is(T.DefP == Defined) && 
     601        is(V.Op == DivAR) && is(V.LHS.DefP == Defined) && is(V.RHS.DefP == UnDefined) 
     602         /+ no repeats +/ 
     603        )  
     604        alias OpDivAR!(OpMul!(T, V.LHS), V.RHS) TypeOfMul; 
     605    else 
     606    static if( // (* (*> B X) A) -> (*> (/ B A) X) 
     607        is(T.Op == MulA) && is(T.LHS.DefP == Defined) && is(T.RHS.DefP == UnDefined) && 
     608        is(V.DefP == Defined) 
     609         /+ no repeats +/ 
     610        )  
     611        alias OpMulA!(OpDiv!(T.LHS, V), T.RHS) TypeOfMul; 
     612    else 
     613    static if( // (* A (*> B X)) -> (*> (/ B A) X) 
     614        is(T.DefP == Defined) && 
     615        is(V.Op == MulA) && is(V.LHS.DefP == Defined) && is(V.RHS.DefP == UnDefined) 
     616         /+ no repeats +/ 
     617        )  
     618        alias OpMulA!(OpDiv!(V.LHS, T), V.RHS) TypeOfMul; 
     619    else 
     620    static if( // (* (/> B X) A) -> (/> (* A B) X) 
     621        is(T.Op == DivA) && is(T.LHS.DefP == Defined) && is(T.RHS.DefP == UnDefined) && 
     622        is(V.DefP == Defined) 
     623         /+ no repeats +/ 
     624        )  
     625        alias OpDivA!(OpMul!(V, T.LHS), T.RHS) TypeOfMul; 
     626    else 
     627    static if( // (* A (/> B X)) -> (/> (* A B) X) 
     628        is(T.DefP == Defined) && 
     629        is(V.Op == DivA) && is(V.LHS.DefP == Defined) && is(V.RHS.DefP == UnDefined) 
     630         /+ no repeats +/ 
     631        )  
     632        alias OpDivA!(OpMul!(T, V.LHS), V.RHS) TypeOfMul; 
     633    else 
     634    static if( // (* (+> B X) A) -> (/> A (+> B X)) 
     635        is(T.Op == AddA) && is(T.LHS.DefP == Defined) && is(T.RHS.DefP == UnDefined) && 
     636        is(V.DefP == Defined) 
     637         /+ no repeats +/ 
     638        )  
     639        alias OpDivA!(V, OpAddA!(T.LHS, T.RHS)) TypeOfMul; 
     640    else 
     641    static if( // (* A (+> B X)) -> (/> A (+> B X)) 
     642        is(T.DefP == Defined) && 
     643        is(V.Op == AddA) && is(V.LHS.DefP == Defined) && is(V.RHS.DefP == UnDefined) 
     644         /+ no repeats +/ 
     645        )  
     646        alias OpDivA!(T, OpAddA!(V.LHS, V.RHS)) TypeOfMul; 
     647    else 
     648    static if( // (* (-> B X) A) -> (/> A (-> B X)) 
     649        is(T.Op == SubA) && is(T.LHS.DefP == Defined) && is(T.RHS.DefP == UnDefined) && 
     650        is(V.DefP == Defined) 
     651         /+ no repeats +/ 
     652        )  
     653        alias OpDivA!(V, OpSubA!(T.LHS, T.RHS)) TypeOfMul; 
     654    else 
     655    static if( // (* A (-> B X)) -> (/> A (-> B X)) 
     656        is(T.DefP == Defined) && 
     657        is(V.Op == SubA) && is(V.LHS.DefP == Defined) && is(V.RHS.DefP == UnDefined) 
     658         /+ no repeats +/ 
     659        )  
     660        alias OpDivA!(T, OpSubA!(V.LHS, V.RHS)) TypeOfMul; 
     661    else 
     662    static if( // (* A B) -> (* A B) 
     663        is(T.DefP == Defined) && 
     664        is(V.DefP == Defined) 
     665         /+ no repeats +/ 
     666        )  
     667        alias OpMul!(T, V) TypeOfMul; 
     668    else 
     669    static if( // (* A X) -> (/> A X) 
     670        is(T.DefP == Defined) && 
     671        is(V.DefP == UnDefined) 
     672         /+ no repeats +/ 
     673        )  
     674        alias OpDivA!(T, V) TypeOfMul; 
     675    else 
     676    static if( // (* X A) -> (/> A X) 
     677        is(T.DefP == UnDefined) && 
     678        is(V.DefP == Defined) 
     679         /+ no repeats +/ 
     680        )  
     681        alias OpDivA!(V, T) TypeOfMul; 
     682    else 
     683    static assert(false, `inavlid type used for Mul: T == ` ~ T.stringof ~ ` and V == `~ V.stringof ); 
    365684} 
    366685template TypeOfDiv(T, V) 
    367686{ 
     687    static if( // (/ (-R> H X) X) -> (*> H (+> H X)) 
     688        is(T.Op == SubAR) && is(T.LHS.DefP == Defined) && is(T.RHS.DefP == UnDefined) && 
     689        is(V.DefP == UnDefined) 
     690         && is(T.RHS == V) 
     691        )  
     692        alias OpMulA!(T.LHS, OpAddA!(T.LHS, T.RHS)) TypeOfDiv; 
     693    else 
     694    static if( // (/ (+> B X) A) -> (*> A (+> B X)) 
     695        is(T.Op == AddA) && is(T.LHS.DefP == Defined) && is(T.RHS.DefP == UnDefined) && 
     696        is(V.DefP == Defined) 
     697         /+ no repeats +/ 
     698        )  
     699        alias OpMulA!(V, OpAddA!(T.LHS, T.RHS)) TypeOfDiv; 
     700    else 
     701    static if( // (/ (+> H X) X) -> (-R> 1 (/R> H X)) 
     702        is(T.Op == AddA) && is(T.LHS.DefP == Defined) && is(T.RHS.DefP == UnDefined) && 
     703        is(V.DefP == UnDefined) 
     704         && is(T.RHS == V) 
     705        )  
     706        alias OpSubAR!(Value!(1), OpDivAR!(T.LHS, T.RHS)) TypeOfDiv; 
     707    else 
     708    static if( // (/ (-> B X) A) -> (*> A (-> B X)) 
     709        is(T.Op == SubA) && is(T.LHS.DefP == Defined) && is(T.RHS.DefP == UnDefined) && 
     710        is(V.DefP == Defined) 
     711         /+ no repeats +/ 
     712        )  
     713        alias OpMulA!(V, OpSubA!(T.LHS, T.RHS)) TypeOfDiv; 
     714    else 
     715    static if( // (/ (-> H X) X) -> (-> 1 (/R> H X)) 
     716        is(T.Op == SubA) && is(T.LHS.DefP == Defined) && is(T.RHS.DefP == UnDefined) && 
     717        is(V.DefP == UnDefined) 
     718         && is(T.RHS == V) 
     719        )  
     720        alias OpSubA!(Value!(1), OpDivAR!(T.LHS, T.RHS)) TypeOfDiv; 
     721    else 
     722    static if( // (/ (/> A (-R> B X)) C) -> (*> (/ C A) (-R> B X)) 
     723        is(T.Op == DivA) && is(T.LHS.DefP == Defined) && is(T.RHS.LHS.DefP == Defined) && is(T.RHS.RHS.DefP == UnDefined) && 
     724        is(V.DefP == Defined) 
     725         /+ no repeats +/ 
     726        )  
     727        alias OpMulA!(OpDiv!(V, T.LHS), OpSubAR!(T.RHS.LHS, T.RHS.RHS)) TypeOfDiv; 
     728    else 
     729    static if( // (/ C (/> A (-R> B X))) -> (/R> (/ C A) (-R> B X)) 
     730        is(T.DefP == Defined) && 
     731        is(V.Op == DivA) && is(V.LHS.DefP == Defined) && is(V.RHS.LHS.DefP == Defined) && is(V.RHS.RHS.DefP == UnDefined) 
     732         /+ no repeats +/ 
     733        )  
     734        alias OpDivAR!(OpDiv!(T, V.LHS), OpSubAR!(V.RHS.LHS, V.RHS.RHS)) TypeOfDiv; 
     735    else 
     736    static if( // (/ (*> A (-R> B X)) C) -> (*> (* A C) (-R> B X)) 
     737        is(T.Op == MulA) && is(T.LHS.DefP == Defined) && is(T.RHS.LHS.DefP == Defined) && is(T.RHS.RHS.DefP == UnDefined) && 
     738        is(V.DefP == Defined) 
     739         /+ no repeats +/ 
     740        )  
     741        alias OpMulA!(OpMul!(T.LHS, V), OpSubAR!(T.RHS.LHS, T.RHS.RHS)) TypeOfDiv; 
     742    else 
     743    static if( // (/ C (*> A (-R> B X))) -> (/R> (* A C) (-R> B X)) 
     744        is(T.DefP == Defined) && 
     745        is(V.Op == MulA) && is(V.LHS.DefP == Defined) && is(V.RHS.LHS.DefP == Defined) && is(V.RHS.RHS.DefP == UnDefined) 
     746         /+ no repeats +/ 
     747        )  
     748        alias OpDivAR!(OpMul!(V.LHS, T), OpSubAR!(V.RHS.LHS, V.RHS.RHS)) TypeOfDiv; 
     749    else 
     750    static if( // (/ (/R> A (+> B X)) C) -> (/R> (/ A C) (+> B X)) 
     751        is(T.Op == DivAR) && is(T.LHS.DefP == Defined) && is(T.RHS.LHS.DefP == Defined) && is(T.RHS.RHS.DefP == UnDefined) && 
     752        is(V.DefP == Defined) 
     753         /+ no repeats +/ 
     754        )  
     755        alias OpDivAR!(OpDiv!(T.LHS, V), OpAddA!(T.RHS.LHS, T.RHS.RHS)) TypeOfDiv; 
     756    else 
     757    static if( // (/ C (/R> A (+> B X))) -> (*> (/ A C) (+> B X)) 
     758        is(T.DefP == Defined) && 
     759        is(V.Op == DivAR) && is(V.LHS.DefP == Defined) && is(V.RHS.LHS.DefP == Defined) && is(V.RHS.RHS.DefP == UnDefined) 
     760         /+ no repeats +/ 
     761        )  
     762        alias OpMulA!(OpDiv!(V.LHS, T), OpAddA!(V.RHS.LHS, V.RHS.RHS)) TypeOfDiv; 
     763    else 
     764    static if( // (/ (/> A (+> B X)) C) -> (*> (/ C A) (+> B X)) 
     765        is(T.Op == DivA) && is(T.LHS.DefP == Defined) && is(T.RHS.LHS.DefP == Defined) && is(T.RHS.RHS.DefP == UnDefined) && 
     766        is(V.DefP == Defined) 
     767         /+ no repeats +/ 
     768        )  
     769        alias OpMulA!(OpDiv!(V, T.LHS), OpAddA!(T.RHS.LHS, T.RHS.RHS)) TypeOfDiv; 
     770    else 
     771    static if( // (/ C (/> A (+> B X))) -> (/R> (/ C A) (+> B X)) 
     772        is(T.DefP == Defined) && 
     773        is(V.Op == DivA) && is(V.LHS.DefP == Defined) && is(V.RHS.LHS.DefP == Defined) && is(V.RHS.RHS.DefP == UnDefined) 
     774         /+ no repeats +/ 
     775        )  
     776        alias OpDivAR!(OpDiv!(T, V.LHS), OpAddA!(V.RHS.LHS, V.RHS.RHS)) TypeOfDiv; 
     777    else 
     778    static if( // (/ (*> A (+> B X)) C) -> (*> (* C A) (+> B X)) 
     779        is(T.Op == MulA) && is(T.LHS.DefP == Defined) && is(T.RHS.LHS.DefP == Defined) && is(T.RHS.RHS.DefP == UnDefined) && 
     780        is(V.DefP == Defined) 
     781         /+ no repeats +/ 
     782        )  
     783        alias OpMulA!(OpMul!(V, T.LHS), OpAddA!(T.RHS.LHS, T.RHS.RHS)) TypeOfDiv; 
     784    else 
     785    static if( // (/ C (*> A (+> B X))) -> (/R> (* A C) (+> B X)) 
     786        is(T.DefP == Defined) && 
     787        is(V.Op == MulA) && is(V.LHS.DefP == Defined) && is(V.RHS.LHS.DefP == Defined) && is(V.RHS.RHS.DefP == UnDefined) 
     788         /+ no repeats +/ 
     789        )  
     790        alias OpDivAR!(OpMul!(V.LHS, T), OpAddA!(V.RHS.LHS, V.RHS.RHS)) TypeOfDiv; 
     791    else 
     792    static if( // (/ (/R> A (-> B X)) C) -> (/R> (/ A C) (-> B X)) 
     793        is(T.Op == DivAR) && is(T.LHS.DefP == Defined) && is(T.RHS.LHS.DefP == Defined) && is(T.RHS.RHS.DefP == UnDefined) && 
     794        is(V.DefP == Defined) 
     795         /+ no repeats +/ 
     796        )  
     797        alias OpDivAR!(OpDiv!(T.LHS, V), OpSubA!(T.RHS.LHS, T.RHS.RHS)) TypeOfDiv; 
     798    else 
     799    static if( // (/ C (/R> A (-> B X))) -> (*> (/ A C) (-> B X)) 
     800        is(T.DefP == Defined) && 
     801        is(V.Op == DivAR) && is(V.LHS.DefP == Defined) && is(V.RHS.LHS.DefP == Defined) && is(V.RHS.RHS.DefP == UnDefined) 
     802         /+ no repeats +/ 
     803        )  
     804        alias OpMulA!(OpDiv!(V.LHS, T), OpSubA!(V.RHS.LHS, V.RHS.RHS)) TypeOfDiv; 
     805    else 
     806    static if( // (/ (/> A (-> B X)) C) -> (*> (/ C A) (-> B X)) 
     807        is(T.Op == DivA) && is(T.LHS.DefP == Defined) && is(T.RHS.LHS.DefP == Defined) && is(T.RHS.RHS.DefP == UnDefined) && 
     808        is(V.DefP == Defined) 
     809         /+ no repeats +/ 
     810        )  
     811        alias OpMulA!(OpDiv!(V, T.LHS), OpSubA!(T.RHS.LHS, T.RHS.RHS)) TypeOfDiv; 
     812    else 
     813    static if( // (/ C (/> A (-> B X))) -> (/R> (/ C A) (-> B X)) 
     814        is(T.DefP == Defined) && 
     815        is(V.Op == DivA) && is(V.LHS.DefP == Defined) && is(V.RHS.LHS.DefP == Defined) && is(V.RHS.RHS.DefP == UnDefined) 
     816         /+ no repeats +/ 
     817        )  
     818        alias OpDivAR!(OpDiv!(T, V.LHS), OpSubA!(V.RHS.LHS, V.RHS.RHS)) TypeOfDiv; 
     819    else 
    368820    static if( // (/ (*> A (-> B X)) C) -> (*> (* C A) (-> B X)) 
    369821        is(T.Op == MulA) && is(T.LHS.DefP == Defined) && is(T.RHS.LHS.DefP == Defined) && is(T.RHS.RHS.DefP == UnDefined) && 
    …… 
    422874        alias OpDivAR!(OpDiv!(T, V.LHS), V.RHS) TypeOfDiv; 
    423875    else 
    424     static if( // (/ (+> B X) A) -> (*> A (+> B X)) 
    425         is(T.Op == AddA) && is(T.LHS.DefP == Defined) && is(T.RHS.DefP == UnDefined) && 
    426         is(V.DefP == Defined) 
    427          /+ no repeats +/ 
    428         )  
    429         alias OpMulA!(V, OpAddA!(T.LHS, T.RHS)) TypeOfDiv; 
    430     else 
    431876    static if( // (/ A (+> B X)) -> (/R> A (+> B X)) 
    432877        is(T.DefP == Defined) && 
    …… 
    436881        alias OpDivAR!(T, OpAddA!(V.LHS, V.RHS)) TypeOfDiv; 
    437882    else 
    438     static if( // (/ (-> B X) A) -> (*> A (-> B X)) 
    439         is(T.Op == SubA) && is(T.LHS.DefP == Defined) && is(T.RHS.DefP == UnDefined) && 
    440         is(V.DefP == Defined) 
    441          /+ no repeats +/ 
    442         )  
    443         alias OpMulA!(V, OpSubA!(T.LHS, T.RHS)) TypeOfDiv; 
    444     else 
    445883    static if( // (/ A (-> B X)) -> (/R> A (-> B X)) 
    446884        is(T.DefP == Defined) && 
    …… 
    450888        alias OpDivAR!(T, OpSubA!(V.LHS, V.RHS)) TypeOfDiv; 
    451889    else 
     890    static if( // (/ A B) -> (/ A B) 
     891        is(T.DefP == Defined) && 
     892        is(V.DefP == Defined) 
     893         /+ no repeats +/ 
     894        )  
     895        alias OpDiv!(T, V) TypeOfDiv; 
     896    else 
    452897    static if( // (/ A X) -> (/R> A X) 
    453898        is(T.DefP == Defined) && 
    …… 
    456901        )  
    457902        alias OpDivAR!(T, V) TypeOfDiv; 
    458     else 
    459     static if( // (/ A B) -> (/ A B) 
    460         is(T.DefP == Defined) && 
    461         is(V.DefP == Defined) 
    462          /+ no repeats +/ 
    463         )  
    464         alias OpDiv!(T, V) TypeOfDiv; 
    465903    else 
    466904    static if( // (/ X A) -> (*> A X) 
    …… 
    473911    static assert(false, `inavlid type used for Div: T == ` ~ T.stringof ~ ` and V == `~ V.stringof ); 
    474912} 
    475 template TypeOfMul(T, V) 
    476 { 
    477     static if( // (* (*> A (-> B X)) C) -> (*> (/ A C) (-> B X)) 
    478         is(T.Op == MulA) && is(T.LHS.DefP == Defined) && is(T.RHS.LHS.DefP == Defined) && is(T.RHS.RHS.DefP == UnDefined) && 
    479         is(V.DefP == Defined) 
    480          /+ no repeats +/ 
    481         )  
    482         alias OpMulA!(OpDiv!(T.LHS, V), OpSubA!(T.RHS.LHS, T.RHS.RHS)) TypeOfMul; 
    483     else 
    484     static if( // (* C (*> A (-> B X))) -> (*> (/ A C) (-> B X)) 
    485         is(T.DefP == Defined) && 
    486         is(V.Op == MulA) && is(V.LHS.DefP == Defined) && is(V.RHS.LHS.DefP == Defined) && is(V.RHS.RHS.DefP == UnDefined) 
    487          /+ no repeats +/ 
    488         )  
    489         alias OpMulA!(OpDiv!(V.LHS, T), OpSubA!(V.RHS.LHS, V.RHS.RHS)) TypeOfMul; 
    490     else 
    491     static if( // (* (/R> B X) A) -> (/R> (* A B) X) 
    492         is(T.Op == DivAR) && is(T.LHS.DefP == Defined) && is(T.RHS.DefP == UnDefined) && 
    493         is(V.DefP == Defined) 
    494          /+ no repeats +/ 
    495         )  
    496         alias OpDivAR!(OpMul!(V, T.LHS), T.RHS) TypeOfMul; 
    497     else 
    498     static if( // (* A (/R> B X)) -> (/R> (* A B) X) 
    499         is(T.DefP == Defined) && 
    500         is(V.Op == DivAR) && is(V.LHS.DefP == Defined) && is(V.RHS.DefP == UnDefined) 
    501          /+ no repeats +/ 
    502         )  
    503         alias OpDivAR!(OpMul!(T, V.LHS), V.RHS) TypeOfMul; 
    504     else 
    505     static if( // (* (*> B X) A) -> (*> (/ B A) X) 
    506         is(T.Op == MulA) && is(T.LHS.DefP == Defined) && is(T.RHS.DefP == UnDefined) && 
    507         is(V.DefP == Defined) 
    508          /+ no repeats +/ 
    509         )  
    510         alias OpMulA!(OpDiv!(T.LHS, V), T.RHS) TypeOfMul; 
    511     else 
    512     static if( // (* A (*> B X)) -> (*> (/ B A) X) 
    513         is(T.DefP == Defined) && 
    514         is(V.Op == MulA) && is(V.LHS.DefP == Defined) && is(V.RHS.DefP == UnDefined) 
    515          /+ no repeats +/ 
    516         )  
    517         alias OpMulA!(OpDiv!(V.LHS, T), V.RHS) TypeOfMul; 
    518     else 
    519     static if( // (* (/> B X) A) -> (/> (* A B) X) 
    520         is(T.Op == DivA) && is(T.LHS.DefP == Defined) && is(T.RHS.DefP == UnDefined) && 
    521         is(V.DefP == Defined) 
    522          /+ no repeats +/ 
    523         )  
    524         alias OpDivA!(OpMul!(V, T.LHS), T.RHS) TypeOfMul; 
    525     else 
    526     static if( // (* A (/> B X)) -> (/> (* A B) X) 
    527         is(T.DefP == Defined) && 
    528         is(V.Op == DivA) && is(V.LHS.DefP == Defined) && is(V.RHS.DefP == UnDefined) 
    529          /+ no repeats +/ 
    530         )  
    531         alias OpDivA!(OpMul!(T, V.LHS), V.RHS) TypeOfMul; 
    532     else 
    533     static if( // (* (+> B X) A) -> (/> A (+> B X)) 
    534         is(T.Op == AddA) && is(T.LHS.DefP == Defined) && is(T.RHS.DefP == UnDefined) && 
    535         is(V.DefP == Defined) 
    536          /+ no repeats +/ 
    537         )  
    538         alias OpDivA!(V, OpAddA!(T.LHS, T.RHS)) TypeOfMul; 
    539     else 
    540     static if( // (* A (+> B X)) -> (/> A (+> B X)) 
    541         is(T.DefP == Defined) && 
    542         is(V.Op == AddA) && is(V.LHS.DefP == Defined) && is(V.RHS.DefP == UnDefined) 
    543          /+ no repeats +/ 
    544         )  
    545         alias OpDivA!(T, OpAddA!(V.LHS, V.RHS)) TypeOfMul; 
    546     else 
    547     static if( // (* (-> B X) A) -> (/> A (-> B X)) 
    548         is(T.Op == SubA) && is(T.LHS.DefP == Defined) && is(T.RHS.DefP == UnDefined) && 
    549         is(V.DefP == Defined) 
    550          /+ no repeats +/ 
    551         )  
    552         alias OpDivA!(V, OpSubA!(T.LHS, T.RHS)) TypeOfMul; 
    553     else 
    554     static if( // (* A (-> B X)) -> (/> A (-> B X)) 
    555         is(T.DefP == Defined) && 
    556         is(V.Op == SubA) && is(V.LHS.DefP == Defined) && is(V.RHS.DefP == UnDefined) 
    557          /+ no repeats +/ 
    558         )  
    559         alias OpDivA!(T, OpSubA!(V.LHS, V.RHS)) TypeOfMul; 
    560     else 
    561     static if( // (* A X) -> (/> A X) 
    562         is(T.DefP == Defined) && 
    563         is(V.DefP == UnDefined) 
    564          /+ no repeats +/ 
    565         )  
    566         alias OpDivA!(T, V) TypeOfMul; 
    567     else 
    568     static if( // (* A B) -> (* A B) 
    569         is(T.DefP == Defined) && 
    570         is(V.DefP == Defined) 
    571          /+ no repeats +/ 
    572         )  
    573         alias OpMul!(T, V) TypeOfMul; 
    574     else 
    575     static if( // (* X A) -> (/> A X) 
    576         is(T.DefP == UnDefined) && 
    577         is(V.DefP == Defined) 
    578          /+ no repeats +/ 
    579         )  
    580         alias OpDivA!(V, T) TypeOfMul; 
    581     else 
    582     static assert(false, `inavlid type used for Mul: T == ` ~ T.stringof ~ ` and V == `~ V.stringof ); 
    583 } 
    584913