A RetroSearch Logo

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

Search Query:

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

abstract class NodeSeq extends AbstractSeq[Node] with collection.immutable.Seq[Node] with ScalaVersionSpecificNodeSeq with Equality with Serializable

 

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

Inherited from ScalaVersionSpecificNodeSeq

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