Packages

p

fastparse

internal

package internal

Ordering
  1. Alphabetic
Visibility
  1. Public
  2. All

Type Members

  1. final class CompactTrieNode extends AnyRef
  2. trait Instrument extends AnyRef
  3. class Lazy[T] extends AnyRef
  4. case class Logger(f: (String) ⇒ Unit) extends Product with Serializable
  5. case class Msgs(value: List[Lazy[String]]) extends Product with Serializable
  6. final class RepImpls[T] extends AnyVal
  7. final class TrieNode extends AnyRef
  8. class UberBuffer extends AnyRef

    A very fast circular, growable read-write byte buffer.

Value Members

  1. object Logger extends Serializable
  2. object MacroImpls

    Fastparse relies heavily on macro-based inlining to provide good performance: inlining allows for better optimization at each callsite compared to all callsites calling into the same shared function body.

    Fastparse relies heavily on macro-based inlining to provide good performance: inlining allows for better optimization at each callsite compared to all callsites calling into the same shared function body. Most of these macros do not do anything fancy and simply inline the body of a plain-old-function, although a handful do some partial evaluation e.g. optimizing the LiteralStr and CharIn macros in cases where the String/Char values are known at compile time.

  3. object MacroRepImpls

    Implementations of the various .rep/.repX overloads.

    Implementations of the various .rep/.repX overloads. The most common and simple overloads are implemented as macros for performance, while the more complex/general cases are left as normal methods to avoid code bloat and allow the use of default/named arguments (which don't work in macros due to https://github.com/scala/bug/issues/5920).

    Even the normal method overloads are manually-specialized to some extent for various sorts of inputs as a best-effort attempt ot minimize branching in the hot paths.

  4. object Msgs extends Serializable
  5. object Util

Ungrouped