ExecResult

abstract val index: Int

abstract val input: String

final def !=(arg0: AnyRef): Boolean

final def !=(arg0: scala.Any): Boolean

final def ##(): Int

def +(other: String): String

def ++[B >: A](that: Array[_ <: B]): Array[B]

def ++[B >: A, That](that: GenTraversableOnce[B])(implicit bf: CanBuildFrom[Array[UndefOr[String]], B, That]): That

def ++(xs: GenTraversableOnce[UndefOr[String]]): WrappedArray[UndefOr[String]]

def ++[B >: A, That](that: GenTraversableOnce[B])(implicit bf: CanBuildFrom[WrappedArray[UndefOr[String]], B, That]): That

def ++[B >: A, That](that: GenTraversableOnce[B])(implicit bf: CanBuildFrom[collection.Iterable[UndefOr[String]], B, That]): That

def ++:[B >: A, That](that: collection.Traversable[B])(implicit bf: CanBuildFrom[Array[UndefOr[String]], B, That]): That

def ++:[B >: A, That](that: collection.TraversableOnce[B])(implicit bf: CanBuildFrom[Array[UndefOr[String]], B, That]): That

def ++:[B >: A, That](that: collection.Traversable[B])(implicit bf: CanBuildFrom[WrappedArray[UndefOr[String]], B, That]): That

def ++:[B >: A, That](that: collection.TraversableOnce[B])(implicit bf: CanBuildFrom[WrappedArray[UndefOr[String]], B, That]): That

def ++:[B >: A, That](that: collection.Traversable[B])(implicit bf: CanBuildFrom[collection.Iterable[UndefOr[String]], B, That]): That

def ++:[B >: A, That](that: collection.TraversableOnce[B])(implicit bf: CanBuildFrom[collection.Iterable[UndefOr[String]], B, That]): That

def ++=:(xs: collection.TraversableOnce[|[String, Unit]]): WrappedArray[UndefOr[String]]

def +:[B >: A, That](elem: B)(implicit bf: CanBuildFrom[Array[UndefOr[String]], B, That]): That

def +:[B >: A, That](elem: B)(implicit bf: CanBuildFrom[WrappedArray[UndefOr[String]], B, That]): That

def +=:(elem: |[String, Unit]): WrappedArray[UndefOr[String]]

def -(elem1: UndefOr[String], elem2: UndefOr[String], elems: UndefOr[String]*): WrappedArray[UndefOr[String]]

def -(elem: UndefOr[String]): WrappedArray[UndefOr[String]]

def --(xs: GenTraversableOnce[UndefOr[String]]): WrappedArray[UndefOr[String]]

def --=(xs: collection.TraversableOnce[|[String, Unit]]): WrappedArray[UndefOr[String]]

def -=(x: |[String, Unit]): WrappedArray[UndefOr[String]]

def -=(elem1: |[String, Unit], elem2: |[String, Unit], elems: |[String, Unit]*): WrappedArray[UndefOr[String]]

def ->[B](y: B): (ExecResult, B)

def :+[B >: A, That](elem: B)(implicit bf: CanBuildFrom[Array[UndefOr[String]], B, That]): That

def :+[B >: A, That](elem: B)(implicit bf: CanBuildFrom[WrappedArray[UndefOr[String]], B, That]): That

def <<(cmd: Message[UndefOr[String]]): Unit

final def ==(arg0: AnyRef): Boolean

final def ==(arg0: scala.Any): Boolean

def andThen[C](k: (UndefOr[String]) ⇒ C): PartialFunction[Int, C]

def append(elems: UndefOr[String]*): Unit

def appendAll(xs: collection.TraversableOnce[UndefOr[String]]): Unit

def apply(index: Int): UndefOr[String]

Access the element at the given index.

def applyOrElse[A1 <: A, B1 >: B](x: A1, default: (A1) ⇒ B1): B1

val array: Array[UndefOr[String]]

final def asInstanceOf[T0]: T0

def clone(): AnyRef

def collect[B, That](pf: PartialFunction[UndefOr[String], B])(implicit bf: CanBuildFrom[Array[UndefOr[String]], B, That]): That

def compose[A](g: (A) ⇒ Int): (A) ⇒ UndefOr[String]

def concat[B >: UndefOr[String]](items: Array[_ <: B]*): Array[B]

concat creates a new array consisting of the elements in the this object on which it is called, followed in order by, for each argument, the elements of that argument (if the argument is an array) or the argument itself (if the argument is not an array).

def copyToArray[B >: A](xs: scala.Array[B], start: Int, len: Int): Unit

def copyToArray[B >: A](xs: scala.Array[B]): Unit

def copyToArray[B >: A](xs: scala.Array[B], start: Int): Unit

def copyToArray[B >: A](xs: scala.Array[B], start: Int, len: Int): Unit

def copyToArray[B >: A](xs: scala.Array[B]): Unit

def copyToArray[B >: A](xs: scala.Array[B], start: Int): Unit

def copyToArray[B >: A](xs: scala.Array[B], start: Int, len: Int): Unit

def copyToArray[B >: A](xs: scala.Array[B]): Unit

def copyToArray[B >: A](xs: scala.Array[B], start: Int): Unit

def copyToBuffer[B >: A](dest: Buffer[B]): Unit

def copyToBuffer[B >: A](dest: Buffer[B]): Unit

def copyToBuffer[B >: A](dest: Buffer[B]): Unit

def diff[B >: A](that: GenSeq[B]): Array[UndefOr[String]]

def diff[B >: A](that: GenSeq[B]): WrappedArray[UndefOr[String]]

def ensuring(cond: (ExecResult) ⇒ Boolean, msg: ⇒ scala.Any): ExecResult

def ensuring(cond: (ExecResult) ⇒ Boolean): ExecResult

def ensuring(cond: Boolean, msg: ⇒ scala.Any): ExecResult

def ensuring(cond: Boolean): ExecResult

final def eq(arg0: AnyRef): Boolean

def equals(arg0: scala.Any): Boolean

def finalize(): Unit

def flatMap[B, That](f: (UndefOr[String]) ⇒ GenTraversableOnce[B])(implicit bf: CanBuildFrom[Array[UndefOr[String]], B, That]): That

def fold[A1 >: A](z: A1)(op: (A1, A1) ⇒ A1): A1

def fold[A1 >: A](z: A1)(op: (A1, A1) ⇒ A1): A1

def fold[A1 >: A](z: A1)(op: (A1, A1) ⇒ A1): A1

def foldLeft[B](z: B)(op: (B, UndefOr[String]) ⇒ B): B

def foldRight[B](z: B)(op: (UndefOr[String], B) ⇒ B): B

def foreach[U](f: (UndefOr[String]) ⇒ U): Unit

def formatted(fmtstr: String): String

final def getClass(): Class[_]

def hasOwnProperty(v: String): Boolean

Tests whether this object has the specified property as a direct property.

def hashCode(): Int

def indexOf[B >: A](elem: B, from: Int): Int

def indexOf[B >: A](elem: B): Int

def indexOf[B >: A](elem: B, from: Int): Int

def indexOf[B >: A](elem: B): Int

def indexOfSlice[B >: A](that: GenSeq[B], from: Int): Int

def indexOfSlice[B >: A](that: GenSeq[B]): Int

def indexOfSlice[B >: A](that: GenSeq[B], from: Int): Int

def indexOfSlice[B >: A](that: GenSeq[B]): Int

def insert(n: Int, elems: UndefOr[String]*): Unit

def insertAll(n: Int, elems: collection.Traversable[UndefOr[String]]): Unit

def intersect[B >: A](that: GenSeq[B]): Array[UndefOr[String]]

def intersect[B >: A](that: GenSeq[B]): WrappedArray[UndefOr[String]]

final def isInstanceOf[T0]: Boolean

def isPrototypeOf(v: Object): Boolean

Tests whether this object is in the prototype chain of another object.

def join(seperator: String = ","): String

The join() method joins all elements of an array into a string.

def jsIterator(): Iterator[UndefOr[String]]

ECMAScript 6 JavaScript Iterator for this Array.

def jsSlice(start: Int = 0, end: Int = Int.MaxValue): Array[UndefOr[String]]

The slice() method returns a shallow copy of a portion of an array.

def lastIndexOf[B >: A](elem: B, end: Int): Int

def lastIndexOf[B >: A](elem: B): Int

def lastIndexOf[B >: A](elem: B, end: Int): Int

def lastIndexOf[B >: A](elem: B): Int

def lastIndexOfSlice[B >: A](that: GenSeq[B], end: Int): Int

def lastIndexOfSlice[B >: A](that: GenSeq[B]): Int

def lastIndexOfSlice[B >: A](that: GenSeq[B], end: Int): Int

def lastIndexOfSlice[B >: A](that: GenSeq[B]): Int

def length: Int

Length of the array.

def length_=(v: Int): Unit

Sets the length of the array.

def lift: (Int) ⇒ Option[UndefOr[String]]

def map[B, That](f: (UndefOr[String]) ⇒ B)(implicit bf: CanBuildFrom[Array[UndefOr[String]], B, That]): That

def mapResult[NewTo](f: (Array[UndefOr[String]]) ⇒ NewTo): Builder[UndefOr[String], NewTo]

def mapResult[NewTo](f: (WrappedArray[UndefOr[String]]) ⇒ NewTo): Builder[UndefOr[String], NewTo]

def max[B >: A](implicit cmp: Ordering[B]): UndefOr[String]

def max[B >: A](implicit cmp: Ordering[B]): UndefOr[String]

def max[B >: A](implicit cmp: Ordering[B]): UndefOr[String]

def min[B >: A](implicit cmp: Ordering[B]): UndefOr[String]

def min[B >: A](implicit cmp: Ordering[B]): UndefOr[String]

def min[B >: A](implicit cmp: Ordering[B]): UndefOr[String]

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def orElse[A1 <: A, B1 >: B](that: PartialFunction[A1, B1]): PartialFunction[A1, B1]

def padTo[B >: A, That](len: Int, elem: B)(implicit bf: CanBuildFrom[Array[UndefOr[String]], B, That]): That

def padTo[B >: A, That](len: Int, elem: B)(implicit bf: CanBuildFrom[WrappedArray[UndefOr[String]], B, That]): That

def patch[B >: A, That](from: Int, patch: GenSeq[B], replaced: Int)(implicit bf: CanBuildFrom[Array[UndefOr[String]], B, That]): That

def patch[B >: A, That](from: Int, patch: GenSeq[B], replaced: Int)(implicit bf: CanBuildFrom[WrappedArray[UndefOr[String]], B, That]): That

def pop(): UndefOr[String]

The pop() method removes the last element from an array and returns that element.

def prepend(elems: UndefOr[String]*): Unit

def prependAll(xs: collection.TraversableOnce[UndefOr[String]]): Unit

def product[B >: A](implicit num: Numeric[B]): B

def product[B >: A](implicit num: Numeric[B]): B

def product[B >: A](implicit num: Numeric[B]): B

def propertyIsEnumerable(v: String): Boolean

Tests whether the specified property in an object can be enumerated by a call to js.Object.properties, with the exception of properties inherited through the prototype chain.

def push(items: UndefOr[String]*): Int

The push() method mutates an array by appending the given elements and returning the new length of the array.

def readOnly: collection.Seq[UndefOr[String]]

def reduce[A1 >: A](op: (A1, A1) ⇒ A1): A1

def reduce[A1 >: A](op: (A1, A1) ⇒ A1): A1

def reduce[A1 >: A](op: (A1, A1) ⇒ A1): A1

def reduceLeft[B >: A](op: (B, UndefOr[String]) ⇒ B): B

def reduceLeft[B >: A](op: (B, UndefOr[String]) ⇒ B): B

def reduceLeft[B >: A](op: (B, UndefOr[String]) ⇒ B): B

def reduceLeftOption[B >: A](op: (B, UndefOr[String]) ⇒ B): Option[B]

def reduceLeftOption[B >: A](op: (B, UndefOr[String]) ⇒ B): Option[B]

def reduceLeftOption[B >: A](op: (B, UndefOr[String]) ⇒ B): Option[B]

def reduceOption[A1 >: A](op: (A1, A1) ⇒ A1): Option[A1]

def reduceOption[A1 >: A](op: (A1, A1) ⇒ A1): Option[A1]

def reduceOption[A1 >: A](op: (A1, A1) ⇒ A1): Option[A1]

def reduceRight[B >: A](op: (UndefOr[String], B) ⇒ B): B

def reduceRight[B >: A](op: (UndefOr[String], B) ⇒ B): B

def reduceRight[B >: A](op: (UndefOr[String], B) ⇒ B): B

def reduceRightOption[B >: A](op: (UndefOr[String], B) ⇒ B): Option[B]

def reduceRightOption[B >: A](op: (UndefOr[String], B) ⇒ B): Option[B]

def reduceRightOption[B >: A](op: (UndefOr[String], B) ⇒ B): Option[B]

def remove(n: Int, count: Int): Unit

def remove(n: Int): UndefOr[String]

def reverseInPlace(): Array[UndefOr[String]]

The reverse() method reverses an array in place.

def reverseMap[B, That](f: (UndefOr[String]) ⇒ B)(implicit bf: CanBuildFrom[Array[UndefOr[String]], B, That]): That

def reverseMap[B, That](f: (UndefOr[String]) ⇒ B)(implicit bf: CanBuildFrom[WrappedArray[UndefOr[String]], B, That]): That

def runWith[U](action: (UndefOr[String]) ⇒ U): (Int) ⇒ Boolean

def sameElements[B >: A](that: GenIterable[B]): Boolean

def sameElements[B >: A](that: GenIterable[B]): Boolean

def sameElements[B >: A](that: GenIterable[B]): Boolean

def scan[B >: A, That](z: B)(op: (B, B) ⇒ B)(implicit cbf: CanBuildFrom[Array[UndefOr[String]], B, That]): That

def scan[B >: A, That](z: B)(op: (B, B) ⇒ B)(implicit cbf: CanBuildFrom[WrappedArray[UndefOr[String]], B, That]): That

def scan[B >: A, That](z: B)(op: (B, B) ⇒ B)(implicit cbf: CanBuildFrom[collection.Iterable[UndefOr[String]], B, That]): That

def scanLeft[B, That](z: B)(op: (B, UndefOr[String]) ⇒ B)(implicit bf: CanBuildFrom[Array[UndefOr[String]], B, That]): That

def scanRight[B, That](z: B)(op: (UndefOr[String], B) ⇒ B)(implicit bf: CanBuildFrom[Array[UndefOr[String]], B, That]): That

def shift(): UndefOr[String]

The shift() method removes the first element from an array and returns that element.

def sort(compareFn: Function2[UndefOr[String], UndefOr[String], Int] = ???): Array[UndefOr[String]]

The sort() method sorts the elements of an array in place and returns the array.

def sorted[B >: A](implicit ord: math.Ordering[B]): Array[UndefOr[String]]

def sorted[B >: A](implicit ord: math.Ordering[B]): WrappedArray[UndefOr[String]]

def splice(index: Int, deleteCount: Int, items: UndefOr[String]*): Array[UndefOr[String]]

Removes and adds new elements at a given index in the array.

def sum[B >: A](implicit num: Numeric[B]): B

def sum[B >: A](implicit num: Numeric[B]): B

def sum[B >: A](implicit num: Numeric[B]): B

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

def toArray[B >: A](implicit arg0: ClassTag[B]): scala.Array[B]

def toArray[B >: A](implicit arg0: ClassTag[B]): scala.Array[B]

def toArray[B >: A](implicit arg0: ClassTag[B]): scala.Array[B]

def toLocaleString(): String

def toString(): String

def transform(f: (|[String, Unit]) ⇒ |[String, Unit]): WrappedArray[UndefOr[String]]

def trimEnd(n: Int): Unit

def trimStart(n: Int): Unit

def union[B >: A, That](that: GenSeq[B])(implicit bf: CanBuildFrom[Array[UndefOr[String]], B, That]): That

def union[B >: A, That](that: GenSeq[B])(implicit bf: CanBuildFrom[WrappedArray[UndefOr[String]], B, That]): That

def unshift(items: UndefOr[String]*): Int

The unshift() method adds one or more elements to the beginning of an array and returns the new length of the array.

def update(index: Int, value: UndefOr[String]): Unit

Set the element at the given index.

def updated[B >: A, That](index: Int, elem: B)(implicit bf: CanBuildFrom[Array[UndefOr[String]], B, That]): That

def updated[B >: A, That](index: Int, elem: B)(implicit bf: CanBuildFrom[WrappedArray[UndefOr[String]], B, That]): That

def valueOf(): scala.Any

final def wait(): Unit

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

final def wait(arg0: Long): Unit

def zip[A1 >: A, B, That](that: GenIterable[B])(implicit bf: CanBuildFrom[Array[UndefOr[String]], (A1, B), That]): That

def zip[A1 >: A, B, That](that: GenIterable[B])(implicit bf: CanBuildFrom[WrappedArray[UndefOr[String]], (A1, B), That]): That

def zip[A1 >: A, B, That](that: GenIterable[B])(implicit bf: CanBuildFrom[collection.Iterable[UndefOr[String]], (A1, B), That]): That

def zipAll[B, A1 >: A, That](that: GenIterable[B], thisElem: A1, thatElem: B)(implicit bf: CanBuildFrom[Array[UndefOr[String]], (A1, B), That]): That

def zipAll[B, A1 >: A, That](that: GenIterable[B], thisElem: A1, thatElem: B)(implicit bf: CanBuildFrom[WrappedArray[UndefOr[String]], (A1, B), That]): That

def zipAll[B, A1 >: A, That](that: GenIterable[B], thisElem: A1, thatElem: B)(implicit bf: CanBuildFrom[collection.Iterable[UndefOr[String]], (A1, B), That]): That

def zipWithIndex[A1 >: A, That](implicit bf: CanBuildFrom[Array[UndefOr[String]], (A1, Int), That]): That

def zipWithIndex[A1 >: A, That](implicit bf: CanBuildFrom[WrappedArray[UndefOr[String]], (A1, Int), That]): That

def zipWithIndex[A1 >: A, That](implicit bf: CanBuildFrom[collection.Iterable[UndefOr[String]], (A1, Int), That]): That

def →[B](y: B): (ExecResult, B)

def ++=(xs: collection.TraversableOnce[|[String, Unit]]): ArrayOps[UndefOr[String]]

def ++=(xs: collection.TraversableOnce[|[String, Unit]]): WrappedArray[UndefOr[String]]

def +=(elem: |[String, Unit]): ArrayOps[UndefOr[String]]

def +=(elem1: |[String, Unit], elem2: |[String, Unit], elems: |[String, Unit]*): ArrayOps[UndefOr[String]]

def +=(elem: |[String, Unit]): WrappedArray[UndefOr[String]]

def +=(elem1: |[String, Unit], elem2: |[String, Unit], elems: |[String, Unit]*): WrappedArray[UndefOr[String]]

def /:[B](z: B)(op: (B, UndefOr[String]) ⇒ B): B

def /:[B](z: B)(op: (B, UndefOr[String]) ⇒ B): B

def /:[B](z: B)(op: (B, UndefOr[String]) ⇒ B): B

def :\[B](z: B)(op: (UndefOr[String], B) ⇒ B): B

def :\[B](z: B)(op: (UndefOr[String], B) ⇒ B): B

def :\[B](z: B)(op: (UndefOr[String], B) ⇒ B): B

def addString(b: StringBuilder): StringBuilder

def addString(b: StringBuilder, sep: String): StringBuilder

def addString(b: StringBuilder, start: String, sep: String, end: String): StringBuilder

def addString(b: StringBuilder): StringBuilder

def addString(b: StringBuilder, sep: String): StringBuilder

def addString(b: StringBuilder, start: String, sep: String, end: String): StringBuilder

def addString(b: StringBuilder): StringBuilder

def addString(b: StringBuilder, sep: String): StringBuilder

def addString(b: StringBuilder, start: String, sep: String, end: String): StringBuilder

def aggregate[B](z: B)(seqop: (B, UndefOr[String]) ⇒ B, combop: (B, B) ⇒ B): B

def aggregate[B](z: B)(seqop: (B, UndefOr[String]) ⇒ B, combop: (B, B) ⇒ B): B

def aggregate[B](z: B)(seqop: (B, UndefOr[String]) ⇒ B, combop: (B, B) ⇒ B): B

def apply(index: Int): UndefOr[String]

def apply(index: Int): B

Access the element at the given index.

def apply(index: Int): UndefOr[String]

def canEqual(that: scala.Any): Boolean

def canEqual(that: scala.Any): Boolean

def canEqual(that: scala.Any): Boolean

def clear(): Unit

def clear(): Unit

def clone(): WrappedArray[UndefOr[String]]

def collect[B, That](pf: PartialFunction[UndefOr[String], B])(implicit bf: CanBuildFrom[WrappedArray[UndefOr[String]], B, That]): That

def collect[B, That](pf: PartialFunction[UndefOr[String], B])(implicit bf: CanBuildFrom[collection.Iterable[UndefOr[String]], B, That]): That

def collectFirst[B](pf: PartialFunction[UndefOr[String], B]): Option[B]

def collectFirst[B](pf: PartialFunction[UndefOr[String], B]): Option[B]

def collectFirst[B](pf: PartialFunction[UndefOr[String], B]): Option[B]

def combinations(n: Int): collection.Iterator[Array[UndefOr[String]]]

def combinations(n: Int): collection.Iterator[WrappedArray[UndefOr[String]]]

def companion: GenericCompanion[WrappedArray]

def companion: GenericCompanion[collection.Iterable]

def concat[B >: UndefOr[String]](items: Array[_ <: B]*): Array[B]

concat creates a new array consisting of the elements in the this object on which it is called, followed in order by, for each argument, the elements of that argument (if the argument is an array) or the argument itself (if the argument is not an array).

def contains(elem: scala.Any): Boolean

def contains(elem: scala.Any): Boolean

def containsSlice[B](that: GenSeq[B]): Boolean

def containsSlice[B](that: GenSeq[B]): Boolean

def corresponds[B](that: GenSeq[B])(p: (UndefOr[String], B) ⇒ Boolean): Boolean