Sort of.A Module Foo is (since this CTP?) compiled to two static classes: Foo and $Foo. Top level let constants in Foo are compiled to properties on the Foo class, let functions are compiled to static methods returning a FastFunc.Any static initialization (do <whatever>) in the module is not done in the Foo class, and neither are the fields holding the actual object of the let constants. These are in the $Foo class instead. So, something like this:

1
2
3
4
5
6
7

module Foo

let f = printfn "Called f"

let realf() = ignore

do printfn "Foo init"

gets compiled to the following C# equivalent:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

public static class Foo
{
    // Methods
    public static FastFunc<a, Unit> realf<a>()
    {
        return new realf@7<a>();
    }

    // Properties
    [CompilationMapping(SourceConstructFlags.Value)]
    public static Unit f
    {
        get
        {
            return $Foo.f@5;
        }
    }

    // Nested Types elided (fastfunc for the realf)

}

The $Foo class does the actual initialization:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

internal static class $Foo
{
    // Fields
    [DebuggerBrowsable(DebuggerBrowsableState.Never)]
    internal static readonly Unit f@5;
    [DebuggerBrowsable(DebuggerBrowsableState.Never), CompilerGenerated, DebuggerNonUserCode]
    internal static int init@;

    // Methods
    static $Foo()
    {
        Unit local1 = f@5 = ExtraTopLevelOperators.printfn<Unit>(new PrintfFormat<Unit, TextWriter, Unit, Unit, Unit>("Called f"));
        ExtraTopLevelOperators.printfn<Unit>(new PrintfFormat<Unit, TextWriter, Unit, Unit, Unit>("Foo init"));
    }
}

Some conclusions:

• Module initialization code is order-dependent - it matters where you put your do's and lets (but I believe this has always been the case)
• Initialization code for a module will _only_ be run if you access a let constant from that module, _not_ before you call a function (or type?) of that module (since calling a function does not even access the initializtion class $Foo). I am quite sure this is a (confusing!) change.

I think that last thing bit us: calling a type's constructor or function in a module does not run the initialization in the module at all.I'm going to send all this to fsbugs as well, I think. It should get some attention.