Lens in Scala

函数式访问器在haskell里被叫做Lens。在面向对象语言里这个没有什么必要，不过作为练习，我们看如何在scala表示van Laarhoven lens.

先给出haskell里的lens类型：

type Lens s a = forall f. Functor f => (a -> f a) -> (s -> f s)

这里有一个全局量词forall f，所以等价的scala lens类型我们得用一个generic函数来表示：

trait Lens[S, A] {
  def apply[F[_] : Functor](l: A => F[A])(s: S) : F[S]
}

上面在语义上，apply函数必须对所有的functor都满足，所以等价于forall f。

有了类型，我们开始加构造器。

haskell的lens构造器：

lens :: (s -> a) -> (s -> a -> s) -> Lens s a
lens getter setter l b = setter b <$> l (getter b)

其实可以证明任何一个lens构造器其实和这个都是等价的，因为((s->a), (s->a->s))和forall f. Functor f => (a -> f a) -> (s -> f s)是等价的。

对应的scala lens构造器：

object Lens {
  def apply[S, A](getter: S => A, setter: S => A => S) = new Lens[S, A] {
    def apply[F[_] : Functor](l: A => F[A])(s: S) : F[S] = {
      val m = implicitly[Functor[F]]
      m.fmap[A, S](l(getter(s)))(setter(s))
    } 
  }
}

有了lens，我们现在要加get和set函数了。

在加这两个函数前，我们需要两个functor： Const和Identity。

这里只给出scala版本的：（haskell版本的可以看这里）

trait Functor[F[_]] {
  def fmap[A, B](a: F[A])(f: A => B) : F[B] 
}

case class Const[A, B](a: A, b: B)

object ConstFunctor {
  implicit def constFunctor[C] = new Functor[({type c[a] = Const[C, a]})#c] {
    def fmap[A, B](a: Const[C, A])(f: A => B) = new Const(a.a, f(a.b))
  }
}

case class Identity[A](a: A)

object IdentityFunctor {
  implicit def identityFunctor = new Functor[Identity] {
    def fmap[A, B](a: Identity[A])(f: A => B) = new Identity(f(a.a))
  }
}

使用Const和Identity，我们可以得到get和set，这里也只给出scala版本的：

trait Lens[S, A] {
  import ConstFunctor._
  import IdentityFunctor._
  def apply[F[_] : Functor](l: A => F[A])(s: S) : F[S]
  def get(s: S) : A = apply[({type C[a] = Const[A, a]})#C]((a: A) => new Const(a, a))(s).a
  def set(s: S, a: A) = apply[Identity]((_: A) => new Identity(a))(s).a
}

好了，最后给个用例：

case class A(a: Int, b: Int)

object Main {
  
  def main(args: Array[String]) {
    val l = Lens1((a: A) => a.a, (a: A) => {(b: Int) => new A(b, a.b)})
    println(l.get(l.set(A(2, 6), 3)))
  }

}