関数型プログラミングの世界

関数型プログラミングの世界Welcome to the world of the functional programming

村田賢太Kenta Murata 2011.06.11 #osc11do

1Monday, June 13, 2011

自己紹介


http://www.flickr.com/photos/koichiroo/5244581973/

村田賢太mrkn

高専カンファレンス副代表

Ruby コミッタRuby 札幌




2010年3月1日月曜日 4Monday, June 13, 2011

関数型プログラミングの世界Welcome to the world of the functional programming

村田賢太Kenta Murata 2011.06.11 #osc11do


Functional Programming

関数型プログラミング


Imperative Programming

Procedural Programming

命令型プログラミング手続き型プログラミング


機械語Fortran

BasicCobolAlgol

CC++JavaLISP


状態を書き換えることで計算を進めていく





High-order Functions

Lazy Evaluation

高階関数遅延 (怠惰) 評価


http://www.flickr.com/photos/stevendepolo/5597111652

Functionsas Building Blocks

for constructing programs12Monday, June 13, 2011



http://www.flickr.com/photos/pseudoego/5417919481

Functions as Gluefor bonding functions




http://www.flickr.com/photos/32712959@N07/3222623206

A lot of programming languages

available forfunctional programming




C でもVB でもPHP でも


関数型言語を使う理由はプログラムを関数型のやり方で自然に記述するため


自然だから脳を邪魔しない



高階関数


例リスト処理


リスト処理を最も得意とする言語は LISP ではなく関数型言語である


Haskell での線形リストは [ と ] で囲み、要素をカンマで区切って並べる。

e.g. [] [1, 2, 3]

この表記は糖衣構文であり、内部ではコロン演算子 (:) で要素をひとつずつ結合させ、末尾に空リストを置く表記に変換されている。

e.g. [1] => 1 : [] [1, 2, 3] => 1 : 2 : 3 : []


リストを構築するコロン演算 (:) は、LISP では cons 関数に対応する。

cons をあえて Haskell で関数として定義すると以下のようになる。

cons :: a -> [a] -> [a] -- 型宣言cons x [] = [x] -- 関数の本体cons x1 (x2:xs) = x1 : (cons x2 xs)


cons :: a -> [a] -> [a] -- 型宣言

cons x [] = [x] -- 関数の本体cons x1 (x2:xs) = x1 : (cons x2 xs)

// 型宣言を C++ で書くとtemplate <typename a>std::list<a>cons(a const& x, std::list<a> const& xs);

引数返り値

第1引数↓

第2引数↓


cons :: a -> [a] -> [a] -- 型宣言

cons x [] = [x] -- 関数の本体cons x1 (x2:xs) = x1 : (cons x2 xs)

e.g. cons 0 [1,2,3,4] => x1 は 0, x2 は 1, xs は [2,3,4]

引数返り値

第1引数↓

第2引数↓

リストパターン: リスト型の値を分解し各変数へ束縛する


引数で与えられた整数 (Int) のリストについて、全要素の総和を求める関数 sum は以下のようになる。

sum :: [Int] -> Intsum [] = 0sum (n:ns) = n + (sum ns)


cons と sum を比較してみよう。

cons :: a -> [a] -> [a]cons x [] = [x]cons x1 (x2:xs) = x1 : (cons x2 xs)

sum :: [Int] -> Intsum [] = 0sum (n:ns) = n + (sum ns)

共通のパターンが見えませんか？


cons x [] = [x]sum [] = 0

cons x1 (x2:xs) = x1 : (cons x2 xs)sum (n :ns) = n + (sum ns)

似てるでしょ？


引数で与えられた整数 (Int) のリストについて、全要素の総積を求める関数 product は以下のようになる。

product :: [Int] -> Intproduct [] = 1product (n:ns) = n * product ns


cons x [] = [x]sum [] = 0product [] = 1

cons x1 (x2:xs) = x1 : (cons x2 xs)sum (n :ns) = n + (sum ns)product (n :ns) = n * (product ns)



引数で与えられた真偽値 (Bool) のリストについて、全要素の論理積を求める関数 allTrue は以下のようになる。

allTrue :: [Bool] -> BoolallTrue [] = TrueallTrue (b:bs) = b && allTrue ns


引数で与えられた真偽値 (Bool) のリストについて、全要素の論理和を求める関数 anyTrue は以下のようになる。

anyTrue :: [Bool] -> BoolanyTrue [] = FalseanyTrue (b:bs) = b || anyTrue ns


cons x [] = [x]sum [] = 0product [] = 1allTrue [] = TrueanyTrue [] = False

cons x1 (x2:xs) = x1 : (cons x2 xs)sum (n :ns) = n + (sum ns)product (n :ns) = n * (product ns)allTrue (b :bs) = b && (allTrue bs)anyTrue (b :bs) = b || (anyTrue bs)



cons x [] = [x]sum [] = 0product [] = 1allTrue [] = TrueanyTrue [] = False

cons x1 (x2:xs) = x1 : (cons x2 xs)sum (n :ns) = n + (sum ns)product (n :ns) = n * (product ns)allTrue (b :bs) = b && (allTrue bs)anyTrue (b :bs) = b || (anyTrue bs)


各関数に固有の値は以下の3つ関数名空リストに対する値演算子


関数固有の値をパラメータとする関数を抽出

reduce :: (a -> [a] -> a) -> a -> [a] -> areduce f x0 [] = x0reduce f x0 (x1:xs) = f x1 (reduce f x0 xs)

この関数を使うと以下のように書き換えられる。

sum = reduce (+) 0product = reduce (*) 1allTrue = reduce (&&) TrueanyTrue = reduce (||) False











引数が足りない → 部分適用






引数が足りない → 部分適用足りない引数を受け取る関数になる (カリー化)


cons と reduce を使うとリストの結合を作れる

append :: [a] -> [a] -> [a]append xs ys = reduce (:) ys xs

展開すれば分かる

append [1,2] [3,4]-> reduce (:) [3,4] [1,2]-> reduce (:) [3,4] (1:2:[])-> 1 : (reduce (:) [3,4] (2:[]))-> 1 : 2 : (reduce (:) [3,4] [])-> 1 : 2 : [3,4]-> [1,2,3,4]


Haskell (関数型言語) はリスト処理を LISP なんかよりも随分と素直に表現できている


関数が勝手にカリー化される


高階関数を自然に使える












非関数型言語でも同じ考え方は流用できる


-- Haskellreduce (+) 0 [1..10]

// C++int ns[] = {1,2,3,4,5,6,7,8,9,10};std::accumulate(ns, ns + 10, 0, &std::plus<int>);

# Ruby[*1..10].inject(0, :+)


関数型言語は自然だから脳を邪魔しない


Lazy Evaluation

遅延 (怠惰) 評価


関数型プログラミングの真髄


無限を手玉に取る力


http://www.sampou.org/haskell/article/whyfp.html46Monday, June 13, 2011

http://www.sampou.org/haskell/article/whyfp.html

http://www.sampou.org/haskell/article/whyfp.html

http://www.infoq.com/interviews/john-hughes-fp47Monday, June 13, 2011

http://www.infoq.com/interviews/john-hughes-fp

http://www.infoq.com/interviews/john-hughes-fp

http://weblog.raganwald.com/2007/03/why-why-functional-programming-matters.html48Monday, June 13, 2011

http://weblog.raganwald.com/2007/03/why-why-functional-programming-matters.html

http://weblog.raganwald.com/2007/03/why-why-functional-programming-matters.html

language evaluation pureness

Haskell lazy pure

Concurrent Clean lazy pure

OCaml strict impure

F# strict impure

Scheme strict impure


language evaluation pureness

Haskell lazy pure

Concurrent Clean lazy pure

OCaml strict impure

F# strict impure

Scheme strict impure


おさらい


2010年3月1日月曜日 52Monday, June 13, 2011





A lot of programming languages

available forfunctional programming




関数型言語を使う理由はプログラムを関数型のやり方で自然に記述するため



高階関数












Lazy Evaluation

遅延 (怠惰) 評価


無限を手玉に取る力


Education

関数型プログラミングの世界