AllFunctions

Value Members

final def !=(arg0: AnyRef): Boolean

Definition Classes
AnyRef
final def !=(arg0: Any): Boolean

Definition Classes
Any
final def ##(): Int

Definition Classes
AnyRef → Any
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.
Returns f applied to the contents of as if non-empty, otherwise, the zero element of the Monoid for the type B.

Definition Classes
ListFunctions
final def ==(arg0: AnyRef): Boolean

Definition Classes
AnyRef
final def ==(arg0: Any): Boolean

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

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

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

Definition Classes
ListFunctions
final def asInstanceOf[T0]: T0

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

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

Catamorphism over the option.
Catamorphism over the option. Returns the provided function some applied to item contained in the Option if it is defined, otherwise, the provided value none.

Definition Classes
OptionFunctions
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.
Constructs a non-empty list with the given string if it is not empty, otherwise, returns the second argument.

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

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

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

Definition Classes
StringFunctions
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws()
def encode(s: String)(implicit c: CharSet): Array[Byte]

Definition Classes
StringFunctions
final def eq(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def equals(arg0: Any): Boolean

Definition Classes
AnyRef → Any
final def filterM[A, M[_]](as: List[A])(p: (A) ⇒ M[Boolean])(implicit arg0: Monad[M]): M[List[A]]

Definition Classes
ListFunctions
def finalize(): Unit

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws()
final def findM[A, M[_]](as: List[A])(p: (A) ⇒ M[Boolean])(implicit arg0: Monad[M]): M[Option[A]]

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

Alias for cata
Alias for cata

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

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

Definition Classes
OptionFunctions
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.
Returns the given value if None, otherwise lifts the Some value to Option and passes it to the given function.

Definition Classes
OptionFunctions
final def getClass(): Class[_]

Definition Classes
AnyRef → Any
final def groupByM[A, M[_]](as: List[A])(p: (A, A) ⇒ M[Boolean])(implicit arg0: Monad[M]): M[List[List[A]]]

Definition Classes
ListFunctions
def hashCode(): Int

Definition Classes
AnyRef → Any
final def heads[A](as: Stream[A]): Stream[Stream[A]]

Definition Classes
StreamFunctions
final def initz[A](as: List[A]): List[List[A]]

Definition Classes
ListFunctions
final def intercalate[A](as1: Stream[Stream[A]], as2: Stream[A]): Stream[A]

Definition Classes
StreamFunctions
final def intercalate[A](as1: List[List[A]], as2: List[A]): List[A]

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

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

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

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

Definition Classes
ListFunctions
final def isInstanceOf[T0]: Boolean

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

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

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

Definition Classes
StreamFunctions
final def ne(arg0: AnyRef): Boolean

Definition Classes
AnyRef
final def none[A]: Option[A]

Definition Classes
OptionFunctions
final def notify(): Unit

Definition Classes
AnyRef
final def notifyAll(): Unit

Definition Classes
AnyRef
final def orEmpty[A, M[_]](oa: Option[A])(implicit arg0: Pointed[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.
Returns the item contained in the Option wrapped in type M if the Option is defined, otherwise, the empty value for type M.

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

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

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

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

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

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

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

Definition Classes
StringFunctions
final def partitionM[A, M[_]](as: List[A])(p: (A) ⇒ M[Boolean])(implicit arg0: Monad[M]): M[(List[A], List[A])]

Definition Classes
ListFunctions
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.
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.

Definition Classes
StringFunctions
final def powerset[A](as: List[A]): List[List[A]]

Definition Classes
ListFunctions
final def some[A](a: A): Option[A]

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

Definition Classes
ListFunctions
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
final def tails[A](as: Stream[A]): Stream[Stream[A]]

Definition Classes
StreamFunctions
final def tailz[A](as: List[A]): List[List[A]]

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

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

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

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

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

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

Definition Classes
OptionFunctions
def toString(): String

Definition Classes
AnyRef → Any
final def toSuccess[A, E](oa: Option[A])(e: ⇒ E): Validation[E, A]

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

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

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

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

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

Definition Classes
StreamFunctions
def unsafeCharsNel(s: String): NonEmptyList[Char]

Definition Classes
StringFunctions
final def wait(): Unit

Definition Classes
AnyRef
Annotations
@throws()
final def wait(arg0: Long, arg1: Int): Unit

Definition Classes
AnyRef
Annotations
@throws()
final def wait(arg0: Long): Unit

Definition Classes
AnyRef
Annotations
@throws()
final def zapp[A, B, C](a: Stream[A])(f: Stream[(A) ⇒ (B) ⇒ C]): Stream[(B) ⇒ C]

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

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

Definition Classes
ListFunctions

object AllFunctions extends AllFunctions

Value Members

final def !=(arg0: AnyRef): Boolean

final def !=(arg0: Any): Boolean

final def ##(): Int

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

final def ==(arg0: AnyRef): Boolean

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)]

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

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])]

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

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

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

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

def clone(): AnyRef

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

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: Monad[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]]

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

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

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

final def getClass(): Class[_]

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

def hashCode(): Int

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

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

final def intercalate[A](as1: Stream[Stream[A]], as2: Stream[A]): Stream[A]

final def intercalate[A](as1: List[List[A]], as2: List[A]): List[A]

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

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

final def isInstanceOf[T0]: Boolean

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

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

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

final def ne(arg0: AnyRef): Boolean

final def none[A]: Option[A]

final def notify(): Unit

final def notifyAll(): Unit

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

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 arg0: Monad[M]): M[(List[A], List[A])]

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

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

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

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

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

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

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

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

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

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]]