Scala Standard Library 2.13.15 - scala.collection.immutable.WrappedString (original) (raw)

final class WrappedString extends AbstractSeq[Char] with IndexedSeq[Char] with IndexedSeqOps[Char, IndexedSeq, WrappedString] with Serializable

 

Ordering

1. Alphabetic
2. By Inheritance

Inherited

1. WrappedString
2. Serializable
3. IndexedSeq
4. IndexedSeqOps
5. IndexedSeq
6. IndexedSeqOps
7. AbstractSeq
8. Seq
9. SeqOps
10. Iterable
11. AbstractSeq
12. Seq
13. Equals
14. SeqOps
15. PartialFunction
16. Function1
17. AbstractIterable
18. Iterable
19. IterableFactoryDefaults
20. IterableOps
21. IterableOnceOps
22. IterableOnce
23. AnyRef
24. Any

Implicitly

1. by UnwrapOp

2. by iterableOnceExtensionMethods

3. by any2stringadd

4. by StringFormat

5. by Ensuring

6. by ArrowAssoc

7. Hide All

8. Show All

Visibility

1. Public
2. Protected

Instance Constructors

1.  new WrappedString(self: String)

Value Members

1.  final def !=(arg0: Any): Boolean
2.  final def ##: Int
3.  def +(other: String): String
4.  final def ++[B >: Char](suffix: IterableOnce[B]): IndexedSeq[B]
5.  final def ++:[B >: Char](prefix: IterableOnce[B]): IndexedSeq[B]
6.  final def +:[B >: Char](elem: B): IndexedSeq[B]
7.  def ->[B](y: B): (WrappedString, B)
8.  final def :+[B >: Char](elem: B): IndexedSeq[B]
9.  final def :++[B >: Char](suffix: IterableOnce[B]): IndexedSeq[B]
10.  final def ==(arg0: Any): Boolean
11.  final def addString(b: mutable.StringBuilder): b.type
12.  final def addString(b: mutable.StringBuilder, sep: String): b.type
13.  def addString(b: mutable.StringBuilder, start: String, sep: String, end: String): b.type
14.  def andThen[C](k: PartialFunction[Char, C]): PartialFunction[Int, C]
15.  def andThen[C](k: (Char) => C): PartialFunction[Int, C]
16.  def appended[B >: Char](elem: B): IndexedSeq[B]
17.  def appendedAll[B >: Char](suffix: IterableOnce[B]): IndexedSeq[B]
18.  def apply(i: Int): Char
19.  def applyOrElse[A1 <: Int, B1 >: Char](x: A1, default: (A1) => B1): B1
20.  final def applyPreferredMaxLength: Int
21.  final def asInstanceOf[T0]: T0
22.  def canEqual(that: Any): Boolean
23.  def className: String
24.  def clone(): AnyRef
25.  final def coll: WrappedString.this.type
26.  def collect[B](pf: PartialFunction[Char, B]): IndexedSeq[B]
27.  def collectFirst[B](pf: PartialFunction[Char, B]): Option[B]
28.  def combinations(n: Int): Iterator[WrappedString]
29.  def compose[R](k: PartialFunction[R, Int]): PartialFunction[R, Char]
30.  def compose[A](g: (A) => Int): (A) => Char
31.  final def concat[B >: Char](suffix: IterableOnce[B]): IndexedSeq[B]
32.  def contains[A1 >: Char](elem: A1): Boolean
33.  def containsSlice[B >: Char](that: collection.Seq[B]): Boolean
34.  def copyToArray[B >: Char](xs: Array[B], start: Int, len: Int): Int
35.  def copyToArray[B >: Char](xs: Array[B], start: Int): Int
36.  def copyToArray[B >: Char](xs: Array[B]): Int
37.  def corresponds[B](that: collection.Seq[B])(p: (Char, B) => Boolean): Boolean
38.  def corresponds[B](that: IterableOnce[B])(p: (Char, B) => Boolean): Boolean
39.  def count(p: (Char) => Boolean): Int
40.  def diff[B >: Char](that: collection.Seq[B]): WrappedString
41.  def distinct: WrappedString
42.  def distinctBy[B](f: (Char) => B): WrappedString
43.  def drop(n: Int): WrappedString
44.  def dropRight(n: Int): WrappedString
45.  def dropWhile(p: (Char) => Boolean): WrappedString
46.  def elementWise: ElementWiseExtractor[Int, Char]
47.  def empty: WrappedString
48.  def endsWith[B >: Char](that: collection.Iterable[B]): Boolean
49.  def ensuring(cond: (WrappedString) => Boolean, msg: => Any): WrappedString
50.  def ensuring(cond: (WrappedString) => Boolean): WrappedString
51.  def ensuring(cond: Boolean, msg: => Any): WrappedString
52.  def ensuring(cond: Boolean): WrappedString
53.  final def eq(arg0: AnyRef): Boolean
54.  def equals(other: Any): Boolean
55.  def exists(p: (Char) => Boolean): Boolean
56.  def filter(pred: (Char) => Boolean): WrappedString
57.  def filterNot(pred: (Char) => Boolean): WrappedString
58.  def finalize(): Unit
59.  def find(p: (Char) => Boolean): Option[Char]
60.  def findLast(p: (Char) => Boolean): Option[Char]
61.  def flatMap[B](f: (Char) => IterableOnce[B]): IndexedSeq[B]
62.  def flatten[B](implicit asIterable: (Char) => IterableOnce[B]): IndexedSeq[B]
63.  def fold[A1 >: Char](z: A1)(op: (A1, A1) => A1): A1
64.  def foldLeft[B](z: B)(op: (B, Char) => B): B
65.  def foldRight[B](z: B)(op: (Char, B) => B): B
66.  def forall(p: (Char) => Boolean): Boolean
67.  def foreach[U](f: (Char) => U): Unit
68.  def fromSpecific(coll: IterableOnce[Char]): WrappedString
69.  final def getClass(): Class[_ <: AnyRef]
70.  def groupBy[K](f: (Char) => K): Map[K, WrappedString]
71.  def groupMap[K, B](key: (Char) => K)(f: (Char) => B): Map[K, IndexedSeq[B]]
72.  def groupMapReduce[K, B](key: (Char) => K)(f: (Char) => B)(reduce: (B, B) => B): Map[K, B]
73.  def grouped(size: Int): Iterator[WrappedString]
74.  def hashCode(): Int
75.  def head: Char
76.  def headOption: Option[Char]
77.  def indexOf[B >: Char](elem: B, from: Int = 0): Int
78.  def indexOf[B >: Char](elem: B): Int
79.  def indexOfSlice[B >: Char](that: collection.Seq[B]): Int
80.  def indexOfSlice[B >: Char](that: collection.Seq[B], from: Int): Int
81.  def indexWhere(p: (Char) => Boolean): Int
82.  def indexWhere(p: (Char) => Boolean, from: Int): Int
83.  def indices: Range
84.  def init: WrappedString
85.  def inits: Iterator[WrappedString]
86.  def intersect[B >: Char](that: collection.Seq[B]): WrappedString
87.  def isDefinedAt(idx: Int): Boolean
88.  def isEmpty: Boolean
89.  final def isInstanceOf[T0]: Boolean
90.  def isTraversableAgain: Boolean
91.  def iterableFactory: SeqFactory[IndexedSeq]
92.  def iterator: Iterator[Char]
93.  def knownSize: Int
94.  def last: Char
95.  def lastIndexOf[B >: Char](elem: B, end: Int = length - 1): Int
96.  def lastIndexOfSlice[B >: Char](that: collection.Seq[B]): Int
97.  def lastIndexOfSlice[B >: Char](that: collection.Seq[B], end: Int): Int
98.  def lastIndexWhere(p: (Char) => Boolean): Int
99.  def lastIndexWhere(p: (Char) => Boolean, end: Int): Int
100.  def lastOption: Option[Char]
101.  def lazyZip[B](that: collection.Iterable[B]): LazyZip2[Char, B, WrappedString.this.type]
102.  def length: Int
103.  final def lengthCompare(that: collection.Iterable[_]): Int
104.  final def lengthCompare(len: Int): Int
105.  final def lengthIs: SizeCompareOps
106.  def lift: (Int) => Option[Char]
107.  def map[B](f: (Char) => B): IndexedSeq[B]
108.  def max[B >: Char](implicit ord: math.Ordering[B]): Char
109.  def maxBy[B](f: (Char) => B)(implicit ord: math.Ordering[B]): Char
110.  def maxByOption[B](f: (Char) => B)(implicit ord: math.Ordering[B]): Option[Char]
111.  def maxOption[B >: Char](implicit ord: math.Ordering[B]): Option[Char]
112.  def min[B >: Char](implicit ord: math.Ordering[B]): Char
113.  def minBy[B](f: (Char) => B)(implicit ord: math.Ordering[B]): Char
114.  def minByOption[B](f: (Char) => B)(implicit ord: math.Ordering[B]): Option[Char]
115.  def minOption[B >: Char](implicit ord: math.Ordering[B]): Option[Char]
116.  final def mkString: String
117.  final def mkString(sep: String): String
118.  final def mkString(start: String, sep: String, end: String): String
119.  final def ne(arg0: AnyRef): Boolean
120.  def newSpecificBuilder: Builder[Char, WrappedString]
121.  def nonEmpty: Boolean
122.  final def notify(): Unit
123.  final def notifyAll(): Unit
124.  def occCounts[B](sq: collection.Seq[B]): mutable.Map[B, Int]
125.  def orElse[A1 <: Int, B1 >: Char](that: PartialFunction[A1, B1]): PartialFunction[A1, B1]
126.  def padTo[B >: Char](len: Int, elem: B): IndexedSeq[B]
127.  def partition(p: (Char) => Boolean): (WrappedString, WrappedString)
128.  def partitionMap[A1, A2](f: (Char) => Either[A1, A2]): (IndexedSeq[A1], IndexedSeq[A2])
129.  def patch[B >: Char](from: Int, other: IterableOnce[B], replaced: Int): IndexedSeq[B]
130.  def permutations: Iterator[WrappedString]
131.  def prepended[B >: Char](elem: B): IndexedSeq[B]
132.  def prependedAll[B >: Char](prefix: IterableOnce[B]): IndexedSeq[B]
133.  def product[B >: Char](implicit num: math.Numeric[B]): B
134.  def reduce[B >: Char](op: (B, B) => B): B
135.  def reduceLeft[B >: Char](op: (B, Char) => B): B
136.  def reduceLeftOption[B >: Char](op: (B, Char) => B): Option[B]
137.  def reduceOption[B >: Char](op: (B, B) => B): Option[B]
138.  def reduceRight[B >: Char](op: (Char, B) => B): B
139.  def reduceRightOption[B >: Char](op: (Char, B) => B): Option[B]
140.  def reverse: WrappedString
141.  def reverseIterator: Iterator[Char]
142.  def reversed: collection.Iterable[Char]
143.  def runWith[U](action: (Char) => U): (Int) => Boolean
144.  def sameElements[B >: Char](o: IterableOnce[B]): Boolean
145.  def scan[B >: Char](z: B)(op: (B, B) => B): IndexedSeq[B]
146.  def scanLeft[B](z: B)(op: (B, Char) => B): IndexedSeq[B]
147.  def scanRight[B](z: B)(op: (Char, B) => B): IndexedSeq[B]
148.  def search[B >: Char](elem: B, from: Int, to: Int)(implicit ord: math.Ordering[B]): SearchResult
149.  def search[B >: Char](elem: B)(implicit ord: math.Ordering[B]): SearchResult
150.  def segmentLength(p: (Char) => Boolean, from: Int): Int
151.  final def segmentLength(p: (Char) => Boolean): Int
152.  final def size: Int
153.  final def sizeCompare(that: collection.Iterable[_]): Int
154.  final def sizeCompare(otherSize: Int): Int
155.  final def sizeIs: SizeCompareOps
156.  def slice(from: Int, until: Int): WrappedString
157.  def sliding(size: Int, step: Int): Iterator[WrappedString]
158.  def sliding(size: Int): Iterator[WrappedString]
159.  def sortBy[B](f: (Char) => B)(implicit ord: Ordering[B]): WrappedString
160.  def sortWith(lt: (Char, Char) => Boolean): WrappedString
161.  def sorted[B >: Char](implicit ord: Ordering[B]): WrappedString
162.  def span(p: (Char) => Boolean): (WrappedString, WrappedString)
163.  def splitAt(n: Int): (WrappedString, WrappedString)
164.  def startsWith[B >: Char](that: IterableOnce[B], offset: Int = 0): Boolean
165.  def stepper[S <: Stepper[_]](implicit shape: StepperShape[Char, S]): S with EfficientSplit
166.  def stringPrefix: String
167.  def sum[B >: Char](implicit num: math.Numeric[B]): B
168.  final def synchronized[T0](arg0: => T0): T0
169.  def tail: WrappedString
170.  def tails: Iterator[WrappedString]
171.  def take(n: Int): WrappedString
172.  def takeRight(n: Int): WrappedString
173.  def takeWhile(p: (Char) => Boolean): WrappedString
174.  def tapEach[U](f: (Char) => U): WrappedString
175.  def to[C1](factory: Factory[Char, C1]): C1
176.  def toArray[B >: Char](implicit arg0: ClassTag[B]): Array[B]
177.  final def toBuffer[B >: Char]: Buffer[B]
178.  final def toIndexedSeq: IndexedSeq[Char]
179.  def toList: List[Char]
180.  def toMap[K, V](implicit ev: <:<[Char, (K, V)]): Map[K, V]
181.  final def toSeq: WrappedString.this.type
182.  def toSet[B >: Char]: Set[B]
183.  def toString(): String
184.  def toVector: Vector[Char]
185.  def transpose[B](implicit asIterable: (Char) => collection.Iterable[B]): IndexedSeq[IndexedSeq[B]]
186.  def unapply(a: Int): Option[Char]
187.  def unwrap: String
188.  def unzip[A1, A2](implicit asPair: (Char) => (A1, A2)): (IndexedSeq[A1], IndexedSeq[A2])
189.  def unzip3[A1, A2, A3](implicit asTriple: (Char) => (A1, A2, A3)): (IndexedSeq[A1], IndexedSeq[A2], IndexedSeq[A3])
190.  def updated[B >: Char](index: Int, elem: B): IndexedSeq[B]
191.  def view: StringView
192.  final def wait(): Unit
193.  final def wait(arg0: Long, arg1: Int): Unit
194.  final def wait(arg0: Long): Unit
195.  def withFilter(p: (Char) => Boolean): WithFilter[Char, [_]IndexedSeq[_]]
196.  def zip[B](that: IterableOnce[B]): IndexedSeq[(Char, B)]
197.  def zipAll[A1 >: Char, B](that: collection.Iterable[B], thisElem: A1, thatElem: B): IndexedSeq[(A1, B)]
198.  def zipWithIndex: IndexedSeq[(Char, Int)]

Deprecated Value Members

1.  def /:[B](z: B)(op: (B, Char) => B): B
2.  final def /:[B](z: B)(op: (B, Char) => B): B
3.  def :\[B](z: B)(op: (Char, B) => B): B
4.  final def :\[B](z: B)(op: (Char, B) => B): B
5.  def aggregate[B](z: => B)(seqop: (B, Char) => B, combop: (B, B) => B): B
6.  def collectFirst[B](f: PartialFunction[Char, B]): Option[B]
7.  def companion: IterableFactory[[_]IndexedSeq[_]]
8.  def copyToBuffer(dest: Buffer[Char]): Unit
9.  final def copyToBuffer[B >: Char](dest: Buffer[B]): Unit
10.  def count(f: (Char) => Boolean): Int
11.  def exists(f: (Char) => Boolean): Boolean
12.  def filter(f: (Char) => Boolean): Iterator[Char]
13.  def find(p: (Char) => Boolean): Option[Char]
14.  def flatMap[B](f: (Char) => IterableOnce[B]): IterableOnce[B]
15.  def fold[A1 >: A](z: A1)(op: (A1, A1) => A1): A1
16.  def foldLeft[B](z: B)(op: (B, Char) => B): B
17.  def foldRight[B](z: B)(op: (Char, B) => B): B
18.  def forall(f: (Char) => Boolean): Boolean
19.  def foreach[U](f: (Char) => U): Unit
20.  def formatted(fmtstr: String): String
21.  def hasDefiniteSize: Boolean
22.  def isEmpty: Boolean
23.  def map[B](f: (Char) => B): IterableOnce[B]
24.  def max(implicit ord: math.Ordering[Char]): Char
25.  def maxBy[B](f: (Char) => B)(implicit cmp: math.Ordering[B]): Char
26.  def min(implicit ord: math.Ordering[Char]): Char
27.  def minBy[B](f: (Char) => B)(implicit cmp: math.Ordering[B]): Char
28.  def mkString: String
29.  def mkString(sep: String): String
30.  def mkString(start: String, sep: String, end: String): String
31.  def nonEmpty: Boolean
32.  final def prefixLength(p: (Char) => Boolean): Int
33.  def product(implicit num: math.Numeric[Char]): Char
34.  def reduce(f: (Char, Char) => Char): Char
35.  def reduceLeft(f: (Char, Char) => Char): Char
36.  def reduceLeftOption(f: (Char, Char) => Char): Option[Char]
37.  def reduceOption(f: (Char, Char) => Char): Option[Char]
38.  def reduceRight(f: (Char, Char) => Char): Char
39.  def reduceRightOption(f: (Char, Char) => Char): Option[Char]
40.  final def repr: WrappedString
41.  def reverseMap[B](f: (Char) => B): IndexedSeq[B]
42.  def sameElements[B >: A](that: IterableOnce[B]): Boolean
43.  def seq: WrappedString.this.type
44.  def size: Int
45.  def sum(implicit num: math.Numeric[Char]): Char
46.  def to[C1](factory: Factory[Char, C1]): C1
47.  def toArray[B >: A](implicit arg0: ClassTag[B]): Array[B]
48.  def toBuffer[B >: A]: Buffer[B]
49.  def toIndexedSeq: collection.IndexedSeq[Char]
50.  final def toIterable: collection.Iterable[Char]
51.  final def toIterable: WrappedString.this.type
52.  def toIterator: Iterator[Char]
53.  final def toIterator: Iterator[Char]
54.  def toList: List[Char]
55.  def toMap[K, V](implicit ev: <:<[Char, (K, V)]): Map[K, V]
56.  def toSeq: Seq[Char]
57.  def toSet[B >: A]: Set[B]
58.  def toStream: Stream[Char]
59.  final def toStream: Stream[Char]
60.  final def toTraversable: collection.Traversable[Char]
61.  final def toTraversable: collection.Traversable[Char]
62.  def toVector: Vector[Char]
63.  final def union[B >: Char](that: collection.Seq[B]): IndexedSeq[B]
64.  def view(from: Int, until: Int): IndexedSeqView[Char]
65.  def withFilter(f: (Char) => Boolean): Iterator[Char]
66.  def →[B](y: B): (WrappedString, B)

Inherited from java.io.Serializable

Inherited from IndexedSeq[Char]

Inherited from IndexedSeqOps[Char, IndexedSeq, WrappedString]

Inherited from collection.IndexedSeq[Char]

Inherited from collection.IndexedSeqOps[Char, [_]IndexedSeq[_], WrappedString]

Inherited from AbstractSeq[Char]

Inherited from Seq[Char]

Inherited from SeqOps[Char, [_]IndexedSeq[_], WrappedString]

Inherited from Iterable[Char]

Inherited from collection.AbstractSeq[Char]

Inherited from collection.Seq[Char]

Inherited from Equals

Inherited from collection.SeqOps[Char, [_]IndexedSeq[_], WrappedString]

Inherited from PartialFunction[Int, Char]

Inherited from (Int) => Char

Inherited from AbstractIterable[Char]

Inherited from collection.Iterable[Char]

Inherited from IterableFactoryDefaults[Char, [x]IndexedSeq[x]]

Inherited from IterableOps[Char, [_]IndexedSeq[_], WrappedString]

Inherited from IterableOnceOps[Char, [_]IndexedSeq[_], WrappedString]

Inherited from IterableOnce[Char]

Inherited from AnyRef

Inherited from Any

Inherited by implicit conversion UnwrapOp fromWrappedString to UnwrapOp

Inherited by implicit conversion iterableOnceExtensionMethods fromWrappedString to IterableOnceExtensionMethods[Char]

Inherited by implicit conversion any2stringadd fromWrappedString to any2stringadd[WrappedString]

Inherited by implicit conversion StringFormat fromWrappedString to StringFormat[WrappedString]

Inherited by implicit conversion Ensuring fromWrappedString to Ensuring[WrappedString]

Inherited by implicit conversion ArrowAssoc fromWrappedString to ArrowAssoc[WrappedString]

Ungrouped