utils/japgolly.microlibs.utils/Utils

Utils

object Utils
class Object
trait Matchable
class Any
Utils.type

Value members

Concrete methods

def arraySeqConcatDistinct[A](x: ArraySeq[A], y: ArraySeq[A])(implicit e: Eq[A]): ArraySeq[A]
def countOccurrences(str: String, subString: String): Int
def cutoffStr(s: String, cutoff: Int): String
@nowarn("cat=unused")
def dups[A : UnivEq](as: IterableOnce[A]): Iterator[A]
@nowarn("cat=unused")
def enumOrdering[A : UnivEq, B : Ordering](as: IterableOnce[A])(by: A => B): Ordering[A]
def filterAndSortByName[A](as: Iterable[A])(f: A => Boolean, name: A => String): Iterable[A]
@inline
final def filterOutAndSortByName[A](as: Iterable[A])(f: A => Boolean, name: A => String): Iterable[A]
def fitCollectionIndex(i: Int, length: Int): Int

Fit an index within the acceptable window of indices.

Fit an index within the acceptable window of indices.

Value parameters:
i

The index needing correction.

length

The length of the collection. Must be > 0.

Returns:

0 ≤ new-index < length

def flattenArraySeqs[A : ClassTag](input: Seq[ArraySeq[A]]): ArraySeq[A]
def levenshtein(str1: String, str2: String): Int

Space = Θ(mn) Time = Θ(nᵐ)

Space = Θ(mn) Time = Θ(nᵐ)

def logTime[A](name: String)(a: => A): A
def mergeDisjointMaps[K, V](x: Map[K, V], y: Map[K, V]): Map[K, V]
def mergeMaps[K, V](x: Map[K, V], y: Map[K, V])(combine: (V, V) => V): Map[K, V]
@nowarn("cat=unused")
def mergeSets[A : UnivEq](x: Set[_ <: A], y: Set[_ <: A]): Set[A]
def mergeSets[A : UnivEq](x: Set[_ <: A], y: Set[_ <: A], z: Set[_ <: A]): Set[A]
def mergeSets[A : UnivEq](w: Set[_ <: A], x: Set[_ <: A], y: Set[_ <: A], z: Set[_ <: A]): Set[A]
def mergeSets[A : UnivEq](v: Set[_ <: A], w: Set[_ <: A], x: Set[_ <: A], y: Set[_ <: A], z: Set[_ <: A]): Set[A]
@nowarn("cat=unused")
def nextElement[A : UnivEq](as: IndexedSeq[A])(a: A): A
def partitionBetween[F <: (Iterable), A](as: F[A])(split: (A, A) => Boolean)(implicit cbf: Factory[A, F[A]]): (F[A], F[A])
def partitionConsecutive[F <: (Iterable), A](as: F[A])(implicit cbf: Factory[A, F[A]], n: Numeric[A]): (F[A], F[A])
def partitionConsecutiveBy[F <: (Iterable), A, B](as: F[A])(f: A => B)(implicit cbf: Factory[A, F[A]], n: Numeric[B]): (F[A], F[A])
def quickStringExists(strings: Set[String]): String => Boolean
def quickStringLookup[A](map: Map[String, A]): String => Option[A]
def regexEscape(s: String): String

Pattern.quote doesn't work in Scala.JS.

Pattern.quote doesn't work in Scala.JS.

http://stackoverflow.com/questions/2593637/how-to-escape-regular-expression-in-javascript

def regexEscapeAndWrap(s: String): String
def separate(input: String, g: String => Int): Vector[Either[String, String]]
def separateByWhitespaceOrCommas(input: String): Vector[Either[String, String]]
def sideBySideStringSeqs(vec1: IndexedSeq[String], vec2: IndexedSeq[String], sep: String): Vector[String]
def sideBySideStrings(str1: String, str2: String, sep: String): String
@nowarn("cat=unused")
def uniqueDupsNested[A, B : UnivEq](as: IterableOnce[A])(bs: A => IterableOnce[B]): Set[B]
def univEqAndArbitraryOrder[A](values: Iterable[A]): UnivEq[A] & Order[A]
def vectorConcatDistinct[A](x: Vector[A], y: Vector[A])(implicit e: Eq[A]): Vector[A]