package monocle
import scalaz.std.anyVal._
import scalaz.std.list._
import scalaz.std.option._
import scalaz.syntax.std.boolean._
import scalaz.syntax.std.option._
import scalaz.syntax.tag._
import scalaz.{Choice, Foldable, Maybe, Monoid, \/}
abstract class Fold[S, A] extends Serializable { self =>
def foldMap[M: Monoid](f: A => M)(s: S): M
@inline final def fold(s: S)(implicit ev: Monoid[A]): A =
foldMap(identity)(s)
@inline final def getAll(s: S): List[A] =
foldMap(List(_))(s)
@inline final def find(p: A => Boolean)(s: S): Option[A] =
foldMap(a => (if(p(a)) Some(a) else None).first)(s).unwrap
@inline final def headOption(s: S): Option[A] =
find(_ => true)(s)
@inline final def exist(p: A => Boolean)(s: S): Boolean =
foldMap(p(_).disjunction)(s).unwrap
@inline final def all(p: A => Boolean)(s: S): Boolean =
foldMap(p(_).conjunction)(s).unwrap
@inline final def sum[S1](other: Fold[S1, A]): Fold[S \/ S1, A] =
new Fold[S \/ S1, A]{
def foldMap[M: Monoid](f: A => M)(s: S \/ S1): M =
s.fold(self.foldMap(f), other.foldMap(f))
}
@deprecated("use headOption", since = "1.1.0")
@inline final def headMaybe(s: S): Maybe[A] =
find(_ => true)(s).toMaybe
@inline final def composeFold[B](other: Fold[A, B]): Fold[S, B] =
new Fold[S, B] {
def foldMap[M: Monoid](f: B => M)(s: S): M =
self.foldMap(other.foldMap(f)(_))(s)
}
@inline final def composeGetter[C](other: Getter[A, C]): Fold[S, C] =
composeFold(other.asFold)
@inline final def composeTraversal[B, C, D](other: PTraversal[A, B, C, D]): Fold[S, C] =
composeFold(other.asFold)
@inline final def composeOptional[B, C, D](other: POptional[A, B, C, D]): Fold[S, C] =
composeFold(other.asFold)
@inline final def composePrism[B, C, D](other: PPrism[A, B, C, D]): Fold[S, C] =
composeFold(other.asFold)
@inline final def composeLens[B, C, D](other: PLens[A, B, C, D]): Fold[S, C] =
composeFold(other.asFold)
@inline final def composeIso[B, C, D](other: PIso[A, B, C, D]): Fold[S, C] =
composeFold(other.asFold)
@inline final def ^|->>[B, C, D](other: PTraversal[A, B, C, D]): Fold[S, C] =
composeTraversal(other)
@inline final def ^|-?[B, C, D](other: POptional[A, B, C, D]): Fold[S, C] =
composeOptional(other)
@inline final def ^<-?[B, C, D](other: PPrism[A, B, C, D]): Fold[S, C] =
composePrism(other)
@inline final def ^|->[B, C, D](other: PLens[A, B, C, D]): Fold[S, C] =
composeLens(other)
@inline final def ^<->[B, C, D](other: PIso[A, B, C, D]): Fold[S, C] =
composeIso(other)
}
object Fold extends FoldInstances {
def id[A]: Fold[A, A] =
Iso.id[A].asFold
def codiagonal[A]: Fold[A \/ A, A] =
new Fold[A \/ A, A]{
def foldMap[M: Monoid](f: A => M)(s: A \/ A): M =
s.fold(f,f)
}
def fromFoldable[F[_]: Foldable, A]: Fold[F[A], A] =
new Fold[F[A], A] {
def foldMap[M: Monoid](f: A => M)(s: F[A]): M =
Foldable[F].foldMap(s)(f)
}
}
sealed abstract class FoldInstances {
implicit val foldChoice: Choice[Fold] = new Choice[Fold]{
def choice[A, B, C](f: => Fold[A, C], g: => Fold[B, C]): Fold[A \/ B, C] =
f sum g
def id[A]: Fold[A, A] =
Fold.id[A]
def compose[A, B, C](f: Fold[B, C], g: Fold[A, B]): Fold[A, C] =
g composeFold f
}
}