类型代替异常处理
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
根据前面的知识，我们可给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
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
回顾下前面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
OptionT的pure方法和none方法和之前的一样，接受参数只需要一个pure方法，所以参数是Applicative
核心方法flatMap定义一个表达式函数体，flatMap返回一个lambda，类型（（A）-> OptionT
- 当OptionT类型对象flatMap一个Monad
实例，我们可以调用一个具体的f函数，类型（A）-> OptionT - 如果调用flatMap的OptionT实例，内部value对应Option类型部分的值不存在，则直接返回None，转换为Monad
实例，再用OptionT类型包裹 - 如果对应Option类型值存在，Some类型对象，那么就用函数f接收该对象的value进行处理，最终返回一个处理后的新的OptionT对象
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)
}
}