Scala Standard Library 2.13.15 - scala.collection.mutable.StringBuilder (original) (raw)

final class StringBuilder extends AbstractSeq[Char] with ReusableBuilder[Char, String] with IndexedSeq[Char] with IndexedSeqOps[Char, IndexedSeq, StringBuilder] with IterableFactoryDefaults[Char, IndexedSeq] with CharSequence with Serializable

 

Ordering

1. Alphabetic
2. By Inheritance

Inherited

1. StringBuilder
2. Serializable
3. CharSequence
4. IndexedSeq
5. IndexedSeqOps
6. IndexedSeq
7. IndexedSeqOps
8. ReusableBuilder
9. Builder
10. Growable
11. Clearable
12. AbstractSeq
13. Seq
14. SeqOps
15. Cloneable
16. Cloneable
17. Iterable
18. AbstractSeq
19. Seq
20. Equals
21. SeqOps
22. PartialFunction
23. Function1
24. AbstractIterable
25. Iterable
26. IterableFactoryDefaults
27. IterableOps
28. IterableOnceOps
29. IterableOnce
30. AnyRef
31. Any

Implicitly

1. by iterableOnceExtensionMethods

2. by any2stringadd

3. by StringFormat

4. by Ensuring

5. by ArrowAssoc

6. Hide All

7. Show All

Visibility

1. Public
2. Protected

Instance Constructors

1.  new StringBuilder(initCapacity: Int, initValue: String)
2.  new StringBuilder(str: String)
3.  new StringBuilder(capacity: Int)
4.  new StringBuilder()
5.  new StringBuilder(underlying: java.lang.StringBuilder)

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.  def ++=(s: String): StringBuilder.this.type
7.  final def ++=(elems: IterableOnce[Char]): StringBuilder.this.type
8.  final def +:[B >: Char](elem: B): IndexedSeq[B]
9.  final def +=(elem: Char): StringBuilder.this.type
10.  def ->[B](y: B): (StringBuilder, B)
11.  final def :+[B >: Char](elem: B): IndexedSeq[B]
12.  final def :++[B >: Char](suffix: IterableOnce[B]): IndexedSeq[B]
13.  final def ==(arg0: Any): Boolean
14.  def addAll(s: String): StringBuilder.this.type
15.  def addAll(elems: IterableOnce[Char]): StringBuilder.this.type
16.  def addOne(x: Char): StringBuilder.this.type
17.  final def addString(b: StringBuilder): b.type
18.  final def addString(b: StringBuilder, sep: String): b.type
19.  def addString(b: StringBuilder, start: String, sep: String, end: String): b.type
20.  def andThen[C](k: PartialFunction[Char, C]): PartialFunction[Int, C]
21.  def andThen[C](k: (Char) => C): PartialFunction[Int, C]
22.  def append(x: Char): StringBuilder.this.type
23.  def append(x: Double): StringBuilder.this.type
24.  def append(x: Float): StringBuilder.this.type
25.  def append(x: Long): StringBuilder.this.type
26.  def append(x: Int): StringBuilder.this.type
27.  def append(x: Short): StringBuilder.this.type
28.  def append(x: Byte): StringBuilder.this.type
29.  def append(x: Boolean): StringBuilder.this.type
30.  def append(s: StringBuilder): StringBuilder.this.type
31.  def append(cs: CharSequence): StringBuilder.this.type
32.  def append(s: String): StringBuilder.this.type
33.  def append(x: Any): StringBuilder.this.type
34.  def appendAll(xs: Array[Char], offset: Int, len: Int): StringBuilder.this.type
35.  def appendAll(xs: Array[Char]): StringBuilder.this.type
36.  def appendAll(xs: IterableOnce[Char]): StringBuilder.this.type
37.  def appendAll(xs: String): StringBuilder.this.type
38.  def appended[B >: Char](elem: B): IndexedSeq[B]
39.  def appendedAll[B >: Char](suffix: IterableOnce[B]): IndexedSeq[B]
40.  def apply(i: Int): Char
41.  def applyOrElse[A1 <: Int, B1 >: Char](x: A1, default: (A1) => B1): B1
42.  final def asInstanceOf[T0]: T0
43.  def canEqual(that: Any): Boolean
44.  def capacity: Int
45.  def charAt(index: Int): Char
46.  def chars(): IntStream
47.  def className: String
48.  def clear(): Unit
49.  def clone(): StringBuilder
50.  def codePoints(): IntStream
51.  final def coll: StringBuilder.this.type
52.  def collect[B](pf: PartialFunction[Char, B]): IndexedSeq[B]
53.  def collectFirst[B](pf: PartialFunction[Char, B]): Option[B]
54.  def combinations(n: Int): Iterator[StringBuilder]
55.  def compose[R](k: PartialFunction[R, Int]): PartialFunction[R, Char]
56.  def compose[A](g: (A) => Int): (A) => Char
57.  final def concat[B >: Char](suffix: IterableOnce[B]): IndexedSeq[B]
58.  def contains[A1 >: Char](elem: A1): Boolean
59.  def containsSlice[B >: Char](that: collection.Seq[B]): Boolean
60.  def copyToArray[B >: Char](xs: Array[B], start: Int, len: Int): Int
61.  def copyToArray[B >: Char](xs: Array[B], start: Int): Int
62.  def copyToArray[B >: Char](xs: Array[B]): Int
63.  def corresponds[B](that: collection.Seq[B])(p: (Char, B) => Boolean): Boolean
64.  def corresponds[B](that: IterableOnce[B])(p: (Char, B) => Boolean): Boolean
65.  def count(p: (Char) => Boolean): Int
66.  def delete(start: Int, end: Int): StringBuilder.this.type
67.  def deleteCharAt(index: Int): StringBuilder.this.type
68.  def diff[B >: Char](that: collection.Seq[B]): StringBuilder
69.  def distinct: StringBuilder
70.  def distinctBy[B](f: (Char) => B): StringBuilder
71.  def drop(n: Int): StringBuilder
72.  def dropRight(n: Int): StringBuilder
73.  def dropWhile(p: (Char) => Boolean): StringBuilder
74.  def elementWise: ElementWiseExtractor[Int, Char]
75.  def empty: StringBuilder
76.  def endsWith[B >: Char](that: collection.Iterable[B]): Boolean
77.  def ensureCapacity(newCapacity: Int): Unit
78.  def ensuring(cond: (StringBuilder) => Boolean, msg: => Any): StringBuilder
79.  def ensuring(cond: (StringBuilder) => Boolean): StringBuilder
80.  def ensuring(cond: Boolean, msg: => Any): StringBuilder
81.  def ensuring(cond: Boolean): StringBuilder
82.  final def eq(arg0: AnyRef): Boolean
83.  def equals(o: Any): Boolean
84.  def exists(p: (Char) => Boolean): Boolean
85.  def filter(pred: (Char) => Boolean): StringBuilder
86.  def filterNot(pred: (Char) => Boolean): StringBuilder
87.  def finalize(): Unit
88.  def find(p: (Char) => Boolean): Option[Char]
89.  def findLast(p: (Char) => Boolean): Option[Char]
90.  def flatMap[B](f: (Char) => IterableOnce[B]): IndexedSeq[B]
91.  def flatten[B](implicit asIterable: (Char) => IterableOnce[B]): IndexedSeq[B]
92.  def fold[A1 >: Char](z: A1)(op: (A1, A1) => A1): A1
93.  def foldLeft[B](z: B)(op: (B, Char) => B): B
94.  def foldRight[B](z: B)(op: (Char, B) => B): B
95.  def forall(p: (Char) => Boolean): Boolean
96.  def foreach[U](f: (Char) => U): Unit
97.  def fromSpecific(coll: IterableOnce[Char]): StringBuilder
98.  final def getClass(): Class[_ <: AnyRef]
99.  def groupBy[K](f: (Char) => K): immutable.Map[K, StringBuilder]
100.  def groupMap[K, B](key: (Char) => K)(f: (Char) => B): immutable.Map[K, IndexedSeq[B]]
101.  def groupMapReduce[K, B](key: (Char) => K)(f: (Char) => B)(reduce: (B, B) => B): immutable.Map[K, B]
102.  def grouped(size: Int): Iterator[StringBuilder]
103.  def hashCode(): Int
104.  def head: Char
105.  def headOption: Option[Char]
106.  def indexOf(str: String, fromIndex: Int): Int
107.  def indexOf(str: String): Int
108.  def indexOf[B >: Char](elem: B): Int
109.  def indexOf[B >: Char](elem: B, from: Int): Int
110.  def indexOfSlice[B >: Char](that: collection.Seq[B]): Int
111.  def indexOfSlice[B >: Char](that: collection.Seq[B], from: Int): Int
112.  def indexWhere(p: (Char) => Boolean): Int
113.  def indexWhere(p: (Char) => Boolean, from: Int): Int
114.  def indices: immutable.Range
115.  def init: StringBuilder
116.  def inits: Iterator[StringBuilder]
117.  def insert(index: Int, x: Char): StringBuilder.this.type
118.  def insert(index: Int, x: Double): StringBuilder.this.type
119.  def insert(index: Int, x: Float): StringBuilder.this.type
120.  def insert(index: Int, x: Long): StringBuilder.this.type
121.  def insert(index: Int, x: Int): StringBuilder.this.type
122.  def insert(index: Int, x: Short): StringBuilder.this.type
123.  def insert(index: Int, x: Byte): StringBuilder.this.type
124.  def insert(index: Int, x: Boolean): StringBuilder.this.type
125.  def insert(index: Int, x: String): StringBuilder.this.type
126.  def insert(index: Int, x: Any): StringBuilder.this.type
127.  def insertAll(index: Int, xs: Array[Char]): StringBuilder.this.type
128.  def insertAll(index: Int, xs: IterableOnce[Char]): StringBuilder.this.type
129.  def insertAll(index: Int, str: Array[Char], offset: Int, len: Int): StringBuilder.this.type
130.  def intersect[B >: Char](that: collection.Seq[B]): StringBuilder
131.  def isDefinedAt(idx: Int): Boolean
132.  def isEmpty: Boolean
133.  final def isInstanceOf[T0]: Boolean
134.  def isTraversableAgain: Boolean
135.  def iterableFactory: SeqFactory[IndexedSeq]
136.  def iterator: Iterator[Char]
137.  def knownSize: Int
138.  def last: Char
139.  def lastIndexOf(str: String, fromIndex: Int): Int
140.  def lastIndexOf(str: String): Int
141.  def lastIndexOf[B >: Char](elem: B, end: Int = length - 1): Int
142.  def lastIndexOfSlice[B >: Char](that: collection.Seq[B]): Int
143.  def lastIndexOfSlice[B >: Char](that: collection.Seq[B], end: Int): Int
144.  def lastIndexWhere(p: (Char) => Boolean): Int
145.  def lastIndexWhere(p: (Char) => Boolean, end: Int): Int
146.  def lastOption: Option[Char]
147.  def lazyZip[B](that: collection.Iterable[B]): LazyZip2[Char, B, StringBuilder.this.type]
148.  def length(): Int
149.  final def lengthCompare(that: collection.Iterable[_]): Int
150.  final def lengthCompare(len: Int): Int
151.  final def lengthIs: SizeCompareOps
152.  def length_=(n: Int): Unit
153.  def lift: (Int) => Option[Char]
154.  def map[B](f: (Char) => B): IndexedSeq[B]
155.  def mapInPlace(f: (Char) => Char): StringBuilder.this.type
156.  def mapResult[NewTo](f: (String) => NewTo): Builder[Char, NewTo]
157.  def max[B >: Char](implicit ord: math.Ordering[B]): Char
158.  def maxBy[B](f: (Char) => B)(implicit ord: math.Ordering[B]): Char
159.  def maxByOption[B](f: (Char) => B)(implicit ord: math.Ordering[B]): Option[Char]
160.  def maxOption[B >: Char](implicit ord: math.Ordering[B]): Option[Char]
161.  def min[B >: Char](implicit ord: math.Ordering[B]): Char
162.  def minBy[B](f: (Char) => B)(implicit ord: math.Ordering[B]): Char
163.  def minByOption[B](f: (Char) => B)(implicit ord: math.Ordering[B]): Option[Char]
164.  def minOption[B >: Char](implicit ord: math.Ordering[B]): Option[Char]
165.  final def mkString: String
166.  final def mkString(sep: String): String
167.  final def mkString(start: String, sep: String, end: String): String
168.  final def ne(arg0: AnyRef): Boolean
169.  def newSpecificBuilder: Builder[Char, StringBuilder]
170.  def nonEmpty: Boolean
171.  final def notify(): Unit
172.  final def notifyAll(): Unit
173.  def occCounts[B](sq: collection.Seq[B]): Map[B, Int]
174.  def orElse[A1 <: Int, B1 >: Char](that: PartialFunction[A1, B1]): PartialFunction[A1, B1]
175.  def padTo[B >: Char](len: Int, elem: B): IndexedSeq[B]
176.  def partition(p: (Char) => Boolean): (StringBuilder, StringBuilder)
177.  def partitionMap[A1, A2](f: (Char) => Either[A1, A2]): (IndexedSeq[A1], IndexedSeq[A2])
178.  def patch[B >: Char](from: Int, other: IterableOnce[B], replaced: Int): IndexedSeq[B]
179.  def permutations: Iterator[StringBuilder]
180.  def prepended[B >: Char](elem: B): IndexedSeq[B]
181.  def prependedAll[B >: Char](prefix: IterableOnce[B]): IndexedSeq[B]
182.  def product[B >: Char](implicit num: math.Numeric[B]): B
183.  def reduce[B >: Char](op: (B, B) => B): B
184.  def reduceLeft[B >: Char](op: (B, Char) => B): B
185.  def reduceLeftOption[B >: Char](op: (B, Char) => B): Option[B]
186.  def reduceOption[B >: Char](op: (B, B) => B): Option[B]
187.  def reduceRight[B >: Char](op: (Char, B) => B): B
188.  def reduceRightOption[B >: Char](op: (Char, B) => B): Option[B]
189.  def replace(start: Int, end: Int, str: String): StringBuilder.this.type
190.  def result(): String
191.  def reverse: StringBuilder
192.  def reverseInPlace(): StringBuilder.this.type
193.  def reverseIterator: Iterator[Char]
194.  def reversed: collection.Iterable[Char]
195.  def runWith[U](action: (Char) => U): (Int) => Boolean
196.  def sameElements[B >: Char](that: IterableOnce[B]): Boolean
197.  def scan[B >: Char](z: B)(op: (B, B) => B): IndexedSeq[B]
198.  def scanLeft[B](z: B)(op: (B, Char) => B): IndexedSeq[B]
199.  def scanRight[B](z: B)(op: (Char, B) => B): IndexedSeq[B]
200.  def search[B >: Char](elem: B, from: Int, to: Int)(implicit ord: math.Ordering[B]): SearchResult
201.  def search[B >: Char](elem: B)(implicit ord: math.Ordering[B]): SearchResult
202.  def segmentLength(p: (Char) => Boolean, from: Int): Int
203.  final def segmentLength(p: (Char) => Boolean): Int
204.  def setCharAt(index: Int, ch: Char): StringBuilder.this.type
205.  def setLength(len: Int): Unit
206.  final def size: Int
207.  final def sizeCompare(that: collection.Iterable[_]): Int
208.  final def sizeCompare(otherSize: Int): Int
209.  final def sizeHint(coll: IterableOnce[_], delta: Int = 0): Unit
210.  def sizeHint(size: Int): Unit
211.  final def sizeHintBounded(size: Int, boundingColl: collection.Iterable[_]): Unit
212.  final def sizeIs: SizeCompareOps
213.  def slice(from: Int, until: Int): StringBuilder
214.  def sliding(size: Int, step: Int): Iterator[StringBuilder]
215.  def sliding(size: Int): Iterator[StringBuilder]
216.  def sortBy[B](f: (Char) => B)(implicit ord: Ordering[B]): StringBuilder
217.  def sortInPlace[B >: Char]()(implicit ord: Ordering[B]): StringBuilder.this.type
218.  def sortInPlaceBy[B](f: (Char) => B)(implicit ord: Ordering[B]): StringBuilder.this.type
219.  def sortInPlaceWith(lt: (Char, Char) => Boolean): StringBuilder.this.type
220.  def sortWith(lt: (Char, Char) => Boolean): StringBuilder
221.  def sorted[B >: Char](implicit ord: Ordering[B]): StringBuilder
222.  def span(p: (Char) => Boolean): (StringBuilder, StringBuilder)
223.  def splitAt(n: Int): (StringBuilder, StringBuilder)
224.  def startsWith[B >: Char](that: IterableOnce[B], offset: Int = 0): Boolean
225.  def stepper[S <: Stepper[_]](implicit shape: StepperShape[Char, S]): S with EfficientSplit
226.  def stringPrefix: String
227.  def subSequence(start: Int, end: Int): CharSequence
228.  def substring(start: Int, end: Int): String
229.  def substring(start: Int): String
230.  def sum[B >: Char](implicit num: math.Numeric[B]): B
231.  final def synchronized[T0](arg0: => T0): T0
232.  def tail: StringBuilder
233.  def tails: Iterator[StringBuilder]
234.  def take(n: Int): StringBuilder
235.  def takeRight(n: Int): StringBuilder
236.  def takeWhile(p: (Char) => Boolean): StringBuilder
237.  def tapEach[U](f: (Char) => U): StringBuilder
238.  def to[C1](factory: Factory[Char, C1]): C1
239.  def toArray[B >: Char](implicit ct: ClassTag[B]): Array[B]
240.  final def toBuffer[B >: Char]: Buffer[B]
241.  def toCharArray: Array[Char]
242.  def toIndexedSeq: immutable.IndexedSeq[Char]
243.  def toList: immutable.List[Char]
244.  def toMap[K, V](implicit ev: <:<[Char, (K, V)]): immutable.Map[K, V]
245.  def toSeq: immutable.Seq[Char]
246.  def toSet[B >: Char]: immutable.Set[B]
247.  def toString(): String
248.  def toVector: immutable.Vector[Char]
249.  def transpose[B](implicit asIterable: (Char) => collection.Iterable[B]): IndexedSeq[IndexedSeq[B]]
250.  def unapply(a: Int): Option[Char]
251.  val underlying: java.lang.StringBuilder
252.  def unzip[A1, A2](implicit asPair: (Char) => (A1, A2)): (IndexedSeq[A1], IndexedSeq[A2])
253.  def unzip3[A1, A2, A3](implicit asTriple: (Char) => (A1, A2, A3)): (IndexedSeq[A1], IndexedSeq[A2], IndexedSeq[A3])
254.  def update(idx: Int, elem: Char): Unit
255.  def updated[B >: Char](index: Int, elem: B): IndexedSeq[B]
256.  def view: IndexedSeqView[Char]
257.  final def wait(): Unit
258.  final def wait(arg0: Long, arg1: Int): Unit
259.  final def wait(arg0: Long): Unit
260.  def withFilter(p: (Char) => Boolean): WithFilter[Char, [_]IndexedSeq[_]]
261.  def zip[B](that: IterableOnce[B]): IndexedSeq[(Char, B)]
262.  def zipAll[A1 >: Char, B](that: collection.Iterable[B], thisElem: A1, thatElem: B): IndexedSeq[(A1, B)]
263.  def zipWithIndex: IndexedSeq[(Char, Int)]

Deprecated Value Members

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

Inherited from java.io.Serializable

Inherited from CharSequence

Inherited from IndexedSeq[Char]

Inherited from IndexedSeqOps[Char, IndexedSeq, StringBuilder]

Inherited from collection.IndexedSeq[Char]

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

Inherited from ReusableBuilder[Char, String]

Inherited from Builder[Char, String]

Inherited from Growable[Char]

Inherited from Clearable

Inherited from AbstractSeq[Char]

Inherited from Seq[Char]

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

Inherited from Cloneable[StringBuilder]

Inherited from java.lang.Cloneable

Inherited from Iterable[Char]

Inherited from collection.AbstractSeq[Char]

Inherited from collection.Seq[Char]

Inherited from Equals

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

Inherited from PartialFunction[Int, Char]

Inherited from (Int) => Char

Inherited from collection.AbstractIterable[Char]

Inherited from collection.Iterable[Char]

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

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

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

Inherited from IterableOnce[Char]

Inherited from AnyRef

Inherited from Any

Inherited by implicit conversion iterableOnceExtensionMethods fromStringBuilder to IterableOnceExtensionMethods[Char]

Inherited by implicit conversion any2stringadd fromStringBuilder to any2stringadd[StringBuilder]

Inherited by implicit conversion StringFormat fromStringBuilder to StringFormat[StringBuilder]

Inherited by implicit conversion Ensuring fromStringBuilder to Ensuring[StringBuilder]

Inherited by implicit conversion ArrowAssoc fromStringBuilder to ArrowAssoc[StringBuilder]

Ungrouped