Switching C # Class to F #

Question

I am C # dev since ancient times.

I study F # and use it for scientific purposes / research / approbation. I find many of my functionality powerful, but I try to write classes - the main thing I know is to do very well in C #.

Which would help me (and the community) translate the following C # code.

class CoolAttribute : Attribute { } class BaseClass { public BaseClass(int zzz) { // zzz doesn't matter; what matters is that zzz is required } public virtual void XHello() { Console.WriteLine("I'm BaseClass."); } } interface IFirst { void Hello(); } interface ISecond { int MagicNumber(); } [DebuggerDisplay("pubI = {pubI}")] class SampleClass : BaseClass, IFirst, ISecond { private int privI; protected int protI; public int pubI; private static string s_privStr; static SampleClass() { s_privStr = ""; } public event Action<string> OnSomething = (el) => { }; public int PubI { get { return pubI; } set { pubI = value; } } public static string StatStr { get { return s_privStr; } } // Default constructor SampleClass() : base(0) { privI = 1; protI = 2; pubI = 3; } // Other constructor SampleClass(int a, int b, int c) : base(a + b + c) { privI = a; protI = b; pubI = c; } [Conditional("DEBUG")] public void PubSimpleMethod() { } protected virtual void ProtVirtMethod() { OnSomething("From the virt method."); } private static void PrivStatMethod() { } public void Hello() { Console.WriteLine("Hello (IFirst)"); } public override void XHello() { Console.WriteLine("I'm SampleClass"); } public int MagicNumber() { return privI + protI + pubI; } public void Additional([Cool] int i) { } public static SampleClass operator +(SampleClass a, SampleClass b) { return new SampleClass(a.privI + b.privI, a.protI + b.protI, a.pubI + b.pubI); } } 

F # translation [work in progress, for updating with answers]:

 //// wrong ... //type CoolAtribute = // extend Attribute type BaseClass(zzz : int) = // virtual abstract XHello : unit -> unit default this.XHello() = printfn "I'm BaseClass." // seems Ok type IFirst = abstract Hello : unit type ISecond = abstract MagicNumber : int [<DebuggerDisplay("pubI = {pubI}")>] // ???? type SampleClass() = inherit BaseClass(0) // necessary argument ? 1 constructor // implements IFirst, ISecond let mutable privI = 0 // initialization required // protI // pubI // wrong: //let static mutable s_privStr = "" // static constructor // event OnSomething // seems Ok member this.PubI with get() = privI and set(value) = privI <- value // ?? //static member StatStr // with get() = s_privStr // and set(value) = s_privStr <- value // Default constructor // Other constructor // C#: SampleClass(int a, int b, int c) [<Conditional("DEBUG")>] member this.PubSimpleMethod() = do ignore abstract ProtVirtMethod : unit -> unit //protected default this.ProtVirtMethod() = // raise event OnSomething("From the virt method."); //private //static member this.PrivStatMethod() = do ignore member this.Hello() = printfn "Hello (IFirst)" // override member this.XHello() = printfn "I'm SampleClass" member this.MagicNumber() : int = privI + protI + pubI // apply attribute to the argument member this.Additional( (*[Cool*) i :int) = do ignore // operator + 

Answer 1

Most of the code looks good to me, but you cannot use a simple member to define virtual methods. (This is because F # code usually does not use implementation inheritance, so this is often not required).

To define a virtual method, you need to use abstract and default :

 type Virtual() = abstract Foo : int -> int default this.Foo(n) = n + 1 

To override a method in a derived type, you can write:

 type Derived() = inherit Virtual() override this.Foo(n) = n + 2