Skip to content
Permalink
Branch: master
Find file Copy path
Fetching contributors…
Cannot retrieve contributors at this time
346 lines (281 sloc) 10.8 KB
package eu.timepit.refined
import eu.timepit.refined.api.{Inference, Result, Validate}
import eu.timepit.refined.api.Inference.==>
import eu.timepit.refined.boolean.Not
import eu.timepit.refined.collection._
import eu.timepit.refined.generic.Equal
import eu.timepit.refined.internal.Resources
import eu.timepit.refined.numeric.{GreaterEqual, Interval}
import shapeless.Witness
import shapeless.nat._0
/** Module for collection predicates. */
object collection extends CollectionInference {
/**
* Predicate that counts the number of elements in a `Traversable`
* which satisfy the predicate `PA` and passes the result to the numeric
* predicate `PC`.
*/
final case class Count[PA, PC](pa: PA, pc: PC)
/** Predicate that checks if a `Traversable` is empty. */
final case class Empty()
/**
* Predicate that checks if the predicate `P` holds for all elements of a
* `Traversable`.
*/
final case class Forall[P](p: P)
/**
* Predicate that checks if the predicate `P` holds for the first element
* of a `Traversable`.
*/
final case class Head[P](p: P)
/**
* Predicate that checks if the predicate `P` holds for the element at
* index `N` of a sequence.
*/
final case class Index[N, P](n: N, p: P)
/**
* Predicate that checks if the predicate `P` holds for all but the last
* element of a `Traversable`.
*/
final case class Init[P](p: P)
/**
* Predicate that checks if the predicate `P` holds for the last element
* of a `Traversable`.
*/
final case class Last[P](p: P)
/**
* Predicate that checks if the size of a `Traversable` satisfies the
* predicate `P`.
*/
final case class Size[P](p: P)
/**
* Predicate that checks if the predicate `P` holds for all but the first
* element of a `Traversable`.
*/
final case class Tail[P](p: P)
/**
* Predicate that checks if a `Traversable` contains a value
* equal to `U`.
*/
type Contains[U] = Exists[Equal[U]]
/**
* Predicate that checks if the predicate `P` holds for some elements of a
* `Traversable`.
*/
type Exists[P] = Not[Forall[Not[P]]]
/**
* Predicate that checks if the size of a `Traversable` is greater than
* or equal to `N`.
*/
type MinSize[N] = Size[GreaterEqual[N]]
/**
* Predicate that checks if the size of a `Traversable` is less than
* or equal to `N`.
*/
type MaxSize[N] = Size[Interval.Closed[_0, N]]
/** Predicate that checks if a `Traversable` is not empty. */
type NonEmpty = Not[Empty]
object Count {
implicit def countValidate[A, PA, RA, PC, RC, T](
implicit va: Validate.Aux[A, PA, RA],
vc: Validate.Aux[Int, PC, RC],
ev: T => Traversable[A]
): Validate.Aux[T, Count[PA, PC], Count[List[va.Res], vc.Res]] =
new Validate[T, Count[PA, PC]] {
override type R = Count[List[va.Res], vc.Res]
override def validate(t: T): Res = {
val ra = t.toList.map(va.validate)
val rc = vc.validate(ra.count(_.isPassed))
rc.as(Count(ra, rc))
}
override def showExpr(t: T): String =
vc.showExpr(count(t))
override def showResult(t: T, r: Res): String = {
val c = count(t)
val expr = t.map(va.showExpr).mkString("count(", ", ", ")")
Resources.predicateTakingResultDetail(s"$expr = $c", r, vc.showResult(c, r.detail.pc))
}
private def count(t: T): Int =
t.count(va.isValid)
}
}
object Empty {
implicit def emptyValidate[T](implicit ev: T => Traversable[_]): Validate.Plain[T, Empty] =
Validate.fromPredicate(_.isEmpty, t => s"isEmpty($t)", Empty())
}
object Forall {
implicit def forallValidate[A, P, R, T[a] <: Traversable[a]](
implicit v: Validate.Aux[A, P, R]
): Validate.Aux[T[A], Forall[P], Forall[List[v.Res]]] =
new Validate[T[A], Forall[P]] {
override type R = Forall[List[v.Res]]
override def validate(t: T[A]): Res = {
val rt = t.toList.map(v.validate)
Result.fromBoolean(rt.forall(_.isPassed), Forall(rt))
}
override def showExpr(t: T[A]): String =
t.map(v.showExpr).mkString("(", " && ", ")")
}
implicit def forallValidateView[A, P, R, T](
implicit v: Validate.Aux[A, P, R],
ev: T => Traversable[A]
): Validate.Aux[T, Forall[P], Forall[List[v.Res]]] =
forallValidate[A, P, R, Traversable].contramap(ev)
}
object Head {
implicit def headValidate[A, P, R, T[a] <: Traversable[a]](
implicit v: Validate.Aux[A, P, R]
): Validate.Aux[T[A], Head[P], Head[Option[v.Res]]] =
new Validate[T[A], Head[P]] {
override type R = Head[Option[v.Res]]
override def validate(t: T[A]): Res = {
val ra = t.headOption.map(v.validate)
Result.fromBoolean(ra.fold(false)(_.isPassed), Head(ra))
}
override def showExpr(t: T[A]): String =
optElemShowExpr(t.headOption, v.showExpr)
override def showResult(t: T[A], r: Res): String =
optElemShowResult(t.headOption, r.detail.p, (a: A) => s"head($t) = $a", v.showResult)
}
implicit def headValidateView[A, P, R, T](
implicit v: Validate.Aux[A, P, R],
ev: T => Traversable[A]
): Validate.Aux[T, Head[P], Head[Option[v.Res]]] =
headValidate[A, P, R, Traversable].contramap(ev)
}
object Index {
implicit def indexValidate[A, P, R, N <: Int, T](
implicit v: Validate.Aux[A, P, R],
ev: T => PartialFunction[Int, A],
wn: Witness.Aux[N]
): Validate.Aux[T, Index[N, P], Index[N, Option[v.Res]]] =
new Validate[T, Index[N, P]] {
override type R = Index[N, Option[v.Res]]
override def validate(t: T): Res = {
val ra = t.lift(wn.value).map(v.validate)
Result.fromBoolean(ra.fold(false)(_.isPassed), Index(wn.value, ra))
}
override def showExpr(t: T): String =
optElemShowExpr(t.lift(wn.value), v.showExpr)
override def showResult(t: T, r: Res): String =
optElemShowResult(
t.lift(wn.value),
r.detail.p,
(a: A) => s"index($t, ${wn.value}) = $a",
v.showResult
)
}
}
object Init {
implicit def initValidate[A, P, R, T[a] <: Traversable[a]](
implicit v: Validate.Aux[A, P, R]
): Validate.Aux[T[A], Init[P], Init[List[v.Res]]] =
new Validate[T[A], Init[P]] {
override type R = Init[List[v.Res]]
override def validate(t: T[A]): Res = {
val ra = t.toList.dropRight(1).map(v.validate)
Result.fromBoolean(ra.forall(_.isPassed), Init(ra))
}
override def showExpr(t: T[A]): String =
t.toList.dropRight(1).map(v.showExpr).mkString("(", " && ", ")")
}
implicit def initValidateView[A, P, R, T](
implicit v: Validate.Aux[A, P, R],
ev: T => Traversable[A]
): Validate.Aux[T, Init[P], Init[List[v.Res]]] =
initValidate[A, P, R, Traversable].contramap(ev)
}
object Last {
implicit def lastValidate[A, P, R, T[a] <: Traversable[a]](
implicit v: Validate.Aux[A, P, R]
): Validate.Aux[T[A], Last[P], Last[Option[v.Res]]] =
new Validate[T[A], Last[P]] {
override type R = Last[Option[v.Res]]
override def validate(t: T[A]): Res = {
val ra = t.lastOption.map(v.validate)
Result.fromBoolean(ra.fold(false)(_.isPassed), Last(ra))
}
override def showExpr(t: T[A]): String =
optElemShowExpr(t.lastOption, v.showExpr)
override def showResult(t: T[A], r: Res): String =
optElemShowResult(t.lastOption, r.detail.p, (a: A) => s"last($t) = $a", v.showResult)
}
implicit def lastValidateView[A, P, R, T](
implicit v: Validate.Aux[A, P, R],
ev: T => Traversable[A]
): Validate.Aux[T, Last[P], Last[Option[v.Res]]] =
lastValidate[A, P, R, Traversable].contramap(ev)
}
object Size {
implicit def sizeValidate[T, P, RP](
implicit v: Validate.Aux[Int, P, RP],
ev: T => Traversable[_]
): Validate.Aux[T, Size[P], Size[v.Res]] =
new Validate[T, Size[P]] {
override type R = Size[v.Res]
override def validate(t: T): Res = {
val r = v.validate(t.size)
r.as(Size(r))
}
override def showExpr(t: T): String =
v.showExpr(t.size)
override def showResult(t: T, r: Res): String = {
val size = t.size
val nested = v.showResult(size, r.detail.p)
Resources.predicateTakingResultDetail(s"size($t) = $size", r, nested)
}
}
}
object Tail {
implicit def tailValidate[A, P, R, T[a] <: Traversable[a]](
implicit v: Validate.Aux[A, P, R]
): Validate.Aux[T[A], Tail[P], Tail[List[v.Res]]] =
new Validate[T[A], Tail[P]] {
override type R = Tail[List[v.Res]]
override def validate(t: T[A]): Res = {
val ra = t.toList.drop(1).map(v.validate)
Result.fromBoolean(ra.forall(_.isPassed), Tail(ra))
}
override def showExpr(t: T[A]): String =
t.toList.drop(1).map(v.showExpr).mkString("(", " && ", ")")
}
implicit def tailValidateView[A, P, R, T](
implicit v: Validate.Aux[A, P, R],
ev: T => Traversable[A]
): Validate.Aux[T, Tail[P], Tail[List[v.Res]]] =
tailValidate[A, P, R, Traversable].contramap(ev)
}
private def optElemShowExpr[A](elem: Option[A], f: A => String): String =
elem.fold(Resources.showExprEmptyCollection)(f)
private def optElemShowResult[A, R](
elem: Option[A],
res: Option[Result[R]],
f: A => String,
g: (A, Result[R]) => String
): String =
(elem, res) match {
case (Some(a), Some(r)) =>
Resources.predicateTakingResultDetail(f(a), r, g(a, r))
case _ => Resources.showResultEmptyCollection
}
}
private[refined] trait CollectionInference {
implicit def existsInference[A, B](implicit p1: A ==> B): Exists[A] ==> Exists[B] =
p1.adapt("existsInference(%s)")
implicit def existsNonEmptyInference[P]: Exists[P] ==> NonEmpty =
Inference.alwaysValid("existsNonEmptyInference")
implicit def headInference[A, B](implicit p1: A ==> B): Head[A] ==> Head[B] =
p1.adapt("headInference(%s)")
implicit def headExistsInference[P]: Head[P] ==> Exists[P] =
Inference.alwaysValid("headExistsInference")
implicit def indexInference[N, A, B](implicit p1: A ==> B): Index[N, A] ==> Index[N, B] =
p1.adapt("indexInference(%s)")
implicit def indexExistsInference[N, P]: Index[N, P] ==> Exists[P] =
Inference.alwaysValid("indexExistsInference")
implicit def lastInference[A, B](implicit p1: A ==> B): Last[A] ==> Last[B] =
p1.adapt("lastInference(%s)")
implicit def lastExistsInference[P]: Last[P] ==> Exists[P] =
Inference.alwaysValid("lastExistsInference")
implicit def sizeInference[A, B](implicit p1: A ==> B): Size[A] ==> Size[B] =
p1.adapt("sizeInference(%s)")
}
You can’t perform that action at this time.