インストール

Ubuntu の場合は標準リポジトリに入っているので apt でインストールできます。

sudo aptitude install libapache2-mod-musicindex
sudo a2enmod musicindex

必要に応じてコーデックをインストールします。対応コーデックはドキュメントを参照してください。

sudo aptitude install libmp4v2-0

設定

通常の Apache の設定通り，ディレクトリへのアクセスを許可します。

Alias /music /var/music
<Directory /var/music>
   Options Indexes MultiViews FollowSymLinks
   AllowOverride Indexes
   Order allow,deny
   allow from all
</Directory>

上記設定ではすべての人がアクセスできるようになっているので，必要に応じてアクセス制限をしましょう。

音楽ディレクトリ (ここでは /var/music) 内の .htaccess ファイルか，上記の Directory ディレクティブ内に musicindex の設定を追記します。

MusicIndex      On +Stream +Download +Search -Rss -Tarball
MusicSortOrder  album disc track artist title length bitrate freq filetype filename uri
MusicFields     title artist album length bitrate
MusicPageTitle  Title
MusicDefaultCss musicindex.css
MusicDirPerLine 3

意味はだいたい見た感じのままです。最低限 MusicIndex On があれば， musicindex が動きます。

Apache の再起動

再起動したら完成です。 http://www.example.com/music にアクセスしてストリーミングを楽しみます。

sudo /etc/init.d/apache2 restart

その他

キャッシュシステムに MySQL が使えたり， URL パラメーターを与えると RSS や PODCAST を吐いたり， CD カバーの画像を指定できたりするようです。詳しくは README ファイルを読みましょう。

var platform = Environment.OSVersion.Platform;
Console.WriteLine(platform == PlatformID.MacOSX);  // false

実は Mac OS X では platform には PlatformID.Unix になります^[a]。

苦肉の策ではありますが， UNIX 系 OS に標準で搭載されている uname を用いて OS を調べることができます^[b]。

var platform = Environment.OSVersion.Platform;
if (platform != PlatformID.Unix)
{
   return platform;
}
using (var uname = new Process())
{
   uname.StartInfo.FileName = "uname";
   uname.StartInfo.Arguments = "-s";
   uname.StartInfo.RedirectStandardOutput = true;
   uname.StartInfo.UseShellExecute = false;
   uname.Start();
   var kernelName = uname.StandardOutput.ReadLine();
   uname.WaitForExit();
   return kernelName == "Darwin" ? PlatformID.MacOSX : PlatformID.Unix;
}

カーネルの名前が Darwin ならば Mac OS X，そうでなければその他の UNIX であるとしています。 PATH が変更されていたら例外が投げられるなどいろいろ問題がありますが，とりあえずうまくいくと思います。

脚注

1. Bug 515570 - System.Environment.OSVersion.Platform returns wrong result on Mac OS X
2. リンク先では -a オプションと書いてありますが， -s オプション (オプションなしと同じ) で十分だとます。

とは言っても C# でできないから困ってるのであって，本当に C# だけで解決するのは難しいです。そこでもう少し低レベルな MSIL を使って解決しましょう。

準備

IL Support という Visual Studio の拡張を利用します。この拡張は， C# や F# のプロジェクトで MSIL を利用するための補助機能が含まれます。

IL Support は，具体的には一部のコードを宣言のみで実装せずにコンパイルし，それを逆コンパイルした後に IL コードとマージして再度コンパイルをする，という手法をとっているようです。 Visual Studio の無償版ではおそらく拡張機能は使えないので IL Support は利用できませんが，同様の考え方で同じことが実現できるはずです^[a]。

プロジェクトの作成

IL Support をインストールして再起動すると，プロジェクトテンプレートに IL Support プロジェクトが追加されています。例えばクラスライブラリプロジェクトを作成すると，次のようなファイルが追加されます。

using System;
using System.Collections.Generic;
using System.Linq;
using System.Runtime.CompilerServices;
using System.Text;

namespace Library1
{
   public class Class1
   {
      [MethodImpl(MethodImplOptions.ForwardRef)]
      public extern int Square(int number);
   }
}

.class public Library1.Class1
{
   .method public int32 Square(int32 number) cil managed
   {
      .maxstack 2
      ldarg.1
      dup
      mul
      ret
   }
}

見て想像できるように， Square というメソッドの中身を IL で記述することができます。 IL レベルではジェネリック型制約に System.Delegate や System.Enum が使えるので，このような制約が必要な部分を IL で書いてやれば良いわけです。ちなみに extern で宣言する部分は IL の宣言とマッチしている必要はありません。 IL の方が優先されるので， C# でジェネリック型制約が書けないので宣言ができない，という心配はありません。というか extern の宣言は無くても良いみたいです。

IL を直接書ける人は少数派だと思うので，いったん制約を甘くしたプロトタイプのコードを記述してコンパイルし， ildasm で逆アセンブルした IL コードを修正するか，あるいは最初に述べたような制限のない言語で記述してコンパイル，逆コンパイルした IL コードをコピペする，という方法が容易だと思います。

他の使い方

IL Support は F# プロジェクトサポートもあるので， F# で family のアクセシビリティ (C# の protected) を使うこともできます。これで C# と F# がもっと仲良しになれる気がします。

脚注

1. 各言語のコンパイラに加え， IL アセンブラ (ilasm) と IL 逆アセンブラ (ildasm) を使います。

NemerleUnit.dll のコンパイル

NemerleUnit は zip や msi 形式で配布されるアセンブリ群の中に含まれていないので，自前でコンパイルしてやる必要があります。 NemerleUnit のソースコードはチェンジセット 430eb4a78f 時点で Nemerle 1.1.372.0-RC の Nemerle.Compiler API に対応していないので，以下の修正を加える必要があります。

// 修正前
def mods = AttributesAndModifiers(NemerleModifiers.Public, attrs);
// 修正後
def mods = Modifiers(NemerleAttributes.Public, attrs);

修正したら以下のようにコンパイルできます。

ncc /t:library /out:NemerleUnit.dll /r:nunit.framework.dll /r:Nemerle.Compiler.dll /i macros.n

使う

NemerleUnit 名前空間を using するだけで OK です。コンパイル時には NemerleUnit.dll と nunit.framework.dll を参照に指定します。

公式ページにある通り，以下のように記述できます。インデント構文を使った方が自然言語らしく表現できます。

#pragma indent

using NemerleUnit

setup
   def abc = ["a", "b", "c"]

teardown
   ()

test "length of an empty list"
   assert [].Length equals 0

test "length of a three element list"
   assert abc.Length equals 3

test "equals"
   assert abc equals ["a", "b", "c"]
   assert abc does not equal ["c", "b", "a"]

test "contains"
   assert abc.Contains("a")
   assert abc.Contains("b")
   assert abc.Contains("c")

通常の構文で書いた場合は以下のようになります。

using NemerleUnit;

setup
{
   def abc = ["a", "b", "c"];
}

teardown
{
   ();
}

test "length of an empty list"
{
   assert [].Length equals 0;
}

test "length of a three element list"
{
   assert abc.Length equals 3;
}

test "equals"
{
   assert abc equals ["a", "b", "c"];
   assert abc does not equal ["c", "b", "a"];
}

test "contains"
{
   assert abc.Contains("a");
   assert abc.Contains("b");
   assert abc.Contains("c");
}

上記のソースコードをコンパイルしてできたアセンブリを NUnit ランナーで読み込んでやると，以下のようになります。

using System.Math;
using Nemerle.Imperative;

def isSquare(x : int)
{
   Sqrt(x) % 1 == 0;
}

def squareAnyFunctional(values)
{
   match (values)
   {
      | [] => false;
      | x :: xs => if (isSquare(x)) true
                   else squareAnyFunctional(xs);
   }
}

def squareAnyProcedural(values)
{
   foreach (x in values)
   {
      when (isSquare(x))
      {
         return true;
      }
   }
   false;
}

def squareAnyLabeledBlock(values)
{
   ret:
   {
      foreach (x in values)
      {
         when (isSquare(x))
         {
            ret(true);
         }
      }
      false;
   }
}

squareAnyFunctional はパターンマッチングによる関数型的な書き方， squareAnyProcedural は普通の手続き型的な書き方です。 Nemerle 的に面白いのは 3 つ目の squareAnyBlock でしょう。ブロックにラベルを付けて，そのラベル付きブロックが返す値が何であるかを明示的に示すことが可能です。やっていることは手続き型的書き方と変わりませんが，ブロックが値を持つということを意識して書くことができるのが良いと思います。

args(sqrt)

ここで得られる結果はクロージャオブジェクトなので， formals 関数により，リストオブジェクトにすることができます。

formals(args(sqrt))

リストなので， length 関数により引数の数を得ることができます^[a]。

length(formals(args(sqrt)))

これを用いて，例えば，特定の名前空間に存在するすべての関数の引数の数を取得したい場合は次のようにできます。

e <- asNamespace("stats")
exports <- sapply(ls(envir=e), get, envir=e)
functions <- exports[sapply(exports, is.function)]
sapply(functions, function(f) length(formals(args(f))))

結果は stats 名前空間に公開された関数の引数の個数の名前付きベクトルです。ジェネリック関数のように重複もありますが，これで引数の個数の分布を調べても面白いと思います。

脚注

1. ただし， ... は 1 つの引数として扱われます。

前回のままでも良いのですが，最初に Brainfuck の実行環境である仮想マシンのクラスを作成します。

public class BrainfuckMachine
   invariant 0 <= pointer && pointer < memory.Length
{
   private memory : array[char];
   private mutable pointer : int;

   public this(memorySize = 64 : int)
      requires memorySize > 0
         otherwise throw ArgumentOutOfRangeException("memorySize")
   {
      memory = array (memorySize);
   }

   public Initialize() : void
   {
      Array.Clear(memory, 0, memory.Length);
      pointer = 0;
   }

   public Execute(source : string) : void
   {
      def parser = BrainfuckParser();
      match (parser.Parse(source))
      {
         | option.Some(commands) =>
               foreach (c in commands)
               {
                  Proceed(c);
               }
         | option.None => throw FormatException();
      }
   }

   private Proceed(command : BrainfuckExpression) : void
   {
      match (command)
      {
         | BrainfuckExpression.MoveRight => ++pointer;
         | BrainfuckExpression.MoveLeft => --pointer;
         | BrainfuckExpression.Increment => ++memory[pointer];
         | BrainfuckExpression.Decrement => --memory[pointer];
         | BrainfuckExpression.Get => memory[pointer] = ReadKey(true).KeyChar;
         | BrainfuckExpression.Put => Write(memory[pointer]);
         | BrainfuckExpression.Loop as loop =>
               while (memory[pointer] != 0)
               {
                  foreach (c in loop.Body)
                  {
                     Proceed(c);
                  }
               }
         | _ => throw InvalidEnumArgumentException();
      }
   }
}

このクラスを用いて，マクロを使わずに普通に Brainfuck のソースコードを実行すると次のようになります。

def machine = BrainfuckMachine();
machine.Execute(source);

さて，マクロの登場です。 Nemerle ではマクロを用いて自由に構文を拡張することができます。例えば次のように構文を拡張できます。。

bf(source);
bf[256](source);  // 仮想マシンのメモリーサイズを指定

マクロによる構文の拡張は単純で，次のように記述してやります。

macro BrainfuckInlineExecution(memorySize, source)
syntax ("bf", Optional("[", memorySize, "]"), "(", source, ")")
{
   def memorySize = if (memorySize == null) <[ 64 ]> else memorySize;
   <[
      def machine = BrainfuckMachine($memorySize);
      machine.Execute($source);
   ]>
}

syntax で構文のマクロを作成することができます。 Optional で指定した構文は省略可能になります。ここでは Brainfuck を実行する仮想マシンのメモリーサイズを省略できるようになっています。

Nemerle だと，本当に簡単に言語内言語が実装できてしまうのですね。

ソースコード

ソースコードを Bitbucket にアップロードしています。

まず Brainfuck の構文を表す variant^[a] を定義します。

using System.Collections.Generic;

variant BrainfuckExpression
{
   | MoveRight
   | MoveLeft
   | Increment
   | Decrement
   | Put
   | Get
   | BeginLoop
   | EndLoop
   | Loop { Begin : BeginLoop;
            Body : List[BrainfuckExpression];
            End : EndLoop; }
}

次にパーサーです。 PegGrammerAttribute に直接 PEG の文法を放り込んでやり，それぞれの実装をクラス内で定義やるだけです。文法と実装がマッチしていなければコンパイルエラーになります。

簡単のために，改行を含む空白文字やコメントを一切許容しない，もっとも単純な文法を定義します。

using System;
using System.Collections.Generic;
using Nemerle.Peg;

[PegGrammar(Options = EmitDebugSources, Commands,
grammar
{
   SingleCommand : BrainfuckExpression = '>' / '<' / '+' / '-' / ',' / '.';
   BeginLoop : BrainfuckExpression = '[';
   EndLoop : BrainfuckExpression = ']';
   Loop : BrainfuckExpression = BeginLoop Commands* EndLoop;
   Commands : List[BrainfuckExpression] = (Loop / SingleCommand)*;
})]
class BrainfuckParser
{
   SingleCommand(token : NToken) : BrainfuckExpression
   {
      match (this._parsingSource.OriginalText[token.StartPos])
      {
         | '>' => BrainfuckExpression.MoveRight();
         | '<' => BrainfuckExpression.MoveLeft();
         | '+' => BrainfuckExpression.Increment();
         | '-' => BrainfuckExpression.Decrement();
         | ',' => BrainfuckExpression.Get();
         | '.' => BrainfuckExpression.Put();
         | _ => throw NotSupportedException();
      }
   }

   BeginLoop(_ : NToken) : BrainfuckExpression
   {
      BrainfuckExpression.BeginLoop();
   }

   EndLoop(_ : NToken) : BrainfuckExpression
   {
      BrainfuckExpression.EndLoop();
   }

   Loop(begin : BrainfuckExpression, body : List[List[BrainfuckExpression]], end : BrainfuckExpression) : BrainfuckExpression.Loop
   {
      BrainfuckExpression.Loop(begin :> BrainfuckExpression.BeginLoop,
                               body[0],
                               end :> BrainfuckExpression.EndLoop);
   }

   Commands(commands : List[BrainfuckExpression]) : List[BrainfuckExpression]
   {
      commands;
   }
}

これだけで Brainfuck のパーサーが完成です。小難しいことはすべて勝手にやってくれます。なお，コンパイルする際には， Nemerle.Peg.dll と Nemerle.Peg.Macros.dll を参照に加える必要があります。

実際に使う際は，普通にインスタンスを生成して Parse メソッドを呼ぶだけです。パースに成功すれば option.Some が，失敗すれば option.None が返ってきます。

using System;
using System.Console;
using System.ComponentModel;
using Nemerle.Assertions;

module Program
{
   Main() : void
   {
      // Hello, world!
      def source = "+++++++++[>++++++++>+++++++++++>+++++<<<-]>.>++.+++++++..+++.>-.------------.<++++++++.--------.+++.------.--------.>+.";
      _ = Execute(source);
   }

   Execute(source : string, memorySize = 0x1000 : int) : array[char]
      requires source != null
         otherwise throw ArgumentNullException("source")
      requires memorySize > 0
         otherwise throw ArgumentOutOfRangeException("memorySize")
      ensures value != null
   {
      def parser = BrainfuckParser();
      def memory = array (memorySize);
      mutable pointer = 0;
      match (parser.Parse(source))
      {
         | option.Some(commands) =>
              foreach (c in commands)
              {
                 Proceed(c, memory, ref pointer);
              }
         | option.None => throw FormatException();
      }
      memory;
   }

   Proceed(command : BrainfuckExpression, memory : array[char], pointer : ref int) : void
      requires memory != null
         otherwise throw ArgumentNullException("memory")
      requires 0 <= pointer && pointer < memory.Length
         otherwise throw ArgumentOutOfRangeException("pointer")
      ensures 0 <= pointer && pointer < memory.Length
         otherwise throw OutOfMemoryException()
   {
      match (command)
      {
         | BrainfuckExpression.MoveRight => ++pointer;
         | BrainfuckExpression.MoveLeft => --pointer;
         | BrainfuckExpression.Increment => ++memory[pointer];
         | BrainfuckExpression.Decrement => --memory[pointer];
         | BrainfuckExpression.Get => memory[pointer] = ReadKey(true).KeyChar;
         | BrainfuckExpression.Put => Write(memory[pointer]);
         | BrainfuckExpression.Loop as loop =>
              while (memory[pointer] != 0)
              {
                 foreach (c in loop.Body)
                 {
                    Proceed(c, memory, ref pointer);
                 }
              }
         | _ => throw InvalidEnumArgumentException();
      }
   }
}

このコードだけでも， Nemerle の特徴が随所に表れている気がします。

感想

Nemerle は Java 界隈で言うところの Scala 的な位置づけの言語だと思います。 C# のようなメジャーな言語とのギャップも小さく，かつ関数型の強力な表現力も持っています。マクロによる構文拡張はチート級です^[b]。

.NET の言語としては Visual Studio によるサポートが弱いのがネックですが^[c]，とても書きやすい言語だと思います。

ソースコード

ソースコードを Bitbucket にアップロードしています。

参考文献

• Nemerle.PEG - Nemerle Forum

脚注

1. F# の判別共用体に相当するものだと思います。
2. 例えばコード中の foreach や while は実はマクロです。
3. Nemerle 1.1 RC では Visual Studio 2010 用の拡張も含まれています。しかし，プロジェクトとして扱えたりエディターでシンタックスハイライトができるくらいで，リファクタリングまわりはまったく使い物にならず，インテリセンスも弱いです。

まず組み合わせを構成する要素を表すクラスを作成します。

public class Element
{
   private readonly int capacity;
   private int value;

   public Element(int capacity, int value)
   {
      this.capacity = capacity;
      this.value = value;
   }

   public int Value
   {
      get { return this.value; }
   }

   public event EventHandler Exceeded;
   public event EventHandler ValueReset;

   public void Succeed()
   {
      this.value++;
      if (this.value >= this.capacity)
      {
         OnExceeded(EventArgs.Empty);
      }
   }

   public void Reset(int value)
   {
      this.value = value;
      OnValueReset(EventArgs.Empty);
   }

   protected virtual void OnExceeded(EventArgs e)
   {
      if (Exceeded != null)
      {
         Exceeded(this, e);
      }
   }

   protected virtual void OnValueReset(EventArgs e)
   {
      if (ValueReset != null)
      {
         ValueReset(this, e);
      }
   }
}

最初に挙げた例のように，要素を 1 つずつカウントアップしていくのが簡単です。カウントアップして取りうる値の最大値になったら，前の要素をカウントアップして，自身はリセットします。この要素間の連絡をイベントが担うわけですね。

次に要素を管理するクラスを作成します。

public class Combination
{
   private readonly LinkedList<Element> elements;
   private bool hasMore;

   public Combination(int n, int k)
   {
      if (n < 0)
      {
         throw new ArgumentOutOfRangeException("n");
      }
      if (k < 0 || n < k)
      {
         throw new ArgumentOutOfRangeException("k");
      }
      this.elements = new LinkedList<Element>();
      while (--k >= 0)
      {
         var count = this.elements.Count;
         var element = new Element(n - k, count);
         var node = this.elements.AddLast(element);
         AddEvent(node);
      }
      this.hasMore = true;
   }

   public bool HasMore
   {
      get { return this.hasMore; }
   }

   public int[] Current
   {
      get { return this.elements.Select(e => e.Value).ToArray(); }
   }

   public void MoveNext()
   {
      this.elements.Last.Value.Succeed();
   }

   private void AddEvent(LinkedListNode<Element> node)
   {
      var element = node.Value;
      if (node.Previous == null)
      {
         element.Exceeded += (sender, e) => this.hasMore = false;
      }
      else
      {
         var previous = node.Previous.Value;
         element.Exceeded += (sender, e) =>
         {
            previous.Succeed();
            element.Reset(previous.Value + 1);
         };
         previous.ValueReset += (sender, e) =>
         {
            element.Reset(previous.Value + 1);
         };
      }
   }
}

LinkedList に追加する際に，追加する要素に前の要素と連絡をするためのイベントを追加します。実装を簡単にするために IEnumerator<T> と少し違うインターフェイスになっています。さらに言えば， Current を呼ぶたびに毎回新しい配列を作っていて微妙です。修正は容易ですが，あえてこの実装を採用することもないので，簡単のためにこうしています。

以下のように使います。

for (var c = new Combination(5, 3); c.HasMore; c.MoveNext())
{
   var values = c.Current;
   Console.WriteLine(string.Join(", ", values));
}

// output
// 0, 1, 2
// 0, 1, 3
// 0, 1, 4
// 0, 2, 3
// 0, 2, 4
// 0, 3, 4
// 1, 2, 3
// 1, 2, 4
// 1, 3, 4
// 2, 3, 4

[Flags]
enum Flag { None = 0, A = 1, B = 2, C = 3, D = 4, E = 5 }

// DecomposeFlag(Flag.None) -> { Flag.None }
// DecomposeFlag(Flag.A) -> { Flag.A }
// DecomposeFlag(Flag.C) -> { Flag.A, Flags.B }
// DecomposeFlag(Flag.C | Flag.E) -> { Flag.A, Flag.B, Flags.D }
// DecomposeFlag(Flag.None | Flag.E) -> { Flag.A, Flags.D }

ジェネリックを諦める場合

public static ISet<Enum> DecomposeFlag(Enum value)
{
   if (value == null)
   {
      throw new ArgumentNullException("value");
   }
   var enumType = value.GetType();
   if (Convert.ToUInt64(value) == 0)
   {
      return new HashSet<Enum> { value };
   }
   var flags = (from Enum flag in Enum.GetValues(enumType)
                where Convert.ToUInt64(flag) != 0
                where value.HasFlag(flag)
                select flag).ToList();
   var result= from flag in flags
                where flags.All(e => e == flag || !flag.HasFlag(e))
                select flag
   return new HashSet<Enum>(result);
}

無理やりジェネリック

public static ISet<TEnum> DecomposeFlag<TEnum>(TEnum value)
   where TEnum : struct
{
   var enumType = typeof(TEnum);
   if (!enumType.IsEnum)
   {
      throw new NotSupportedException();
   }
   ulong bits = Convert.ToUInt64(value);
   if (bits == 0)
   {
      return new HashSet<TEnum> { value };
   }
   var flags = (from Enum flag in Enum.GetValues(enumType)
                let flagBits = Convert.ToUInt64(flag)
                where flagBits != 0
                where (bits & flagBits) == flagBits
                select flag).ToList();
   var result = from flag in flags
                let flagBits = Convert.ToUInt64(flag)
                where set.Select(Convert.ToUInt64).All(e => e == flagBits || (e | flagBits) != flagBits)
                select (TEnum)Convert.ChangeType(flag, enumType);
   return new HashSet<TEnum>(result);
}

ちなみに整数のまま扱うなら以下のように書くこともできます。

   var flags = (from Enum flag in Enum.GetValues(enumType)
                let flagBits = Convert.ToUInt64(flag)
                where flagBits != 0
                where (bits & flagBits) == flagBits
                select flagBits).ToList();
   Type underlyingType = enumType.GetEnumUnderlyingType();
   var result = from flagBits in flags
                where flags.All(e => e == flagBits || (e | flagBits) != flagBits)
                select (TEnum)Convert.ChangeType(flagBits, underlyingType);
   return new HashSet<TEnum>(result);
}

折衷案

public static ISet<TEnum> DecomposeFlag<TEnum>(Enum value)
   where TEnum : struct
{
   if (value == null)
   {
      throw new ArgumentNullException("value");
   }
   var enumType = typeof(TEnum);
   if (enumType != value.GetType())
   {
      throw new NotSupportedException();
   }
   if (Convert.ToUInt64(value) == 0)
   {
      return new HashSet<TEnum> { (TEnum)Convert.ChangeType(value, enumType) };
   }
   var flags = (from Enum flag in Enum.GetValues(enumType)
                where Convert.ToUInt64(flag) != 0
                where value.HasFlag(flag)
                select flag).ToList();
   var removing = from flag in flags
                  where flags.All(e => e == flag || !flag.HasFlag(e))
                  select (TEnum)Convert.ChangeType(flag, enumType);
   return new HashSet<TEnum>(result);
}

結局

どれもいまいちに見えます。何か良い書き方はあるのでしょうか。

ここで唐突に F# に登場してもらいます。

let DecomposeFlag (value : 'T when 'T : enum<_>) : ISet<'T> =
   if Convert.ToUInt64(value) = 0uL
   then
      new HashSet<'T> ([value]) :> ISet<'T>
   else
      let has flag = (flag :> Enum).HasFlag
      let flags = Enum.GetValues typeof<'T>
                  |> Seq.cast<'T>
                  |> Seq.filter (fun flag -> Convert.ToUInt64 flag <> 0uL)
                  |> Seq.filter (has value)
      let result = flags
                   |> Seq.filter (fun flag -> Seq.forall (fun e -> e = flag || not (has flag e)) flags)
      new HashSet<'T> (result) :> ISet<'T>

なんだ最初から F# で書けば良かったのか，というお話でした^[b]。

更新履歴

• [2012-01-08 12:20] F# 版の返り値の型を明示。その他瑣末な修正。
• [2012-01-08 16:00] C# 版で Any を使っていたのを， F# 版 の forall にあわせて All を使うように変更。
• [2012-01-09 06:35] ジェネリック版でジェネリック型が enum でないときに投げる例外を NoSupportedException に変更。

脚注

1. delegate もそうですね。
2. ちなみにこれを逆コンパイルして C# のコードに変換すると where T : Enum とかついてました。ずるい。