Tweet
Tweet

Slide 1

Slide 1 text

Pythonで始めてみよう関数型プログラミング Terajima Satoshi (@meganehouser) PyCon JP 2019 | 17 Sep. 2019

Slide 2

Slide 2 text

お前誰よ Terajima Satoshi @meganehouser 所属 株式会社SQUEEZE Python Django / Django REST framework AngularJS / Angular Meguro.LYAHFGG主催 (すごいHaskell本を原書で読む会) 2

Slide 3

Slide 3 text

私はなぜ関数型プログラミングを愛するよう になったか それは、10年以上前の話 私は前職のSIerでアプリケーション開発をしていた。 動作環境は .NET Framework ⾔語はC#を使っていた 3

Slide 4

Slide 4 text

そこで、素敵なプログラミング⾔語に出会ってしまった 4

Slide 5

Slide 5 text

5

Slide 6

Slide 6 text

F# OCamlの影響を⾊濃く受けた、.NET Framework向けの⾔語 ⼿続型、オブジェクト指向、関数型に対応した強い静的型付けのマ ルチパラダイムプログラミング⾔語 REPLがある コンパイルもスクリプト実⾏も可能 6

Slide 7

Slide 7 text

F#で関数型プログラミングの魅⼒に⽬覚めた 7

Slide 8

Slide 8 text

この発表のゴール 便利な関数型⾔語の機能を知る Pythonを使って関数型⾔語スタイルでプログラミングする⽅法の概 要を知る Pythonで関数型⾔語を実現するパッケージの使い⽅・実現⽅法の概 要を知る 関数型プログラミングを試してみたくなる 8

Slide 9

Slide 9 text

⽬次 関数型プログラミングとは Pythonでの関数型プログラミング実現⽅法 関数型プログラミング機能の紹介 関数合成 関数のカリー化 不変/永続データ構造 パターンマッチ モナド まとめ 9

Slide 10

Slide 10 text

注意 この発表では関数型プログラミングの機能解説のためにPython以外 のソースが豊富に出てきますが... 雰囲気で理解してください 10

Slide 11

Slide 11 text

関数型プログラミングとは

Slide 12

Slide 12 text

関数型プログラミングとは プログラミングパラダイムの⼀つ ⼿続き型プログラミング 命令実⾏の列としてプログラムを記述していくプログラミングスタ イル 関数型プログラミング 複数の式を、関数の適⽤によって組み合わせていくプログラミング スタイル 12

Slide 13

Slide 13 text

関数型⾔語の特徴 データに複数の関数を適⽤するプログラミングスタイル そのため、以下の機能が豊富 特定の⽬的のためのデータ型をユーザが定義する 関数を組み合わせて新たな関数を作る 13

Slide 14

Slide 14 text

関数型プログラミングの例 F#のパイプライン演算⼦ let add x y = x + y // add : int -> int -> int let minus x y = x - y // minus : int -> int -> int let display = printfn "number is %d" // display : int -> unit // パイプライン演算⼦を使⽤しない通常の書き⽅ display(minus 20 (add 5 10)) // パイプライン演算⼦を使⽤した書き⽅ 10 |> add 5 |> minus 20 |> display // => "number is 5" 14

Slide 15

Slide 15 text

Pythonでの関数型プログラミング実現⽅法

Slide 16

Slide 16 text

発表の進捗 関数型プログラミングとは Pythonでの関数型プログラミング実現⽅法 <- Now 関数型プログラミング機能の紹介 関数合成 関数のカリー化 不変/永続データ構造 パターンマッチ モナド まとめ

Slide 17

Slide 17 text

Pythonにおける関数型プログラミング機能の 実現⽅法 1. 標準機能・標準パッケージで実現 2. Pythonコードへのコンパイラによって実現 3. AST変換で実現 4. がんばって3rdパーティパッケージとして実現 17

Slide 18

Slide 18 text

⽅法1. 標準機能・標準パッケージで実現 公式ドキュメントに解説が掲載されている 関数型プログラミング HOWTO — Python 3.7.4 ドキュメント 標準機能・パッケージで関数型スタイルのプログラミングをす る⽅法を解説 iterator, generator itertools functools 18

Slide 19

Slide 19 text

⽅法2. Pythonを⽣成するコンパイラで実現 Pythonの実⾏までの⽣成物 Pythonの⽣成物にコンパイルされる⾔語の例 Pythonコードにコンパイルする⾔語 Coconut PythonのASTにコンパイルする⾔語 Hylang Pythonのbytecodeにコンパイルする⾔語 dg 19

Slide 20

Slide 20 text

Pythonコードにコンパイルするプログラミング⾔語 Coconut Programming Language Pythonと互換性があり、関数型⾔語の便利な機能を追加している # パイプライン演算⼦, 部分適⽤ range(10) |> map$(pow$(?, 2)) |> list # 代数的データ型 data Empty() data Leaf(n) data Node(l, r) # データ型によって適⽤される関数を切り替える機能 def size(Empty()) = 0 addpattern def size(Leaf(n)) = 1 addpattern def size(Node(l, r)) = size(l) + size(r) 出典: http://coconut-lang.org/ 20

Slide 21

Slide 21 text

PythonのASTにコンパイルするプログラミング⾔語 hylang/hy: A dialect of Lisp that's embedded in Python ⽂法はLisp マクロもある defn simple-conversation [] (print "Hello! I'd like to get to know you. Tell me about yourself!") (setv name (input "What is your name? ")) (setv age (input "What is your age? ")) (print (+ "Hello " name "! I see you are " age " years old."))) (simple-conversation) 出典: Tutorial — hy 0.17.0 documentation 21

Slide 22

Slide 22 text

CPython bytecodeにコンパイルするプログラミング⾔語 dg — it's a Python! No, it's a Haskell! Haskellのような⾒た⽬の動的⾔語 Slow. Stupid. Absolutely adorable. import '/asyncio' main = async $ loop -> task = "Hello, {}!".format whatever where await asyncio.sleep 1 whatever = "World" await task loop = asyncio.get_event_loop! loop.run_until_complete $ main loop 出典: https://pyos.github.io/dg/ 22

Slide 23

Slide 23 text

⽅法3. AST変換で実現する MacroPy3 lihaoyi/macropy モジュールのインポートフックでAST変換を⾏うマクロ インポート時に変換が⾛るのでマクロを使⽤したコードは __main__モジュールでは使⽤不可 参照： 30,000ft Overview — MacroPy3 1.1.0 documentation マクロの例として代数的データ型、パターンマッチ等が提供されて いる 23

Slide 24

Slide 24 text

⽅法4. がんばって3rdパーティパッケージとして実現 パッケージをインストールしてimportすればそのままPythonコード で使える 例 fn.py / Pyrsistent / Pampy / typesafe-monad / etc. この発表で取り上げるのはこの⽅法 24

Slide 25

Slide 25 text

関数型プログラミング機能の紹介

Slide 26

Slide 26 text

関数合成 (Function synthesis)

Slide 27

Slide 27 text

発表の進捗 関数型プログラミングとは Pythonでの関数型プログラミング実現⽅法 関数型プログラミング機能の紹介 関数合成 <- Now 関数のカリー化 不変/永続データ構造 パターンマッチ モナド

Slide 28

Slide 28 text

関数を組み合わせて… 例題：複数の割引関数を適⽤した後の価格が⾼額か少額か判定したい apple = ('apple', 300) def discount_by_day(fruit): # 曜⽇によって割引 price = fruit[1] * 0.9 if datetime.now().weekday() in (5, 6) else fruit[1] return fruit[0], price def discount_by_time(fruit): # 時間帯によって割引 price = fruit[1] * 0.9 if datetime.now().hour > 21 else fruit[1] return fruit[0], price def get_price_rank(fruit): # 価格によって価格区分を返す return 'High'if fruit[1] >= 300 else 'Low' 28

Slide 29

Slide 29 text

単純に関数を適⽤する場合の問題点 price_rank = is_high_price(late_discount(week_of_day_discount(apple))) # => 'Low' 関数の呼び出しが⼊れ⼦になって可読性が低い 実⾏の順序と、関数の並び順が逆になっている 29

Slide 30

Slide 30 text

[解決に使うFP機能] 関数合成 2個の関数を合成して新しい1個の関数を作り出す機能 専⽤の演算⼦を使⽤して関数合成を⾏う 処理する順序で関数を並べて定義できるので可読性が⾼い F# での関数合成の例 let add50 x = x + 50 // add50 : int -> int let add100 x = x + 100 // add100 : int -> int let minus100 x = x - 100 // minus100 : int -> int // newFunc : int -> int let newFunc = add50 >> add100 >> minus100 newFunc 10 // => 10 30

Slide 31

Slide 31 text

F#における関数合成の実装 F#などの関数型⾔語では、記号を組み合わせた新たな演算⼦が定義 可能 関数合成の演算⼦も⾔語仕様内で定義することができる let (>>) f g x = g(f x) 31

Slide 32

Slide 32 text

Pythonで関数合成を提供するパッケージ fn.py fnpy/fn.py: Missing features of fp in Python -- active fork of kachayev/fn.py pip3 install fn.py Scalaスタイルのラムダ式 永続データ構造 ストリームと無限シーケンス 関数のカリー化 etc. 32

Slide 33

Slide 33 text

[解決] fn.pyのFクラスで関数合成 fn.F 関数合成と部分適⽤を簡単に使えるようになる関数ラッパークラス 例題を関数合成で書き換えたコード 関数呼び出しの⼊れ⼦がなくなり、関数が呼び出される順序で記載でき る from fn import F apple = ('apple', 300) # 各関数定義は省略 new_func = (F() >> discount_by_day >> discount_by_time >> get_price_rank) print(new_func(apple)) # => 'Low' 33

Slide 34

Slide 34 text

fn.Fの関数合成の実装⽅法 Pythonでは演算⼦は特殊メソッドのオーバーロードによって実現 新たな記号を使⽤した演算⼦を増やすことはできない Fクラスの__rshift__をオーバーロードして >> 演算⼦の機能を上書 きしている class F(object): @classmethod def __compose(cls, f, g): return cls(lambda *args, **kwargs: f(g(*args, **kwargs))) def __ensure_callable(self, f): return self.__class__(*f) if isinstance(f, tuple) else f def __rshift__(self, g): return self.__class__.__compose(self.__ensure_callable(g), self.f) ソース出典: fn.py/func.py at master · fnpy/fn.py 34

Slide 35

Slide 35 text

関数のカリー化 (Curried function)

Slide 36

Slide 36 text

発表の進捗 関数型プログラミングとは Pythonでの関数型プログラミング実現⽅法 関数型プログラミング機能の紹介 関数のカリー化 <- Now 不変/永続データ構造 パターンマッチ モナド

Slide 37

Slide 37 text

関数の引数が増えたら… 例題： rateを引数で指定できるようにする def discount_by_day(rate, fruit): price = fruit[1] * rate if datetime.now().weekday() in (5,6) else fruit[1] return fruit[0], price def discount_by_time(rate, fruit): price = fruit[1] * rate if datetime.now().hour >= 21 else fruit[1] return fruit[0], price def get_price_rank:(fruit): return 'High'if fruit[1] > 300 else 'Low' 37

Slide 38

Slide 38 text

lambda式で対応する場合の問題点 lambda式で、引数が1個の関数にする 簡単な定型的な動作のために追加する⽂字数が多い lambdaって何回もタイプしたくない new_func = (F() >> (lambda fruit: discount_by_day(0.8, fruit)) >> (lambda fruit: discount_by_time(0.8, fruit)) >> get_price_rank) print(new_func(apple)) # => 'Low' 38

Slide 39

Slide 39 text

[解決に使うFP機能] カリー化された関数 F# の関数は、標準でカリー化された関数になっており引数の部分 適⽤ができる 部分適⽤ 複数の引数を必要とする関数に対して、⼀部のみ引数を適⽤するこ とができる 部分適⽤した関数は、残りの引数を必要とする関数になる F#の関数の部分適⽤の例 let add x y = x + y let addFive = add 5 addFive 3 // => 8 39

Slide 40

Slide 40 text

カリー化 カリー化 (currying, カリー化された=curried) とは、複数の引数を とる関数を、引数が「もとの関数の最初の引数」で戻り値が「もと の関数の残りの引数を取り結果を返す関数」であるような関数にす ること（あるいはその関数のこと）である。 [出典] カリー化 - Wikipedia // 3 引数の関数は // (int, int, int) -> int だと普通は考えるが... let add x y z = x + y + z // add: int -> int -> int -> int let add' = add 1 // add': (1) int -> int -> int let add'' = add' 2 // add'': (1) (2) int -> int let result = add'' 3 // result: (1) (2) (3) int // => 6 40

Slide 41

Slide 41 text

Pythonで関数をカリー化を提供するパッケージ fn.pyのcurriedデコレータで関数をカリー化できる >>> from fn.func import curried >>> @curried ... def sum5(a, b, c, d, e): ... return a + b + c + d + e ... >>> sum5(1)(2)(3)(4)(5) 15 >>> sum5(1, 2, 3)(4, 5) 15 出典: https://github.com/fnpy/fn.py#function-currying 41

Slide 42

Slide 42 text

[解決] 割引関数にcurriedデコレータを追加 例題の割引関数をカリー化したコード from fn.func import curried @curried def discount_by_day(rate, fruit): ... @curried def discount_by_time(rate, fruit): ... 42

Slide 43

Slide 43 text

[解決] 割引関数に引数を部分適⽤する 例題の関数合成する関数の引数(rate)を部分適⽤したコード new_func = (F() >> discount_by_day(0.8) >> discount_by_time(0.8) >> get_price_rank) print(new_func(apple)) # => 'Low' lambda式を書く必要がなくなり可読性が上がった 43

Slide 44

Slide 44 text

fn.pyのcurriedの実装⽅法 /fn/func.py#L61-L102 実際はカリー化は⾏なっていない 標準モジュール(functools.partial)を使って引数を部分適⽤している 引数が全て揃った場合は、引数を元の関数に与えて戻り値を returnする 引数が揃っていない場合は、引数を部分適⽤した関数をさらに curriedでラップしてreturnする 44

Slide 45

Slide 45 text

標準モジュールのfunctools.partial 関数に引数の部分適⽤したCallableオブジェクトを返す >>> from functools import partial >>> basetwo = partial(int, base=2) >>> basetwo.__doc__ = 'Convert base 2 string to an int.' >>> basetwo('10010') 18 出典: functools --- ⾼階関数と呼び出し可能オブジェクトの操作 — Python 3.7.4 ドキュメント 45

Slide 46

Slide 46 text

[おまけ] fn.Fクラスの部分適⽤機能 fn.Fは関数合成と部分適⽤を簡単に使えるようになる関数ラッパー クラス new_func = (F() >> (discount_by_day, 0.8) >> (discount_by_time, 0.8) >> get_price_rank) print(new_func(apple)) # => 'Low' 46

Slide 47

Slide 47 text

ここでちょっと休憩 47

Slide 48

Slide 48 text

不変/永続データ構造 (Immutable/Persistent data structure)

Slide 49

Slide 49 text

発表の進捗 関数型プログラミングとは Pythonでの関数型プログラミング実現⽅法 関数型プログラミング機能の紹介 関数のカリー化 不変/永続データ構造 <- Now パターンマッチ モナド まとめ

Slide 50

Slide 50 text

listを操作する関数の問題点 例題： 関数でlistを操作して結果を⽐較する def add_mango(fs: List[str]) -> List[str]: fs.append('mango') return fs def change_from_apple_to_banana(fs: List[str]) -> List[str]: fs[fs.index('apple')] = 'banana' return fs fruits = ['apple', 'melon'] fruits1 = add_mango(fruits) fruits2 = change_from_apple_to_banana(fruits) assert fruits1 != fruits2 # AssertionError !! Pythonの関数は参照渡しのため引数で渡したリストも変更される 関数呼び出しごとにリストをコピーする必要がある 毎回listをコピーする必要があるので⾮効率 50

Slide 51

Slide 51 text

[解決に使⽤するFP機能] 永続データ構造 変更される際に変更前のバージョンを保持するデータ構造 追加・更新・削除操作ごとに新たなオブジェクトが返る データが不変となることで、関数の参照透過性が上がる Clojureでのリスト(ベクター)操作の例 user=> (def foo [0 1 2 3]) #'user/foo user=> (conj foo 7) [0 1 2 3 7] user=> (assoc foo 2 9) [0 1 9 3] user=> (println foo) [0 1 2 3] nil F#も基本的にはデータは不変だが 永続データ的な操作を提供して いない 51

Slide 52

Slide 52 text

参照透過性 ある式が参照透過であるとは、その式をその式の値に置き換えても プログラムの振る舞いが変わらないことを⾔う。 (出典: 参照透過性 - Wikipedia) 純粋関数 引数を受け取って、戻り値を返す以外の副作⽤を持たない参照透過 な関数のことを純粋関数という 純粋関数は、テストしやすい 純粋関数を組み合わせて書かれたロジックは、解釈しやすい 52

Slide 53

Slide 53 text

Pythonで不変・永続データ構造を提供するパッケージ tobgu/pyrsistent Python標準モジュールのlist,tuple,dict,classなどに似せた不変/永 続/関数型のデータ型を提供するパッケージ >>> from pyrsistent import v, pvector >>> v1 = v(1, 2, 3) >>> v2 = v1.append(4) >>> v3 = v2.set(1, 5) >>> v1 pvector([1, 2, 3]) >>> v2 pvector([1, 2, 3, 4]) >>> v3 pvector([1, 5, 3, 4]) 出典: https://pyrsistent.readthedocs.io/en/latest/intro.html#pvector 53

Slide 54

Slide 54 text

[解決] 永続データ構造に置き換える 例題のリスト操作関数を永続データ構造に置き換えたコード from pyrsistent import v, PVector def add_mango(fs: PVector[str]) -> PVector[str]: return fs.append('mango') def change_from_apple_to_banana(fs: PVector[str]) -> PVector[str]: return fs.set(fs.index('apple'), 'banana') fruits = ['apple', 'melon'] fruits1 = add_mango(fruits) fruits2 = change_from_apple_to_banana(fruits) assert fruits1 != fruits2 引数に渡したlistが変更されないことで純粋関数となり使いやすくなった 54

Slide 55

Slide 55 text

Pyrsistentの実装 データの操作時に新しく作成したオブジェクトを返すが、なるべく パフォーマンスがPython標準組み込みのデータ型に⾒劣りしないよ うに気をつけて実装されている C⾔語拡張版も⼊っており、使⽤可能な環境では⾃動的に使⽤され る 55

Slide 56

Slide 56 text

Pyrsistentの実装 (PVectorの例) 32個の値のlistをnodeとする⽊構造を共有している ⼤量データでもデータ操作時、対象データに関連するノードの 再作成のみであとは共有できるため pyrsistent/_pvector.py at master · tobgu/pyrsistent 56

Slide 57

Slide 57 text

パターンマッチ (Pattern matching)

Slide 58

Slide 58 text

発表の進捗 関数型プログラミングとは Pythonでの関数型プログラミング実現⽅法 関数型プログラミング機能の紹介 関数のカリー化 不変/永続データ構造 パターンマッチ <- Now モナド まとめ

Slide 59

Slide 59 text

dictの形によって動作を変えたい… 例題： 予約希望の⼈数構成によって予約割り当てする部屋を変えたい # ⼤⼈と⼦供で予約したい request1 = {'date': '2019-08-10', 'numbers': {'adults': 2, 'children': 2}} # ⼤⼈のみで予約したい request2 = {'date': '2019-08-10', 'numbers': {'adults': 1}} 59

Slide 60

Slide 60 text

dictのkeyの有無の判定で条件分岐する場合の問題点 def reserve(request): num_of_children = request['numbers'].get('children') date_ = request['date'] num_of_adults = request['numbers']['adults'] if num_of_children is None: return reserve_general_room(date, num_of_adults) else: return reserve_familly_room(date, num_of_adults, num_of_children) 関数の実装から、想定されているdictの形式が掴みづらい 60

Slide 61

Slide 61 text

[解決に使⽤するFP機能] パターンマッチ 構造を持つデータを分解し、構成要素を取り出す 構造または分解・取得したデータによって条件分岐を⾏う F#でのパターンマッチの例 type Person = {Name: string; Gender: int} // 1: male, 2: female let genderName person = match person with | { Name=n; Gender=1 } -> n + " is male" | { Name=n; Gender=2 } -> n + " is female" | _ -> "undeterminded" genderName {Name="Taro"; Gender=1} 61

Slide 62

Slide 62 text

Pythonでパターンマッチを提供するパッケージ santinic/pampy: Pampy: The Pattern Matching for Python you always dreamed of. Pythonでは制御構⽂は追加できないので、引数で callback関数を指定する ⽂字列, 数値, tuple, list, dict, dataclass等、様々なデー タ形式でマッチングが可能 from pampy import match, _ input = [1, 2, 3] pattern = [1, 2, _] action = lambda x: f"it's {x}" match(input, pattern, action) 出典: https://github.com/santinic/pampy 62

Slide 63

Slide 63 text

Pampyで複数のパターンを使う場合 match([1,2,3], [1, 2, _], lambda x: f"it's {x}", [9, 9, 9], lambda x: "All nine", _, lambda x: "unmatch", ) pattern, actionのpairを複数書く _ 単体のpatternはどんな値にもmatchするため、デフォルトの actionの定義できる 63

Slide 64

Slide 64 text

[解決] 条件分岐をパターンマッチで書き換える 例題の条件分岐をパターンマッチで書き換えたコード from pampy import match, _ def reserve(request): return match(request, {'date': _, 'numbers': {'adults': _, 'children': _}}, reserve_familly_room, {'date': _, 'numbers': {'adults': _}}, reserve_general_room, ) 想定されるデータ形式が把握しやすい 想定されるデータ形式と、アクションが連続しているので可読性が ⾼い 64

Slide 65

Slide 65 text

Pampyの実装 match_value patternの型を調べる 型ごとにmatching⽤の関数が⽤意されており呼び出す 例えばdictの場合(match_dict) valueがdictではない場合はunmatch key同⼠とvalue同⼠がmatchするか⽐較（⽐較には match_valueを再度呼び出す) patternのdictのkeyかvalueが_の場合は、それぞれ key_extracted, value_extractedとして保持する pampy/pampy.py at master · santinic/pampy 65

Slide 66

Slide 66 text

モナド (Monad)

Slide 67

Slide 67 text

発表の進捗 関数型プログラミングとは Pythonでの関数型プログラミング実現⽅法 関数型プログラミング機能の紹介 関数のカリー化 不変/永続データ構造 パターンマッチ モナド <- Now まとめ

Slide 68

Slide 68 text

Haskell ⾮正格な評価を特徴とする純粋関数型プログラミング⾔語 Haskell の美しさを 知っている⼈は、 ⼈⽣に絶望することはない。 Haskell で世界を変えたい。 「Haskell 教養としての関数型プログラミング」の帯より引⽤ モナドはHaskellで標準ライブラリとして提供され広まった 68

Slide 69

Slide 69 text

モナドとは Haskellを設計したメンバーのひとり、フィリップ・ワドラー⽒いわ く…… 「モナドは単なる⾃⼰関⼿の圏におけるモノイド対象だ よ。何か問題でも？」 69

Slide 70

Slide 70 text

70

Slide 71

Slide 71 text

モナドとは型クラス 型クラスとは データ型をカテゴライズする役割を持つ機能 データ型が実装すべき関数のシグネチャを定義 イメージ的にはオブジェクト指向プログラミングにおけるインター フェース Monadの型クラスの継承関係 この順序で説明するのがメジャーな説明⽅法 71

Slide 72

Slide 72 text

Functor Functorの定義 class Functor f where fmap :: (a -> b) -> f a -> f b Functor則 Functorを実装する際に満たすべき規則 # id でファンクター値を写した場合、ファンクター値が変化してはいけない fmap id = id # 、すべてのファンクター値x に対して以下の等式が成り⽴つ fmap (f . g) x = fmap f (fmap g x) 72

Slide 73

Slide 73 text

Applicative Functor Applicative Functorの定義 class Functor f => Applicative f where pure :: a -> f a (<*>) :: f (a -> b) -> f a -> f b 73

Slide 74

Slide 74 text

Monad Monadの定義 class Applicative m => Monad m where return :: a -> m a (>>=) :: m a -> (a -> m b) -> m b (>>) :: m a -> m b -> m b x >> y = x >>= _ -> y fail :: String -> m a fail :: msg = error msg 74

Slide 75

Slide 75 text

モナド則 モナドを実装するときに満たすべき規則 左恒等性 return x >>= f == f x 右恒等性 m >>= return == m 結合性 (m >>= f) >>= g == m >>= (\x -> f x >>= g) 75

Slide 76

Slide 76 text

モナドの詳しい説明は時間が⾜りないので省 略します 今回はモナドの使い⽅に着⽬して説明します 76

Slide 77

Slide 77 text

改めてモナドとは ⽂脈を持った値について、⽂脈を持たない値について想定した関数を適 ⽤したり、関数を組み合わせたりする関数(演算⼦)を定義した型クラス 77

Slide 78

Slide 78 text

モナドの例 1 「Maybeモナド」 Maybeは値が存在する|存在しない⽂脈を持った型 data Maybe a = Just a | Nothing 例としてx + yが100を超える場合はNothingを返す関数を定義 addLimit :: Int -> Int -> Maybe Int addLimit x y | (x + y) <= 100 = Just(x + y) | otherwise = Nothing 78

Slide 79

Slide 79 text

Maybeモナドのバインド関数 バインド関数 (>>=) 左辺の⽂脈付きの値を、右辺の⽂脈なし引数を取り⽂脈付き値を返す関 数に適⽤する演算⼦ Just 10 >>= addLimit 20 >>= addLimit 30 -- Just 60 Just 20 >>= addLimit 90 >>= addLimit 60 -- Nothing 右辺値がNothingの場合は関数をバイパスしてNothingを返すよう に定義されている 79

Slide 80

Slide 80 text

やっとPythonのモナド typesafe-monad correl/typesafe-monads PyMonadをベースに型アノテーションをつけた Maybeモナド, Listモナド, Resultモナド, Futureモナド, Readerモナ ドを実装 80

Slide 81

Slide 81 text

戻り値が存在しない場合がある関数の組み合わせ 例題： 存在しない可能性のある値を取得する関数の組み合わせ def get_user(user_id: int) -> Optional[User]: try: return User.objects.get(pk=user_id) except DoesNotExist: return None def get_user_photo(user: User) -> Optional[UserPhoto]: try: return UserPhoto.objects.get(user=User) except DoesNotExist: return None def get_photo_datetime(user_photo: UserPhoto) -> datetime: return user_photo.datetime 81

Slide 82

Slide 82 text

普通に組み合わせた場合の問点 user_id = 101 user = get_user(user_id) if user: user_photo = get_user_photo(user) if user_photo: return get_photo_datetime(user_photo) if⽂ごとにネストが深くなってしまう 82

Slide 83

Slide 83 text

[解決] Maybeモナド まずは関数を、⽂脈なしの引数をとって⽂脈ありの戻り値を返す関数に 書き直す from monads.maybe import Maybe, Just, Nothing def get_user(user_id: int) -> Maybe[User]: try: return Just(User.objects.get(pk=user_id)) except DoesNotExist: return Nothing() def get_user_photo(user: User) -> Maybe[UserPhoto]: try: return Just(UserPhoto.objects.get(user=User)) except DoesNotExist: return Nothing() def get_photo_datetime(user_photo: UserPhoto) -> Maybe[datetime]: return Just(user_photo.datetime) 83

Slide 84

Slide 84 text

[解決] Maybeモナド 次に関数をbind関数（bind演算⼦）で結合する Just(101) >> get_user >> get_user_photo >> get_photo_datetime Pythonでは新たな記号を⽤いた演算⼦を作成することはできない typesafe-monadではbind関数を >> に割り当てている Pythonは新たな演算⼦は増やせないのでパッケージ間で使⽤ する記号がかぶりがち 84

Slide 85

Slide 85 text

実装 Functor, Applicative, Monadで必要なメソッド(実装は空)を定義 具体的なモナド(ex. Maybe)でbind関数などのメソッドをオーバー ライドして中⾝を実装 コンテナ型(ex. Just, Nothing)は具体的なモナドを継承 85

Slide 86

Slide 86 text

時間の都合でいろいろ説明を省略したので、 次回は「Pythonで⼀から学ぶモナド」を発表 したいです。 86

Slide 87

Slide 87 text

まとめ

Slide 88

Slide 88 text

関数型プログラミングは… いろいろな便利な機能がある Pythonでのプログラミングでもパッケージを使って利⽤することが できる 楽しい！ 88

Slide 89

Slide 89 text

もっと関数型プログラミングに詳しくなりたい！ 今回、解説できたのは機能やパッケージの使い⽅の⼊り⼝の部分 興味が出てきた⽅はぜひ関数型プログラミング沼に⾶び込み⾒まし ょう Meguro.LYAHFF(すごいHaskell本の原書を読む会) SQUEEZEブースでもお待ちしております 89

Slide 90

Slide 90 text

Let's enjoy Python & Functional Programming !! ご静聴ありがとうございました !!