einblickerの日記

「ランタイムのチェックを一度で済ます」を存在型で

Scala | 23:33 |

型レベルString - いじわるだねっ

ランタイムのチェックを一度で済ます - EAGLE 雑記

こういうテクニック面白い。

ただ、ランタイムチェックを一度で済ませるというだけなら、依存型っぽい物を作らなくても存在型を使えば似たようなことが出来そうだなーと思ったのでやってみました。Scalaで。

import scalaz._
import Scalaz._

type Stuff = List[Int]
case class Thing(id: String, stuff: Stuff)

type Result = (A, A, Show[A], Monoid[A]) forSome { type A }

def eqIdCheck(x: Thing, y: Thing): Option[Result] = {
  if (x.id == y.id)
    Some((
      x, y,
      new Show[Thing] {
        def show(a: Thing) = a.toString.show
      },
      new Monoid[Thing] {
        val zero = Thing(x.id, Nil)
        def append(s1: Thing, s2: => Thing) = Thing("id1", s1.stuff ::: s2.stuff)
      }
    ))
  else
    None
}

val result1 = eqIdCheck(Thing("id1", List(1)), Thing("id1", List(2)))

result1.get match {
  case (a, b, s, m) =>
    implicit val (show, monoid) = (s, m)
    (a |+| b |+| b).println
    val x = Thing("id1", List(10))
    //(a |+| x).println //idが同じでも、まだeqIdCheckでチェックされていないのでコンパイルエラー
}

val result2 = eqIdCheck(Thing("id2", List(10)), Thing("id2", List(20)))

result1.get match {
  case (a1, b1, s1, m1) =>
    implicit val (show1, monoid1) = (s1, m1)
    result2.get match {
      case (a2, b2, s2, m2) =>
        implicit val (show2, monoid2) = (s2, m2)
        (a1 |+| b1).println
        (a2 |+| b2).println
        //(a1 |+| b2).println //異なるeqIdCheckの呼び出しで得られたThingをappendしようとするとコンパイルエラー
    }
}

aとxは異なる型の値だとコンパイラが認識してくれるので、|+|を適用するところでコンパイルエラーにしてくれる！　スゴイ！　implicit valを一々作らないといけないのがちょっとダサいけれども…。

zipWithの方も同じような感じでできました。

type ZipWith[A[_], T] = { type Apply[U] = ((T, T) => U) => (A[T], A[T]) => A[U] }
type Result[T] = (A[T], A[T], Show[A[T]], Forall[ZipWith[A, T]#Apply]) forSome { type A[_] }

def sameLength[T](xs: List[T], ys: List[T]): Option[Result[T]] = {
  if (xs.length == ys.length)
    Some((
      xs, ys,
      new Show[List[T]]{
        def show(a: List[T]) = a.toString.show
      },
      new Forall[ZipWith[List, T]#Apply]{
        def apply[U] = (f: (T, T) => U) =>
          (_: List[T]).zip(_: List[T]).map{case (a, b) => f(a, b)}
      }
    ))
  else
    None
}

sameLength(List(1, 2), List(3, 4)).get match {
  case (a1, b1, s1, zip1) =>
    implicit val show1 = s1
    sameLength(List(10, 20, 30), List(40, 50, 60)).get match {
      case (a2, b2, s2, zip2) =>
        implicit val show2 = s2
        zip1[Int](_ + _)(a1, b1).println
        zip2[Int](_ + _)(a2, b2).println
        //zip1[Int](_ + _)(a1, List(3, 4)).println //これはコンパイルエラー
        //zip2[Int](_ + _)(a1, b2).println //これもコンパイルエラー
    }
}

やはりimplicit valを書くのがちょっと不細工。出来ればこんなふうに書きたい。

//こう書いたら
hoge match {
  case (foo, implicit bar) => 
    fugafuga
}
//↓これと同じ意味になる
hoge match {
  case (foo, _bar) =>
    implicit val bar = _bar
    fugafuga
}

Scala2.10 以降に入るかもしれない機能まとめ - scalaとか・・・で紹介されているmacroがあれば出来るのかなぁ。現状でもコンパイラプラグインを使うと出来そうだけれど敷居が高そうな気が。

追記：

わざわざShowクラスのインスタンスを作らなくてもprintln関数の適用はできる（引数がAny型の関数に存在型の値を適用可能）みたいですね…。もうちょっと綺麗に書けそうなので、sameLengthの方を書きなおしてみました。

sameLength — Gist

追記２：

今更ながら推移関係が成り立つ版も書いてみた。

sameLength(4) — Gist

けどScalaの存在型が変な挙動をするのでちょっと微妙な書き方になってしまった。恐らくScalaでは存在型が必要な場面では代わりに抽象メンバーとパス依存型を使うことが推奨されているのだと思われる。のでそのことを後日記事に纏めたい…。