5 分ではわからない HM 型推論 - わいわいswiftc 2020 4/20

5 分ではわからない HM 型推論 - わいわいswiftc 2020 4/20

191e95d4b1db10818fa15181dad4ddd2?s=128

Biacco42

April 20, 2020
Tweet

Transcript

  1. 5 分ではわからない HM 型推論 in わいわいswiftcオンライン Biacco42

  2. 4/17 に行われた 型システム祭りオンライン での LT 発表の拡大版になります。 https://opt.connpass.com/event/169724/

  3. プログラミング言語の基礎概念 [五十嵐淳 サイエンス社 2011] だいたいこれの 8 章 〜 10 章

    https://amzn.to/2XOsC4N
  4. お話すること • 型システムの具体的実装例であ ることが多い ML の構文の ごく簡単な説明 • 型システムに関する表現の ごく簡単な説明

    • HM 型推論のざっくりした アルゴリズム • let 多相の実現法の概念 • ML の導出・推論規則 • 定理と証明 • 具体的な実装 しないこと
  5. お話すること • 型システムの具体的実装例であ ることが多い ML の構文の ごく簡単な説明 • 型システムに関する表現の ごく簡単な説明

    • HM 型推論のざっくりした アルゴリズム • let 多相の実現法の概念 • ML の導出・推論規則 • 定理と証明 • 具体的な実装 しないこと
  6. 5 分では説明しようがなかった なのでだいぶ天下り・省略した説明をして ML や型システムに関する文章が 雰囲気で読めるところを目指す

  7. 問題:自動で型をつけたい let f = fun x -> x + 1

    in f 問:この式の返す値の型は?
  8. 問題:自動で型をつけたい let f = fun x -> x + 1

    in f 問:この式の返す値の型は? ML 風の式 全ては式でありある値に評価できる
  9. 問題:自動で型をつけたい let f = fun x -> x + 1

    in f 問:この式の返す値の型は? 変数宣言みたいなやつ
  10. 問題:自動で型をつけたい let f = fun x -> x + 1

    in f 問:この式の返す値の型は? in の後ろで別名が使える
  11. 問題:自動で型をつけたい let f = fun x -> x + 1

    in f 問:この式の返す値の型は? 関数定義
  12. 問題:自動で型をつけたい let f = fun x -> x + 1

    in f 問:この式の返す値の型は? 引数
  13. 問題:自動で型をつけたい let f = fun x -> x + 1

    in f 問:この式の返す値の型は? 本体 (式) 引数をパラメタとして使える
  14. 問題:自動で型をつけたい let f = fun x -> x + 1

    in f `+` は int -> int -> int => x: int
  15. 問題:自動で型をつけたい let f = fun x -> x + 1

    in f `+` は int -> int -> int => x: int `x + 1` より fun x -> x + 1: int -> int
  16. 問題:自動で型をつけたい let f = fun x -> x + 1

    in f `+` は int -> int -> int => x: int `x + 1` より fun x -> x + 1: int -> int `fun x -> x + 1` よりこの式全体の型は f: int -> int
  17. 問題:自動で型をつけたい (2) let id = fun x -> x in

    If id false then 1 else id 2 問:この式の返す値の型は?
  18. 問題:自動で型をつけたい (2) let id = fun x -> x in

    If id false then 1 else id 2 `id` は bool -> bool
  19. 問題:自動で型をつけたい (2) let id = fun x -> x in

    If id false then 1 else id 2 `id` は bool -> bool `id` は bool -> bool
  20. 型推論の定式化 https://en.wikipedia.org/wiki/Hindley%E2%80%93Milner_type_system

  21. ???????

  22. 型推論の定式化 https://en.wikipedia.org/wiki/Hindley%E2%80%93Milner_type_system 項 (Exp) の表現

  23. 型推論の定式化 https://en.wikipedia.org/wiki/Hindley%E2%80%93Milner_type_system 項 (Exp) の表現 型変数 (型推論中の仮説)

  24. 型推論の定式化 https://en.wikipedia.org/wiki/Hindley%E2%80%93Milner_type_system 項 (Exp) の表現 型変数 (型推論中の仮説) 型環境と型付け

  25. 型推論の定式化 https://en.wikipedia.org/wiki/Hindley%E2%80%93Milner_type_system 項 (Exp) の表現 型変数 (型推論中の仮説) 型環境と型付け 型代入 (Substitution)

  26. 型推論の定式化 https://en.wikipedia.org/wiki/Hindley%E2%80%93Milner_type_system 項 (Exp) の表現 型変数 (型推論中の仮説) 型環境と型付け 型代入 (Substitution)

    これがしたい
  27. 型変数と型スキームと型環境 https://en.wikipedia.org/wiki/Hindley%E2%80%93Milner_type_system 型環境 Γ のもとで

  28. 型変数と型スキームと型環境 型環境 Γ のもとで項 e が型変数 σ に型付けできる

  29. 型変数と型スキームと型環境

  30. 型変数と型スキームと型環境 σ は τ (型変数・型コンストラクタ) or

  31. 型変数と型スキームと型環境 σ は τ (型変数・型コンストラクタ) or 型スキーム

  32. 補:型スキーム α は全称量化された型変数 型スキームの引数のようなもの

  33. 補:型スキーム σ は型スキームの実体 ex: α -> α つまりはだいたい λ 抽象と同じ

  34. 型変数と型スキームと型環境 σ は τ (型変数・型コンストラクタ) or 型スキーム

  35. 型変数と型スキームと型環境 Γ は空集合 or σ は τ (型変数・型コンストラクタ) or 型スキーム

  36. 型変数と型スキームと型環境 Γ は空集合 or Γ に x: σ の型スキームを 加えたもの

    (再帰的定義) σ は τ (型変数・型コンストラクタ) or 型スキーム
  37. 型変数と型スキームと型環境 項 e は型環境 Γ によって提供されるある型変数 x を 型スキーム σ’

    として与えた場合に 型 (スキーム) σ に評価できる
  38. σ って具体的な型なの?

  39. 型代入 (Substitution) 型代入 S は型環境や型スキーム中の 型変数を τ i に置き換える

  40. 型代入 (Substitution) 型代入 S は型環境や型スキーム中の 型変数を τ i に置き換える 型環境に型代入

    S を適用した型環境では 項 e が型代入 S を適用した型 (スキーム) Sσ に型付けできる
  41. 型代入 (Substitution) 型代入 S は型環境や型スキーム中の 型変数を τ i に置き換える 型環境に型代入

    S を適用した型環境では 項 e が型代入 S を適用した型 (スキーム) Sσ に型付けできる いい感じの型代入 S を見つけると具体的な型が定まる
  42. 【再掲】問題:自動で型をつけたい let f = fun x -> x + 1

    in f `+` は int -> int -> int => x: int `x + 1` より fun x -> x + 1: int -> int `fun x -> x + 1` よりこの式全体の型は f: int -> int
  43. 【再掲】問題:自動で型をつけたい let f = fun x -> x + 1

    in f `+` は int -> int -> int => x: int `x + 1` より fun x -> x + 1: int -> int `fun x -> x + 1` よりこの式全体の型は f: int -> int 型に関する連立方程式としてみれる = 型の仮定を置き換えていく = 連立方程式を解く型代入 S をさがす!
  44. 型付けのアルゴリズム:項の定義 abstract class Term {} case class Var(x: String) extends

    Term {} case class Lam(x: String, e: Term) extends Term {} case class App(f: Term, e: Term) extends Term {} case class Let(x: String, e: Term, f: Term) extends Term {}
  45. 型付けのアルゴリズム:項の定義 abstract class Term {} case class Var(x: String) extends

    Term {} 型変数 case class Lam(x: String, e: Term) extends Term {} case class App(f: Term, e: Term) extends Term {} case class Let(x: String, e: Term, f: Term) extends Term {}
  46. 型付けのアルゴリズム:項の定義 abstract class Term {} case class Var(x: String) extends

    Term {} 型変数 case class Lam(x: String, e: Term) extends Term {} ラムダ式 case class App(f: Term, e: Term) extends Term {} case class Let(x: String, e: Term, f: Term) extends Term {}
  47. 型付けのアルゴリズム:項の定義 abstract class Term {} case class Var(x: String) extends

    Term {} 型変数 case class Lam(x: String, e: Term) extends Term {} ラムダ式 case class App(f: Term, e: Term) extends Term {} 関数適用 case class Let(x: String, e: Term, f: Term) extends Term {}
  48. 型付けのアルゴリズム:項の定義 abstract class Term {} case class Var(x: String) extends

    Term {} 型変数 case class Lam(x: String, e: Term) extends Term {} ラムダ式 case class App(f: Term, e: Term) extends Term {} 関数適用 case class Let(x: String, e: Term, f: Term) extends Term {} let 式
  49. 型付けのアルゴリズム:項の定義 abstract class Term {} case class Var(x: String) extends

    Term {} 型変数 case class Lam(x: String, e: Term) extends Term {} ラムダ式 case class App(f: Term, e: Term) extends Term {} 関数適用 case class Let(x: String, e: Term, f: Term) extends Term {} let 式 ex: λx. cons x nil = Lam("x", App(App(Var("cons"), Var("x")), Var("nil")))
  50. 型付けのアルゴリズム:S を探す def tp(env: Env, e: Term, t: Type, s:

    Subst): Subst = { e match { case Var(x) => // 型変数の場合 val u = lookup(env, x) unifier(u.newInstance, t, s) case Lam(x, e1) => // ラムダ式 val a, b = newTyvar() val s1 = unifier(t, Arrow(a, b), s) val env1 = {x, TypeScheme(List(), a)} :: env tp(env1, e1, b, s1) } case App(e1, e2) => // 関数適用 val a = newTyvar() val s1 = tp(env, e1, Arrow(a, t), s) tp(env, e2, a, s1) case Let(x, e1, e2) => // let 式 val a = newTyvar() val s1 = tp(env, e1, a, s) tp({x, gen(env, s1(a))} :: env, e2, t, s1)
  51. 型付けのアルゴリズム:S を探す def tp(env: Env, e: Term, t: Type, s:

    Subst): Subst = { e match { case Var(x) => // 型変数の場合 val u = lookup(env, x) unifier(u.newInstance, t, s) case Lam(x, e1) => // ラムダ式 val a, b = newTyvar() val s1 = unifier(t, Arrow(a, b), s) val env1 = {x, TypeScheme(List(), a)} :: env tp(env1, e1, b, s1) } case App(e1, e2) => // 関数適用 val a = newTyvar() val s1 = tp(env, e1, Arrow(a, t), s) tp(env, e2, a, s1) case Let(x, e1, e2) => // let 式 val a = newTyvar() val s1 = tp(env, e1, a, s) tp({x, gen(env, s1(a))} :: env, e2, t, s1) 式の AST を手繰る
  52. 型付けのアルゴリズム:S を探す def tp(env: Env, e: Term, t: Type, s:

    Subst): Subst = { e match { case Var(x) => // 型変数の場合 val u = lookup(env, x) unifier(u.newInstance, t, s) case Lam(x, e1) => // ラムダ式 val a, b = newTyvar() val s1 = unifier(t, Arrow(a, b), s) val env1 = {x, TypeScheme(List(), a)} :: env tp(env1, e1, b, s1) } case App(e1, e2) => // 関数適用 val a = newTyvar() val s1 = tp(env, e1, Arrow(a, t), s) tp(env, e2, a, s1) case Let(x, e1, e2) => // let 式 val a = newTyvar() val s1 = tp(env, e1, a, s) tp({x, gen(env, s1(a))} :: env, e2, t, s1) 再帰的な項の探索
  53. 型付けのアルゴリズム:S を探す def tp(env: Env, e: Term, t: Type, s:

    Subst): Subst = { e match { case Var(x) => // 型変数の場合 val u = lookup(env, x) unifier(u.newInstance, t, s) case Lam(x, e1) => // ラムダ式 val a, b = newTyvar() val s1 = unifier(t, Arrow(a, b), s) val env1 = {x, TypeScheme(List(), a)} :: env tp(env1, e1, b, s1) } case App(e1, e2) => // 関数適用 val a = newTyvar() val s1 = tp(env, e1, Arrow(a, t), s) tp(env, e2, a, s1) case Let(x, e1, e2) => // let 式 val a = newTyvar() val s1 = tp(env, e1, a, s) tp({x, gen(env, s1(a))} :: env, e2, t, s1) 連立方程式 e1: a -> t の導入
  54. 型付けのアルゴリズム:S を探す def tp(env: Env, e: Term, t: Type, s:

    Subst): Subst = { e match { case Var(x) => // 型変数の場合 val u = lookup(env, x) unifier(u.newInstance, t, s) case Lam(x, e1) => // ラムダ式 val a, b = newTyvar() val s1 = unifier(t, Arrow(a, b), s) val env1 = {x, TypeScheme(List(), a)} :: env tp(env1, e1, b, s1) } case App(e1, e2) => // 関数適用 val a = newTyvar() val s1 = tp(env, e1, Arrow(a, t), s) tp(env, e2, a, s1) case Let(x, e1, e2) => // let 式 val a = newTyvar() val s1 = tp(env, e1, a, s) tp({x, gen(env, s1(a))} :: env, e2, t, s1) 単一化 再帰的な項の探索
  55. 単一化?

  56. 型付けのアルゴリズム:S を探す def tp(env: Env, e: Term, t: Type, s:

    Subst): Subst = { e match { case Var(x) => // 型変数の場合 val u = lookup(env, x) unifier(u.newInstance, t, s) case Lam(x, e1) => // ラムダ式 val a, b = newTyvar() val s1 = unifier(t, Arrow(a, b), s) val env1 = {x, TypeScheme(List(), a)} :: env tp(env1, e1, b, s1) } case App(e1, e2) => // 関数適用 val a = newTyvar() val s1 = tp(env, e1, Arrow(a, t), s) tp(env, e2, a, s1) case Let(x, e1, e2) => // let 式 val a = newTyvar() val s1 = tp(env, e1, a, s) tp({x, gen(env, s1(a))} :: env, e2, t, s1) 単一化 = 連立方程式の両辺が等しくなる解を探す
  57. 単一化:HM 型システムの中心 def unifier(t: Type, u: Type, s: Subst): Subst

    = (s(t), s(u)) match { case (Tyvar(a), Tyvar(b)) if (a == b) => s case (Tyvar(a), _) if !(tyvars(u) contains a) => s.extend(Tyvar(a), u) case (_, Tyvar(a)) => unifier(u, t, s) } case (Arrow(t1, t2), Arrow(u1, u2)) => unifier(t1, u1, unifier(t2, u2, s)) case (Tycon(k1, ts), Tycon(k2, us)) if (k1 == k2) => (ts zip us).foldLeft(s)((s, tu) => unifier(tu._1, tu._2, s)) case _ => throw new TypeError 型代入 S の元で型変数 t と u が同じになるような より拡張した型代入 S’ を探す = 単一化
  58. 単一化:HM 型システムの中心 def unifier(t: Type, u: Type, s: Subst): Subst

    = (s(t), s(u)) match { case (Tyvar(a), Tyvar(b)) if (a == b) => s case (Tyvar(a), _) if !(tyvars(u) contains a) => s.extend(Tyvar(a), u) case (_, Tyvar(a)) => unifier(u, t, s) } case (Arrow(t1, t2), Arrow(u1, u2)) => unifier(t1, u1, unifier(t2, u2, s)) case (Tycon(k1, ts), Tycon(k2, us)) if (k1 == k2) => (ts zip us).foldLeft(s)((s, tu) => unifier(tu._1, tu._2, s)) case _ => throw new TypeError 同じ型変数ならなにもしない
  59. 単一化:HM 型システムの中心 def unifier(t: Type, u: Type, s: Subst): Subst

    = (s(t), s(u)) match { case (Tyvar(a), Tyvar(b)) if (a == b) => s case (Tyvar(a), _) if !(tyvars(u) contains a) => s.extend(Tyvar(a), u) case (_, Tyvar(a)) => unifier(u, t, s) } case (Arrow(t1, t2), Arrow(u1, u2)) => unifier(t1, u1, unifier(t2, u2, s)) case (Tycon(k1, ts), Tycon(k2, us)) if (k1 == k2) => (ts zip us).foldLeft(s)((s, tu) => unifier(tu._1, tu._2, s)) case _ => throw new TypeError 片方が型変数のときそれを相手の型での置き換えるように 型環境を拡張する
  60. 単一化:HM 型システムの中心 def unifier(t: Type, u: Type, s: Subst): Subst

    = (s(t), s(u)) match { case (Tyvar(a), Tyvar(b)) if (a == b) => s case (Tyvar(a), _) if !(tyvars(u) contains a) => s.extend(Tyvar(a), u) case (_, Tyvar(a)) => unifier(u, t, s) } case (Arrow(t1, t2), Arrow(u1, u2)) => unifier(t1, u1, unifier(t2, u2, s)) case (Tycon(k1, ts), Tycon(k2, us)) if (k1 == k2) => (ts zip us).foldLeft(s)((s, tu) => unifier(tu._1, tu._2, s)) case _ => throw new TypeError 関数適用ならそれぞれの引数と返り値が同じになるように 型代入を拡張する
  61. 単一化:HM 型システムの中心 def unifier(t: Type, u: Type, s: Subst): Subst

    = (s(t), s(u)) match { case (Tyvar(a), Tyvar(b)) if (a == b) => s case (Tyvar(a), _) if !(tyvars(u) contains a) => s.extend(Tyvar(a), u) case (_, Tyvar(a)) => unifier(u, t, s) } case (Arrow(t1, t2), Arrow(u1, u2)) => unifier(t1, u1, unifier(t2, u2, s)) case (Tycon(k1, ts), Tycon(k2, us)) if (k1 == k2) => (ts zip us).foldLeft(s)((s, tu) => unifier(tu._1, tu._2, s)) case _ => throw new TypeError 型コンストラクタならそれぞれの要素の型が同一になるよう 型環境を拡張
  62. 【再掲】型付けのアルゴリズム:S を探す def tp(env: Env, e: Term, t: Type, s:

    Subst): Subst = { e match { case Var(x) => // 型変数の場合 val u = lookup(env, x) unifier(u.newInstance, t, s) case Lam(x, e1) => // ラムダ式 val a, b = newTyvar() val s1 = unifier(t, Arrow(a, b), s) val env1 = {x, TypeScheme(List(), a)} :: env tp(env1, e1, b, s1) } case App(e1, e2) => // 関数適用 val a = newTyvar() val s1 = tp(env, e1, Arrow(a, t), s) tp(env, e2, a, s1) case Let(x, e1, e2) => // let 式 val a = newTyvar() val s1 = tp(env, e1, a, s) tp({x, gen(env, s1(a))} :: env, e2, t, s1) 単一化 再帰的な項の探索
  63. 型付けのアルゴリズム:S を探す def tp(env: Env, e: Term, t: Type, s:

    Subst): Subst = { e match { case Var(x) => // 型変数の場合 val u = lookup(env, x) unifier(u.newInstance, t, s) case Lam(x, e1) => // ラムダ式 val a, b = newTyvar() val s1 = unifier(t, Arrow(a, b), s) val env1 = {x, TypeScheme(List(), a)} :: env tp(env1, e1, b, s1) } case App(e1, e2) => // 関数適用 val a = newTyvar() val s1 = tp(env, e1, Arrow(a, t), s) tp(env, e2, a, s1) case Let(x, e1, e2) => // let 式 val a = newTyvar() val s1 = tp(env, e1, a, s) tp({x, gen(env, s1(a))} :: env, e2, t, s1) 項を手繰りながら 連立方程式を立てつつ => 単一化で再帰的に解く
  64. 【再掲】問題:自動で型をつけたい (2) let id = fun x -> x in

    If id false then 1 else id 2 `id` は bool -> bool `id` は bool -> bool
  65. let 多相 let id = fun x -> x in

    If id false then 1 else id 2 let 式においてのみ型変数の多相性の伝搬を許す
  66. let 多相 let id = fun x -> x in

    If id false then 1 else id 2 let 式においてのみ型変数の多相性の伝搬を許す => 実はすでに登場している型スキーマの   全称量化された型変数がこれ
  67. let 多相 let id = fun x -> x in

    If id false then 1 else id 2 let 式においてのみ型変数の多相性の伝搬を許す => 実はすでに登場している型スキーマの   全称量化された型変数がこれ 'a -> 'a ==> ∀α.α -> α
  68. 型スキームのインスタンス化 全称量化された型変数に具体的な型を適用すること ∀α.α -> α => 'a -> 'a  とか ∀α.α -> α => int

    -> int
  69. 型スキームのインスタンス化 (2) Γ が ∀α.α -> 'b のもとで S {α

    -> τ} のとき SΓ は?   ∀α.α -> 'b => ∀τ.τ -> 'b ?
  70. 型スキームのインスタンス化 (2) Γ が ∀α.α -> 'b のもとで S {α

    -> τ} のとき SΓ は?   ∀α.α -> 'b => ∀τ.τ -> 'b ?
  71. 型スキームのインスタンス化 (2) Γ が ∀α.α -> 'b のもとで S {α

    -> τ} のとき SΓ は? S{α -> τ} ∀α.α -> 'b => S{'a -> τ} ∀'a.'a -> 'b => S{'a -> τ} 'a -> 'b => τ -> 'b 置き換える型変数の名前を変更しても意味は変わらない => α変換
  72. 型付けのアルゴリズム:S を探す def tp(env: Env, e: Term, t: Type, s:

    Subst): Subst = { e match { case Var(x) => // 型変数の場合 val u = lookup(env, x) unifier(u.newInstance, t, s) case Lam(x, e1) => // ラムダ式 val a, b = newTyvar() val s1 = unifier(t, Arrow(a, b), s) val env1 = {x, TypeScheme(List(), a)} :: env tp(env1, e1, b, s1) } case App(e1, e2) => // 関数適用 val a = newTyvar() val s1 = tp(env, e1, Arrow(a, t), s) tp(env, e2, a, s1) case Let(x, e1, e2) => // let 式 val a = newTyvar() val s1 = tp(env, e1, a, s) tp({x, gen(env, s1(a))} :: env, e2, t, s1) 型スキームのインスタンス化
  73. 型付けのアルゴリズム:S を探す def tp(env: Env, e: Term, t: Type, s:

    Subst): Subst = { e match { case Var(x) => // 型変数の場合 val u = lookup(env, x) unifier(u.newInstance, t, s) case Lam(x, e1) => // ラムダ式 val a, b = newTyvar() val s1 = unifier(t, Arrow(a, b), s) val env1 = {x, TypeScheme(List(), a)} :: env tp(env1, e1, b, s1) } case App(e1, e2) => // 関数適用 val a = newTyvar() val s1 = tp(env, e1, Arrow(a, t), s) tp(env, e2, a, s1) case Let(x, e1, e2) => // let 式 val a = newTyvar() val s1 = tp(env, e1, a, s) tp({x, gen(env, s1(a))} :: env, e2, t, s1) newInstance は全称量化された型変数を ある型変数に固定したコピーを作ってからから単一化する
  74. 問題:自動で型をつけたい (2) let id = fun x -> x in

    If id false then 1 else id 2 `id instance #1` は 'a -> 'a `id instance #2` は 'b -> 'b twemoji by Twitter CC BY 4.0
  75. 問題:自動で型をつけたい (2) let id = fun x -> x in

    If id false then 1 else id 2 `id instance #1` は 'a -> 'a => bool -> bool `id instance #2` は 'b -> 'b => int -> int twemoji by Twitter CC BY 4.0
  76. Ref プログラミング言語の基礎概念 [五十嵐淳 サイエンス社 2011] Hindley–Milner type system - Wikipedia

    https://en.wikipedia.org/wiki/Hindley%E2%80%93Milner_type_system#Substitution_in_typings 第 16 章 Hindley/Milner 型推論 - プログラミング言語 Scala 日本語情報サイト https://sites.google.com/site/scalajp/home/documentation/scala-by-example/chapter16 Hindley-Milner型推論アルゴリズムを Groovyで書いてみた http://uehaj.hatenablog.com/entry/2014/02/01/183039 人でもわかる型推論 https://qiita.com/uint256_t/items/7d8c8feeffc03b388825
  77. end twemoji by Twitter CC BY 4.0

  78. @Biacco42