vector

final def !=(arg0: Any): Boolean

final def ##(): Int

final def <^>[A, B](as: IxSq[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 adjacentPairs[A](as: IxSq[A]): IxSq[(A, A)]

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

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

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

final def asInstanceOf[T0]: T0

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

spanM with p's complement.

final def buildIxSq[A, B]: CanBuildFrom[IxSq[A], B, IxSq[B]]

def clone(): AnyRef

final def covariant: Traverse[VectorInstances.generic.IxSq] with MonadPlus[VectorInstances.generic.IxSq] with Each[VectorInstances.generic.IxSq] with Index[VectorInstances.generic.IxSq] with Length[VectorInstances.generic.IxSq] with Zip[VectorInstances.generic.IxSq] with Unzip[VectorInstances.generic.IxSq] with IsEmpty[VectorInstances.generic.IxSq] with Align[VectorInstances.generic.IxSq] { def toIndexedSeq[A](fa: scalaz.std.vector.generic.IxSq[A]): scalaz.std.vector.generic.IxSq[A] }

final def empty[A]: Vector[Nothing]

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

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

def finalize(): Unit

final def findM[A, M[_]](as: IxSq[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.

object generic extends IndexedSeqSubVector with IndexedSeqSubInstances

final def getClass(): Class[_]

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

groupWhenM specialized to scalaz.Id.Id.

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

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

def hashCode(): Int

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

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

final def intersperse[A](as: IxSq[A], a: A): IxSq[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: IxSq[A])(c: C, f: (C, A) ⇒ (C, B)): (C, IxSq[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: IxSq[A])(c: C, f: (C, A) ⇒ (C, B)): (C, IxSq[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 notify(): Unit

final def notifyAll(): Unit

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

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

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

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

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

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

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

[as, as.tail, as.tail.tail, ..., empty IxSq]

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

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

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

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

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

def toString(): String

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

implicit def vectorEqual[A](implicit A0: Equal[A]): Equal[Vector[A]]

implicit val vectorInstance: Traverse[VectorInstances.generic.IxSq] with MonadPlus[VectorInstances.generic.IxSq] with Each[VectorInstances.generic.IxSq] with Index[VectorInstances.generic.IxSq] with Length[VectorInstances.generic.IxSq] with Zip[VectorInstances.generic.IxSq] with Unzip[VectorInstances.generic.IxSq] with IsEmpty[VectorInstances.generic.IxSq] with Align[VectorInstances.generic.IxSq] { def toIndexedSeq[A](fa: scalaz.std.vector.generic.IxSq[A]): scalaz.std.vector.generic.IxSq[A] }

implicit def vectorMonoid[A]: Monoid[Vector[A]]

implicit def vectorOrder[A](implicit A0: Order[A]): Order[Vector[A]]

implicit def vectorShow[A](implicit arg0: Show[A]): Show[Vector[A]]

object vectorSyntax extends ToVectorOps

final def wait(): Unit

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

final def wait(arg0: Long): Unit

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

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