scalaz.Identity.scala Maven / Gradle / Ivy
The newest version!
package scalaz
import annotation.tailrec
sealed trait Identity[A] extends Equals with IdentitySugar[A] {
def value: A
import Scalaz._
def ok = Value(value)
def pure[F[_]](implicit p: Pure[F]): F[A] = p pure value
def dual: Dual[A] = DualTo(value)
def |+|(a: => A)(implicit s: Semigroup[A]): A = s append (value, a)
def ===(a: A)(implicit e: Equal[A]): Boolean = e equal (value, a)
def /==(a: A)(implicit e: Equal[A]): Boolean = !(===(a))
/**
* Returns `a` if it is non-null, otherwise returns `d`.
*/
def ??(d: => A)(implicit ev: Null <:< A): A = Option(value) getOrElse d
/**
* Raises an error if `value ≠ b`, according to the given `Equal`. The message is formated with the given `Show`.
*/
// using the implicit parameter ev here gives better compiler error messages for mistyped expressions like 1 assert_=== "".
// the simpler signature is def assert_===(b: A)(implicit e: Equal[A], s: Show[A])
def assert_===[B](b: B)(implicit e: Equal[A], s: Show[A], ev: B <:< A) = if (≠(b)) error_(shows + " ≠ " + ev(b).shows)
def ?|?(a: A)(implicit o: Order[A]): Ordering = o order (value, a)
def lte(a: A)(implicit o: Order[A]): Boolean = o.order(value, a) != GT
def gte(a: A)(implicit o: Order[A]): Boolean = o.order(value, a) != LT
def lt(a: A)(implicit o: Order[A]): Boolean = o.order(value, a) == LT
def gt(a: A)(implicit o: Order[A]): Boolean = o.order(value, a) == GT
def min(a: A)(implicit o: Order[A]): A = if (lte(a)) value else a
def max(a: A)(implicit o: Order[A]): A = if (gte(a)) value else a
def show(implicit s: Show[A]): List[Char] = s.show(value)
def shows(implicit s: Show[A]): String = s.show(value).mkString
def print(implicit s: Show[A]): Unit = Console.print(shows)
def println(implicit s: Show[A]): Unit = Console.println(shows)
def mapply[F[_], B](f: F[A => B])(implicit ftr: Functor[F]): F[B] = f ∘ (_(value))
def |>[B](f: A => B): B = f(value)
def text(implicit s: Show[A]): xml.Text = xml.Text(value.shows)
def <===>(a: A)(implicit m: MetricSpace[A]): Int = m distance (value, a)
def constantState[S](s: => S): State[S, A] = Scalaz.state((_: S) => (s, value))
def state[S]: State[S, A] = Scalaz.state((_: S, value))
def unfold[M[_], B](f: A => Option[(B, A)])(implicit p: Pure[M], m: Monoid[M[B]]): M[B] = f(value) match {
case None => m.zero
case Some((b, a)) => b.η ⊹ a.unfold(f)
}
def replicate[M[_]](n: Int, f: A => A = a => a)(implicit p: Pure[M], m: Monoid[M[A]]): M[A] = {
@tailrec
def replicate0(accum: M[A], n: Int, a: A): M[A] = if (n > 0) replicate0(accum ⊹ a.η, n - 1, f(a)) else accum
replicate0(∅, n, value)
}
def repeat[M[_]](implicit p: Pure[M], m: Monoid[M[A]]): M[A] = value.η ⊹ repeat
def iterate[M[_]](f: A => A)(implicit p: Pure[M], m: Monoid[M[A]]): M[A] =
value.η ⊹ f(value).iterate(f)
def zipper: Zipper[A] = Scalaz.zipper(Stream.empty, value, Stream.empty)
def unfoldTree[B](f: A => (B, () => Stream[A])): Tree[B] = f(value) match {
case (a, bs) => Scalaz.node(a, bs.apply.unfoldForest(f))
}
def unfoldTreeM[B, M[_]](f: A => M[(B, Stream[A])])(implicit m: Monad[M]): M[Tree[B]] = {
m.bind(f(value), (abs: (B, Stream[A])) =>
m.bind(abs._2.unfoldForestM[B, M](f), (ts: Stream[Tree[B]]) =>
m.pure(Scalaz.node(abs._1, ts))))
}
def node(subForest: Tree[A]*): Tree[A] = Scalaz.node(value, subForest.toStream)
def leaf: Tree[A] = Scalaz.leaf(value)
def success[X]: Validation[X, A] = Scalaz.success(value)
def successNel[X]: ValidationNEL[X, A] = success
def fail[X]: Validation[A, X] = failure(value)
def failNel[X]: ValidationNEL[A, X] = failure(wrapNel)
def some: Option[A] = Some(value)
def pair: (A, A) = (value, value)
def squared: (A, A) = pair
def left[B]: Either[A, B] = Left(value)
def right[B]: Either[B, A] = Right(value)
def wrapNel: NonEmptyList[A] = Scalaz.nel(value)
/**
* @return the result of pf(value) if defined, otherwise the the Zero element of type B.
*/
def matchOrZero[B: Zero](pf: PartialFunction[A, B]): B = ~pf.lift(value)
@tailrec
final def doWhile(f: A => A, p: A => Boolean): A = {
val x = f(value)
if (p(x)) x.doWhile(f, p) else x
}
@tailrec
final def whileDo(f: A => A, p: A => Boolean): A =
if (p(value)) f(value).whileDo(f, p) else value
/** A pair lazy in its right value, with this value on the left and the given value on the right. */
def <&>[B](b: => B): (A :&: B) = lazyTuple(value, b)
/** Convert the value into a monoid */
def unit[M](implicit r: Reducer[A,M]): M = r.unit(value)
/** Convert the value into a monoid in a pointed functor */
def pureUnit[M[_], N](implicit m: Pure[M], r: Reducer[A,N]): M[N] = unit[N].pure
/** Append the value to a monoid for use in left-to-right reduction */
def snoc[C](c: C)(implicit r: Reducer[C,A]): A = r.snoc(value, c)
/** Prepend the value to a monoid for use in right-to-left reduction */
def cons[M](m: M)(implicit r: Reducer[A,M]): M = r.cons(value, m)
/** Constructs a writer with the given value for writing */
def set[W](w: W): Writer[W, A] =
writer[W, A](w, value)
/** Attaches a logger to this value, which accepts log values of the given type L */
def logger[L]: Logger[L, A] =
mkLogger(value)
override def toString: String = value.toString
override def hashCode: Int = value.hashCode
override def equals(o: Any): Boolean = canEqual(o) && value == o.asInstanceOf[Identity[_]].value
def canEqual(o: Any): Boolean = o != null && o.isInstanceOf[Identity[_]]
}
object Identity {
def apply[A](a: => A): Identity[A] = new Identity[A] {
lazy val value = a
}
def unapply[A](v: Identity[A]): Option[A] = Some(v.value)
}
trait Identitys {
implicit def mkIdentity[A](x: => A): Identity[A] = Identity(x)
implicit def unMkIdentity[A](x: Identity[A]): A = x.value
val unital = mkIdentity(())
}
sealed trait IdentitySugar[A] {
self: Identity[A] =>
/** Alias for {@link scalaz.Identity#pure} */
def η[F[_]](implicit p: Pure[F]): F[A] = pure
/** Alias for {@link scalaz.Identity#dual} */
def σ : Dual[A] = dual
/** Alias for {@link scalaz.Identity#|+|} */
def ⊹(a: => A)(implicit s: Semigroup[A]): A = |+|(a)
/** Alias for {@link scalaz.Identity#===} */
def ≟(a: A)(implicit e: Equal[A]): Boolean = ===(a)
/** Alias for {@link scalaz.Identity#/==} */
def ≠(a: A)(implicit e: Equal[A]): Boolean = /==(a)
/** Alias for assert_=== */
def assert_≟[B](b: B)(implicit e: Equal[A], s: Show[A], ev: B <:< A) = assert_===(b)
}
© 2015 - 2025 Weber Informatics LLC | Privacy Policy