class Class1
{
    public Prop1 : int
    {
        mutable fld : int;
        get { fld; }
        set { fld = value; }
    }
    
    public Prop2 : int
    {
        mutable fld : int; // <== field: static mutable fld : int; redefined in `Program'
        get { fld; }
        set { fld = value; }
    }
}

class Class2
{
    public Prop1 : int
    {
        mutable fld : int;
        get { fld; }
        set { fld = value; }
    }
    
    public Prop2 : int
    {
        get { fld; }         // <== unbound name `fld'
        set { fld = value; } // <== unbound name `fld'
    }
}

class Class1
{
    static Inst1 : Class1
    {
        mutable inst1Field : Class1;
        get
        {
            when (inst1Field == null)
            {
                inst1Field = Class();
                // ... здесь инициализация inst1Field
            }
            instField;
        }
    }
    
    static Inst2 : Class1
    {
        mutable inst2Field : Class1;
        get
        {
            when (inst2Field == null)
            {
                inst2Field = Class();
                // ... здесь инициализация inst2Field
            }
            instField;
        }
    }
}

using Nemerle;
using System.Console;

module Program
{
  [Memoize]
  Inst1() : string
  {
    WriteLine("Init Inst1");
    "Inst1"
  }
  Main() : void
  {
    WriteLine("Hi!");
    WriteLine(Inst1());
    WriteLine(Inst1());
  }
}

using Nemerle;
using System.Console;

module Program
{
  Inst1() : string
  {
    memoize 
    {
      WriteLine("Init Inst1");
      "Inst1"
    }
  }
  Inst2 : string
  {
    get 
    {
      memoize (Scope = Class, Synchronized = false)
      {
        WriteLine("Init Inst1");
        "Inst1"
      }
    }
  }

  Main() : void
  {
    WriteLine("Hi!");
    WriteLine(Inst1());
    WriteLine(Inst1());
    WriteLine(Inst2);
    WriteLine(Inst2);
  }
}

M>class Class1
M>{
M>    static Inst1 : Class1
M>    {
M>        mutable inst1Field : Class1;
M>        get
M>        {
M>            when (inst1Field == null)
M>            {
M>                inst1Field = Class();
M>                // ... здесь инициализация inst1Field
M>            }
M>            instField;
M>        }
M>    }
M>

using Nemerle;

class Class1
{
  static Inst1 : Class1
  {
    [Memoize]
    get
    {
        inst1Field = Class();
        // ... здесь инициализация inst1Field
    }
  }

[Memoize] // тут прекрасно подойдет атрибут
getMyDictionary() : IList[MyDictionary]
{
  db.GetTable.[MyDictionary]().ToList()
}

getMyDictionaryString(key : int) : string
{
  memoize // а тут уже не очень
  {
    getMyDictionary().ToDictionary(d => d.Id, d => d.Text)
  }[key]
}

getMyDictionaryKey(str : string) : int
{
  memoize 
  {
    getMyDictionary().ToDictionary(d => d.Text, d => d.Id)
  }[str]
}

Z>using Nemerle;
Z>using System.Console;

Z>module Program
Z>{
Z>  [Memoize]
Z>  Inst1() : string
Z>  {
Z>    WriteLine("Init Inst1");
Z>    "Inst1"
Z>  }
Z>  Main() : void
Z>  {
Z>    WriteLine("Hi!");
Z>    WriteLine(Inst1());
Z>    WriteLine(Inst1());
Z>  }
Z>}