final class ofLong extends AnyVal
- Alphabetic
- By Inheritance
- ofLong
- AnyVal
- Any
- Hide All
- Show All
- Public
- Protected
Instance Constructors
- new ofLong(self: Array[Long])
Value Members
- final def !=(arg0: Any): Boolean
- Definition Classes
- Any
- final def ##: Int
- Definition Classes
- Any
- def ++(that: ofLong): ofLong
- final def ==(arg0: Any): Boolean
- Definition Classes
- Any
- def ===(that: ofLong): Boolean
- Annotations
- @inline()
- def addString(b: StringBuilder, start: String, sep: String, end: String): StringBuilder
- final def asInstanceOf[T0]: T0
- Definition Classes
- Any
- def collect[A](f: PartialFunction[Long, A])(implicit A: ClassTag[A]): Array[A]
can not avoid boxing
PartialFunction#applyOrElse
use.withFilter(predicate).map(f)
instead - def collectBoolean(f: PartialFunction[Long, Boolean]): ofBoolean
can not avoid boxing
PartialFunction#applyOrElse
use.withFilter(predicate).map(f)
instead - def collectByte(f: PartialFunction[Long, Byte]): ofByte
can not avoid boxing
PartialFunction#applyOrElse
use.withFilter(predicate).map(f)
instead - def collectChar(f: PartialFunction[Long, Char]): ofChar
can not avoid boxing
PartialFunction#applyOrElse
use.withFilter(predicate).map(f)
instead - def collectDouble(f: PartialFunction[Long, Double]): ofDouble
can not avoid boxing
PartialFunction#applyOrElse
use.withFilter(predicate).map(f)
instead - def collectFirst[A](f: PartialFunction[Long, A])(implicit A: ClassTag[A]): Option[A]
- def collectFirstBoolean(f: PartialFunction[Long, Boolean]): Option[Boolean]
- def collectFirstByte(f: PartialFunction[Long, Byte]): Option[Byte]
- def collectFirstChar(f: PartialFunction[Long, Char]): Option[Char]
- def collectFirstDouble(f: PartialFunction[Long, Double]): Option[Double]
- def collectFirstFloat(f: PartialFunction[Long, Float]): Option[Float]
- def collectFirstInt(f: PartialFunction[Long, Int]): Option[Int]
- def collectFirstLong(f: PartialFunction[Long, Long]): Option[Long]
- def collectFirstRef[Y <: AnyRef](f: PartialFunction[Long, Y])(implicit arg0: ClassTag[Y]): Option[Y]
- def collectFirstShort(f: PartialFunction[Long, Short]): Option[Short]
- def collectFloat(f: PartialFunction[Long, Float]): ofFloat
can not avoid boxing
PartialFunction#applyOrElse
use.withFilter(predicate).map(f)
instead - def collectInt(f: PartialFunction[Long, Int]): ofInt
can not avoid boxing
PartialFunction#applyOrElse
use.withFilter(predicate).map(f)
instead - def collectLong(f: PartialFunction[Long, Long]): ofLong
can not avoid boxing
PartialFunction#applyOrElse
use.withFilter(predicate).map(f)
instead - def collectRef[Y <: AnyRef](f: PartialFunction[Long, Y])(implicit arg0: ClassTag[Y]): ofRef[Y]
can not avoid boxing
PartialFunction#applyOrElse
use.withFilter(predicate).map(f)
instead - def collectShort(f: PartialFunction[Long, Short]): ofShort
can not avoid boxing
PartialFunction#applyOrElse
use.withFilter(predicate).map(f)
instead - def contains(elem: Long): Boolean
- def count(f: (Long) => Boolean): Int
- def deleteFirst(elem: Long): ofLong
- def drop(n: Int): ofLong
- def dropRight(n: Int): ofLong
- def dropWhile(f: (Long) => Boolean): ofLong
- def dropWhileR(f: (Long) => Boolean): ofLong
- def endsWith(that: Array[Long]): Boolean
- def exists(f: (Long) => Boolean): Boolean
- def filter(f: (Long) => Boolean): ofLong
- def filterNot(f: (Long) => Boolean): ofLong
- def find(f: (Long) => Boolean): Option[Long]
- def flatMap[A](f: (Long) => Array[A])(implicit A: ClassTag[A]): Array[A]
- def flatMapBoolean(f: (Long) => Array[Boolean]): ofBoolean
- def flatMapByte(f: (Long) => Array[Byte]): ofByte
- def flatMapChar(f: (Long) => Array[Char]): ofChar
- def flatMapDouble(f: (Long) => Array[Double]): ofDouble
- def flatMapFloat(f: (Long) => Array[Float]): ofFloat
- def flatMapInt(f: (Long) => Array[Int]): ofInt
- def flatMapLong(f: (Long) => Array[Long]): ofLong
- def flatMapRef[Y <: AnyRef](f: (Long) => Array[Y])(implicit arg0: ClassTag[Y]): ofRef[Y]
- def flatMapShort(f: (Long) => Array[Short]): ofShort
- def foldLeft[A](z: A)(f: (A, Long) => A)(implicit A: ClassTag[A]): A
- def foldLeftBoolean(z: Boolean)(f: (Boolean, Long) => Boolean): Boolean
- def foldLeftByte(z: Byte)(f: (Byte, Long) => Byte): Byte
- def foldLeftChar(z: Char)(f: (Char, Long) => Char): Char
- def foldLeftDouble(z: Double)(f: (Double, Long) => Double): Double
- def foldLeftFloat(z: Float)(f: (Float, Long) => Float): Float
- def foldLeftInt(z: Int)(f: (Int, Long) => Int): Int
- def foldLeftLong(z: Long)(f: (Long, Long) => Long): Long
- def foldLeftRef[Y](z: Y)(f: (Y, Long) => Y): Y
- def foldLeftShort(z: Short)(f: (Short, Long) => Short): Short
- def foldMapLeft1[A](z: (Long) => A)(f: (A, Long) => A)(implicit A: ClassTag[A]): Option[A]
- def foldMapLeft1Boolean(z: (Long) => Boolean)(f: (Boolean, Long) => Boolean): Option[Boolean]
- def foldMapLeft1Byte(z: (Long) => Byte)(f: (Byte, Long) => Byte): Option[Byte]
- def foldMapLeft1Char(z: (Long) => Char)(f: (Char, Long) => Char): Option[Char]
- def foldMapLeft1Double(z: (Long) => Double)(f: (Double, Long) => Double): Option[Double]
- def foldMapLeft1Float(z: (Long) => Float)(f: (Float, Long) => Float): Option[Float]
- def foldMapLeft1Int(z: (Long) => Int)(f: (Int, Long) => Int): Option[Int]
- def foldMapLeft1Long(z: (Long) => Long)(f: (Long, Long) => Long): Option[Long]
- def foldMapLeft1Ref[Y](z: (Long) => Y)(f: (Y, Long) => Y): Option[Y]
- def foldMapLeft1Short(z: (Long) => Short)(f: (Short, Long) => Short): Option[Short]
- def foldMapRight1[A](z: (Long) => A)(f: (Long, A) => A)(implicit A: ClassTag[A]): Option[A]
- def foldMapRight1Boolean(z: (Long) => Boolean)(f: (Long, Boolean) => Boolean): Option[Boolean]
- def foldMapRight1Byte(z: (Long) => Byte)(f: (Long, Byte) => Byte): Option[Byte]
- def foldMapRight1Char(z: (Long) => Char)(f: (Long, Char) => Char): Option[Char]
- def foldMapRight1Double(z: (Long) => Double)(f: (Long, Double) => Double): Option[Double]
- def foldMapRight1Float(z: (Long) => Float)(f: (Long, Float) => Float): Option[Float]
- def foldMapRight1Int(z: (Long) => Int)(f: (Long, Int) => Int): Option[Int]
- def foldMapRight1Long(z: (Long) => Long)(f: (Long, Long) => Long): Option[Long]
- def foldMapRight1Ref[Y](z: (Long) => Y)(f: (Long, Y) => Y): Option[Y]
- def foldMapRight1Short(z: (Long) => Short)(f: (Long, Short) => Short): Option[Short]
- def foldRight[A](z: A)(f: (Long, A) => A)(implicit A: ClassTag[A]): A
- def foldRightBoolean(z: Boolean)(f: (Long, Boolean) => Boolean): Boolean
- def foldRightByte(z: Byte)(f: (Long, Byte) => Byte): Byte
- def foldRightChar(z: Char)(f: (Long, Char) => Char): Char
- def foldRightDouble(z: Double)(f: (Long, Double) => Double): Double
- def foldRightFloat(z: Float)(f: (Long, Float) => Float): Float
- def foldRightInt(z: Int)(f: (Long, Int) => Int): Int
- def foldRightLong(z: Long)(f: (Long, Long) => Long): Long
- def foldRightRef[Y](z: Y)(f: (Long, Y) => Y): Y
- def foldRightShort(z: Short)(f: (Long, Short) => Short): Short
- def forall(f: (Long) => Boolean): Boolean
- def foreach[U](f: (Long) => U): Unit
- def getClass(): Class[_ <: AnyVal]
- Definition Classes
- AnyVal → Any
- def groupBy[A](f: (Long) => A): Map[A, ofLong]
- def grouped(n: Int): Iterator[ofLong]
- Annotations
- @throws(scala.this.throws.<init>$default$1[IllegalArgumentException])
- def indexOf(elem: Long): Option[Int]
- def initOption: Option[ofLong]
- def inits: Iterator[ofLong]
- def interleave(that: ofLong): ofLong
- def intersperse(a: Long): ofLong
- final def isInstanceOf[T0]: Boolean
- Definition Classes
- Any
- def lastIndexOf(elem: Long): Option[Int]
- def length: Int
- Annotations
- @inline()
- def map[A](f: (Long) => A)(implicit A: ClassTag[A]): Array[A]
- def mapBoolean(f: (Long) => Boolean): ofBoolean
- def mapByte(f: (Long) => Byte): ofByte
- def mapChar(f: (Long) => Char): ofChar
- def mapDouble(f: (Long) => Double): ofDouble
- def mapFloat(f: (Long) => Float): ofFloat
- def mapInt(f: (Long) => Int): ofInt
- def mapLong(f: (Long) => Long): ofLong
- def mapRef[Y <: AnyRef](f: (Long) => Y)(implicit arg0: ClassTag[Y]): ofRef[Y]
- def mapShort(f: (Long) => Short): ofShort
- def max: Option[Long]
- def maxBy[A](f: (Long) => A)(implicit A: Ordering[A]): Option[Long]
- def min: Option[Long]
- def minBy[A](f: (Long) => A)(implicit A: Ordering[A]): Option[Long]
- def minmax: Option[(Long, Long)]
- def mkString: String
- def mkString(sep: String): String
- def mkString(start: String, sep: String, end: String): String
- def partition(f: (Long) => Boolean): (ofLong, ofLong)
- def product: Long
- def productDouble: Double
- def reduceLeftOption(f: (Long, Long) => Long): Option[Long]
- def reduceRightOption(f: (Long, Long) => Long): Option[Long]
- def reverse: ofLong
- def reverseMap[A](f: (Long) => A)(implicit A: ClassTag[A]): Array[A]
- def reverseMapBoolean(f: (Long) => Boolean): ofBoolean
- def reverseMapByte(f: (Long) => Byte): ofByte
- def reverseMapChar(f: (Long) => Char): ofChar
- def reverseMapDouble(f: (Long) => Double): ofDouble
- def reverseMapFloat(f: (Long) => Float): ofFloat
- def reverseMapInt(f: (Long) => Int): ofInt
- def reverseMapLong(f: (Long) => Long): ofLong
- def reverseMapRef[Y <: AnyRef](f: (Long) => Y)(implicit arg0: ClassTag[Y]): ofRef[Y]
- def reverseMapShort(f: (Long) => Short): ofShort
- def reverse_:::(prefix: ofLong): ofLong
- def scanLeft[A](z: A)(f: (A, Long) => A)(implicit A: ClassTag[A]): Array[A]
- def scanLeft1(f: (Long, Long) => Long): ofLong
- def scanLeftBoolean(z: Boolean)(f: (Boolean, Long) => Boolean): ofBoolean
- def scanLeftByte(z: Byte)(f: (Byte, Long) => Byte): ofByte
- def scanLeftChar(z: Char)(f: (Char, Long) => Char): ofChar
- def scanLeftDouble(z: Double)(f: (Double, Long) => Double): ofDouble
- def scanLeftFloat(z: Float)(f: (Float, Long) => Float): ofFloat
- def scanLeftInt(z: Int)(f: (Int, Long) => Int): ofInt
- def scanLeftLong(z: Long)(f: (Long, Long) => Long): ofLong
- def scanLeftRef[Y <: AnyRef](z: Y)(f: (Y, Long) => Y)(implicit arg0: ClassTag[Y]): ofRef[Y]
- def scanLeftShort(z: Short)(f: (Short, Long) => Short): ofShort
- def scanRight[A](z: A)(f: (Long, A) => A)(implicit A: ClassTag[A]): Array[A]
- def scanRight1(f: (Long, Long) => Long): ofLong
- def scanRightBoolean(z: Boolean)(f: (Long, Boolean) => Boolean): ofBoolean
- def scanRightByte(z: Byte)(f: (Long, Byte) => Byte): ofByte
- def scanRightChar(z: Char)(f: (Long, Char) => Char): ofChar
- def scanRightDouble(z: Double)(f: (Long, Double) => Double): ofDouble
- def scanRightFloat(z: Float)(f: (Long, Float) => Float): ofFloat
- def scanRightInt(z: Int)(f: (Long, Int) => Int): ofInt
- def scanRightLong(z: Long)(f: (Long, Long) => Long): ofLong
- def scanRightRef[Y <: AnyRef](z: Y)(f: (Long, Y) => Y)(implicit arg0: ClassTag[Y]): ofRef[Y]
- def scanRightShort(z: Short)(f: (Long, Short) => Short): ofShort
- val self: Array[Long]
- def size: Int
- Annotations
- @inline()
- def slice(from: Int, until: Int): ofLong
- def sliding(_size: Int, step: Int = 1): Iterator[ofLong]
- Annotations
- @throws(scala.this.throws.<init>$default$1[IllegalArgumentException])
- def sorted: ofLong
- def span(f: (Long) => Boolean): (ofLong, ofLong)
- def splitAt(n: Int): (ofLong, ofLong)
- def startsWith(that: Array[Long], offset: Int = 0): Boolean
- def sum: Long
- def tailOption: Option[ofLong]
- def tails: Iterator[ofLong]
- def take(n: Int): ofLong
- def takeRight(n: Int): ofLong
- def takeWhile(f: (Long) => Boolean): ofLong
- def takeWhileR(f: (Long) => Boolean): ofLong
- def toArray: Array[Long]
- def toList: List[Long]
- def toString(): String
- Definition Classes
- ofLong → Any
- def updated(index: Int, elem: Long): ofLong
- Annotations
- @throws(scala.this.throws.<init>$default$1[IndexOutOfBoundsException])
- def withFilter(f: (Long) => Boolean): WithFilterLong