AllFunctions

final def !=(arg0: Any): Boolean

final def ##(): Int

final def <^>[A, B](as: List[A])(f: (NonEmptyList[A]) ⇒ B)(implicit arg0: Monoid[B]): B

Returns f applied to the contents of as if non-empty, otherwise, the zero element of the Monoid for the type B.

final def ==(arg0: Any): Boolean

final def ToScalazOrderFromOrdering[A](oa: scala.math.Ordering[A]): Order[A]

final def adjacentPairs[A](as: List[A]): List[(A, A)]

[(as(0), as(1)), (as(1), as(2)), ... (as(size-2), as(size-1))]

final def allPairs[A](as: List[A]): List[(A, A)]

Combinations of as and as, excluding same-element pairs.

final def asInstanceOf[T0]: T0

final def breakM[A, M[_]](as: List[A])(p: (A) ⇒ M[Boolean])(implicit arg0: Monad[M]): M[(List[A], List[A])]

spanM with p's complement.

final def cata[A, X](oa: Option[A])(some: (A) ⇒ X, none: ⇒ X): X

Catamorphism over the option.

def charsNel(s: String, e: ⇒ NonEmptyList[Char]): NonEmptyList[Char]

Constructs a non-empty list with the given string if it is not empty, otherwise, returns the second argument.

def charsNel(s: String): Option[NonEmptyList[Char]]

Constructs a non-empty list with the value if it is not empty, otherwise, throws an error.

def charsNelErr(s: String, message: ⇒ String): NonEmptyList[Char]

def clone(): AnyRef

def encode(s: String)(implicit c: CharSet): Array[Byte]

Encode s according to a Java character set identifier.

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

final def filterM[A, M[_]](as: List[A])(p: (A) ⇒ M[Boolean])(implicit arg0: Applicative[M]): M[List[A]]

def finalize(): Unit

final def findM[A, M[_]](as: List[A])(p: (A) ⇒ M[Boolean])(implicit arg0: Monad[M]): M[Option[A]]

Run p(a)s left-to-right until it yields a true value, answering Some(that), or None if nothing matched p.

final def fix[A](f: (⇒ A) ⇒ A): A

f(f(f(... for referentially transparent f.

final def fold[A, X](oa: Option[A])(some: (A) ⇒ X, none: ⇒ X): X

Alias for cata

final def foldLift[F[_], A, B](oa: Option[A])(b: ⇒ B, k: (F[A]) ⇒ B)(implicit p: Applicative[F]): B

Returns the given value if None, otherwise lifts the Some value and passes it to the given function.

final def foldLiftOpt[A, B](oa: Option[A])(b: ⇒ B, k: (Option[A]) ⇒ B): B

Returns the given value if None, otherwise lifts the Some value to Option and passes it to the given function.

final def getClass(): Class[_]

final def groupBy1[A, B](as: List[A])(f: (A) ⇒ B): Map[B, NonEmptyList[A]]

As with the standard library groupBy but preserving the fact that the values in the Map must be non-empty

final def groupWhen[A](as: List[A])(p: (A, A) ⇒ Boolean): List[NonEmptyList[A]]

groupWhenM specialized to scalaz.Id.Id.

final def groupWhenM[A, M[_]](as: List[A])(p: (A, A) ⇒ M[Boolean])(implicit arg0: Monad[M]): M[List[NonEmptyList[A]]]

Split at each point where p(as(n), as(n+1)) yields false.

def hashCode(): Int

final def heads[A](as: Stream[A]): Stream[Stream[A]]

[as take 1, as take 2, ..., as]

final def initz[A](as: List[A]): List[List[A]]

[Nil, as take 1, as take 2, ..., as]

final def intersperse[A](as: Stream[A], a: A): Stream[A]

Intersperse the element a between each adjacent pair of elements in as

final def intersperse[A](as: List[A], a: A): List[A]

Intersperse the element a between each adjacent pair of elements in as

final def isInstanceOf[T0]: Boolean

final def mapAccumLeft[A, B, C](as: List[A])(c: C, f: (C, A) ⇒ (C, B)): (C, List[B])

All of the Bs, in order, and the final C acquired by a stateful left fold over as.

final def mapAccumRight[A, B, C](as: List[A])(c: C, f: (C, A) ⇒ (C, B)): (C, List[B])

All of the Bs, in order as-wise, and the final C acquired by a stateful right fold over as.

final def merge[A](s1: Stream[A], s2: Stream[A]): Stream[A]

final def ne(arg0: AnyRef): Boolean

final def nil[A]: List[A]

scala.Nil with a sometimes more convenient type

final def none[A]: Option[A]

scala.None with a sometimes more convenient type.

final def notify(): Unit

final def notifyAll(): Unit

final def orEmpty[A, M[_]](oa: Option[A])(implicit arg0: Applicative[M], arg1: PlusEmpty[M]): M[A]

Returns the item contained in the Option wrapped in type M if the Option is defined, otherwise, the empty value for type M.

def parseBoolean(s: String): Validation[IllegalArgumentException, Boolean]

def parseByte(s: String): Validation[NumberFormatException, Byte]

def parseDouble(s: String): Validation[NumberFormatException, Double]

def parseFloat(s: String): Validation[NumberFormatException, Float]

def parseInt(s: String): Validation[NumberFormatException, Int]

def parseLong(s: String): Validation[NumberFormatException, Long]

def parseShort(s: String): Validation[NumberFormatException, Short]

final def partitionM[A, M[_]](as: List[A])(p: (A) ⇒ M[Boolean])(implicit F: Applicative[M]): M[(List[A], List[A])]

A pair of passing and failing values of as against p.

def plural(s: String, n: Long): String

Returns the same String value if the given value is 1 otherwise pluralises this String by appending an "s" unless this String ends with "y" and not one of ["ay", "ey", "iy", "oy", "uy"] in which case the 'y' character is chopped and "ies" is appended.

final def powerset[A](as: List[A]): List[List[A]]

final def some[A](a: A): Option[A]

scala.Some.apply with a sometimes more convenient type.

final def spanM[A, M[_]](as: List[A])(p: (A) ⇒ M[Boolean])(implicit arg0: Monad[M]): M[(List[A], List[A])]

A pair of the longest prefix of passing as against p, and the remainder.

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

final def tailOption[A](as: List[A]): Option[List[A]]

final def tails[A](as: Stream[A]): Stream[Stream[A]]

[as, as.tail, as.tail.tail, ..., Stream(as.last)]

final def tailz[A](as: List[A]): List[List[A]]

[as, as.tail, as.tail.tail, ..., Nil]

final def takeUntilM[A, M[_]](as: List[A])(p: (A) ⇒ M[Boolean])(implicit arg0: Monad[M]): M[List[A]]

Run p(a)s and collect as while p yields false.

final def takeWhileM[A, M[_]](as: List[A])(p: (A) ⇒ M[Boolean])(implicit arg0: Monad[M]): M[List[A]]

Run p(a)s and collect as while p yields true.

final def toFailure[A, B](oa: Option[A])(b: ⇒ B): Validation[A, B]

final def toLeft[A, B](oa: Option[A])(b: ⇒ B): \/[A, B]

final def toNel[A](as: List[A]): Option[NonEmptyList[A]]

final def toRight[A, E](oa: Option[A])(e: ⇒ E): \/[E, A]

def toString(): String

final def toSuccess[A, E](oa: Option[A])(e: ⇒ E): Validation[E, A]

final def toZipper[A](as: Stream[A]): Option[Zipper[A]]

final def toZipper[A](as: List[A]): Option[Zipper[A]]

def unfold[A, B](seed: A)(f: (A) ⇒ Option[(B, A)]): Stream[B]

final def unfoldForest[A, B](as: Stream[A])(f: (A) ⇒ (B, () ⇒ Stream[A])): Stream[Tree[B]]

final def unfoldForestM[A, B, M[_]](as: Stream[A])(f: (A) ⇒ M[(B, Stream[A])])(implicit arg0: Monad[M]): M[Stream[Tree[B]]]

def unsafeCharsNel(s: String): NonEmptyList[Char]

final def wait(): Unit

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

final def wait(arg0: Long): Unit

final def zapp[A, B, C](a: Stream[A])(f: Stream[(A) ⇒ (B) ⇒ C]): Stream[(B) ⇒ C]

final def zipperEnd[A](as: Stream[A]): Option[Zipper[A]]

final def zipperEnd[A](as: List[A]): Option[Zipper[A]]

final def groupByM[A, M[_]](as: List[A])(p: (A, A) ⇒ M[Boolean])(implicit arg0: Monad[M]): M[List[NonEmptyList[A]]]