Kotlin(十七)函数式编程<4>

类型代替异常处理

Kotlin里面摒弃强制异常捕获检查机制,再编译时期尽量发现错误

抛出异常做法本身是一种副作用,破坏了“引用透明性”。但是任何程序要对具体错误捕捉并且给出正确反馈,可以利用Monad这种更抽象的数据结构,代替异常处理错误。用类型处理错误,这种方式有一个优点,类型安全。

1. Option 与 OptionT

Kotlin可空类型,某种程度就是利用类型代替Checked Exception来防止NPE(NullPointerException缩写)问题。

@Suppress("UNCHECKED_CAST", "NOTHING_TO_INLINE")
inline fun  Kind.unwrap(): Option =
    this as Option


sealed class Option : Kind {
  object K
}

data class Some(val value: V) : Option()
object None : Option()

Kind 和 Kind 模拟一种高阶类型,用它们可以表示存在值或者空值两种状态。分别对应数据类Some和单利对象None实现Option()

根据前面的知识,我们可给Option类型扩展flatMap,pure和map方法,从而让它具有组合能力

object OptionMonad : Monad {
  override fun  Kind.flatMap(f: (A) -> Kind): Kind {
    val oa = this
    return when (oa) {
      is Some -> f(oa.value)
      else -> None
    }
  }

  override fun  pure(a: A): Kind {
    return Some(a)
  }
}

结合前面的StdIO,实现一个readInt 方法,对Option 变量进行求和操作,通过errorHandleWithOption 处理这些错误

fun readInt():StdIO>{
    return StdIOMonad.run {
        val r = StdIO.read().map {
            when{
                it.matches(Regex("[0-9]+")) -> Some(it.toInt())
                else -> None
            }
        }
        r.unwrap()
    }
}

fun addOption(oa:Option,ob:Option) = {
    OptionMonad.run {
        oa.flatMap {a->
            ob.map { b -> a + b }
        }
    }
}

fun errorHandleWithOption(){
    StdIOMonad.run {
        readInt().flatMap { oi ->
            readInt().flatMap { oj ->
                val r = addOption(oi,oj)
                var display = when(r){
                    is Some<*> -> r.value.toString()
                    else -> ""
                }
                StdIO.write(display)
            }

        }
    }
}

测试

println(addOption(Some(11), Some(22)).invoke())

当前的方法来说,当第一次读值出现错误,理想状态是马上返回非正常的结果,当前依旧会进行第二次读值。
对StdIO进行组合,内部是Option类型,每次必须对Option类型的值进行模式匹配,然后处理。如果把StdIO>的StdIO>看成一个整体,可以直接对T进行组合操作。

回顾下前面Applicative,Functor


interface Functor {
  abstract fun  Kind.map(f: (A) -> B): Kind
}

interface Applicative : Functor {
  fun  pure(a: A): Kind
  fun  Kind.ap(f: Kind B>): Kind
  override fun  Kind.map(f: (A) -> B): Kind {
    return ap(pure(f))
  }
}

OptionT的数据类型

package top.zcwfeng.kt.functional

import top.zcwfeng.kt.functional.typeclass.*

data class OptionT(val value: Kind>) {
  object K

  companion object {
    fun  pure(AP: Applicative, v: A): OptionT {
      return OptionT(AP.pure(Some(v)))
    }

    fun  none(AP: Applicative): OptionT {
      return OptionT(AP.pure(None))
    }

    fun  liftF(M: Functor, fa: Kind): OptionT {
      val v = M.run {
        fa.map {
            Some(it)
        }
      }
      return OptionT(v)
    }
  }

  fun  flatMap(M: Monad, f: (A) -> OptionT): OptionT {
    val r = M.run {
      value.flatMap { oa ->
        when (oa) {
          is Some -> f(oa.value).value
          else -> M.pure(None)
        }
      }
    }
    return OptionT(r)
  }

  fun  map(F: Functor, f: (A) -> B): OptionT {
    val r: Kind> = F.run {
      value.map { ov ->
        OptionMonad.run {
          ov.map(f).unwrap()
        }
      }
    }
    return OptionT(r)
  }

}


fun main(args: Array) {
  val fa1 = OptionT.pure(ListMonad, 1)
  val fa2 = OptionT.pure(ListMonad, 2)
  val fa3 = fa1.flatMap(ListMonad) { a1: Int ->
    fa2.map(ListMonad) { a2: Int ->
      a1 + a2
    }
  }
  println(fa3.value)
}

和Option不一样,OptionT的参数Kind>,如果存在Option类型值,我们可以给他套上类型构造器F然后在包裹OptionT类型

OptionT的pure方法和none方法和之前的一样,接受参数只需要一个pure方法,所以参数是Applicative 就行,没必要Monad

核心方法flatMap定义一个表达式函数体,flatMap返回一个lambda,类型((A)-> OptionT)-> Option

fun errorHandleWithOptionT(){
    fun readInt(): OptionT {
        val r =  StdIOMonad.run {
            val r = StdIO.read().map {
                when {
                    it.matches(Regex("[0-9]+")) -> Some(it.toInt())
                    else -> None
                }
            }
            r.unwrap()
        }
        return OptionT(r)
    }
    val add = readInt().flatMap(StdIOMonad){i ->
        readInt().flatMapF(StdIOMonad){j->
            StdIO.write((i+j).toString())
        }
    }
    add.getOrElseF(StdIOMonad,StdIO.write("input error"))
}

OptionT增加两个方法

fun  flatMapF(M: Monad, f: (A) -> Kind): OptionT {
    val ob = M.run {
      value.flatMap {
        when (it) {
          is Some -> f(it.value).map {
            Some(it)
          }
          else -> pure(None)
        }
      }
    }
    return OptionT(ob)
  }

  fun getOrElseF(M:Monad,fa:Kind):Kind{
    return M.run {
      value.flatMap {
        when(it){
          is Some -> M.pure(it.value)
          else -> fa
        }
      }
    }
  }

2. Either 与 EitherT

显示业务错误的种类多样化,不仅仅一种。针对不同种类,最好能提供不同的处理方式。

思考一个简化版本

sealed class Either(){
  class Right(val value: B) : Either()
  class Left(val value: A) : Either()
}

实现非A即B,Option也可以认为是特殊的Either,知识代表是否存在。Either更加通用,但是没有支持高阶类型。定义一个新的Either,那么需要定义一个Kind2

typealias Kind2 = Kind, B>

Either 的实现

@Suppress("UNCHECKED_CAST", "NOTHING_TO_INLINE")
inline fun  Kind2.unwrap(): Either =
  this as Either


sealed class Either : Kind2 {
  object K
}

data class Right(val value: B) : Either()
data class Left(val value: A) : Either()

根据前面构建的套路,需要给Either增加一个EitherMonad

class EitherMonad : Monad> {
  override fun  Kind, A>.flatMap(f: (A) -> Kind, B>): Kind, B> {
    val eab = this
    return when (eab) {
      is Right -> f(eab.value)
      is Left -> eab
      else -> TODO()
    }
  }

  override fun  pure(a: A): Kind, A> {
    return Right(a)
  }
}

Either 也存在同样问题,在面临多种组合场景的情况,还是需要类似OptionT的Either版本解决问题,同样的命令方式,他是EitherT
类似OptionT改进思路,定义EitherT


data class EitherT(val value: Kind>) {
  companion object {
    fun  pure(AP: Applicative, b: B): EitherT {
      return EitherT(AP.pure(Right(b)))
    }
  }

  fun  flatMap(M: Monad, f: (A) -> EitherT): EitherT {
    val v = M.run {
      value.flatMap { ela ->
        when (ela) {
          is Left -> M.pure(Left(ela.value))
          is Right -> f(ela.value).value

        }
      }
    }
    return EitherT(v)
  }

  fun  map(F: Functor, f: ((A) -> B)): EitherT {
    val felb = F.run {
      value.map { ela ->
        EitherMonad().run {
          ela.map(f).unwrap()
        }
      }
    }
    return EitherT(felb)
  }
}

fun main(args: Array) {
  val e1 = EitherT.pure(ListMonad, 1)
  val e2 = EitherT.pure(ListMonad, 2)
  val e3 = e1.flatMap(ListMonad) { v1 ->
    e2.map(ListMonad) { v2 ->
      v1 + v2
    }
  }
  println(e3.value)
}

结合之前读值求和例子,将基于Either例子改写

fun errorHandlerWithEitherT() {
    fun readInt(): EitherT {
        val r = StdIOMonad.run {
            StdIO.read().map {
                when {
                    it.matches(Regex("[0-9]+")) -> Right(it.toInt())
                    else -> Left("$(it) is not a number ")
                }
            }
        }
        return EitherT(r)
    }

    val add = readInt().flatMap(StdIOMonad) { i ->
        readInt().flatMapF(StdIOMonad) { j ->
            StdIO.write((i + j).toString())
        }
    }
    
    add.valueOrF(StdIOMonad) { err ->
        StdIO.write(err)
    }
}

你可能感兴趣的:(Kotlin(十七)函数式编程<4>)