<p class="1999">1999年は・・・</p>

p.\31\39\39\39 {
  font-weight: bold;
}

シンプルな分岐制御、分岐条件に１つのBooleanをとる。キーワードthenは必須で分岐条件の終わりを示し、続いてtrueだった場合に実行されるコードが続く。

let x = 12
if x = 12 then
    System.Console.WriteLine("x is 12")

ほかの多くの言語にあるような暗黙の型変換は行われず、F#では0や非ゼロをBooleanのtrueやfalseとして扱ってはくれないので、プログラマは=演算子(等号)や<>演算子(非等号)をつかって明示的にBooleanを求める必要がある。

if else 式

let x =12
if x = 12 then
    System.Console.WriteLine("x is 12")
else
    System.Console.WriteLine("x is not 12")

if elif else 式

let x = 12
if x = 12 then
    System.Console.WriteLine(" x is 12")
elif x = 20
    System.Console.WriteLine("x is 20")
else
    System.Console.WriteLine("other")

また、関数言語では、ifも”statement”(文)ではなく”expression”(式)なので値を返す。

let x = 12
let msg = if x = 12 then
    "x is 12"
else
    "x is not 12"
System.Console.WriteLine(msg)

ただし、ifから戻る値の型は一つだけなので、if節else節から戻る値の型が異なると、コンパイルエラーになる。

let x = 12
let msg = if x = 12 then
    "x is 12"  //戻り値はint型
else
    System.Console.WriteLine("x is not 12") //戻り値がunit型になるのでコンパイルエラー　

ループ while/do

while ( System.DateTime.Now.Minute <> 0) do
    System.Console.WriteLine("0分ではありません")

while/doは”statement”(文)なので、戻り値はない。　なので関数言語ではあまりwhile/doは使われない。

ループ for

for i = 1 to System.DateTime.Now.Hour do
    System.Console.WriteLine("foobar")

toの代わりに、downtoというキーワードを用いれば、デクリメントになる。

for i = 10 downto 1 do
    System.Console.WriteLine("i = {0}", i)

単純なforの場合、式ではなく文なので何の値も返さない。

例外

F#での例外処理は、try..withとtyr…finallyという構文で例外を処理する。C#にあるtry…with…finallyという構文はサポートしない。

try…with

let result =
    try
        let req = System.Net.WebRequest.Create("Not a legitimate URL");
        let resp = req.GetResponse()
        let stream = resp.GetResponseStream()
        let reader = new System.IO.StreamReader(stream)
        let html = reader.ReadToEnd()
        html
    with
        | :? System.UriFormatException -> "You gave a bad URL"
        | :? System.Net.WebException as webEx -> "Some other exception: " + webEx.Message
        | ex -> "We got an exception: " + ex.Message
results

キーワードtryとwithの間がガードブロックで、with以降に例外をキャッチするブロックがそれぞれ続く。
ifの時と同様にtry..withも式なのでtryブロックからの戻り値とwithブロックの例外処理による戻り値の型に互換性がないとエラーになる。

例外をキャッチを行う節はそれぞれ”|”で区切られ、以下のような構文になる。例外は構文内のパターンによってフィルタリングされる。

 | パターン-> 式

例外のフィルターパターンにはいくつかの記述の仕方がある。
特定の.NET例外をキャッチしたい場合

| :? .NET例外の型　-> 式
例
 | :? System.UriFormatException -> "You gave a bad URL"

特定の.NET例外をキャッチして、さらに式ないで参照したい場合はasで識別子を付ける。.NET例外というのは.NET側で定義されている例外という意味。

| :? .NET例外の型 as 識別子　-> 式
例
| :? System.Net.WebException as webEx -> "Some other exception: " + webEx.Message

F#で定義されたF#例外をキャッチしたい場合

| 例外の名前(引数) -> 式 //引数にスローされた例外の引数の値がバインディングされる。

//例
//exception Error1 of string と例外 Error1を定義されているとする

| Error(str) -> Sytem.Console.WriteLine(str)

単純に任意の例外をキャッチする場合

単純に識別子を記述するだけ、例外はその識別子をつかって参照する。
| 識別子 -> 式
例
| ex -> ex.hoge

任意の例外にマッチし特定の条件が成立する場合

| 識別子 when 条件

例
 | ex when val = 0 -> System.Console.WriteLine("val is 1")

try…finally

try…finallyではtryブロック内で例外が起ろうが起こるまいが、finallyブロックを実行する

let result = try
    (12 / 0)
finally
    System.Console.WriteLine("In finally block")

tryブロック内で例外発生しなかったときは、tryブロック内の最終的な値が戻り値として返される。tryブロック内で例外が発生した時は戻り値はなく、finallyブロック内の結果は戻り値に影響しない。発生した例外は上位のスタックフレームに送られ、例外ハンドラを探すが、ハンドラが見つからない場合、プログラム終了することになる。

例外のスロー

例外はキーワードraiseによってスローする

try
    raise (new System.Exception("I don't wana!"))
finally
    System.Console.WriteLine("In finally block")

例外の定義

F#には2通りの例外の定義の方法があり、
１つは、C#やVisualBasicのように例外クラスを定義する方法
もう1つは、exceptionキーワードを使って例外を定義する方法がある。

//exception 例外タイプ　of 引数タイプ
exception MyException of string

ほかの言語と同じようにtrue/falseのいずれかの値を持つ。

整数型

F#では8ビット～64ビット、符号付き/符号なしなど幅広いタイプの整数型を持つ。

ビット演算

浮動小数点型

数値型の変換

F#では、ほかの多くの言語が行ってくれるような数値型間での暗黙の型変換というものが行われない。
たとえば、int型とfloat型の計算は、int型が自動的にfloat型に変換されて計算がおこなわれるがF#では、明示的にキャストして計算を行う必要がある。

let i =4 //int型
let f = 4.0 // float32型

//let result = i + f   // コンパイルエラーとなる

let result = (float32 i) + f // float32 へ明示的にキャストする必要がある

文字型と文字列型

string型のリテラルは”some string”というようにダブルクォートで文字列をかこみ、エスケープ処理も行われるが、文字列の前に@をつけた場合その文字列はエスケープされずにそのまま評価される。

let str1= "C:\\Prg\\FSharp\\Examples" //エスケープされる
let str2 = @"C:\Prg\FSharp\Examples" //エスケープされない

また、マルチラインストリングリテラルといって、C#などと違い、ダブルクォート内で改行してもＯＫ

let str3 = "Hello,
world of f sharp" //\nと書く代わりに改行をそのまま行ってもＯＫ

Unit

Unit型は、特別な型で、型のないことを表す型のようなもの。
voidやnullを組み合わせたような感じ
値を返さないような関数の戻り値として使用されたりする。

単位

F#には、プリミティブ型に加えて、単位に関する注釈を追加できる。単位を定義するにはコンパイラが分かるようにMeasureアノテーションを記述する。

[<measure>] type usd  //USドル　を表すusdという単位を定義
[<measure>] type euro  //ユーロを表すeuroという単位を定義

関数の定義にも単位をしていすることができる。

let usdRoyaltyCheck = 1500000.00<usd>   //単位が<usd>のfloat型を定義
let usdToEuro (dollars : float<usd>) =
    dollars * 1.5<euro/usd>   // 単位が <euro/usd> のfloat型の値1.5 という意味。

もし引数の単位が異なるとType mismatchのコンパイルエラーが発生する。

リテラル

Listeral アノテーションをつけて名前と値のバインディングを定義すると、それは定数として扱われる。おもにC#とF#を相互利用する場合や、match式なので使用される。

[<literal>]
let str = "Hello, world"

複数行コメント

[f#](* これはF#の
複数行コメントです。 *)
[/f#]

行コメント
[f#]// これは一行コメント[/f#]

ドキュメンテーションコメント
///とスラッシュを三つ続ける、C#のようなドキュメンテーションコメントにも対応している
コメント内で推奨されているタグについてはこちらを参照
[f#]//例
///

/// Use it wisely[/f#]

識別子

F#の識別子は、C++やC#のようにキャラクタ＋数字＋アンダースコアを使用することができる。ユニコード対応なので日本語でもＯＫ。ただし、最初の一文字はキャラクタがアンダースコアである必要がある。

[f#]
let a = “foo” //OK
let _b = “bar” //OK
let 1c = “boo” // Error
[/f#]

以下のF#の予約語も識別子として使用できない
[f#]
abstract and as asr assert atomic base begin break checked class component
const constraint constructor continue default delegate do done downcast
downto eager elif else end event exception extern external false finally
fixed for fun function functor global if in include inherit inline
interface internal land lazy let lor lsl lsr lxor match member method mixin
mod module mutable namespace new null object of open or override parallel
private process protected public pure rec return sealed sig static struct
tailcall then to trait true try type upcast use val virtual void volatile
when while with yield
[/f#]

プリプロセッサディレクティブ・コンパイラディレクティブ

#if#elseや#lightなどのように#で始まるプリプロセッサディレクティブやコンパイラディレクティブを記述することで、条件コンパイルや、簡易構文の有効無効などの設定を行う事が出来る。

MSDN コンパイラディレクティブ

簡易構文

F#では、簡易構文といって、有効にするとin/begin/endなどのキーワードを省略してコードを記述することができる。
簡易構文では空白によるインテントで構成要素の先頭と末尾を示す。
#lightコンパイラディレクティブによって簡易構文の有効/無効を指定できる（デフォルトで有効）

msdn 詳細構文

NativeProcessを試そうと思ったら、いくつか躓いたのでメモ。

アプリケーション記述ファイルのネームスペースをAIR2.0以降のものにしておく

AIRがNativeProcessをサポートしたのは、2.0以降なのでアプリケーション記述ファイルのネームスペースがそれ以前のものだと、flash.desktop.NativeProcessが定義されていないとされて実行時にエラーになります。（コンパイルはできる）

Flash Builderを使っている人は大丈夫だと思うが、FlashDevelopのAIRプロジェクトで書き出されるアプリケーション記述ファイルのネームスペースは1.5のままなので、書き換えるのを忘れると　アレ？　ってことになる。(この時点ではFlashdevelop 3.3.2)

FlashDevelopのプロジェクト内のapplication.xmlの

<application xmlns="http://ns.adobe.com/air/application/1.5">
   ....
</application>

を以下のように書き換える。

<application xmlns="http://ns.adobe.com/air/application/2.0">
   ....
</application>

NativeProcessは拡張デスクトップでのみ利用できる

NativeProcessは拡張でクストップでのみ利用できる。拡張でクストップというのは、ネイティブインストーラーによってインストールされたアプリケーションに適用されるデバイスプロファイル。つまり、拡張デスクトップの機能を利用するなら、アプリケーションをwindowsならexe、macならDMG、LinuxならRPM、bin、debなどのそれぞれのＯＳでお馴染みのインストーラーによってインストールする必要がある。

ネイティブインストーラを作るには以下を参考に。
デスクトップネイティブインストーラーのパッケージ化

デバイスプロファイルについては以下を参考に。
Adobe AIR デバイスプロファイル

拡張デスクトップのデバイスプロファイルでデバッグするには

いちいち、ネイティブインストーラーを作ってインストールしてテストするのはかなり面倒なので
adlコマンドに-profileオプションでextendedDesktopを指定してやるか、
アプリケーション記述ファイルのsupportedProfiles要素にextendedDesktopを記述して、デバイスプロファイルを拡張デスクトップのみに制限してやるとNativeProcessを利用できるようになる。

//例
adl -profile extendedDesktop application.xml bin

<application xmlns="http://ns.adobe.com/air/application/2.0">
   ....
    <supportedProfiles>extendedDesktop</supportedProfiles>
    ....
</application>

[actionscript]
package
{
import flash.display.Sprite;
/**
* …
* @author Motoki Matsumoto
*/
public class E4XFiltering extends Sprite
{
private var _xml:XML =

[actionscript]
package
{
import flash.display.Sprite;
import flash.utils.getQualifiedClassName;
import flash.utils.getDefinitionByName;
/**
* …
* @author Motoki Matsumoto
*/
public class GetClassRef extends Sprite
{
public static const TEST_MESSAGE:String = “foobar”;
public function GetClassRef()
{
super();
var s:Sprite = new Sprite();
var cls:Class = getClass(s);
}

private function getClass( obj:* ):Class
{
return getDefinitionByName( getQualifiedClassName(obj)) as Class;
}
}
}
[/actionscript]

以下の例だと、クラスBClassに定義されてるメソッドtestFuncを
クラスAClassの中からスタティックメソッドとして実行している。
もちろん、$thisのスコープはAClassのインスタンスとなる。
んで、運悪く、AClassにもBClassにも同じ名前のメソッド
sayHelloなんてものがあると、気づかずに処理が進んでしまったりするわけだ。

バリバリＰＨＰやってる人には常識なのかな？
他のクラスのメソッドをコール出来るって時点でかなり違和感。

<?php
//filename: exp001.php
class AClass{
	public function test(){
		BClass::testFunc();
	}
	public function sayHello(){
		echo "Hello, World. I'm a AClass.";
	}
}
class BClass{
	public function testFunc(){
		echo "-------inside BClass::testFunc-----\n";
		$this->sayHello();	echo "\n";
		echo "------------------------------------\n";
	}
	public function sayHello(){
		echo "Hello, World. I'm a BClass.";
	}
}

$test = new AClass();
$test->test(); 		echo "\n";

BClass::sayHello(); echo "\n";

>php exp001.php
-------inside BClass::testFunc-----
Hello, World. I'm a AClass.
------------------------------------

Hello, World. I'm a BClass.

// 引数に文字リテラルを渡しているので警告が発生。
funciton &returnRef(){
    return "Hello world";
}

//何も返さない場合は、
//return を引数なしで実行して強制的にNULLを返すようにする。
function &returnEmpty(){
    echo 'Some process';
    return ; //NULLが返る。
}

指定した文字プロパティとマッチする　\p{xx}

Unicodeにはキャラクタカテゴリーといって、文字の種類によってカテゴリーごとに分類がされています。
$、€、¥はなどの通貨記号はSymbol Currencyカテゴリーに、+や-などの数学に使う記号はMathematical Symbolと言った具合にカテゴリーが割り当てられています。

たとえば、通貨記号にマッチさせたい場合は、
通貨記号が属すカテゴリーSymbol Currencyの文字プロパティ(Sc)をマッチングパターンに指定してやります。

    //例
    preg_match(/\p{Sc}/u, $str);

さらに、\pの後に一文字だけ記述すると、その文字で始まるすべての文字プロパティを指定することもできます。
たとえば、アルファベットを表す文字プロパティLは、Lｌ, Lm, Lo, Lt, Luといった他の文字プロパティをすべて含みます。

指定した文字プロパティを持たない　\P{xx}

\p{XX]の否定を\P{XX}と表す。　
例えば大文字のアルファベットLu を含まない文字とマッチは\P{Lu}と表し、これは\p{^Lu}同じ意味になります。

拡張Unicodeシーケンス（結合文字）とマッチする \X

\Xは 拡張Unicodeシーケンスを構成するUnicode文字にマッチします。
これは、正規表現 ?>\P{M}\p{M} と等価で、記号を含まない文字\P{M}とそれに続く、０個以上の記号を含む文字\p{M}のアトミックなグループにマッチします。
具体的な例をあげると、「が」を結合文字として表すと「か」(U+304B)＋「゛」(U+3099)というという２つの文字から作られる結合文字としてあらわす事が出来ます。このような結合文字に対して\Xはマッチします。
もちろん、結合済みの「が」(U+304C)も存在します。

http://www.php.net/manual/ja/regexp.reference.unicode.php