using System.Console;
using Oyster.Units;
using Oyster.Units.Macros;

def m1 = Cgs.Mass(1); // 1 грамм
def m2 = Si.Mass(m1); // Автоматическое преобразование в килограммы. В результате получаем 0.001 кг

WriteLine($"Mass in SI: $m2, in CGS: $m1");

def l1 = Cgs.Length(100); // 100 см
def l2 = Si.Length(l1);   // Автоматическое преобразование. Результат - 1 м

WriteLine($"Length in SI: $l2, in CGS: $l1");

def t1 = Cgs.Time(1); // 1 с
def t2 = Si.Time(t1); // Тоже 1 с, т.к. единицы измерения времени в системах СИ и СГС совпадают.

WriteLine($"Time in SI: $t2, in CGS: $t1");

// Теперь немного более сложный пример. Предыдущие величины (масса, длина, время) являются
// базовыми (ортами) в обеих системах единиц. Здесь же мы имеем дело с производными величинами -
// скоростью, енергией и мощностью
def v1 = Cgs.Velocity(10); // 10 см/с
def v2 = Si.Velocity(v1);  // Результат преобразования - 0.1 м/с

WriteLine($"Velocity in SI: $v2, in CGS: $v1");

def e1 = Si.Energy(0.0001); // 10e-4 Дж.
def e2 = Cgs.Energy(e1);    // e2 = 1000 эрг

WriteLine($"Energy in SI: $e1, in CGS: $e2");

// Это - пример работы с внесистемными единицами. В данном случае мощность переводится из ваттов
// в лошадиные силы
def p1 = Si.Power(1000); // 1000 Вт
def p2 = Ext.Power(p1);  // 1.35962 лс

WriteLine($"Power in SI: $p1, in Ext system: $p2");

// Пример работы с простейшими арифметическими действиями
def a1 = Si.Acceleration(1); // 1 м/с2
def a2 = Cgs.Acceleration(a1 + Cgs.Acceleration(200)); // 1 м/с2 + 200 см/с2 = 300 см/с2, как и должно было быть

WriteLine($"Acceleration: a1 = $a1, a2 = $a2");

// Сила
def f1 = Si.Force(10);      // 10 Н
def f2 = Cgs.Force(f1*2);  // 10 Н * 2 = 2000000 дин

def f3 = Si.Force(m1*l2/(t1*t1)); // 1 г * 1 м / (1 с * 1 с) = 0.001 Н
// А вот так уже не скомпилируется - не та размерность
//def f4 = Si.Force(m1*l2/t1);
// Вот что выдаёт ncc:
// Main.n(122,10,122,18): error : each overload has an error during call:
// Main.n(122,10,122,18): error : overload #1, method Oyster.Units.Si.Force..ctor(value : System.Double) : void
// Main.n(122,10,122,18): error : in argument #1 (value) of Oyster.Units.Si.Force, needed a System.Double, got _N_TempUnitType5439: _N_TempUnitType5439 is not a subtype of System.Double [simple require]
// Main.n(122,10,122,18): error : overload #2, method Oyster.Units.Si.Force..ctor(value : Oyster.Units.AbstractUnitType_1_1_-2_0_0_0_0) : void
// Main.n(122,10,122,18): error : in argument #1 (value) of Oyster.Units.Si.Force, needed a Oyster.Units.AbstractUnitType_1_1_-2_0_0_0_0, got _N_TempUnitType5439: _N_TempUnitType5439 is not a subtype of Oyster.Units.AbstractUnitType_1_1_-2_0_0_0_0 [simple require]

WriteLine($"Force: f1 = $f1, f2 = $f2, f3 = $f3");

// Здесь ошибка компиляции - пытаемся складывать енергию, массу и скорость
//WriteLine($"ERROR = $(e1 + e2 + v1 + v2 + m1 + m2)");
// Вот что выдаёт ncc (точнее, мой макрос):
// Main.n(135,52,135,64): error : Expression { e1 + e2 [+] v1 } can't be compiled because units are having different dimensions.

// Здесь происходит преобразование на лету. В результате имеем 0.0002 Дж - результат имеет тот же тип, 
// что и левый операнд
WriteLine($"Result = $(e1 + e2)");

// Здесь выводится единица, т.к. e1 и e2 содержат одно и то же значение, но выраженное в разных 
// системах единиц
WriteLine($"Result = $(e1/e2)")

using System;
using Nemerle.Utility;

namespace Oyster.Units
{
    /// Automatically attached to all concrete unit type implemetations
    public class ConcreteUnitTypeAttribute : Attribute
    {
        [Accessor] _normalizationCoef : double;

        public this(normalizationCoef : double)
        {
            _normalizationCoef = normalizationCoef
        }
    }
}

using Nemerle.Utility;

namespace Oyster.Units
{
    /// Base class for all unit types
    abstract public class UnitTypeBase
    {
        /// Unit value as double
        [Accessor] _value : double;
        

        /// Constructs given unit type instance from any other unit type instance
        protected this(value : UnitTypeBase)
        {
            // Perform normalization-denormalization here
            this(value._value * value.NormalizationCoef / NormalizationCoef)
        }
        
        /// Constructs given unit type instance from double
        protected this(value : double)
        {
            _value = value
        }
        

        /// Unit type normalization coefficient
        abstract public NormalizationCoef : double { get; }
        
        /// ToString() override
        override public ToString() : string
        {
            _value.ToString()
        }
    }
}

using System;
using System.Collections.Generic;
using Nemerle.Collections;
using Nemerle.Compiler;
using Nemerle.Compiler.Parsetree;
using Nemerle.Utility;

using NST = Nemerle.Compiler.NamespaceTree;

namespace Oyster.Units.Macros
{
    /// Used at compile time by Units macros - stores some intermediate information
    module CompileTimeUtil
    {
        /// Units NS name
        public UnitsNamespace = "Oyster.Units";

        /// Stores list of base units (such as mass or length) registered in the system
        public mutable BaseUnits : list[string];

        /// Stores list of all registered units including aliases
        public mutable AllUnits : list[string];

        /// Stores powers list for given base unit or alias
        public mutable PowersMap : Dictionary[string, list[int]] = Dictionary();
        

        /// Generates (or gets) given unit type with given or automatically generated name,
        /// given base units powers and given normalization coefficient
        public GetUnitType(env : GlobalEnv, typeName : string, baseUnitPowers : list[int], normalizationCoef : double) : TypeInfo
        {
            // Determine name of the type to be generated
            def typeName = match (typeName)
            {
                | null => Macros.NewSymbol("TempUnitType")
                | _ => Macros.UseSiteSymbol(typeName)
            };
            
            // Try to find this type by name among existing ones
            def unitType = env.LookupType([ typeName.Id ]);
            if (unitType.HasValue)
            {
                unitType.Value
            }
            else
            {
                // Generate new type
                def abstractTypeName = Macros.UseSiteSymbol(GetAbstractUnitType(baseUnitPowers).Name);
                def unitType = DefineInCustomNamespace(<[ decl:
                    [ConcreteUnitType($(normalizationCoef : double))]
                    public class $(typeName : name) : $(abstractTypeName : name)
                    {
                        public this(value : $(abstractTypeName : name))
                        {
                            base(value)
                        }
                        
                        public this(value : double)
                        {
                            base(value)
                        }
                        
                        
                        override public NormalizationCoef : double
                        {
                            get { $(normalizationCoef : double) }
                        }
                        
            
            static public @:>(value : $(typeName : name)) : double
            {
              value.Value
            }
            
            static public @:(value : double) : $(typeName : name)
            {
              $(typeName : name)(value)
            }


                        static public @*(unit : $(typeName : name), value : double) : $(typeName : name)
                        {
                            $(typeName : name)(unit.Value * value)
                        }

                        static public @/(unit : $(typeName : name), value : double) : $(typeName : name)
                        {
                            $(typeName : name)(unit.Value / value)
                        }

                        static public @+(unit : $(typeName : name), value : double) : $(typeName : name)
                        {
                            $(typeName : name)(unit.Value + value)
                        }

                        static public @-(unit : $(typeName : name), value : double) : $(typeName : name)
                        {
                            $(typeName : name)(unit.Value - value)
                        }


                        static public @*(value : double, unit : $(typeName : name)) : $(typeName : name)
                        {
                            $(typeName : name)(value * unit.Value)
                        }

                        static public @/(value : double, unit : $(typeName : name)) : $(typeName : name)
                        {
                            $(typeName : name)(value / unit.Value)
                        }

                        static public @+(value : double, unit : $(typeName : name)) : $(typeName : name)
                        {
                            $(typeName : name)(value + unit.Value)
                        }

                        static public @-(value : double, unit : $(typeName : name)) : $(typeName : name)
                        {
                            $(typeName : name)(value - unit.Value)
                        }


                        static public @++(value : $(typeName : name)) : $(typeName : name)
                        {
                            $(typeName : name)(value.Value + 1)
                        }

                        static public @--(value : $(typeName : name)) : $(typeName : name)
                        {
                            $(typeName : name)(value.Value - 1)
                        }

                        static public @+(value : $(typeName : name)) : $(typeName : name)
                        {
                            value
                        }

                        static public @-(value : $(typeName : name)) : $(typeName : name)
                        {
                            $(typeName : name)(0 - value.Value)
                        }
                    }
                ]>);

                unitType.Compile();
                unitType
            }
        }
        
        /// Generates (or gets) abstract unit type for given base unit powers
        GetAbstractUnitType(baseUnitPowers : list[int]) : TypeInfo
        {
            def env = GlobalEnv.Core;

            // Try to find given type
            def abstractTypeName = $"$UnitsNamespace.AbstractUnitType$(GenerateUnitTypeSuffix(baseUnitPowers))";
            def abstractType = env.LookupType([ abstractTypeName ]);
            if (abstractType.HasValue)
            {
                abstractType.Value
            }
            else
            {
                // Generate abstract type
                def abstractType = DefineInCustomNamespace(<[ decl:
                    abstract public class $(abstractTypeName : usesite) : UnitTypeBase
                    {
                        protected this(value : $(abstractTypeName : usesite))
                        {
                            base(value)
                        }
                        
                        protected this(value : double)
                        {
                            base(value)
                        }
                    }
                ]>);
                
                abstractType.Compile();
                abstractType
            }
        }


        /// Defines given class in custom global namespace
        public DefineInCustomNamespace(decl : ClassMember.TypeDeclaration) : TypeBuilder
        {
            def builder = GlobalEnv.Core.Define(decl);

            // Register newly created type manually - otherwise it will be unbound
            NST.ExactPath(NString.Split(builder.Name, '.')).Value = NST.TypeInfoCache.Cached(builder);

            builder
        }

        /// Increases power for given unit into list
        public ModifyBaseUnitPower(baseUnitPowers : list[int], unitName : string, f : int -> int) : list[int]
        {
            // Maybe prepare list full of zeroes
            def baseUnitPowers =
                if (baseUnitPowers.Length != 0) baseUnitPowers else List.Map(BaseUnits, fun(_) { 0 });

            List.Map2(BaseUnits, baseUnitPowers, fun(n, i) { if (n == unitName) f(i) else i })
        }

        /// Generates abstract unit type suffix basing on base unit powers
        public GenerateUnitTypeSuffix(baseUnitPowers : list[int]) : string
        {
            | [] => string.Empty
            | _ => "_" + baseUnitPowers.Head.ToString() + GenerateUnitTypeSuffix(baseUnitPowers.Tail)
        }

        /// Parses abstract unit type suffix
        public ParseUnitTypeSuffix(typeName : string) : list[int]
        {
            List.Map(NString.Split(typeName.Substring(typeName.IndexOf('_') + 1), '_'), int.Parse)
        }

        /// Returns PExpr type
        public GetExprType(ctx : Typer, expr : PExpr) : TypeInfo
        {
            ctx.TypeExpr(expr).ty.FixedValue.TypeInfo
        }

        /// Returns normalization coef if type is concrete unit type
        public GetUnitTypeCoef(t : TypeInfo) : option[double]
        {
            | _ is TypeBuilder =>
                // Get attribute using Nemerle approach
                mutable value = None();
                foreach (attr in t.GetModifiers().GetCustomAttributes())
                {
                    | <[ ConcreteUnitType($(coef : double)) ]> => value = Some(coef)
                };
                value
            | _ =>
                // "Usual" attribute gathering
                def attr = Attribute.GetCustomAttribute(t.SystemType, typeof(ConcreteUnitTypeAttribute));
                def attr = attr :> ConcreteUnitTypeAttribute;
                if (attr == null) None() else Some(attr.NormalizationCoef)
        }


        /// Used inside ariphmetic op macros
        public OpMacroBody(
            ctx : Typer,
            lexpr : PExpr,
            rexpr : PExpr,
            opName : string,
            opExpr : PExpr,
            someFun : TypeInfo * TypeInfo * double * double -> PExpr) : PExpr
        {
            def ltype = GetExprType(ctx, lexpr);
            def rtype = GetExprType(ctx, rexpr);
            match ((GetUnitTypeCoef(ltype), GetUnitTypeCoef(rtype)))
            {
                | (Some(lcoef), Some(rcoef)) =>
                    someFun(ltype, rtype, lcoef, rcoef)
                | _ =>
                    def macroPath = NST.ExactPath(["Oyster", "Units", "Macros", opName]);
                    def value = macroPath.Value;
                    macroPath.Value = NST.TypeInfoCache.No();
                    def resexpr = ctx.TypeExpr(opExpr);
                    macroPath.Value = value;
                    <[ $(resexpr : typed) ]>
            }
        }

        /// Used inside * and / macros
        public MulDivMacroBody(
            ctx : Typer,
            lexpr : PExpr,
            rexpr : PExpr,
            opName : string,
            opExpr : PExpr,
            powersFun : int * int -> int,
            coefFun : double * double -> double,
            coefOpExpr : PExpr) : PExpr
        {
            OpMacroBody(
                ctx,
                lexpr,
                rexpr,
                opName,
                opExpr,
                fun (ltype, rtype, lcoef, rcoef)
                {
                    def powers = List.Map2(
                        ParseUnitTypeSuffix(ltype.BaseType.Name),
                        ParseUnitTypeSuffix(rtype.BaseType.Name),
                        powersFun);
                    def concreteType = GetUnitType(ctx.Env, null, powers, 1.0);
                    <[ $(concreteType.FullName : usesite)(double.op_Multiply($coefOpExpr, $(coefFun(lcoef, rcoef) : double))) ]>
                })
        }

        /// Used inside + and - macros
        public AddSubMacroBody(
            ctx : Typer,
            lexpr : PExpr,
            rexpr : PExpr,
            opName : string,
            opExpr : PExpr,
            ctorFun : PExpr -> PExpr) : PExpr
        {
            OpMacroBody(
                ctx,
                lexpr,
                rexpr,
                opName,
                opExpr,
                fun (ltype, rtype, lcoef, rcoef)
                {
                    match (ltype.BaseType.Name)
                    {
                        | s when s == rtype.BaseType.Name =>
                            def coef = rcoef / lcoef;
                            def paramExpr = ctorFun(<[ double.op_Multiply($rexpr.Value, $(coef : double)) ]>);
                            <[ $(ltype.FullName : usesite)($paramExpr) ]>
                        | _ =>
                            Message.FatalError(
                                $"Expression { $lexpr [$opName] $rexpr } can't be compiled "
                                 "because units are having different dimensions.")
                    }
                })
        }
    }
}

using System;
using System.Collections.Generic;
using Nemerle.Collections;
using Nemerle.Compiler;
using Nemerle.Macros;

using System.Console;

namespace Oyster.Units.Macros
{
    using CT = CompileTimeUtil;

    /// Declares unit types with convertion rules
    macro unittypes(namespaceName, body)
    syntax ("unittypes", namespaceName, body)
    {
        // Parse namespace name
        def namespaceName = match (namespaceName)
        {
            | <[ $(n : name) ]> => n.Id
            | _ => Message.FatalError($"Invalid unittypes syntax: expected namespace name part, got $namespaceName")
        };
        
        // Prepare normalization coefficients map
        def coefSubMap = Dictionary();
        
        // Parse units
        match (body)
        {
            | <[ { .. $unitDecls } ]> =>
                // Check if BaseUnits must be initialized
                def initBaseUnits = match (CT.BaseUnits)
                {
                    | null =>
                        CT.BaseUnits = [];
                        true
                    | _ => false
                };

                mutable units = [];
                
                // Process all phys types and add info into PhysTypeHelper
                mutable index = 0;
                mutable calcBaseUnitPowers = initBaseUnits;
                foreach (<[ $decl ]> in unitDecls)
                {
                    def unitCoef = match (decl)
                    {
                        | <[ $(n : name) ]> => (n.Id, 1.0)
                        | <[ $(n : name) : ($coefExpr) ]> =>
                            // Function parses simple coefficient exprs
                            def parseCoefExpr(expr)
                            {
                                | <[ $(d : double) ]> => d
                                | <[ $lhs * $(d : double) ]> => parseCoefExpr(lhs) * d
                                | <[ $lhs / $(d : double) ]> => parseCoefExpr(lhs) / d
                                | _ => Message.FatalError($"Invalid unittypes syntax: expected \"UnitName [: (coefficient expr)]\", got $decl")
                            };
                            (n.Id, parseCoefExpr(coefExpr))
                        | <[ $(n : name) = $aliasExpr ]> =>
                            // Aliases are started - remember it
                            when (calcBaseUnitPowers)
                            {
                                // Fill base units list
                                CT.BaseUnits = units.Reverse();

                                // Prepare powers lists
                                CT.BaseUnits.Iter(fun(unitName) { CT.PowersMap[unitName] = CT.ModifyBaseUnitPower([], unitName, _ + 1) });

                                calcBaseUnitPowers = false
                            };

                            // Prepare powers list
                            def oldN = n.Id == "SpecificGravity";
                            def parseAliasExpr(expr)
                            {
                                | <[ $(n : name) ^ $(x : int) ]> => List.Map(CT.PowersMap[n.Id], _ * x)
                                | <[ $lhs * $(n : name) ^ $(x : int) ]> =>
                                    List.Map2(parseAliasExpr(lhs), parseAliasExpr(<[ $(n : name) ^ $(x : int) ]>), _ + _)
                                | <[ $lhs / $(n : name) ^ $(x : int) ]> =>
                                    List.Map2(parseAliasExpr(lhs), parseAliasExpr(<[ $(n : name) ^ $(x : int) ]>), _ - _)
                                | <[ $(n : name) ]> => parseAliasExpr(<[ $(n : name) ^ 1 ]>)
                                | <[ $lhs * $(n : name) ]> => parseAliasExpr(<[ $lhs * $(n : name) ^ 1 ]>)
                                | <[ $lhs / $(n : name) ]> => parseAliasExpr(<[ $lhs / $(n : name) ^ 1 ]>)
                                | _ => Message.FatalError($"Invalid unittypes syntax: expected \"UnitName = alias\", got $decl")
                            };
                            CT.PowersMap[n.Id] = parseAliasExpr(aliasExpr);

                            (n.Id, 1.0)
                        | _ => Message.FatalError($"Invalid unittypes syntax: expected \"UnitName [: (coefficient expr)]\", got $decl")
                    };

                    units ::= unitCoef[0];

                    // Add new normalization coefficient into map
                    coefSubMap[unitCoef[0]] = unitCoef[1];

                    index++
                };

                units = units.Reverse();
                when (initBaseUnits)
                {
                    CT.AllUnits = units
                }

                // Generate corresponding concrete types
                def units = if (units.Length >= CT.BaseUnits.Length) CT.AllUnits else units;
                foreach (n in units)
                {
                    def powers = CT.PowersMap[n];

                    mutable coef = 0.0;
                    when (!coefSubMap.TryGetValue(n, out coef))
                    {
                        coef = 1.0;

                        // Calculate coefficient from base unit coefficients on the fly
                        List.Iter2(
                            powers,
                            CT.BaseUnits,
                            fun (power : int, name)
                            {
                                when (power != 0)
                                {
                                    def f = if (power > 0) _ * _ else _ / _;
                                    coef = f(coef, Math.Pow(coefSubMap[name], Math.Abs(power)));
                                }
                            })
                    }

                    _ = CT.GetUnitType(
                        GlobalEnv.Core,
                        $"$(CT.UnitsNamespace).$namespaceName.$n",
                        powers,
                        coef)
                }
            | _ => Message.FatalError($"Invalid unittypes syntax: expected semicolon-separated type names, got $body")
        };
        
        <[ () ]>
    }
}

using Nemerle.Collections;
using Nemerle.Compiler;
using Nemerle.Compiler.Typedtree;
using Nemerle.Macros;

namespace Oyster.Units.Macros
{
    using CT = CompileTimeUtil;

    /// Multiplies two units. Inserts usual * if operands are of wrong type
    macro @*(lexpr, rexpr)
    {
        CT.MulDivMacroBody(
            ImplicitCTX(),
            lexpr,
            rexpr,
            "*",
            <[ $lexpr * $rexpr ]>,
            _ + _,
            _ * _,
            <[ double.op_Multiply($lexpr.Value, $rexpr.Value) ]>)
    }

    /// Divides two units. Inserts usual / if operands are of wrong type
    macro @/(lexpr, rexpr)
    {
        CT.MulDivMacroBody(
            ImplicitCTX(),
            lexpr,
            rexpr,
            "/",
            <[ $lexpr / $rexpr ]>,
            _ - _,
            _ / _,
            <[ double.op_Division($lexpr.Value, $rexpr.Value) ]>)
    }

    /// Sums two units. Inserts usual + if operands are of wrong type.
    /// Throws compiler error if unit dimensions are not equal
    macro @+(lexpr, rexpr)
    {
        CT.AddSubMacroBody(
            ImplicitCTX(),
            lexpr,
            rexpr,
            "+",
            <[ $lexpr + $rexpr ]>,
            fun(arg2Expr) { <[ double.op_Addition($lexpr.Value, $arg2Expr) ]> })
    }

    /// Subtracts two units. Inserts usual - if operands are of wrong type.
    /// Throws compiler error if unit dimensions are not equal
    macro @-(lexpr, rexpr)
    {
        CT.AddSubMacroBody(
            ImplicitCTX(),
            lexpr,
            rexpr,
            "-",
            <[ $lexpr - $rexpr ]>,
            fun(arg2Expr) { <[ double.op_Subtraction($lexpr.Value, $arg2Expr) ]> })
    }
}

using Oyster.Units.Macros;

public module UnitDef
{
    public Def() : void
    {
        // SI
        unittypes Si {
            // Base units
            Mass;
            Length;
            Time;
            Temperature;
            CurrentStrength;
            LightIntensity;
            QuantityOfSubstance;

            // Aliases
            Area = Length ^ 2;
            Volume = Area * Length;
            Velocity = Length / Time;
            Acceleration = Velocity / Time;
            AngularVelocity = Velocity;
            AngularAcceleration = Acceleration;
            Density = Mass / Volume;

            Force = Mass * Acceleration;
            Pressure = Mass / Length / Time ^ 2;
            SpecificGravity = Pressure / Length;

            LinearMomentum = Mass * Velocity;
            MomentOfInertia = Mass * Area;

            Energy = Force * Length;
            Power = Energy / Time;

            DynamicViscosity = Mass / Length / Time;
            KinematicViscosity = DynamicViscosity;

            HeatCapacity = Energy / Temperature;
            Entropy = HeatCapacity;
            SpecificHeat = HeatCapacity / Mass;
            SpecificEntropy = SpecificHeat;

            Charge = Time * CurrentStrength;
            LinearDensityOfCharge = Charge / Length;
            SurfaceDensityOfCharge = Charge / Area;
            ElectricFluxDensity = SurfaceDensityOfCharge;
            PackedDensityOfCharge = Charge / Volume;

            Voltage = Power / CurrentStrength;
            ElectricForce = Force / CurrentStrength;
            Resistance = Voltage / CurrentStrength;
            SpecificResistance = Resistance * Length;

            Permittance = Time / Resistance;

            CurrentDensity = CurrentStrength / Length ^ 2
        };

        // CGS
        unittypes Cgs {
            Mass : (1.0 / 1000.0);
            Length : (1.0 / 100.0);
            Time;
            Temperature;
            CurrentStrength : (1.0 / 3000000000.0);
            LightIntensity;
            QuantityOfSubstance
        };

        // EXT
        unittypes Ext {
            Power : (1471.0 / 2.0)
        }
    }
}

physops {
    def res = 100 kg * 7 sec
}

def res = kg 100 * sec 7

def res = 100 kg * 7 sec

namespace My.Phys
{                    
    [assembly: Nemerle.Internal.OperatorAttribute ("My.Phys", "kg", true, 283, 284)]
    [assembly: Nemerle.Internal.OperatorAttribute ("My.Phys", "sec", true, 283, 284)]

    macro @kg(val)
    {
        <[ do_something_crazy_with_kg($val) ]>
    }

    macro @sec(val)
    {
        <[ do_something_crazy_with_sec($val) ]>
    }
}

using System;
using My.Phys;

module Main
{
    do_something_crazy_with_kg(val : double) : double
    {
        val
    }

    do_something_crazy_with_sec(val : double) : double
    {
        val
    }

    Main() : void
    {
        Console.WriteLine(100.0 kg);
        Console.WriteLine(100.0 kg);
        Console.WriteLine(20.0 sec);
        Console.WriteLine(100.0 kg * 20.0 sec);
    }
}

using Nemerle.English;
def yoda = true not;
def reallyObfuscated = yoda !;
def ohmy = 23 ~;

Public, Sealed, Macro, SpecialName  My.Phys.kgMacro : System.Object, Nemerle.Compiler.IMacro {
    Private, Static method My.Phys.kgMacro..cctor() : void {
    {
          def customs = typeof (kgMacro).GetCustomAttributes (false);
          foreach (in ((x is MacroUsageAttribute), customs)) my_usage = x;
          keywords = []
    }

    Public, SpecialName method My.Phys.kgMacro.get_IsInherited() : bool {
        my_usage != null && my_usage.Inherited
    }

    Public, SpecialName method My.Phys.kgMacro.get_Keywords() : list[string] {
        keywords
    }

    Public, SpecialName method My.Phys.kgMacro.get_Usage() : Nemerle.MacroUsageAttribute {
        my_usage
    }

    Public, SpecialName method My.Phys.kgMacro.get_IsTailRecursionTransparent() : bool {
        false
    }
    Public method My.Phys.kgMacro.GetName() : string {
        "kg"
    }
    Public method My.Phys.kgMacro.GetNamespace() : string {
        "My.Phys"
    }
    Public method My.Phys.kgMacro.SyntaxExtension() : 
(Nemerle.Compiler.GrammarElement * list[Nemerle.Compiler.Parsetree.SyntaxElement] 
-> list[Nemerle.Compiler.Parsetree.SyntaxElement]) {
        (null, ((Nemerle.Utility.Identity.[list[SyntaxElement], list[SyntaxElement]] () : object) 
:> list[SyntaxElement] -> list[SyntaxElement]))
    }
    Public method My.Phys.kgMacro.Run(_N_944 : Nemerle.Compiler.Typer, parms : 
list[Nemerle.Compiler.Parsetree.SyntaxElement]) : Nemerle.Compiler.Parsetree.PExpr {
        match (parms) {
              | [SyntaxElement.Expression (val)] => 
                <[ do_something_crazy_with_kg ($(val)) ]>
              | _  => 
                  def len = List.Length (parms);
                  def types = parms.ToString (", ");
Message.FatalError ("macro `" + "kg" + "' expects following list of arguments: (" + 
"PExpr" + ") got some " + len.ToString () + " parameters [" + types + "]")
        }
    }
    Public method My.Phys.kgMacro.CallTransform(trans_p : list[Nemerle.Compiler.Parsetree.PExpr]) : 
list[Nemerle.Compiler.Parsetree.SyntaxElement] {
    {
          mutable trans_res = [];
          match (trans_p) {
            | x :: trans_p => 
              {
                trans_res = SyntaxElement.Expression (x) :: trans_res;
                match (trans_p) {
                      | x :: _  => 
                        trans_res = SyntaxElement.Expression (x) :: trans_res
                      | [] => () }
              }
            | [] => ()
        };
          List.Rev (trans_res)
    }
}

public sealed class kgMacro : IMacro
{
      // Methods
      static kgMacro();
      public kgMacro();
      public list<SyntaxElement> CallTransform(list<PExpr> trans_p);
      public string GetName();
      public string GetNamespace();
      public PExpr Run(Typer _N_944, list<SyntaxElement> parms);
      public Tuple<GrammarElement, Function<list<SyntaxElement>, list<SyntaxElement>>> SyntaxExtension();

      // Properties
      public bool IsInherited { get; }
      public bool IsTailRecursionTransparent { get; }
      public list<string> Keywords { get; }
      public MacroUsageAttribute Usage { get; }

      // Fields
      [Immutable]
      private static list<string> keywords;
      private static MacroUsageAttribute my_usage;
}

VK>>namespace My.Phys
VK>>{                    
VK>>    [assembly: Nemerle.Internal.OperatorAttribute ("My.Phys", "kg", true, 283, 284)]
VK>>    [assembly: Nemerle.Internal.OperatorAttribute ("My.Phys", "sec", true, 283, 284)]