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