title: F# vs C# vs Nemerle
body: <p>Got new project in my TODO and can't chose F# or Nemerle.</p>
  
  <p>I'm currently learning F# and have some projects on Nemerle.</p>
  
  <p>I like F# way , I like indent by default (also I want indent by default for nemerle2), I like many features and magic of F# but there is no macros.</p>
  
  <p>The goal of F# is VS2010 and maybe (maybe) bigger developers team and it's looking like Haskell(can create light Linux programs with it and it's fun).</p>
  
  <p>The goal of Nemerle is macros and I think I like some syntax of Nemerle more. </p>
  
  <p>and most people just like C#...</p>
  
  <ul>
  <li>So the language must be perspective</li>
  <li>Syntax must be logical , easy to
  understand, neat and powerfull(less
  code)</li>
  <li>It must be easy to use with .NET</li>
  <li>So I already closed my self with the
  chose of this 3 ones.</li>
  <li>I can use them all but what about chose one. It's not so easy for me.</li>
  </ul>
  
  <p>just for example I like (Nemerle)</p>
  
  <pre><code>match(STT)
      | 1 with st= "Summ"
      | 2 with st= "AVG" =&gt;
          $"$st : $(summbycol(counter,STT))"
  </code></pre>
  
  <p>much more then (F#)</p>
  
  <pre><code>let (|Let|) v e = (v, e)
  
  match stt with 
  | Let "Summ" (st, 1) 
  | Let "AVG" (st, 2) -&gt; srintf "%s ..." st
  </code></pre>
  
  <p>F# :</p>
  
  <pre><code>["A"; "B"] |&gt; List.iter (fun s  -&gt; printfn "%d"  s.Length)
  </code></pre>
  
  <p>Nemerle:</p>
  
  <pre><code>["A", "B"].Iter(x =&gt; printf("%d", x.Length))
  </code></pre>
  
  <p>F# (hope not mistaken here):</p>
  
  <pre><code>let type X =
      let mytable a = ""
      let mytable b = ""
      new(A, B) = {
      a &lt;- A
      b &lt;- B }
      member X.A 
          with get  = a
      member X.B 
          with get  = a
  </code></pre>
  
  <p>Nemerle : </p>
  
  <pre><code>[Record]
  class X
    public A : string { get; }
    public B : string { get; }
  </code></pre>
  
  <p>C# :</p>
  
  <pre><code>class X
  {
      private readonly string _a;
      public string A { get { return _a; } }
  
      private readonly string _b;
      public string B { get { return _b; } }
  
      public X(string a, string b)
      {
          _a = a;
          _b = b;
      }
  }
  </code></pre>
  
  <p>and here is nemerle code I already can't convert to F# (so I only learning it) ... </p>
  
  <pre><code>abstract class ABase
      abstract public A : string { get; }
  
  interface IB
      B : string { get; }
  
  [Record]
  class My : ABase, IB
      public override A : string { get; }
      public virtual  B : string { get; }
  </code></pre>
  
  <p>Comparison to C#:</p>
  
  <pre><code>abstract class ABase
  {
      abstract public string A { get; }
  }
  
  interface IB
  {
      string B { get; }
  }
  
  class My : ABase, IB
  {
      private readonly string _a;
      public override A : string { get { return _a; } }
  
      private readonly string _b;
      public virtual  B : string { get { return _b; } }
  
      public My(string a, string b)
      {
          _a = a;
          _b = b;
      }
  }
  </code></pre>
  
  <p>Clearly Nemerle code is easier to support and more readable.</p>
  
  <p><strong>@Brian</strong> So that's why I'm asking , show me if that real to make this easer on F# , C# also if you see I do it wrong because I'm not sure about other ways to make clearly the same.</p>