Home - News ( United States | United Kingdom | Italy | Germany ) - Football scores

Showing content from https://www.scala-lang.org/api/2.12.16/scala-xml/scala/xml/Comment.html below:

 

1. Alphabetic
2. By Inheritance

1. Comment
2. Serializable
3. Serializable
4. Product
5. SpecialNode
6. XMLEvent
7. Node
8. NodeSeq
9. Equality
10. Seq
11. Iterable
12. Traversable
13. Immutable
14. AbstractSeq
15. Seq
16. SeqLike
17. GenSeq
18. GenSeqLike
19. PartialFunction
20. Function1
21. AbstractIterable
22. Iterable
23. IterableLike
24. Equals
25. GenIterable
26. GenIterableLike
27. AbstractTraversable
28. Traversable
29. GenTraversable
30. GenericTraversableTemplate
31. TraversableLike
32. GenTraversableLike
33. Parallelizable
34. TraversableOnce
35. GenTraversableOnce
36. FilterMonadic
37. HasNewBuilder
38. AnyRef
39. Any

1.  new Comment(commentText: String)

1.  type Self = NodeSeq
2.  class WithFilter extends FilterMonadic[A, Repr]

1.  final def !=(arg0: Any): Boolean
2.  final def ##(): Int
3.  def ++[B >: Node, That](that: GenTraversableOnce[B])(implicit bf: CanBuildFrom[NodeSeq, B, That]): That
4.  def ++:[B >: Node, That](that: collection.Traversable[B])(implicit bf: CanBuildFrom[NodeSeq, B, That]): That
5.  def ++:[B >: Node, That](that: collection.TraversableOnce[B])(implicit bf: CanBuildFrom[NodeSeq, B, That]): That
6.  def +:[B >: Node, That](elem: B)(implicit bf: CanBuildFrom[NodeSeq, B, That]): That
7.  def /:[B](z: B)(op: (B, Node) ⇒ B): B
8.  def :+[B >: Node, That](elem: B)(implicit bf: CanBuildFrom[NodeSeq, B, That]): That
9.  def :\[B](z: B)(op: (Node, B) ⇒ B): B
10.  final def ==(arg0: Any): Boolean
11.  def \(that: String): NodeSeq
12.  def \@(attributeName: String): String
13.  def \\(that: String): NodeSeq
14.  def addString(b: StringBuilder): StringBuilder
15.  def addString(b: StringBuilder, sep: String): StringBuilder
16.  def addString(b: StringBuilder, start: String, sep: String, end: String): StringBuilder
17.  def aggregate[B](z: ⇒ B)(seqop: (B, Node) ⇒ B, combop: (B, B) ⇒ B): B
18.  def andThen[C](k: (Node) ⇒ C): PartialFunction[Int, C]
19.  def apply(f: (Node) ⇒ Boolean): NodeSeq
20.  def apply(i: Int): Node
21.  def applyOrElse[A1 <: Int, B1 >: Node](x: A1, default: (A1) ⇒ B1): B1
22.  final def asInstanceOf[T0]: T0
23.  final def attribute(uri: String, key: String): Option[Seq[Node]]
24.  final def attribute(key: String): Option[Seq[Node]]
25.  final def attributes: Null.type
26.  def basisForHashCode: Seq[Any]
27.  def buildString(sb: StringBuilder): collection.mutable.StringBuilder
28.  def buildString(stripComments: Boolean): String
29.  def canEqual(other: Any): Boolean
30.  final def child: collection.immutable.Nil.type
31.  def clone(): AnyRef
32.  def collect[B, That](pf: PartialFunction[Node, B])(implicit bf: CanBuildFrom[NodeSeq, B, That]): That
33.  def collectFirst[B](pf: PartialFunction[Node, B]): Option[B]
34.  def combinations(n: Int): collection.Iterator[NodeSeq]
35.  val commentText: String
36.  def companion: GenericCompanion[collection.immutable.Seq]
37.  def compose[A](g: (A) ⇒ Int): (A) ⇒ Node
38.  def contains[A1 >: Node](elem: A1): Boolean
39.  def containsSlice[B](that: GenSeq[B]): Boolean
40.  def copyToArray[B >: Node](xs: Array[B], start: Int, len: Int): Unit
41.  def copyToArray[B >: Node](xs: Array[B]): Unit
42.  def copyToArray[B >: Node](xs: Array[B], start: Int): Unit
43.  def copyToBuffer[B >: Node](dest: Buffer[B]): Unit
44.  def corresponds[B](that: GenSeq[B])(p: (Node, B) ⇒ Boolean): Boolean
45.  def count(p: (Node) ⇒ Boolean): Int
46.  def descendant: List[Node]
47.  def descendant_or_self: List[Node]
48.  def diff[B >: Node](that: GenSeq[B]): NodeSeq
49.  def distinct: NodeSeq
50.  final def doCollectNamespaces: Boolean
51.  final def doTransform: Boolean
52.  def drop(n: Int): NodeSeq
53.  def dropRight(n: Int): NodeSeq
54.  def dropWhile(p: (Node) ⇒ Boolean): NodeSeq
55.  def endsWith[B](that: GenSeq[B]): Boolean
56.  final def eq(arg0: AnyRef): Boolean
57.  def equals(other: Any): Boolean
58.  def exists(p: (Node) ⇒ Boolean): Boolean
59.  def filter(p: (Node) ⇒ Boolean): NodeSeq
60.  def filterNot(p: (Node) ⇒ Boolean): NodeSeq
61.  def finalize(): Unit
62.  def find(p: (Node) ⇒ Boolean): Option[Node]
63.  def flatMap[B, That](f: (Node) ⇒ GenTraversableOnce[B])(implicit bf: CanBuildFrom[NodeSeq, B, That]): That
64.  def flatten[B](implicit asTraversable: (Node) ⇒ GenTraversableOnce[B]): collection.immutable.Seq[B]
65.  def fold[A1 >: Node](z: A1)(op: (A1, A1) ⇒ A1): A1
66.  def foldLeft[B](z: B)(op: (B, Node) ⇒ B): B
67.  def foldRight[B](z: B)(op: (Node, B) ⇒ B): B
68.  def forall(p: (Node) ⇒ Boolean): Boolean
69.  def foreach[U](f: (Node) ⇒ U): Unit
70.  def genericBuilder[B]: Builder[B, collection.immutable.Seq[B]]
71.  final def getClass(): Class[_]
72.  def getNamespace(pre: String): String
73.  def groupBy[K](f: (Node) ⇒ K): Map[K, NodeSeq]
74.  def grouped(size: Int): collection.Iterator[NodeSeq]
75.  def hasDefiniteSize: Boolean
76.  def hashCode(): Int
77.  def head: Node
78.  def headOption: Option[Node]
79.  def indexOf[B >: Node](elem: B, from: Int): Int
80.  def indexOf[B >: Node](elem: B): Int
81.  def indexOfSlice[B >: Node](that: GenSeq[B], from: Int): Int
82.  def indexOfSlice[B >: Node](that: GenSeq[B]): Int
83.  def indexWhere(p: (Node) ⇒ Boolean, from: Int): Int
84.  def indexWhere(p: (Node) ⇒ Boolean): Int
85.  def indices: collection.immutable.Range
86.  def init: NodeSeq
87.  def inits: collection.Iterator[NodeSeq]
88.  def intersect[B >: Node](that: GenSeq[B]): NodeSeq
89.  def isAtom: Boolean
90.  def isDefinedAt(idx: Int): Boolean
91.  def isEmpty: Boolean
92.  final def isInstanceOf[T0]: Boolean
93.  final def isTraversableAgain: Boolean
94.  def iterator: collection.Iterator[Node]
95.  def label: String
96.  def last: Node
97.  def lastIndexOf[B >: Node](elem: B, end: Int): Int
98.  def lastIndexOf[B >: Node](elem: B): Int
99.  def lastIndexOfSlice[B >: Node](that: GenSeq[B], end: Int): Int
100.  def lastIndexOfSlice[B >: Node](that: GenSeq[B]): Int
101.  def lastIndexWhere(p: (Node) ⇒ Boolean, end: Int): Int
102.  def lastIndexWhere(p: (Node) ⇒ Boolean): Int
103.  def lastOption: Option[Node]
104.  def length: Int
105.  def lengthCompare(len: Int): Int
106.  def lift: (Int) ⇒ Option[Node]
107.  def map[B, That](f: (Node) ⇒ B)(implicit bf: CanBuildFrom[NodeSeq, B, That]): That
108.  def max[B >: Node](implicit cmp: Ordering[B]): Node
109.  def maxBy[B](f: (Node) ⇒ B)(implicit cmp: Ordering[B]): Node
110.  def min[B >: Node](implicit cmp: Ordering[B]): Node
111.  def minBy[B](f: (Node) ⇒ B)(implicit cmp: Ordering[B]): Node
112.  def mkString: String
113.  def mkString(sep: String): String
114.  def mkString(start: String, sep: String, end: String): String
115.  def nameToString(sb: StringBuilder): StringBuilder
116.  final def namespace: Null
117.  final def ne(arg0: AnyRef): Boolean
118.  def newBuilder: Builder[Node, NodeSeq]
119.  def nonEmpty: Boolean
120.  def nonEmptyChildren: Seq[Node]
121.  final def notify(): Unit
122.  final def notifyAll(): Unit
123.  def orElse[A1 <: Int, B1 >: Node](that: PartialFunction[A1, B1]): PartialFunction[A1, B1]
124.  def padTo[B >: Node, That](len: Int, elem: B)(implicit bf: CanBuildFrom[NodeSeq, B, That]): That
125.  def par: ParSeq[Node]
126.  def parCombiner: Combiner[Node, ParSeq[Node]]
127.  def partition(p: (Node) ⇒ Boolean): (NodeSeq, NodeSeq)
128.  def patch[B >: Node, That](from: Int, patch: GenSeq[B], replaced: Int)(implicit bf: CanBuildFrom[NodeSeq, B, That]): That
129.  def permutations: collection.Iterator[NodeSeq]
130.  def prefix: String
131.  def prefixLength(p: (Node) ⇒ Boolean): Int
132.  def product[B >: Node](implicit num: Numeric[B]): B
133.  def reduce[A1 >: Node](op: (A1, A1) ⇒ A1): A1
134.  def reduceLeft[B >: Node](op: (B, Node) ⇒ B): B
135.  def reduceLeftOption[B >: Node](op: (B, Node) ⇒ B): Option[B]
136.  def reduceOption[A1 >: Node](op: (A1, A1) ⇒ A1): Option[A1]
137.  def reduceRight[B >: Node](op: (Node, B) ⇒ B): B
138.  def reduceRightOption[B >: Node](op: (Node, B) ⇒ B): Option[B]
139.  def repr: NodeSeq
140.  def reverse: NodeSeq
141.  def reverseIterator: collection.Iterator[Node]
142.  def reverseMap[B, That](f: (Node) ⇒ B)(implicit bf: CanBuildFrom[NodeSeq, B, That]): That
143.  def reversed: List[Node]
144.  def runWith[U](action: (Node) ⇒ U): (Int) ⇒ Boolean
145.  def sameElements[B >: Node](that: GenIterable[B]): Boolean
146.  def scan[B >: Node, That](z: B)(op: (B, B) ⇒ B)(implicit cbf: CanBuildFrom[NodeSeq, B, That]): That
147.  def scanLeft[B, That](z: B)(op: (B, Node) ⇒ B)(implicit bf: CanBuildFrom[NodeSeq, B, That]): That
148.  def scanRight[B, That](z: B)(op: (Node, B) ⇒ B)(implicit bf: CanBuildFrom[NodeSeq, B, That]): That
149.  def scope: NamespaceBinding
150.  def segmentLength(p: (Node) ⇒ Boolean, from: Int): Int
151.  def seq: collection.immutable.Seq[Node]
152.  def size: Int
153.  def sizeHintIfCheap: Int
154.  def slice(from: Int, until: Int): NodeSeq
155.  def sliding(size: Int, step: Int): collection.Iterator[NodeSeq]
156.  def sliding(size: Int): collection.Iterator[NodeSeq]
157.  def sortBy[B](f: (Node) ⇒ B)(implicit ord: math.Ordering[B]): NodeSeq
158.  def sortWith(lt: (Node, Node) ⇒ Boolean): NodeSeq
159.  def sorted[B >: Node](implicit ord: math.Ordering[B]): NodeSeq
160.  def span(p: (Node) ⇒ Boolean): (NodeSeq, NodeSeq)
161.  def splitAt(n: Int): (NodeSeq, NodeSeq)
162.  def startsWith[B](that: GenSeq[B], offset: Int): Boolean
163.  def startsWith[B](that: GenSeq[B]): Boolean
164.  def strict_!=(other: Equality): Boolean
165.  def strict_==(other: Equality): Boolean
166.  def stringPrefix: String
167.  def sum[B >: Node](implicit num: Numeric[B]): B
168.  final def synchronized[T0](arg0: ⇒ T0): T0
169.  def tail: NodeSeq
170.  def tails: collection.Iterator[NodeSeq]
171.  def take(n: Int): NodeSeq
172.  def takeRight(n: Int): NodeSeq
173.  def takeWhile(p: (Node) ⇒ Boolean): NodeSeq
174.  def text: String
175.  def theSeq: Seq[Node]
176.  def thisCollection: collection.Seq[Node]
177.  def to[Col[_]](implicit cbf: CanBuildFrom[Nothing, Node, Col[Node]]): Col[Node]
178.  def toArray[B >: Node](implicit arg0: ClassTag[B]): Array[B]
179.  def toBuffer[B >: Node]: Buffer[B]
180.  def toCollection(repr: NodeSeq): collection.Seq[Node]
181.  def toIndexedSeq: collection.immutable.IndexedSeq[Node]
182.  def toIterable: collection.Iterable[Node]
183.  def toIterator: collection.Iterator[Node]
184.  def toList: List[Node]
185.  def toMap[T, U](implicit ev: <:<[Node, (T, U)]): Map[T, U]
186.  def toSeq: collection.immutable.Seq[Node]
187.  def toSet[B >: Node]: Set[B]
188.  def toStream: collection.immutable.Stream[Node]
189.  def toString(): String
190.  def toTraversable: collection.Traversable[Node]
191.  def toVector: Vector[Node]
192.  def transpose[B](implicit asTraversable: (Node) ⇒ GenTraversableOnce[B]): collection.immutable.Seq[collection.immutable.Seq[B]]
193.  def union[B >: Node, That](that: GenSeq[B])(implicit bf: CanBuildFrom[NodeSeq, B, That]): That
194.  def unzip[A1, A2](implicit asPair: (Node) ⇒ (A1, A2)): (collection.immutable.Seq[A1], collection.immutable.Seq[A2])
195.  def unzip3[A1, A2, A3](implicit asTriple: (Node) ⇒ (A1, A2, A3)): (collection.immutable.Seq[A1], collection.immutable.Seq[A2], collection.immutable.Seq[A3])
196.  def updated[B >: Node, That](index: Int, elem: B)(implicit bf: CanBuildFrom[NodeSeq, B, That]): That
197.  def view(from: Int, until: Int): SeqView[Node, NodeSeq]
198.  def view: SeqView[Node, NodeSeq]
199.  final def wait(): Unit
200.  final def wait(arg0: Long, arg1: Int): Unit
201.  final def wait(arg0: Long): Unit
202.  def withFilter(p: (Node) ⇒ Boolean): FilterMonadic[Node, NodeSeq]
203.  def xmlType(): TypeSymbol
204.  final def xml_!=(other: Any): Boolean
205.  final def xml_==(other: Any): Boolean
206.  def xml_sameElements[A](that: Iterable[A]): Boolean
207.  def zip[A1 >: Node, B, That](that: GenIterable[B])(implicit bf: CanBuildFrom[NodeSeq, (A1, B), That]): That
208.  def zipAll[B, A1 >: Node, That](that: GenIterable[B], thisElem: A1, thatElem: B)(implicit bf: CanBuildFrom[NodeSeq, (A1, B), That]): That
209.  def zipWithIndex[A1 >: Node, That](implicit bf: CanBuildFrom[NodeSeq, (A1, Int), That]): That

RetroSearch is an open source project built by @garambo | Open a GitHub Issue

Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo

HTML: 3.2 | Encoding: UTF-8 | Version: 0.7.4