Identity

def value : A

def != (arg0: AnyRef): Boolean

def != (arg0: Any): Boolean

def ## (): Int

def /== (a: A)(implicit e: Equal[A]): Boolean

def <&> [B] (b: ⇒ B): $colon$amp$colon[A, B]

A pair lazy in its right value, with this value on the left and the given value on the right.

def <===> (a: A)(implicit m: MetricSpace[A]): Int

def == (arg0: AnyRef): Boolean

def == (arg0: Any): Boolean

def === (a: A)(implicit e: Equal[A]): Boolean

def ?? (d: ⇒ A)(implicit ev: <:<[Null, A]): A

Returns a if it is non-null, otherwise returns d.

def ?|? (a: A)(implicit o: Order[A]): Ordering

def asInstanceOf [T0] : T0

def assert_=== [B] (b: B)(implicit e: Equal[A], s: Show[A], ev: <:<[B, A]): Unit

Raises an error if value ≠ b, according to the given Equal.

def assert_≟ [B] (b: B)(implicit e: Equal[A], s: Show[A], ev: <:<[B, A]): Unit

Alias for assert_===

def canEqual (o: Any): Boolean

def clone (): AnyRef

def cons [M] (m: M)(implicit r: Reducer[A, M]): M

Prepend the value to a monoid for use in right-to-left reduction

def constantState [S] (s: ⇒ S): State[S, A]

def doWhile (f: (A) ⇒ A, p: (A) ⇒ Boolean): A

def dual : Dual[A]

def eq (arg0: AnyRef): Boolean

def equal [A] (f: (A, A) ⇒ Boolean): Equal[A]

def equalA [A] : Equal[A]

Constructs an Equal instance for type A based on Any.==.

def equalBy [A, B] (f: (A) ⇒ B)(implicit arg0: Equal[B]): Equal[A]

def equals (o: Any): Boolean

def fail [X] : Validation[A, X]

def failNel [X] : ValidationNEL[A, X]

def finalize (): Unit

def getClass (): java.lang.Class[_]

def gt (a: A)(implicit o: Order[A]): Boolean

def gte (a: A)(implicit o: Order[A]): Boolean

def hashCode (): Int

def isInstanceOf [T0] : Boolean

def iterate [M[_]] (f: (A) ⇒ A)(implicit p: Pure[M], m: Monoid[M[A]]): M[A]

def leaf : Tree[A]

def left [B] : Either[A, B]

def logger [L] : Logger[L, A]

Attaches a logger to this value, which accepts log values of the given type L

def lt (a: A)(implicit o: Order[A]): Boolean

def lte (a: A)(implicit o: Order[A]): Boolean

def mapply [F[_], B] (f: F[(A) ⇒ B])(implicit ftr: Functor[F]): F[B]

def matchOrZero [B] (pf: PartialFunction[A, B])(implicit arg0: Zero[B]): B

def max (a: A)(implicit o: Order[A]): A

def min (a: A)(implicit o: Order[A]): A

def ne (arg0: AnyRef): Boolean

def node (subForest: Tree[A]*): Tree[A]

def notify (): Unit

def notifyAll (): Unit

def ok : Value[A]

def pair : (A, A)

def print (implicit s: Show[A]): Unit

def println (implicit s: Show[A]): Unit

def pure [F[_]] (implicit p: Pure[F]): F[A]

def pureUnit [M[_], N] (implicit m: Pure[M], r: Reducer[A, N]): M[N]

Convert the value into a monoid in a pointed functor

def repeat [M[_]] (implicit p: Pure[M], m: Monoid[M[A]]): M[A]

def replicate [M[_]] (n: Int, f: (A) ⇒ A = a => a)(implicit p: Pure[M], m: Monoid[M[A]]): M[A]

def right [B] : Either[B, A]

def set [W] (w: W): Writer[W, A]

Constructs a writer with the given value for writing

def show (implicit s: Show[A]): List[Char]

def shows (implicit s: Show[A]): String

def snoc [C] (c: C)(implicit r: Reducer[C, A]): A

Append the value to a monoid for use in left-to-right reduction

def some : Option[A]

def squared : (A, A)

def state [S] : State[S, A]

def success [X] : Validation[X, A]

def successNel [X] : ValidationNEL[X, A]

def synchronized [T0] (arg0: ⇒ T0): T0

def text (implicit s: Show[A]): Text

def toString (): String

def unfold [M[_], B] (f: (A) ⇒ Option[(B, A)])(implicit p: Pure[M], m: Monoid[M[B]]): M[B]

def unfoldTree [B] (f: (A) ⇒ (B, () ⇒ Stream[A])): Tree[B]

def unfoldTreeM [B, M[_]] (f: (A) ⇒ M[(B, Stream[A])])(implicit m: Monad[M]): M[Tree[B]]

def unit [M] (implicit r: Reducer[A, M]): M

Convert the value into a monoid

def wait (): Unit

def wait (arg0: Long, arg1: Int): Unit

def wait (arg0: Long): Unit

def whileDo (f: (A) ⇒ A, p: (A) ⇒ Boolean): A

def wrapNel : NonEmptyList[A]

def zipper : Zipper[A]

def |+| (a: ⇒ A)(implicit s: Semigroup[A]): A

def |> [B] (f: (A) ⇒ B): B

def η [F[_]] (implicit p: Pure[F]): F[A]

Alias for scalaz.Identity#pure

def σ : Dual[A]

Alias for scalaz.Identity#dual

def ≟ (a: A)(implicit e: Equal[A]): Boolean

Alias for scalaz.Identity#===

def ≠ (a: A)(implicit e: Equal[A]): Boolean

Alias for scalaz.Identity#/==

def ⊹ (a: ⇒ A)(implicit s: Semigroup[A]): A

Alias for scalaz.Identity#|+|