4

我第一次尝试实现一个 reader monad。

我想使用 monadic 样式来查询数据库。

用例 1：用户与同事具有一对一的关系。伪代码是getUserById(getUserById(id).getColleague())

用例 2：按 id 检索用户列表。伪代码是List(getUserById(id1), getUserById(id2))

这似乎是 monad 的好用例。我的目标是看看我是否可以利用 monads 来改进我的代码

PS：请提供至少一个没有scalaz的答案。

这是代码：

package monad
import com.mongodb.casbah.Imports._

object Monad {
  type UserId = Int
  case class User(id: UserId, name: String, colleagueId: UserId)

  trait Reader[I, A] { self =>
    def run(id: I) : A
    def map[B](f: A => B) : Reader[I, B] = 
      new Reader[I, B] { def run(id: I) = f(self.run(id)) }
    def flatMap[B](f: A => Reader[I, B]) : Reader[I, B] =
      new Reader[I, B] { def run(id: I) = f(self.run(id)).run(id) }
  }

  def coll = MongoClient()("test")("user")

  def DBObject2User(o: DBObject) : User = User(o.as[Double]("id").toInt, o.as[String]("name"), o.as[Double]("colleague").toInt)

  // Strange design, id is not used…
  def User2Colleague(u: User) : Reader[UserId, DBObject] = 
    unit(coll.findOne(MongoDBObject("id" -> u.colleagueId)).get)

  def GetUserById : Reader[UserId, DBObject] = 
    Reader { id: UserId => coll.findOne(MongoDBObject("id" -> id)).get }

  def GetUserById2 : Reader[UserId, User] = GetUserById.map(DBObject2User)

  def unit[A](a: => A) = Reader { id: UserId => a }

  object Reader {
    def apply[I, A](f: I => A) = new Reader[I, A] { def run(i: I) = f(i) }
  }

  def main(args: Array[String]) {
    // I can do
    println(GetUserById2.run(1))

    // Same with for comprehension
    val userReader = for (io <- GetUserById2) yield io
    println(userReader.run(1))

    //Combination to explore one-to-one relation
    val user = GetUserById2.run(1)
    val colleague = GetUserById2.run(user.colleagueId)

    // Same with flatMap
    println(GetUserById2.flatMap(User2Colleague).run(1))

    // Same with for-comprehension but doesn't work
    val io = for {io  <- GetUserById2
                  io2 <- User2Colleague(io).map(DBObject2User)} yield io2
    println(io.run(1))

    //TODO: List[Reader] to Reader[List]
  }
}

这是好方法吗？我有一些疑问，请参阅我的评论Strange design

我怎样才能改进我的代码？

4

3 回答 3

3

我试图修改您的建议，使该集合成为读者的输入，并在我进行时重新命名。

package monad
package object reader{
  type UserId = Int
}
package reader {

case class User(id: UserId, name: String, colleagueId: UserId)

import com.mongodb.casbah.Imports._
import com.mongodb.casbah


trait Reader[I, A] {
  self =>
  val run = apply _

  def apply(id:I):A

  def map[B](f: A => B): Reader[I, B] =
    new Reader[I, B] {
      def apply(id: I) = f(self.run(id))
    }

  def flatMap[B](f: A => Reader[I, B]): Reader[I, B] =
    new Reader[I, B] {
      def apply(id: I) = f(self(id)).run(id)
    }
}

object Reader {
  def unit[A](a: => A) = apply {
    id: UserId => a
  }

  def apply[I, A](f: I => A) = new Reader[I, A] {
    def apply(i: I) = f(i)
  }
}

object Users {

  def asUser(o: DBObject): User = User(o.as[Double]("id").toInt, o.as[String]("name"), o.as[Double]("colleague").toInt)

  def colleague(u: User): Reader[MongoCollection, User] =
    Reader{ 
      coll => asUser(coll.findOne(MongoDBObject("id" -> u.colleagueId)).get)
    }

  def getUserById(id:UserId): Reader[MongoCollection, User] =
    Reader {
      coll => asUser(coll.findOne(MongoDBObject("id" -> id)).get)
    }
}

object Client extends App {

  import Users._
  def coll: casbah.MongoCollection = MongoClient()("test")("user")

  // I can do
  println(getUserById(1)(coll))

  // Same with for comprehension
  val userReader = for (user <- getUserById(1)) yield user
  println(userReader(coll))

  //Combination to explore one-to-one relation
  val user = getUserById(1)(coll)
  val otherUser = getUserById(user.colleagueId)(coll)

  // Same with flatMap
  println(getUserById(1).flatMap(colleague)(coll))

  // Same with for-comprehension but doesn't work
  val coworkerReader = for {user <- getUserById(1)
                            coworker <- colleague(user)} yield coworker
  println(coworkerReader(coll))         
}

}

使用这种方法，我认为代码更容易测试，因为您可以传递依赖项（MongoCollection），同时仅操作签名中的值和函数。在http://blog.originate.com/blog/2013/10/21/reader-monad-for-dependency-injection/阅读更多内容（我不是作者，但这是一个明确的解释）

于 2013-10-29T22:32:11.713 回答
3

Reader monad & monad transformers step-by-step + 使用 mongoDB 的例子，这里有很好的描述。

于 2013-11-07T20:22:06.837 回答
2

您的用法还不错，我发现令人困惑的是，通常认为阅读器的配置输入（如数据库连接数据）在这种情况下是正在检查的用户的 id。

首先，我将IO[I,A]名称更改为Reader[I,A]只是为了使用众所周知的名称进行此类操作[*]

至于User2Colleague(u: User) : IO[UserId, DBObject]方法，丢弃阅读器输入以提供包装在 monad 中的常量值并不少见：这正是您的unit方法所做的！

事实上，我会将其更改为

def User2Colleague(u: User) : Reader[UserId, DBObject] = 
  unit(coll.findOne(MongoDBObject("id" -> u.colleagueId)).get)

甚至与您的客户端代码使用更加一致

def User2Colleague(u: User): DBObject = coll.findOne(MongoDBObject("id" -> u.colleagueId)).get
...
def main(args: Array[String]) {
  val mng = new Mongo()

  val io = for {
    io <- mng
    io2 <- unit(DBObject2User(io))
    io3 <- unit(User2Colleague(io2))
  } yield (DBObject2User(io3))

  println(io.run(1))

我的建议是编写尽可能纯的代码（即没有单子效应），除非需要。这意味着在常规函数中进行映射，然后unit仅根据需要进行包装（以便在 for 理解中进行组合类型检查）

[*] 通常的 IO monad 没有输入类型，它只有一个输出类型，通常用于执行用户 I/O（控制台、打印、电子邮件、发送火箭等），即任何具有外部副作用的东西程序本身。

于 2013-10-29T13:58:53.303 回答