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/Group.html below:

 

1. Alphabetic
2. By Inheritance

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

1.  new Group(nodes: Seq[Node])

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.  def attributes: Nothing
26.  def basisForHashCode: Seq[Node]
27.  def buildString(sb: StringBuilder): Nothing
28.  def buildString(stripComments: Boolean): String
29.  def canEqual(other: Any): Boolean
30.  def child: Nothing
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.  def companion: GenericCompanion[collection.immutable.Seq]
36.  def compose[A](g: (A) ⇒ Int): (A) ⇒ Node
37.  def contains[A1 >: Node](elem: A1): Boolean
38.  def containsSlice[B](that: GenSeq[B]): Boolean
39.  def copyToArray[B >: Node](xs: Array[B], start: Int, len: Int): Unit
40.  def copyToArray[B >: Node](xs: Array[B]): Unit
41.  def copyToArray[B >: Node](xs: Array[B], start: Int): Unit
42.  def copyToBuffer[B >: Node](dest: Buffer[B]): Unit
43.  def corresponds[B](that: GenSeq[B])(p: (Node, B) ⇒ Boolean): Boolean
44.  def count(p: (Node) ⇒ Boolean): Int
45.  def descendant: List[Node]
46.  def descendant_or_self: List[Node]
47.  def diff[B >: Node](that: GenSeq[B]): NodeSeq
48.  def distinct: NodeSeq
49.  def doCollectNamespaces: Boolean
50.  def doTransform: Boolean
51.  def drop(n: Int): NodeSeq
52.  def dropRight(n: Int): NodeSeq
53.  def dropWhile(p: (Node) ⇒ Boolean): NodeSeq
54.  def endsWith[B](that: GenSeq[B]): Boolean
55.  final def eq(arg0: AnyRef): Boolean
56.  def equals(other: Any): Boolean
57.  def exists(p: (Node) ⇒ Boolean): Boolean
58.  def filter(p: (Node) ⇒ Boolean): NodeSeq
59.  def filterNot(p: (Node) ⇒ Boolean): NodeSeq
60.  def finalize(): Unit
61.  def find(p: (Node) ⇒ Boolean): Option[Node]
62.  def flatMap[B, That](f: (Node) ⇒ GenTraversableOnce[B])(implicit bf: CanBuildFrom[NodeSeq, B, That]): That
63.  def flatten[B](implicit asTraversable: (Node) ⇒ GenTraversableOnce[B]): collection.immutable.Seq[B]
64.  def fold[A1 >: Node](z: A1)(op: (A1, A1) ⇒ A1): A1
65.  def foldLeft[B](z: B)(op: (B, Node) ⇒ B): B
66.  def foldRight[B](z: B)(op: (Node, B) ⇒ B): B
67.  def forall(p: (Node) ⇒ Boolean): Boolean
68.  def foreach[U](f: (Node) ⇒ U): Unit
69.  def genericBuilder[B]: Builder[B, collection.immutable.Seq[B]]
70.  final def getClass(): Class[_]
71.  def getNamespace(pre: String): String
72.  def groupBy[K](f: (Node) ⇒ K): Map[K, NodeSeq]
73.  def grouped(size: Int): collection.Iterator[NodeSeq]
74.  def hasDefiniteSize: Boolean
75.  def hashCode(): Int
76.  def head: Node
77.  def headOption: Option[Node]
78.  def indexOf[B >: Node](elem: B, from: Int): Int
79.  def indexOf[B >: Node](elem: B): Int
80.  def indexOfSlice[B >: Node](that: GenSeq[B], from: Int): Int
81.  def indexOfSlice[B >: Node](that: GenSeq[B]): Int
82.  def indexWhere(p: (Node) ⇒ Boolean, from: Int): Int
83.  def indexWhere(p: (Node) ⇒ Boolean): Int
84.  def indices: collection.immutable.Range
85.  def init: NodeSeq
86.  def inits: collection.Iterator[NodeSeq]
87.  def intersect[B >: Node](that: GenSeq[B]): NodeSeq
88.  def isAtom: Boolean
89.  def isDefinedAt(idx: Int): Boolean
90.  def isEmpty: Boolean
91.  final def isInstanceOf[T0]: Boolean
92.  final def isTraversableAgain: Boolean
93.  def iterator: collection.Iterator[Node]
94.  def label: Nothing
95.  def last: Node
96.  def lastIndexOf[B >: Node](elem: B, end: Int): Int
97.  def lastIndexOf[B >: Node](elem: B): Int
98.  def lastIndexOfSlice[B >: Node](that: GenSeq[B], end: Int): Int
99.  def lastIndexOfSlice[B >: Node](that: GenSeq[B]): Int
100.  def lastIndexWhere(p: (Node) ⇒ Boolean, end: Int): Int
101.  def lastIndexWhere(p: (Node) ⇒ Boolean): Int
102.  def lastOption: Option[Node]
103.  def length: Int
104.  def lengthCompare(len: Int): Int
105.  def lift: (Int) ⇒ Option[Node]
106.  def map[B, That](f: (Node) ⇒ B)(implicit bf: CanBuildFrom[NodeSeq, B, That]): That
107.  def max[B >: Node](implicit cmp: Ordering[B]): Node
108.  def maxBy[B](f: (Node) ⇒ B)(implicit cmp: Ordering[B]): Node
109.  def min[B >: Node](implicit cmp: Ordering[B]): Node
110.  def minBy[B](f: (Node) ⇒ B)(implicit cmp: Ordering[B]): Node
111.  def mkString: String
112.  def mkString(sep: String): String
113.  def mkString(start: String, sep: String, end: String): String
114.  def nameToString(sb: StringBuilder): StringBuilder
115.  def namespace: Nothing
116.  final def ne(arg0: AnyRef): Boolean
117.  def newBuilder: Builder[Node, NodeSeq]
118.  val nodes: Seq[Node]
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