在Scala中编写验证函数

type Status[A] = Validation[List[String],A]
type Validate[A] = A => Status[A] // should be Kleisli

val isPositive: Validate[Int] = {x: Int =>
  if (x > 0) x.success else List(s"$x is not positive").failure 
}

val isEven: Validate[Int] = {x: Int =>
  if (x % 2 == 0) x.success else List(s"$x is not even").failure
}

val isEvenPositive = isEven |+| isPositive

case class X(x1: Int,// should be positive 
             x2: Int) // should be even

val x: Validate[X] = (isPositive |@| isEven)(X.apply)

当左手类型是半群时,您可以编写验证.您的列表有效,但scalaz提供内置类型ValidationNel [L,R] =验证[NonEmptyList [L],R],您应该使用它.有一些便利功能,如aValidation.toValidationNel,用于提升单个错误的值.组合的验证将有一个左侧,所有失败累积或右手与成功应用于您的功能

def foo: ValidationNel[String,Int]
def bar: ValidationNel[String,Double]
val composed: ValidationNel[String,Double] = foo(input) |@| bar(input) apply { (i: Int,d: Double) => i * d }

如果你正在寻找一个新的单一函数的组合形式(V作为验证的简写)

(A => V[L,B],A => V[L,C]) => (A => V[L,(B,C)])

然后我不太确定正确的方法.感觉应该有一两个组合器可以做到这一点,但我还没有找到它.

我已经设法编写了这个组合,但我觉得可能有更好的方法.

def composeV[A,B,C,L: Semigroup](f: A => Validation[L,g: A => Validation[L,C]): A => Validation[L,C)] = {
    import scalaz.syntax.arrow._
    import scalaz.syntax.apply._
    import scalaz.std.function.function1Instance
    val oneInput: (A) => (Validation[L,Validation[L,C]) = f &&& g
    oneInput andThen {
      case (vb,vc) =>
        vb |@| vc apply { case x: (B,C) => x }
    }
  }

这是另一种方式：

def composeV[A,C)] = {
  import scalaz.syntax.apply._
  import scalaz.std.function.function1Instance
  f |@| g apply { case (vb,vc) =>
    vb |@| vc apply { case x: (B,C) => x }
  }
}