list

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

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: AnyRef): Boolean

final def ==(arg0: Any): Boolean

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.

def clone(): AnyRef

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 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 initz[A](as: List[A]): List[List[A]]

[Nil, as take 1, as take 2, ..., 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

implicit def listEqual[A](implicit A0: Equal[A]): Equal[List[A]]

implicit val listInstance: Traverse[List] with MonadPlus[List] with Each[List] with Index[List] with Length[List] with Zip[List] with Unzip[List] with Align[List] with IsEmpty[List] with Cobind[List] { def empty[A]: scala.collection.immutable.Nil.type }

implicit def listMonoid[A]: Monoid[List[A]]

implicit def listOrder[A](implicit A0: Order[A]): Order[List[A]]

implicit def listShow[A](implicit arg0: Show[A]): Show[List[A]]

object listSyntax extends ToListOps

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 ne(arg0: AnyRef): Boolean

final def nil[A]: List[A]

scala.Nil with a sometimes more convenient type

final def notify(): Unit

final def notifyAll(): Unit

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.

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

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 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 toNel[A](as: List[A]): Option[NonEmptyList[A]]

def toString(): String

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

final def wait(): Unit

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

final def wait(arg0: Long): Unit

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