ImmutableArray

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

def apply[A](elems: A*)(implicit arg0: ClassTag[A]): ImmutableArray[A]

final def asInstanceOf[T0]: T0

def builderForAnyRef: ImmutableArrayBuilder[AnyRef]

def builderForChar: ImmutableArrayBuilder[Char]

def builderForDouble: ImmutableArrayBuilder[Double]

def builderForFloat: ImmutableArrayBuilder[Float]

def builderForInt: ImmutableArrayBuilder[Int]

def builderForLong: ImmutableArrayBuilder[Long]

def builderForShort: ImmutableArrayBuilder[Short]

implicit def canBuildFrom[A]: CanBuildFrom[Coll, A, ImmutableArray[A]]

implicit val canBuildFromChar: CanBuildFrom[Coll, Char, ImmutableArray[Char]]

implicit val canBuildFromDouble: CanBuildFrom[Coll, Double, ImmutableArray[Double]]

implicit val canBuildFromFloat: CanBuildFrom[Coll, Float, ImmutableArray[Float]]

implicit val canBuildFromInt: CanBuildFrom[Coll, Int, ImmutableArray[Int]]

implicit val canBuildFromLong: CanBuildFrom[Coll, Long, ImmutableArray[Long]]

implicit val canBuildFromShort: CanBuildFrom[Coll, Short, ImmutableArray[Short]]

def clone(): AnyRef

def copy[A](arr: Array[A])(implicit arg0: ClassTag[A]): ImmutableArray[A]

Create a new Immutable Array by creating a copy of the passed in array

def copy[A](col: TraversableOnce[A])(implicit arg0: ClassTag[A]): ImmutableArray[A]

Create a new ImmutableArray by creating a copy of the passed in collection

def empty[A]: ImmutableArray[A]

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

final def getClass(): Class[_]

def hashCode(): Int

final def isInstanceOf[T0]: Boolean

final def ne(arg0: AnyRef): Boolean

def newBuilder[A](initialSize: Int)(implicit arg0: ClassTag[A]): ImmutableArrayBuilder[A]

def newBuilder[A](implicit arg0: ClassTag[A]): ImmutableArrayBuilder[A]

final def notify(): Unit

final def notifyAll(): Unit

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

def toString(): String

def unsafeWrapArray[A](arr: Array[A])(implicit arg0: ClassTag[A]): ImmutableArray[A]

Wrap an existing array in an ImmutableArray.

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

final def wait(arg0: Long): Unit

final def wait(): Unit

def finalize(): Unit

def wrap[A](arr: Array[A])(implicit arg0: ClassTag[A]): ImmutableArray[A]

Wrap an existing array in an ImmutableArray.