Scalaz(19)- Monad: \/ - Monad 版本的 Either

  scala标准库提供了一个Either类型,它可以说是Option的升级版。与Option相同,Either也有两种状态:Left和Right,分别对应Option的None和Some,不同的是Left可以返回一个值。我们通常用这个值来表述异常信息。scalaz也提供了自己版本的Either,并用\/来分辨表示,以及两种状态-\/和\/-。我想scalaz特别提供\/是有原因的:\/不单是一种类型,它是一种type class。更重要的是\/是一种Monad,具备了函数组合能力(composibility)。如此能够方便把Either功能整合到FP编程中去。我们先看看\/的定义:scalaz/Either.scala

sealed abstract class \/[+A, +B] extends Product with Serializable {
...
  def isLeft: Boolean =
    this match {
      case -\/(_) => true
      case \/-(_) => false
    }

  /** Return `true` if this disjunction is right. */
  def isRight: Boolean =
    this match {
      case -\/(_) => false
      case \/-(_) => true
    }
...
 /** Return the right value of this disjunction or the given default if left. Alias for `|` */
  def getOrElse[BB >: B](x: => BB): BB =
    this match {
      case -\/(_) => x
      case \/-(b) => b
    }

  /** Return the right value of this disjunction or the given default if left. Alias for `getOrElse` */
  def |[BB >: B](x: => BB): BB =
    getOrElse(x)

  /** Return the right value of this disjunction or run the given function on the left. */
  def valueOr[BB >: B](x: A => BB): BB =
    this match {
      case -\/(a) => x(a)
      case \/-(b) => b
    }

  /** Return this if it is a right, otherwise, return the given value. Alias for `|||` */
  def orElse[AA >: A, BB >: B](x: => AA \/ BB): AA \/ BB =
    this match {
      case -\/(_) => x
      case \/-(_) => this
    }

  /** Return this if it is a right, otherwise, return the given value. Alias for `orElse` */
  def |||[AA >: A, BB >: B](x: => AA \/ BB): AA \/ BB =
    orElse(x)
...

与Option相同:\/也提供了函数来获取运算值(Right[A]),如getOrElse。那么如何获取异常信息呢?可以用swap后再用getOrElse:

  /** Flip the left/right values in this disjunction. Alias for `unary_~` */
  def swap: (B \/ A) =
    this match {
      case -\/(a) => \/-(a)
      case \/-(b) => -\/(b)
    }

  /** Flip the left/right values in this disjunction. Alias for `swap` */
  def unary_~ : (B \/ A) =
    swap

"ah, error!".left[Int].getOrElse("no error")      //> res2: Any = no error
"ah, error!".left[Int].swap.getOrElse("no error") //> res3: String = ah, error!
(~"ah, error!".left[Int]).getOrElse("no error")   //> res4: String = ah, error!

与Option一样,\/也有两种状态:

/** A left disjunction
 *
 * Often used to represent the failure case of a result
 */
final case class -\/[+A](a: A) extends (A \/ Nothing)

/** A right disjunction
 *
 * Often used to represent the success case of a result
 */
final case class \/-[+B](b: B) extends (Nothing \/ B)

\/实现了map和flatMap:

  /** Map on the right of this disjunction. */
  def map[D](g: B => D): (A \/ D) =
    this match {
      case \/-(a)     => \/-(g(a))
      case b @ -\/(_) => b
    }
 /** Bind through the right of this disjunction. */
  def flatMap[AA >: A, D](g: B => (AA \/ D)): (AA \/ D) =
    this match {
      case a @ -\/(_) => a
      case \/-(b) => g(b)
    }

注意flatMap:如果状态为\/- 则连续运算g(b),如果状态为-\/ 则立即停止运算返回-\/状态。这与Option功能相当。我们用for-comprehension来证明:

 1 val epok = for {
 2     a <- \/-(3)
 3     b <- \/-(2)
 4 } yield a + b                                     //> epok  : scalaz.\/[Nothing,Int] = \/-(5)
 5 val epno = for {
 6     a <- \/-(3)
 7     c <- -\/("breaking out...")
 8     b <- \/-(2)
 9 } yield a + b                                     //> epno  : scalaz.\/[String,Int] = -\/(breaking out...)
10 if (epno.isLeft) (~epno).getOrElse("no error")    //> res5: Any = breaking out...

\/在for-comprehension里的运算行为与Option一致。不过这个\/写法比较别扭。\/type class为任何类型提供了注入方法left和right: scalaz.syntax/EitherOps.scala

  final def left[B]: (A \/ B) =
    -\/(self)

  final def right[B]: (B \/ A) =
    \/-(self)
}

trait ToEitherOps { //可以为任何类型A注入方法
  implicit def ToEitherOps[A](a: A) = new EitherOps(a)
}

现在这个for-comprehension可以这样写:

 1 val epok1 = for {
 2     a <- 3.right
 3     b <- 2.right
 4 } yield a + b                                     //> epok1  : scalaz.\/[Nothing,Int] = \/-(5)
 5 val epno1 = for {
 6     a <- 3.right
 7     c <- "breaking out...".left[Int]
 8     b <- 2.right
 9 } yield a + b                                     //> epno1  : scalaz.\/[String,Int] = -\/(breaking out...)
10 if (epno1.isLeft) (~epno1).getOrElse("no error")  //> res6: Any = breaking out...

这样表述是不是清晰直白多了。

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

发表于

我来说两句

0 条评论
登录 后参与评论

相关文章

来自专栏程序员互动联盟

【编程基础】简单理解大小端那些事儿

什么是计算机大小端?简单来说,大小端(Endian)是指数据存储或者传输时的字节序,大小端分大端和小端。 所谓大端(Big-Endian)模式,是指数据的低位(...

2709
来自专栏Python爬虫与算法进阶

学点算法之队列的学习及应用

约瑟夫问题 约瑟夫问题 有 n 个囚犯站成一个圆圈,准备处决。首先从一个人开始,越过k-2个人(因为第一个人已经被越过),并杀掉第k个人。接着,再越过 k-1个...

3507
来自专栏函数式编程语言及工具

SDP(9):MongoDB-Scala - data access and modeling

    MongoDB是一种文件型数据库,对数据格式没有硬性要求,所以可以实现灵活多变的数据存储和读取。MongoDB又是一种分布式数据库,与传统关系数据库不同...

3504
来自专栏GreenLeaves

EF基础知识小记五(一对多、多对多处理)

本文主要讲EF一对多关系和多对多关系的建立 一、模型设计器 1、一对多关系 右键设计器新增关联 ? ? 导航属性和外键属性可修改 2、多对多关系 右键设计器新增...

2498
来自专栏me的随笔

模板方法模式实践

在实际编程中,会经常遇到多个类中的某些方法实现逻辑类似的情况,这时我们可以将这些类中的相同部分抽象到父类中,对于有差异的地方,子类根据自身的实际需求来各自实现。

672
来自专栏JavaQ

不常见的Date使用问题

最近维护老项目,遇到一个遗留的日期传输问题。A系统远程调用B系统获取申请时间字段,B系统接口返回的申请时间是String类型,结果A、B两个系统显示的申请时间不...

3244
来自专栏Java Edge

Netty源码阅读入门实战(八)-解码(更新 ing)

就像很多标准的架构模式都被各种专用框架所支持一样,常见的数据处理模式往往也是目标实现的很好的候选对象,它可以节省开发人员大量的时间和精力。 当然这也适应于本文...

804
来自专栏Spark学习技巧

Flink DataStream编程指南及使用注意事项。

Flink中的DataStream程序是对数据流进行转换的常规程序(例如,过滤,更新状态,定义窗口,聚合)。数据流的最初的源可以从各种来源(例如,消息队列,套接...

8067
来自专栏小樱的经验随笔

BZOJ 2748: [HAOI2012]音量调节【二维dp,枚举】

2748: [HAOI2012]音量调节 Time Limit: 3 Sec  Memory Limit: 128 MB Submit: 2010  Solve...

2563
来自专栏分布式系统进阶

FBString分析与使用FBString简介

简单来说,使用了三层存储策略+内存分配策略+大小端支持,特别是配合使用 jemalloc, 减少磁盘碎片,加快并发下的分配速度和性能。

752

扫码关注云+社区