ここまでは、ずっとインタプリタ環境のもとでF#のコードを実行してきました。しかし、F#にはインタプリタで動作させる以外にも、コンパイルしてEXEやDLLを生成したり、スクリプトとして動作させたりすることができます。

この節では、それら3つの実行環境の利用方法について詳しく説明していきます。

F#インタプリタは、これまでに使ってきたように、ユーザからの入力を読み込み(read)、その入力を評価(evaluate)し、応答を画面に出力(print)という繰り返しを行うことで、対話的にプログラミングを行うことができる実行環境です。この3つのアクションの繰り返しによる対話環境は、一般的にREPループ(read-eval-print loop)と呼ばれ、F#以外のOCaml、Haskell、Ruby、Pythonなどでも存在します。

この実行可能ファイルを直接起動すると、コンソール上で動作するF#インタプリタが起動しますが、Visual Studio上で動作するF#インタプリタも、内部的にはこのファイルを利用しています。

F#インタプリタには、いくつかの命令が用意されています。これらの命令は「#」から始まる文字列で、ディレクティブ(directive)と呼ばれます。このディレクティブは、F#インタプリタから直接入力することができます。これらのディレクティブを使うと、F#インタプリタ環境そのものに対する指示を出すことができます。どのようなコマンドがあるかは、F#インタプリタ上で#help;;と入力することで一覧表示することができます。ここでは、それらのコマンドをいくつか詳しく説明していきます。

let files = System.IO.Directory.GetFiles(@".")

Array.iter (printfn "File=%s") files

> #load "files.fs";;
[Loading C:\files.fs]
File=C:\.rnd
File=C:\autoexec.bat
File=C:\config.sys
File=C:\hiberfil.sys
File=C:\pagefile.sys

> let c1 = Math.Complex.Create(1.0,5.0);; // PowerPackへの参照が追加されていないのでComplexクラスを認識できない
  let c1 = Math.Complex.Create(1.0,5.0);;
  --------------^^^^^^^

stdin(1,14): error FS0039: The value, constructor, namespace or type 'Complex' is not defined.
A construct with this name was found in FSharp.PowerPack.dll, which contains some modules and types that were implicitly referenced in some previous versions of F#.
You may need to add an explicit reference to this DLL in order to compile this code.

> #r @"C:\Program Files\FSharp-1.9.6.16\bin\PowerPack\FSharp.PowerPack.dll";; // 参照を追加

--> Referenced 'C:\Program Files\FSharp-1.9.6.16\bin\PowerPack\FSharp.PowerPack.dll'

> let c1 = Math.Complex.Create(1.0,5.0);; // 複素数値1+5iを作成
val c1 : Math.Complex = 1r+5i

> let c2 = Math.Complex.Create(2.0,3.0);; // 複素数値2+3iを作成
val c2 : Math.Complex = 2r+3i

> c1 + c2;; // 複素数値同士の加算
val it : Math.Complex = 3r+8i {Conjugate = 3r-8i;
                               ImaginaryPart = 8.0;
                               Magnitude = 8.544003745;
                               Phase = 1.212025657;
                               RealPart = 3.0;
                               i = 8.0;
                               r = 3.0;}

> #I @"C:\Program Files\FSharp-1.9.6.16\bin\PowerPack";; // 検索対象パスを追加
--> Added 'C:\Program Files\FSharp-1.9.6.16\bin\PowerPack' to library include path

> #r @"FSharp.PowerPack.dll";; // ファイル名のみを指定して参照を追加
--> Referenced 'C:\Program Files\FSharp-1.9.6.16\bin\PowerPack\FSharp.PowerPack.dll'

> #help;;
  F# Interactive directives:

    #r "file.dll";;        reference (dynamically load) the given DLL.
    #I "path";;            add the given search path for referenced DLLs.
    #load "file.fs" ...;;  load the given file(s) as if compiled and referenced.
    #time ["on"|"off""];;  toggle timing on/off.
    #help;;                display help.
    #quit;;                exit.

  F# Interactive command line options:

      See 'fsi --help' for options

  Visual Studio key bindings:

      Up/Down   = cycle history
      CTRL-DOT  = interrupt session
      ALT-ENTER = send selected source text to FSI session (adds ;;)

  Please send bug reports to fsbugs@microsoft.com

> type Distance =
    class
      new : x:float * y:float -> Distance
      member X : float
      member Y : float
    end;; // Distanceクラスを定義

> let d = new Distance(3.0,4.0);; // Distanceクラスのインスタンスを生成
val d : Distance

> d;; // 値を確認(未フォーマット)
val it : Distance = FSI_0004+Distance {X = 3.0;
                                       Y = 4.0;}

> fsi.AddPrinter(fun (t:Distance) -> System.String.Format("({0:f3},{1:f3})",t.X,t.Y));; // Distanceのプリンタをインストール
val it : unit = ()

> d;; // 値を確認(プリンタによるフォーマット済み)
val it : Distance = (3.000,4.000)

> let polar_printer (v:Distance) = // 極座標としてフォーマットする関数
    let length = sqrt(v.X*v.X+v.Y*v.Y)
    let angle = atan(v.X/v.Y) // 角度の計算は手抜き
    System.String.Format("Length={0:f3}, Angle={1:f3}", length, angle);;

val polar_printer : Distance -> string

> fsi.AddPrinter(polar_printer);;
val it : unit = ()

> d;;
val it : Distance = Length=5.000, Angle=0.644

F#では、ソースコードをコンパイルして実行可能ファイルやライブラリを生成することができます。

F#コンパイラは、Visual Studioの統合開発環境から利用できますが、当然コマンドラインから直接利用することもできます。ここでは、これらの利用方法を説明します。

1.3.1. Visual Studioからのコンパイル

Visual StudioからF#のプログラムをコンパイルするには、他の言語同様「プロジェクト」を作成する必要があります。Visual Studioで作成できるF#のプロジェクトの種類には、F# Library、F# Application、F# Tutorialの3種類が存在します。

F# Libraryはライブラリアセンブリを作成するプロジェクトで、F# Applicationはプロセスアセンブリを作成するプロジェクトです。F# Tutorialは、実際にはプロセスアセンブリを作成するプロジェクトですが、これは単にF#の機能を紹介するためのサンプルプログラムにすぎません。

では、実際にVisual StudioからF#のプロジェクトを作成する方法を説明します。Visual Studio 2010を立ち上げて、ファイル(F)-新規作成(N)-プロジェクト(P)を選択すると、以下の画面が現れます。

<title>プロジェクトの新規作成</title>

ここではF# Applicatioinを選び、プロジェクトにConsoleApplication1という名前をつけてOKを押してみましょう。すると、以下のようF#プロジェクトの画面に切り替わります。

<title>F#プロジェクトの画面</title>

画面の右側に見えるソリューションエクスプローラーの中に、作成したソリューションConsoleApplication1ができ、その下に同じ名前のF#プロジェクトが作成されました。さらにこのプロジェクトのしたには、Program.fsというF#のソースファイルが作成されています。またReferencesの下には、このプロジェクトが参照しているアセンブリの一覧が現れています。FSharp.Coreというアセンブリは、あまり見慣れない名前ですが、これはF#の標準ライブラリや内部的に使用するものを含んだアセンブリです。

では、実際にコードをコンパイルして実行してみましょう。左側のソースファイルに以下のようにコードを書き、メニューからビルド(B)-ソリューションのビルド(B)を選んでください。下側の出力のタブにビルドの結果が出力されます。

<title>プロジェクトのビルド</title>

C:\Projects\ConsoleApplication1\ConsoleApplication1\bin\DebugにConsoleApplication1.exeというプロセスアセンブリが生成されました。これを実行するには、メニューからデバッグ(D)-デバッグなしで開始(H)を選んでください。以下のように、コマンドプロンプトが立ち上がり、その中でビルドしたプログラムが実行されます。

<title>F#プログラムの実行</title>

C:\>set PATH=%PATH%;C:\Program Files\FSharp-1.9.6.16\bin

printfn "Hello, world!"

C:\Project\FSharp>fsc hello.fs
Microsoft F# Compiler, (c) Microsoft Corporation, All Rights Reserved
F# Version 1.9.6.16, compiling for .NET Framework Version v4.0.20506

C:\Project\FSharp>dir
 ドライブ C のボリューム ラベルがありません。
 ボリューム シリアル番号は B41A-XXXX です

 C:\Project\FSharp のディレクトリ

2009/06/14  18:03    <DIR>          .
2009/06/14  18:03    <DIR>          ..
2009/06/14  18:03             4,096 hello.exe
2009/06/14  18:03                25 hello.fs
               2 個のファイル               4,121 バイト
               2 個のディレクトリ  35,501,461,504 バイトの空き領域

C:\Project\FSharp>hello
Hello, world!

C:\Project\FSharp>fsc hello.fs -o hello2.exe
Microsoft F# Compiler, (c) Microsoft Corporation, All Rights Reserved
F# Version 1.9.6.16, compiling for .NET Framework Version v4.0.20506

C:\Project\FSharp>dir
 ドライブ C のボリューム ラベルがありません。
 ボリューム シリアル番号は B41A-XXXX です

 C:\Project\FSharp のディレクトリ

2009/06/14  18:17    <DIR>          .
2009/06/14  18:17    <DIR>          ..
2009/06/14  18:03             4,096 hello.exe
2009/06/14  18:03                25 hello.fs
2009/06/14  18:17             4,096 hello2.exe
               3 個のファイル               8,217 バイト
               2 個のディレクトリ  35,501,383,680 バイトの空き領域

C:\Project\FSharp>fsc hello.fs -r:System.Windows.Forms.dll
Microsoft F# Compiler, (c) Microsoft Corporation, All Rights Reserved
F# Version 1.9.6.16, compiling for .NET Framework Version v4.0.20506

F#では、記述したF#のコードをスクリプトとして動かすことができます。スクリプトとして動かすと、わざわざコンパイルしてプロセスアセンブリを作らなくても、ソースファイルに書かれたコードを直接実行することができます。F#スクリプトを動かすためには、fsi.exeが必要となります。章のはじめでも説明したように、本来fsi.exeはF#のインタプリタですが、F#スクリプトを動かすためにも使われます。

F#のソースコードには.fsという拡張子がつけられますが、スクリプトファイルには.fsxまたは.fsscriptという拡張子がつけられます。F#の開発環境がインストールされている場合は、エクスプローラ上でその拡張子のファイルを右クリックすると、ポップアップメニューの中に「Run with F# Interactive」というメニュー項目が現れます。これを選択すると、そのスクリプトファイルをF#スクリプトとして実行することができます。

例として、メッセージボックスを出力する以下のプログラムを実行してみましょう。まずscript.fsxというファイルを作成し、そのファイルに以下のコードを記述します。

open System.Windows.Forms

MessageBox.Show("Hello, world!")

スクリプトファイルの中では、#rディレクティブや#loadディレクティブなどの一部のディレクティブを使用することができます。ただし、このディレクティブは、コンパイル時は利用することができないので注意してください。たとえば、#rディレクティブで参照するアセンブリを指定するには、以下のようにスクリプトを記述します。

#r "System.Windows.Forms.dll"

open System.Windows.Forms

MessageBox.Show("Hello, world!")

F#には、型や値や関数をひとつにグループ化する、モジュール(module)という概念があります。オブジェクト指向におけるクラスという概念も、それらをグループ化するための概念ですが、モジュールには以下の特徴があります。

モジュールには、トップレベルモジュール(top-level module)とローカルモジュール(local module)の2種類が存在します。トップレベルモジュールは、ファイル全体を包むモジュールで、1つのファイルに1つしか存在できません。一方、ローカルモジュールは、トップレベルモジュール内に包まれるモジュールで、1つのトップレベルモジュール内に複数存在することができます。

トップレベルモジュールとローカルモジュールの定義は、それぞれ以下のように行います。

// トップレベルモジュール
module [アクセス指定子] [名前空間名.]モジュール名
[値の宣言 | 型の宣言 | 関数の宣言]*

// ローカルモジュール
module [アクセス指定子] モジュール名 =
  [値の宣言 | 型の宣言 | 関数の宣言]*

トップレベルモジュールでは、モジュールを包み込む名前空間を指定することができます。この名前空間が事前に定義されていない場合は、その名前空間を新たに作り、その中にトップレベルモジュールが置かれます。また、トップレベルモジュールの宣言では、モジュール名の後の=が無く、各宣言をインデントしてはいけません。一方、ローカルモジュールでは、各宣言は必ずインデントする必要があります。また、モジュール定義には、public、private、internalといったアクセス指定子をつけることができます。アクセス指定子が省略された場合は、publicとして扱われます。

トップレベルモジュールの宣言は省略することができます。省略された場合は、そのコードを含むファイルのファイル名が、自動的にトップレベルモジュール名(ただしモジュール名の先頭は強制的に大文字にされる)として採用されます。たとえば、myprogram.fsというファイル名だった場合は、自動的にMyprogramというトップレベルモジュール名がつけられます。

ここで、モジュール定義の例を見てみましょう。

// ファイル名: Library1.fs
// トップレベルモジュールMathLibの定義
module MathLib

// ローカルモジュールConstantの定義
module Constant =
  let pi = 3.141592653589793

let plus2 x y = x + y
let plus3 x y z = x + y + z

このコードでは、トップレベルモジュールとしてMathLibを定義し、その中にローカルモジュールとしてConstantを定義しています。このソースコードはLibfary1.fsという名前なので、デフォルトではこれをコンパイルするとLibrary1.dllという名前のファイルが作成されます。

モジュールを利用するには、そのモジュールを含むアセンブリへの参照を追加する必要があります。たとえば、前小節で作成したMathLibというモジュールをF#インタプリタから利用する場合は、以下のようにします。

> #r @"C:\Projects\Library1\Library1\bin\Debug\Library1.dll";; // ライブラリアセンブリLibrary1.dllを参照
--> Referenced 'C:\Projects\Library1\Library1\bin\Debug\Library1.dll'

> MathLib.plus2 2 3;; // トップレベルモジュール内のplus2関数を呼び出す
Binding session to 'C:\Projects\Library1\Library1\bin\Debug\Library1.dll'...
val it : int = 5

> MathLib.Constant.pi;; // ローカルモジュール内のpiの値を参照
val it : float = 3.141592654

この例のように、モジュール内のメンバにアクセスするには、メンバ名の前をモジュール名で修飾する必要があります。しかし以下の例のように、あらかじめモジュールをオープンしておくと、モジュール名の修飾を省略することができます。

> pi;; // まだモジュールをオープンしていないので、メンバ名だけではアクセスできない
  pi;;
  ^^
stdin(6,1): error FS0039: The value or constructor 'pi' is not defined.

> open MathLib.Constant;; // モジュールMathLib.Constantをオープン
> pi;; // オープンしたモジュール内のメンバに、修飾なしでアクセス
val it : float = 3.141592654

> plus2 3 5;; // MathLibはまだオープンしていないので、修飾なしではアクセスできない
  plus2 3 5;;
  ^^^^^

stdin(9,1): error FS0039: The value or constructor 'plus2' is not defined.

F#では、他の.NET Framework上で動作する言語同様、名前空間(namespace)を利用することができます。モジュールと同様、名前空間はコードをグループ化するためのものですが、いくつかの違いがあります。

名前空間はコードの編成単位の最上位に位置するもので、名前空間の下にはモジュールが置かれ、モジュールの下にクラスが置かれます。名前空間の直下には、1つのトップレベルモジュールまたは複数のローカルモジュールのどちらかを置くことができます。名前空間の定義方法は以下のとおりです。

namespace [親名前空間名.]名前空間名

名前空間を包むさらに上位の名前空間を指定する場合は、親名前空間名にその名前空間名を指定します。例を見てみましょう。

namespace MyNamespace

module TopLevelModule

let print() = printfn "I'm a member of top level module."

これは名前空間の直下にトップレベルモジュールを置く例です。トップレベルモジュールは、名前空間の直下に1つしか置くことができません。前節で説明したように、トップレベルモジュールの場合は、モジュール名の前にそれを包む名前空間名を指定することで、モジュールの定義と同時に名前空間の定義もできます。したがって、上記のコードは以下のように書くこともできます。

module MyNamespace.TopLevelModule

let print() = printfn "I'm a member of top level module."

次に、名前空間の下にローカルモジュールを置く場合を説明します。

namespace MyNamespace

module LocalModule1 =

  let print() = printfn "I'm a member of local module 1."

module LocalModule2 =

  let print() = printfn "I'm a member of local module 2."

このようにローカルモジュールは、名前空間の直下に複数個置くことができます。

さらに、名前空間の直下にはdo束縛を置くこともできます。

namespace MyNamespace

module LocalModule1 =

  let print() = printfn "I'm a member of local module 1."

module LocalModule2 =

  let print() = printfn "I'm a member of local module 2."

do MyNamespace.LocalModule1.print()
do MyNamespace.LocalModule2.print()

ここに置かれたdo束縛は、プロセスアセンブリのエントリポイントに配置される、すなわちプロセスアセンブリ(EXE)としてコンパイルした場合ここから実行が開始されます。したがって、上記のコードをコンパイルして実行すると、以下の実行結果が得られます。

I'm a member of local module 1.
I'm a member of local module 2.

ここまでの説明の中で、時々アクセス制御に関する説明がでてきました。はじめにアクセス制御について触れたのはオブジェクト指向のときで、次がモジュールのときでした。オブジェクト指向のときは、クラスのメンバに対してアクセス指定子を指定できることを説明し、モジュールのときは、モジュール自体にアクセス制御を指定できることを説明しました。しかしF#では、この2箇所以外にもいくつかアクセス制御を指定することができます。

アクセス指定子が可能な箇所をまとめてみると以下のようになります。ものによっては、アクセス指定子を書く場所がわかりにくいので注意してください。また、ここで示す文法の定義は見易さを優先したため、一部を省略するなどあまり厳密でないところがあります。

読み取り・書き込みプロパティのアクセス制御は、プロパティ全体に指定することもできますし、getとsetに別々のものを指定することもできます。一番最後のにある型の内部実装とは、discriminated unionおよびレコード型に対して適用できるもので、その型のメンバ全体のアクセス制御を指定することができます。これにより、外部に対して型名だけを公開して、内部実装を隠蔽するといったことができます。

F#インタプリタは、ユーザの入力に対して毎回何らかの応答を返します。その中でも、新たに型や名前空間やモジュールなど定義した場合は、シグネチャ(signature)と呼ばれる文字列を返します。シグネチャには、定義したものの名前と、それが含むメンバの一覧が書かれています。いくつか例を見てみましょう。

> type sex = Male | Female;; // discriminated unionの定義

type sex =
  | Male
  | Female

> type Point = { X : float; Y : float };; // レコード型の定義

type Point =
  {X: float;
   Y: float;}

> type Size(width,height) = // クラスの定義
    member v.Width : float = width
    member v.Height : float = height;;

type Size =
  class
    new : width:float * height:float -> Point
    member Width : float
    member Height : float
  end

> module MyModule =
    let f x = 5;; // ローカルモジュールの定義

module MyModule = begin
  val f : 'a -> int
end

この4つの入力では、それぞれ新たにdiscriminated union、レコード型、クラスの定義、モジュールの定義を入力し、F#インタプリタがその応答としてシグネチャを返しています。シグネチャには、あくまで定義したものの名前とそのメンバの一覧が書かれているだけで、メンバの内部実装は書かれません。

F#コンパイラによってソースファイルをコンパイルする場合でも、--sigオプションを指定することによって、そのファイル内で定義されたもののシグネチャをファイルに呼び出力することができます。ここで出力されるファイルはシグネチャファイル(signature file)と呼ばれ、通常はソースファイル名(拡張子を除く)に加えて.fsiという拡張子をもつファイル名をつけます。例として、以下のソースファイルをライブラリアセンブリとしてコンパイルし、同時にシグネチャファイルを生成してみましょう。

// hello.fs

// 新しい名前空間、モジュールの定義
module MyNamespace.MyModule

let print_hello() = printfn "hello, world!"

このソースファイルでは、まずMyNamespace名前空間の中にMyModuleモジュールを作成し、そのモジュールの中にprint_hello()関数を定義しています。これを実際にコンパイルし、hello.fsiの中身を確認してみましょう。

C:\Project\FSharp>fsc hello.fs --sig:hello.fsi --target:library
Microsoft F# Compiler, (c) Microsoft Corporation, All Rights Reserved
F# Version 1.9.6.16, compiling for .NET Framework Version v4.0.20506

C:\Project\FSharp>dir
 ドライブ C のボリューム ラベルがありません。
 ボリューム シリアル番号は B41A-XXXX です

 C:\Project\FSharp のディレクトリ

2009/06/21  17:48    <DIR>          .
2009/06/21  17:48    <DIR>          ..
2009/06/21  17:59             5,120 hello.dll
2009/06/21  17:58               113 hello.fs
2009/06/21  17:59               105 hello.fsi
               3 個のファイル               5,338 バイト
               2 個のディレクトリ  33,796,431,872 バイトの空き領域

C:\Project\FSharp>type hello.fsi
#light

namespace MyNamespace
  module MyModule = begin
    val print_hello : unit -> unit
  end

このように、ソースファイル内で定義したもののシグネチャがhello.fsiに出力されたことが確認できます。

シグネチャファイルは、自分で定義した型のシグネチャを確認する以外に、もうひとつ重要な使い道があります。それは、アセンブリに含まれる型やモジュール、およびそのメンバのアクセス制御です。F#では、この節の冒頭で説明したようにC#と同じようにアクセス指定子によってアクセス制御をする方法以外に、もうひとつシグネチャファイルを利用してアクセス制御をすることができます。

実はシグネチャファイルは、自分で内容を編集することができ、その編集したものをF#コンパイラに入力ファイルとして与えることができます。その場合、F#コンパイラはシグネチャファイルを解釈し、その内容にしたがって、同じファイル名(拡張子を除く)をもつソースファイル(たとえばprogram.fsiだったらprogram.fs)に含まれる要素の公開・非公開を制御することができます。このシグネチャファイルとペアになっているソースファイルのことを、とくに実装ファイル(implementation file)と呼びます。

具体的には、以下の手順に従ってアクセス制御を行います。

実際に上記の手順にしたがって、シグネチャファイルによるアクセス制御をしてみましょう。まず、以下のコードが書かれたソースファイルMathLib.fsを作成します。ここでは、このソースファイルをライブラリとしてコンパイルすることを考えます。

// ファイル名: MathLib.fs
module MathLib

// 階乗の計算を末尾再帰で行う補助関数
let rec fact_helper n accum =
  if n = 1 then accum
  else fact_helper (n-1) (n*accum)

// 階乗の計算を行う関数(実際の計算は補助関数に任せる)
let fact n = fact_helper n 1

このソースファイルの中では、MathLibというトップレベルモジュールの中にfact_helperとfactという2つの関数を定義しています。ここでは、fact_helperはあくまで補助関数として使っているだけで、外部には公開したくないとします。そこで、まずシグネチャファイルを得るためにこのソースファイルをコンパイラにかけます。ライブラリとしてコンパイルするので、コンパイルオプションには--target:libraryを指定します。また、その際に忘れずに--sigオプションでシグネチャファイルの名前を指定するようにしてください。

C:\Project\FSharp>fsc MathLib.fs --sig:MathLib.fsi --target:library
Microsoft F# Compiler, (c) Microsoft Corporation, All Rights Reserved
F# Version 1.9.6.16, compiling for .NET Framework Version v4.0.20506

C:\Project\FSharp>type MathLib.fsi
#light

module MathLib
val fact_helper : int -> int -> int
val fact : int -> int

これで、MathLib.fsiというシグネチャファイルが生成されました。次にこのシグネチャファイルを編集して、非公開にしたい関数fact_helperのシグネチャを削除してください。すると以下のようなシグネチャファイルになるはずです。

#light

module MathLib
val fact : int -> int

ここで、再びMathLib.fsをコンパイルします。ただし今回は、たった今編集したシグネチャファイルも入力ファイルとしてF#コンパイラに与えます。

C:\Project\FSharp>fsc MathLib.fsi MathLib.fs --target:library
Microsoft F# Compiler, (c) Microsoft Corporation, All Rights Reserved
F# Version 1.9.6.16, compiling for .NET Framework Version v4.0.20506

ここで注意しなければならないのは、コンパイラに与える入力ファイルの順序です。あるソースファイルに対して、シグネチャファイルが存在する場合、必ずシグネチャファイルのほうを先にかかなければなりません。実際、間違った順番で与えると以下のようにコンパイルエラーになります。

C:\Project\FSharp>fsc MathLib.fs MathLib.fsi --target:library
Microsoft F# Compiler, (c) Microsoft Corporation, All Rights Reserved
F# Version 1.9.6.16, compiling for .NET Framework Version v4.0.20506

MathLib.fsi(3,1): error FS0191: An implementation of file or module MathLib has
already been given. Compilation order is significant in F# because of type infer
ence. You may need to adjust the order of your files to place the signature file
 before the implementation. In Visual Studio files are type-checked in the order
 they appear in the project file, which can be edited manually or adjusted using
 the solution explorer

このファイル名の順序は、Visual Studioで開発する場合でも同様に影響します。Visual Studioでは、ソリューションエクスプローラに並んでいるファイル名の順番がそのままコンパイラへ渡すファイルの順番となります。この順番は、ファイル名を右クリックすると出てくるMove Down/Move Upというメニューによって並び替えることができます。

ここまででシグネチャファイルによってアクセス制御されたライブラリMathLib.dllが出来上がりました。では実際にこのライブラリを利用してみましょう。

> #r "C:\Projects\FSharp\MathLib.dll";; // ライブラリアセンブリを参照
--> Referenced 'C:\Projects\FSharp\MathLib.dll'

> MathLib.fact 5 ;; // モジュール内の関数を呼び出す
Binding session to 'C:\Projects\FSharp\MathLib.dll'...
val it : int = 120

> MathLib.fact_helper 5 1;; // モジュール内の非公開関数を呼び出す

  MathLib.fact_helper 5 1;;
  --------^^^^^^^^^^^

stdin(3,9): error FS0039: The value, constructor, namespace or type 'fact_helper' is not defined.

先ほど編集したシグネチャファイルにおいて、fact関数はシグネチャを残したままにしてあるので普通に呼び出すことができています。。しかしfact_helper関数のほうは、シグネチャを削除したので呼び出すことができません。