sikios

F# メモ Option

rei — Thu, 04 Mar 2010 18:23:20 +0000

Option型

C#でいうNullable型のようなもので、値を持たないことも表せるようになる。

引数 x が自然数なら x を、負の数なら None (値を持たない) を返す。

> let natural x =
if x >= 0 then Some x
else None;;

val natural : int -> int option

Option.get
‘a option -> ‘a

Option型は Some (値を持っている) か None (値を持たない) のいずれかを表し、
Some の場合は値を取得できる。
None に対し Option.get を行うと例外が発生する。

> let a = natural 100
let b = natural -100
let c = Option.get a;;

val a : int option = Some 100
val b : int option = None
val c : int = 100

Option.isSome
‘a option -> bool

引数が Some なら true を、None なら false を返す。

Option.isNone
‘a option -> bool

引数が Some なら true を、None なら false を返す。

F# メモ List (2)

rei — Fri, 26 Feb 2010 13:16:49 +0000

リスト関数

関数関数の型	簡単な説明
List.length ‘a list -> int	要素の数を取得する
List.head ‘a list -> ‘a	先頭の要素を取得する
List.tail ‘a list -> ‘a list	先頭の要素を除いたリストを取得する
List.exists (‘a -> bool) -> ‘a list -> bool	条件に合う要素が存在するか調べる
List.rev ‘a list -> ‘a list	順番を逆にしたリストを取得する
List.tryFind (‘a -> bool) -> ‘a list -> ‘a option	条件に合う要素を取得する存在しない場合はNoneを返す
List.zip ‘a list -> ‘b list -> (‘a ‘b) list*	2つのリストの要素を組み合わせ、タプルのリストを作成する
List.filter (‘a -> bool) ‘a list -> ‘a list	条件に合う要素のみを含むリストを作成する
List.partition (‘a -> bool) -> ‘a list -> (‘a list ‘a list)*	条件に合う要素のみを含むリストとそれ以外のリストのタプルを作成する

他にも多数あります。msdn

集約関数 (Aggregate Operators)

リストなどのコレクションには個々の要素に対して何らかの操作を行う関数が多数用意されている。

List.map
(‘a -> ‘b) -> ‘a list -> ‘b list

‘a -> ‘b 変換関数をすべての要素に適用し、’b list を作成する。

例：整数のリストを基に、文字列のリストを作成する。

> let tostr x = sprintf "%d" x
let a = [1..10]
let b = List.map tostr a;;

val tostr : int -> string
val a : int list = [1; 2; 3; 4; 5; 6; 7; 8; 9; 10]
val b : string list = ["1"; "2"; "3"; "4"; "5"; "6"; "7"; "8"; "9"; "10"]

List.reduce
(‘a -> ‘a -> ‘a) ->’a list -> ‘a

リストの要素を辿りながら ‘a 型のアキュムレータを構築していく関数。
(‘a -> ‘a -> ‘a) の部分は現在のアキュムレータとリストの要素を引数とし、新たなアキュムレータを作成する関数。

例：1から5までの整数の積を求める。(ついでに、アキュムレータの確認を行う)

> let multiple a b =
printfn "// %3d = %2d * %d" (a*b) a b
a * b
let b = List.reduce multiple [1..5];;
// 2 = 1 * 2
// 6 = 2 * 3
// 24 = 6 * 4
// 120 = 24 * 5

val multiple : int -> int -> int
val b : int = 120

上の例のように、リストの先頭要素がアキュムレータの初期値となる。

List.fold
(‘acc -> ‘b -> ‘acc) -> ‘acc -> ‘b list -> ‘acc

リストの要素を辿りながら任意の型のアキュムレータを構築していく関数。
List.reduceを汎用的にしたもの。
アキュムレータの初期値を与える必要がある。

例：リスト中の文字数の合計を取得する

> let Count acc (str:string) = acc + str.Length
let dow = [
"Sunday";
"Monday";
"Tuesday";
"Wednesday"
]
let total = List.fold Count 0 dow;;

val Count : int -> string -> int
val dow : string list = ["Sunday"; "Monday"; "Tuesday"; "Wednesday"]
val total : int = 28

List.iter
(‘a -> unit) -> ‘a list -> unit

指定された関数を、リストの各要素に対して順次実行する関数。

F# メモ List (1)

rei — Thu, 25 Feb 2010 16:57:46 +0000

基本

リストの作成。
[] で囲み、要素は ; で区切る。

> let odds = [1;3;5;7;9]
let evens = [2;4;6;8;10];;

val odds : int list = [1; 3; 5; 7; 9]
val evens : int list = [2; 4; 6; 8; 10]

リストの追加。
@ はリストの結合を行う。

> let appended = odds @ evens;;

val appended : int list = [1; 3; 5; 7; 9; 2; 4; 6; 8; 10]

要素の追加。
:: はリストの先頭に要素を追加する。

> 0 :: appended;;
val it : int list = [0; 1; 3; 5; 7; 9; 2; 4; 6; 8; 10]

範囲を指定する。
1から10までの整数のリストを作成する。

> let x = [1..10];;

val x : int list = [1; 2; 3; 4; 5; 6; 7; 8; 9; 10]

範囲と間隔を指定する。
1から10までの奇数のリストを作成する。

> let x = [1..2..10];;

val x : int list = [1; 3; 5; 7; 9]

要素を持たないリスト。

> let emptylist = [];;

val emptylist : 'a list

yield

リストの要素を何らかの手続きで決定させることができる。

> let near x =
[
yield x - 1
yield x
yield x + 1
]
let nearTen = near 10;;

val near : int -> int list
val nearTen : int list = [9; 10; 11]

引数の値とその前後の値を要素とするリストを返す関数 near を作成し、10を与えている。
上から順に評価されるので、10-1=9、10、10+1=11が要素となる。

[] の中には条件式やループ等も使用できる。
30以下の素数のリストを作成する例。

> let primes =
[
let factors n =
[
for i in 2..n-1 do
if n % i = 0 then
yield i
]

for i in 2..30 do
if List.length (factors i) = 0 then
yield i
];;

val primes : int list = [2; 3; 5; 7; 11; 13; 17; 19; 23; 29]

F# メモコメント

rei — Thu, 25 Feb 2010 10:37:58 +0000

行コメント

C++と同じで // から行末までがコメントとして扱われる。

ブロックコメント

(* と *) で囲まれた部分がコメントとなる。

このブロックコメントはネストすることができるので、

1
2
3
4
5
6

(*
outer comment
(*
inner comment
*)
*)

は正しい。しかし、

1
2
3
4
5
6

(*
outer comment
(*
inner comment

*)

はコンパイルエラーとなる。

F# メモタプル

rei — Wed, 24 Feb 2010 21:39:25 +0000

タプルは複数の値を一つの組として扱う機能。
int と string のタプルの型は int * string と表される。
コンマで区切ることでタプルの作成や要素の取得ができる。

> let t = (1234, "1234");;

val t : int * string = (1234, "1234")

> let d, s = t;;

val s : string = "1234"
val d : int = 1234

タプルを関数の引数にするには以下のように括弧で括る必要がある。

> let sum (a, b, c) = a + b + c

let x = sum (12, 23, 34);;

val sum : int * int * int -> int
val x : int = 69

F# メモ unit

rei — Wed, 24 Feb 2010 12:26:33 +0000

unit は値を持たないことを表す型で、CやC#でいう void のようなもの。
() は unit である。

> let x = ();;

val x : unit = ()

ignore は非 unit な式を unit に変換する関数。
つまり値を使わないことを明示する関数。

> ignore(2*2);;
val it : unit = ()

や

> 2*2 |> ignore;;
val it : unit = ()

のように使用できる。

F# メモ関数

rei — Mon, 22 Feb 2010 04:28:47 +0000

定義

2つの int を引数に取り、その和を返す関数 add は以下のように表す。

> let add a b = a + b;;

val add : int -> int -> int

実行してみる。

> add 1 2;;
val it : int = 3

関数の型

float -> int は「float を引数に取り、int を返す関数」と読む。
上の add の場合 int -> int -> int が関数の型で、「intを引数に取り、「intを引数に取り、intを返す関数」を返す関数」と読む。

型推論

上の add 関数のように引数の型が複数考えられるとき、最初に使用されたときの引数を基に関数の型が決まる。(ただし、対話モードでは一旦 ;; で終了した時点で確定する)

> add 1.0 2.0;;

add 1.0 2.0;;
----^^^

stdin(3,5): error FS0001: This expression was expected to have type
int
but here has type
float

のように float を引数とすることはできない。
これは関数 add が int -> int -> int と推論されているため。
float のみを渡せるようにするには、以下のように明示的に型を指定する。

> let addf (a:float) b = a + b;;

val addf : float -> float -> float

> addf 1.0 2.0;;
val it : float = 3.0

ジェネリック関数

‘a のように ‘ を付けた型を指定すると、どんな型でも引数に取ることができる関数を作ることができる。
‘a でも ‘b でも ‘asdfghjk でもいいらしい。

> let str (x:'a) = x.ToString();;

val str : 'a -> string

> str(10);;
val it : string = "10"

スコープ

F#のスコープはインデントで表される。
全くインデントされていないスコープがモジュールスコープ。

> let Pow2 x =
let value = x * x
value;;

val Pow2 : int -> int

> Pow2 10;;
val it : int = 100

関数スコープの最後に評価された値がその関数の戻り値となる。

F# メモ基本演算子

rei — Sun, 21 Feb 2010 11:36:35 +0000

算術演算子

説明不要ですね。

演算子	意味
+	加算
-	減算
*	乗算
/	除算
**	冪算
%	剰余

数学関数

演算子ではありませんが、基本的なものなので。

関数	意味
abs	絶対値を求める
ceil	整数に丸める(大きい方に)
exp	eの引数乗を求める
floor	整数に丸める(小さい方に)
sign	符号を求める(-1, 0 or 1)
log	自然対数を求める
log10	常用対数を求める
sqrt	平方根を求める
cos	コサインを求める
sin	サインを求める
tan	タンジェントを求める
pown	整数の累乗を求める

型変換

型名がそのまま変換関数のように機能する。

> int64 1234.5678;;

val it : int64 = 1234L

ビット演算子

ちょっと特殊。

演算子	意味
&&&	AND
\|\|\|	OR
^^^	XOR
<<<	左シフト
>>>	右シフト

要素へのアクセス

配列や文字列の要素にアクセスする場合は .[] を使用する。
慣れていないうちは . を忘れやすい。

> let str = "abc";;

val str : string = "abc"

> str.[1];;
val it : char = 'b'

論理演算

演算子	意味	例
&&	AND	true && false = false
\|\|	OR	true \|\| false = true
not	NOT	not false = true

比較演算

値同士の比較を行い、bool 値を返す。

演算子	意味
<	より小さいか
<=	以下か
>	より大きいか
>=	以上か
=	同じか
<>	異なるか

compare (関数？) は第一引数の方が小さいときは -1、大きいときは 1、同じなら 0 を返す。

F# メモ基本型

rei — Sat, 20 Feb 2010 09:19:45 +0000

数値型

F#型名	サフィックス	.NET型
byte	uy	System.Byte
sbyte	y	System.SByte
int16	s	System.Int16
uint16	us	System.UInt16
int, int32		System.Int32
uint, uint32	u	System.UInt32
int64	L	System.Int64
uint64	UL	System.UInt64
float		System.Double
float32	f	System.Float
decimal	M	System.Decimal

サフィックスは数値の直後に付ける文字。
整数値のデフォルトは int 、小数値のデフォルトは float。

F#の数値リテラルはデフォルトでは10進表記だが、
プレフィックスによって2進、8進、16進として扱える。

進数	プレフィックス
10進
2進	0b
8進	0o
16進	0x

多倍長整数

その名の通り、64ビットを超える巨大な整数も扱えるようになる。

F#型名	サフィックス	.NET型
bigint	I	System.Numerics.BigInteger

文字

文字型はcharで内部的にはUTF-16の値を保持している。
つまり2バイト。

文字リテラルは ‘a’ のようにアポストロフィーで囲む。

一部の文字はエスケープシーケンスで表す。

文字	文字の意味
\’	アポストロフィ
\”	ダブルクオーツ
\\	バックスラッシュ
\b	バックスペース
\n	LF
\r	CR
\t	水平タブ

文字列

型名は string で、リテラルは “abc” のようにダブルクオーツで囲む。

> let s1 = "any string";;

val s1 : string = "any string""

コード上で改行を含んでも構わない。

> let s2 = "line1
line2
line3";;

val s2 : string = "line1
line2
line3"

コード上でのみ改行する場合。
行末にバックスラッシュで、改行と続く空白文字が無視される。

> let s3 = "line1-\
continue-\
last";;

val s3 : string = "line1-continue-last"

文字列リテラルに B サフィックスを追加することで byte 配列に変換される。
byte に格納できない文字が含まれているとエラーになるので注意。

> let str = "test"B;;

val str : byte [] = [|116uy; 101uy; 115uy; 116uy|]

ブール値

型名は bool で、.NET型名は System.Boolean。
true （真）か false （偽）のどちらかを持つ。

Programming F#

rei — Fri, 19 Feb 2010 10:35:35 +0000

とにかくF#の日本語の書籍がないので、Programming F# を買いました。
英語なので読むのに多少時間はかかりますが、現時点ではこれが一番分かりやすいかと。

気が向いたらまとめてみようと思います。