Packages

  • package root
    Definition Classes
    root
  • package io
    Definition Classes
    root
  • package dylemma
    Definition Classes
    io
  • package spac

    SPaC (short for "Streaming Parser Combinators") is a library for building stream consumers in a declarative style, specialized for tree-like data types like XML and JSON.

    SPaC (short for "Streaming Parser Combinators") is a library for building stream consumers in a declarative style, specialized for tree-like data types like XML and JSON.

    Many utilities for handling XML and JSON data involve parsing the entire "document" to some DOM model, then inspecting and transforming that model to extract information. The downside to these utilities is that when the document is very large, the DOM may not fit in memory. The workaround for this type of problem is to treat the document as a stream of "events", e.g. "StartElement" and "EndElement" for XML, or "StartObject" and "EndObject" for JSON. The downside to this workaround is that writing code to handle these streams can be complicated and error-prone, especially when the DOM is complicated.

    SPaC's goal is to drastically simplify the process of creating code to handle these streams.

    This package contains the "core" SPaC traits; Parser, Transformer, Splitter, and ContextMatcher.

    See the xml and json subpackages (provided by the xml-spac and json-spac libraries respectively) for specific utilities related to handling XML and JSON event streams.

    Definition Classes
    dylemma
  • object Parser

    Definition Classes
    spac
  • FollowedBy
  • Handler
  • ParserFlatten
  • ParserFollowedByOps
  • Stateless

trait Stateless[-In, +Out] extends Parser[In, Out] with Handler[In, Out]

Specialization for Parsers which require no mutable state. A "stateless" parser acts as its own handler.

Source
Parser.scala
Linear Supertypes
Handler[In, Out], Parser[In, Out], AnyRef, Any
Ordering
  1. Grouped
  2. Alphabetic
  3. By Inheritance
Inherited
  1. Stateless
  2. Handler
  3. Parser
  4. AnyRef
  5. Any
Implicitly
  1. by ParserFollowedByOps
  2. by ParserFollowedByOps
  3. by any2stringadd
  4. by StringFormat
  5. by Ensuring
  6. by ArrowAssoc
  1. Hide All
  2. Show All
Visibility
  1. Public
  2. Protected

Abstract Value Members

  1. abstract def finish(): Out

    Signal the end of the data stream to this handler, forcing it to generate a result.

    Signal the end of the data stream to this handler, forcing it to generate a result. Handlers may throw exceptions in response to this, such as a handler which wants the first event from an empty stream.

    Further calls to step or finish after the first call to finish will result in undefined behavior. The general assumption is that a handler should be discarded after its finish method is called.

    returns

    the final result of this parser

    Definition Classes
    Handler
  2. abstract def step(in: In): Either[Out, Handler[In, Out]]

    Advance the state of this handler by accepting a single input of type In.

    Advance the state of this handler by accepting a single input of type In. If doing so would cause this parser to complete, return a Left containing the output. Otherwise, return a Right containing the next parser state.

    Handlers are assumed to be internally-mutable, so it is acceptable to simply update some internal state and then return Right(this), although in some cases it will be desirable to return a separate handler entirely.

    in

    A single input event from a data stream

    returns

    If the input would finish the parser, return a Left containing the result. Otherwise, return a Right containing a Handler which represents the next parsing state. The handler in a Right may be this handler, or a completely separate one.

    Definition Classes
    Handler

Concrete Value Members

  1. final def !=(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  2. final def ##: Int
    Definition Classes
    AnyRef → Any
  3. def +(other: String): String
    Implicit
    This member is added by an implicit conversion from Stateless[In, Out] toany2stringadd[Stateless[In, Out]] performed by method any2stringadd in scala.Predef.
    Definition Classes
    any2stringadd
  4. def ->[B](y: B): (Stateless[In, Out], B)
    Implicit
    This member is added by an implicit conversion from Stateless[In, Out] toArrowAssoc[Stateless[In, Out]] performed by method ArrowAssoc in scala.Predef.
    Definition Classes
    ArrowAssoc
    Annotations
    @inline()
  5. final def ==(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  6. final def asInstanceOf[T0]: T0
    Definition Classes
    Any
  7. def asTopLevelHandler(caller: SpacTraceElement): Handler[In, Out]

    Wraps this handler as a "top level" handler, which will inject a SpacTraceElement (representing the current input or the "EOF" signal) to any exception is thrown by this handler when calling its step or finish methods.

    Wraps this handler as a "top level" handler, which will inject a SpacTraceElement (representing the current input or the "EOF" signal) to any exception is thrown by this handler when calling its step or finish methods.

    Used internally by Parser's parse methods.

    Definition Classes
    Handler
  8. def asTransformer: Transformer[In, Out]

    Represent this parser as a Transformer which emits this parser's result

    Represent this parser as a Transformer which emits this parser's result

    Definition Classes
    Parser
  9. def attempt: Parser[In, Either[Throwable, Out]]

    Like wrapSafe, but represents exceptions as Left and successful results as Right

    Like wrapSafe, but represents exceptions as Left and successful results as Right

    Definition Classes
    Parser
  10. def beforeContext[I2 <: In, StackElem](matcher: ContextMatcher[StackElem, Any])(implicit stackable: StackLike[I2, StackElem], pos: CallerPos): Parser[I2, Out]

    Specialization of interruptedBy for stack-like input types, such that an interruption will occur upon entering a stack context that can be matched by the given matcher.

    Specialization of interruptedBy for stack-like input types, such that an interruption will occur upon entering a stack context that can be matched by the given matcher.

    Example:

    val preludeContext = * \ "prelude"
    val dataContext = * \ "data"
    for {
      prelude <- Splitter(preludeContext).firstOption[Prelude].beforeContext(dataContext).followedByStream
      data <- Splitter(dataContext).as[Data]
    } yield data
    I2

    Subtype of In, or just In (to satisfy contravariance of Parser's In type)

    StackElem

    Specialization of the In type for when it represents a stack push or pop

    matcher

    A matching function that operates on a context stack

    stackable

    Interprets the inputs as stack push/pop events to accumulate a context stack

    returns

    A parser which will perform an early finish() when a matching context is encountered

    Definition Classes
    Parser
  11. def clone(): AnyRef
    Attributes
    protected[lang]
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.CloneNotSupportedException]) @native()
  12. def ensuring(cond: (Stateless[In, Out]) => Boolean, msg: => Any): Stateless[In, Out]
    Implicit
    This member is added by an implicit conversion from Stateless[In, Out] toEnsuring[Stateless[In, Out]] performed by method Ensuring in scala.Predef.
    Definition Classes
    Ensuring
  13. def ensuring(cond: (Stateless[In, Out]) => Boolean): Stateless[In, Out]
    Implicit
    This member is added by an implicit conversion from Stateless[In, Out] toEnsuring[Stateless[In, Out]] performed by method Ensuring in scala.Predef.
    Definition Classes
    Ensuring
  14. def ensuring(cond: Boolean, msg: => Any): Stateless[In, Out]
    Implicit
    This member is added by an implicit conversion from Stateless[In, Out] toEnsuring[Stateless[In, Out]] performed by method Ensuring in scala.Predef.
    Definition Classes
    Ensuring
  15. def ensuring(cond: Boolean): Stateless[In, Out]
    Implicit
    This member is added by an implicit conversion from Stateless[In, Out] toEnsuring[Stateless[In, Out]] performed by method Ensuring in scala.Predef.
    Definition Classes
    Ensuring
  16. final def eq(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  17. def equals(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef → Any
  18. def expectInputs[I2 <: In](expectations: List[(String, (I2) => Boolean)]): Parser[I2, Out]

    Impose expectations on the sequence of inputs to be received by handlers created by this parser.

    Impose expectations on the sequence of inputs to be received by handlers created by this parser. As this parser's handler receives an input, the input will be tested against the head of the expectations list. If the test returns false, the expectation is failed and the handler will throw an exception. If the test returns true, the expectation is satisfied, and the handler will advance to the next expectation. If there are no more expectations left in the list (i.e. N inputs have satisfied the corresponding N expectations), then all expectations have been met and inputs will be treated as normal by the handler. If the handler receives an EOF before all expectations are met, it will throw an exception.

    expectations

    A sequence of label -> test expectations imposed on inputs to this parser

    returns

    A copy of this parser with expectations imposed on its inputs

    Definition Classes
    Parser
  19. def finalize(): Unit
    Attributes
    protected[lang]
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.Throwable])
  20. final def getClass(): Class[_ <: AnyRef]
    Definition Classes
    AnyRef → Any
    Annotations
    @native()
  21. def hashCode(): Int
    Definition Classes
    AnyRef → Any
    Annotations
    @native()
  22. def interruptedBy[I2 <: In](interrupter: Parser[I2, Any]): Parser[I2, Out]

    Create a copy of this parser that will treat a result from the interrupter as an early EOF.

    Create a copy of this parser that will treat a result from the interrupter as an early EOF. This is especially useful for creating followedBy chains involving optional elements.

    Normally, a parser for an optional item in some context will not finish until that context ends, or until the item is encountered. So if the item is not present, followedBy logic won't work since the followUp parser/transformer will not see any events.

    To make sure the leading parser can "fail fast", you can "interrupt" it, typically by creating a parser that immediately returns a result upon entering a particular context, i.e. the context in which the "following" parser will start. Parser#beforeContext provides a convenience for doing so.

    Note that if the interrupter throws an exception, that exception will not be caught. If your interrupter might throw, pass interrupter.wrapSafe instead to swallow the exception.

    I2

    Subtype of In, or just In (to satisfy contravariance of Parser's In type)

    interrupter

    A parser which will be run in parallel with this parser, and whose result will be treated as an early EOF for this parser, forcing an early call to finish().

    returns

    A parser which will perform an early finish() call when the interrupter produces a result.

    Definition Classes
    Parser
  23. final def isInstanceOf[T0]: Boolean
    Definition Classes
    Any
  24. def map[Out2](f: (Out) => Out2): Parser[In, Out2]

    Create a copy of this Parser whose result is transformed by the given function f.

    Create a copy of this Parser whose result is transformed by the given function f.

    Out2

    The new parser's result type

    f

    Result transformation function

    Definition Classes
    Parser
  25. final def ne(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  26. def newHandler: Stateless.this.type

    Parser's main abstract method; constructs a new Handler representing this parser's logic.

    Parser's main abstract method; constructs a new Handler representing this parser's logic. Parsers are expected to be immutable, but Handlers may be internally-mutable.

    Definition Classes
    StatelessParser
  27. final def notify(): Unit
    Definition Classes
    AnyRef
    Annotations
    @native()
  28. final def notifyAll(): Unit
    Definition Classes
    AnyRef
    Annotations
    @native()
  29. def orElse[In2 <: In, Out2 >: Out](fallback: Parser[In2, Out2]): Parser[In2, Out2]

    Combine this parser with the fallback such that failures from the underlying parsers will be ignored as long as at least one succeeds.

    Combine this parser with the fallback such that failures from the underlying parsers will be ignored as long as at least one succeeds. The result will be the result of whichever underlying parser succeeds first. If all of the underlying parsers fail, a SpacException.FallbackChainFailure will be thrown by the returned parser's handler.

    In2

    Subtype of In, or just In (to satisfy Parser's contravariance on the In type)

    Out2

    Supertype of Out, or just Out (to satisfy Parser's covariance on the Out type)

    fallback

    another parser of the same(ish) type as this one

    returns

    A new parser that will succeed if either this parser or the fallback succeed

    Definition Classes
    Parser
  30. def parse(source: Source[In])(implicit pos: CallerPos): Out

    Consume the given source to produce an output or possibly throw a SpacException.

    Consume the given source to produce an output or possibly throw a SpacException.

    The Source[A] type is like Iterable[A] but uses the "lender" pattern to acquire the iterator and close any resources associated with the iterator after the iterator is consumed.

    XML and JSON-specific Source constructors are provided by the "parser backend" libraries i.e. xml-spac-javax and json-spac-jackson.

    source

    An object that can provide a series of In values, e.g. XmlEvent or JsonEvent

    pos

    Captures the caller filename and line number, used to fill in the 'spac trace' if the parser throws an exception

    returns

    The parser result based on the given source

    Definition Classes
    Parser
  31. def parse(inputs: Iterator[In])(implicit pos: CallerPos): Out

    Consume the given inputs iterator to produce an output or possibly throw a SpacException.

    Consume the given inputs iterator to produce an output or possibly throw a SpacException.

    After calling this method, the inputs should be discarded, since consuming an Iterator is a destructive operation.

    inputs

    A series of In values, e.g. XmlEvent or JsonEvent

    pos

    Captures the caller filename and line number, used to fill in the 'spac trace' if the parser throws an exception

    returns

    The parser result based on the given inputs

    Definition Classes
    Parser
    Annotations
    @throws(scala.this.throws.<init>$default$1[io.dylemma.spac.SpacException[_]])
  32. def rethrow[T](implicit ev: <:<[Out, Either[Throwable, T]]): Parser[In, T]

    Like unwrapSafe, but rethrows exceptions from Left or returns results from Right.

    Like unwrapSafe, but rethrows exceptions from Left or returns results from Right. This operation is the opposite of attempt.

    Definition Classes
    Parser
  33. def start(methodName: String = "start")(implicit pos: CallerPos): Handler[In, Out]

    Low-level consumer method: creates a new handler and binds the caller position for its SpacTraceElement.

    Low-level consumer method: creates a new handler and binds the caller position for its SpacTraceElement.

    Used internally by the parse methods. Start with this method if you have some sequence-like datatype that doesn't provide an Iterator.

    This is just a convenience for newHandler.asTopLevelhandler which helps construct a useful SpacTraceElement.

    methodName

    The method name used to construct the SpacTraceElement for the handler. Defaults to "start"

    pos

    Captures the caller filename and line number, used to fill in the 'spac trace' if the parser throws an exception

    returns

    A parser handler that can be used to eventually produce a result by calling its step and/or finish methods

    Definition Classes
    Parser
  34. def stepMany[C[_], In2 <: In](inputs: C[In2])(implicit C: Unconsable[C]): Either[(Out, C[In2]), Handler[In, Out]]

    Convenience function to call step on a sequence of inputs all at once.

    Convenience function to call step on a sequence of inputs all at once. If the step returns a result, this method will return a Left containing that result and the remainder of the inputs that were not consumed. If the inputs run out before the handler returns a result from a step, this method will return a Right containing the latest state of the handler. This method will not call the handler's finish().

    In general, you won't call this method directly. Instead, use one of the Parser trait's parse methods.

    C

    An Unconsable collection, i.e. List or cats.data.Chain

    In2

    Subtype of In, or In (to satisfy contravariance)

    inputs

    A sequence of inputs

    C

    Evidence that the inputs has a head/tail split operation

    returns

    Either the handler's result paired with the remaining inputs, or the new handler state

    Definition Classes
    Handler
  35. final def synchronized[T0](arg0: => T0): T0
    Definition Classes
    AnyRef
  36. def toString(): String
    Definition Classes
    AnyRef → Any
  37. def unwrapSafe[T](implicit ev: <:<[Out, Try[T]]): Parser[In, T]

    Creates a copy of this parser which unwraps the resulting Try, throwing an exception if the result was a Failure.

    Creates a copy of this parser which unwraps the resulting Try, throwing an exception if the result was a Failure. This operation is the opposite of wrapSafe.

    Definition Classes
    Parser
  38. def upcast[Out2](implicit ev: <:<[Out, Out2]): Parser[In, Out2]

    Returns this parser, with the output type widened to Out2, which is some supertype of Out.

    Returns this parser, with the output type widened to Out2, which is some supertype of Out. Uses asInstanceOf rather than creating a new parser.

    Definition Classes
    Parser
  39. final def wait(): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.InterruptedException])
  40. final def wait(arg0: Long, arg1: Int): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.InterruptedException])
  41. final def wait(arg0: Long): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.InterruptedException]) @native()
  42. def withName(name: String): Parser[In, Out]

    Creates a copy of this parser, but with a different toString

    Creates a copy of this parser, but with a different toString

    name

    The new "name" (i.e. toString) for this parser

    returns

    A copy of this parser whose toString returns the given name

    Definition Classes
    Parser
  43. def wrapSafe: Parser[In, Try[Out]]

    Create a copy of this Parser whose handler will catch NonFatal exceptions thrown by the underlying logic.

    Create a copy of this Parser whose handler will catch NonFatal exceptions thrown by the underlying logic. Caught exceptions will be yielded as a Failure output. Normal results will be wrapped in Success.

    returns

    A copy of this parser that will return a Failure instead of throwing exceptions

    Definition Classes
    Parser

Shadowed Implicit Value Members

  1. def followedBy: FollowedBy[In, Out, Parser]

    Intermediate object for creating a sequenced parser in which the result of this parser will be used to initialize a second parser as soon as it is available.

    Intermediate object for creating a sequenced parser in which the result of this parser will be used to initialize a second parser as soon as it is available.

    In other words, the source (series of In values) will be fed into this Parser until this parser's handler returns a result of type Out. At that point, the second parser (as specified by using the apply or flatMap methods on the FollowedBy returned by this method) will be instantiated. Any relevant "stack events" (see Stackable) will be replayed so the second parser has the right context, and from that point on, all In values will be sent to the second parser. When that second parser returns a result, that result becomes the output of the combined parser created by this.followedBy(out => makeSecondParser(out))

    Examples:

    val p1: Parser[A] = /* ... */
    def getP2(p1Result: A): Parser[B] = /* ... */
    val combined: Parser[B] = p1.followedBy(getP2)
    
    // alternative `flatMap` syntax
    val combined: Parser[B] = for {
      p1Result <- p1.followedBy
      p2Result <- getP2(p1Result)
    } yield p2Result

    See Parser's interruptedBy, which is useful when a transformer.parseFirstOption must be followedBy some other parser.

    Implicit
    This member is added by an implicit conversion from Stateless[In, Out] toParserFollowedByOps[In, Out] performed by method ParserFollowedByOps in io.dylemma.spac.Parser.
    Shadowing
    This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
    To access this member you can use a type ascription:
    (stateless: ParserFollowedByOps[In, Out]).followedBy
    Definition Classes
    ParserFollowedByOps
  2. def followedBy: FollowedBy[In, Out, Parser]

    Intermediate object for creating a sequenced parser in which the result of this parser will be used to initialize a second parser as soon as it is available.

    Intermediate object for creating a sequenced parser in which the result of this parser will be used to initialize a second parser as soon as it is available.

    In other words, the source (series of In values) will be fed into this Parser until this parser's handler returns a result of type Out. At that point, the second parser (as specified by using the apply or flatMap methods on the FollowedBy returned by this method) will be instantiated. Any relevant "stack events" (see Stackable) will be replayed so the second parser has the right context, and from that point on, all In values will be sent to the second parser. When that second parser returns a result, that result becomes the output of the combined parser created by this.followedBy(out => makeSecondParser(out))

    Examples:

    val p1: Parser[A] = /* ... */
    def getP2(p1Result: A): Parser[B] = /* ... */
    val combined: Parser[B] = p1.followedBy(getP2)
    
    // alternative `flatMap` syntax
    val combined: Parser[B] = for {
      p1Result <- p1.followedBy
      p2Result <- getP2(p1Result)
    } yield p2Result

    See Parser's interruptedBy, which is useful when a transformer.parseFirstOption must be followedBy some other parser.

    Implicit
    This member is added by an implicit conversion from Stateless[In, Out] toParserFollowedByOps[In, Out] performed by method ParserFollowedByOps in io.dylemma.spac.Parser.
    Shadowing
    This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
    To access this member you can use a type ascription:
    (stateless: ParserFollowedByOps[In, Out]).followedBy
    Definition Classes
    ParserFollowedByOps
  3. def followedByParser: FollowedBy[In, Out, Parser]

    Alias for followedBy, for use when Cat's ApplyOps gets in the way with its own useless followedBy method.

    Alias for followedBy, for use when Cat's ApplyOps gets in the way with its own useless followedBy method.

    Implicit
    This member is added by an implicit conversion from Stateless[In, Out] toParserFollowedByOps[In, Out] performed by method ParserFollowedByOps in io.dylemma.spac.Parser.
    Shadowing
    This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
    To access this member you can use a type ascription:
    (stateless: ParserFollowedByOps[In, Out]).followedByParser
    Definition Classes
    ParserFollowedByOps
  4. def followedByParser: FollowedBy[In, Out, Parser]

    Alias for followedBy, for use when Cat's ApplyOps gets in the way with its own useless followedBy method.

    Alias for followedBy, for use when Cat's ApplyOps gets in the way with its own useless followedBy method.

    Implicit
    This member is added by an implicit conversion from Stateless[In, Out] toParserFollowedByOps[In, Out] performed by method ParserFollowedByOps in io.dylemma.spac.Parser.
    Shadowing
    This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
    To access this member you can use a type ascription:
    (stateless: ParserFollowedByOps[In, Out]).followedByParser
    Definition Classes
    ParserFollowedByOps
  5. def followedByStream: FollowedBy[In, Out, Transformer]

    Intermediate object creating a transformer that depends on this parser.

    Intermediate object creating a transformer that depends on this parser. Particularly useful in cases where one or more specific "info" elements precede a stream of other elements which require that "info" to be parsed.

    Examples:

    val p1: Parser[In, A] = /* ... */
    def getP2Stream(p1Result: A): Transformer[In, B] = /* ... */
    val combined: Transformer[In, B] = p1.andThenStream(getP2Stream)
    
    // alternative `flatMap` syntax
    val combined: Transformer[In, B] = for {
      p1Result <- p1.andThenStream
      p2Result <- getP2Stream(p1Result)
    } yield p2Result

    See followedBy for a general explanation of how the combination works.

    See also, interruptedBy, which is useful when a transformer.parseFirstOption must be followedBy some other transformer.

    Implicit
    This member is added by an implicit conversion from Stateless[In, Out] toParserFollowedByOps[In, Out] performed by method ParserFollowedByOps in io.dylemma.spac.Parser.
    Shadowing
    This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
    To access this member you can use a type ascription:
    (stateless: ParserFollowedByOps[In, Out]).followedByStream
    Definition Classes
    ParserFollowedByOps
  6. def followedByStream: FollowedBy[In, Out, Transformer]

    Intermediate object creating a transformer that depends on this parser.

    Intermediate object creating a transformer that depends on this parser. Particularly useful in cases where one or more specific "info" elements precede a stream of other elements which require that "info" to be parsed.

    Examples:

    val p1: Parser[In, A] = /* ... */
    def getP2Stream(p1Result: A): Transformer[In, B] = /* ... */
    val combined: Transformer[In, B] = p1.andThenStream(getP2Stream)
    
    // alternative `flatMap` syntax
    val combined: Transformer[In, B] = for {
      p1Result <- p1.andThenStream
      p2Result <- getP2Stream(p1Result)
    } yield p2Result

    See followedBy for a general explanation of how the combination works.

    See also, interruptedBy, which is useful when a transformer.parseFirstOption must be followedBy some other transformer.

    Implicit
    This member is added by an implicit conversion from Stateless[In, Out] toParserFollowedByOps[In, Out] performed by method ParserFollowedByOps in io.dylemma.spac.Parser.
    Shadowing
    This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
    To access this member you can use a type ascription:
    (stateless: ParserFollowedByOps[In, Out]).followedByStream
    Definition Classes
    ParserFollowedByOps

Deprecated Value Members

  1. def formatted(fmtstr: String): String
    Implicit
    This member is added by an implicit conversion from Stateless[In, Out] toStringFormat[Stateless[In, Out]] performed by method StringFormat in scala.Predef.
    Definition Classes
    StringFormat
    Annotations
    @deprecated @inline()
    Deprecated

    (Since version 2.12.16) Use formatString.format(value) instead of value.formatted(formatString), or use the f"" string interpolator. In Java 15 and later, formatted resolves to the new method in String which has reversed parameters.

  2. def [B](y: B): (Stateless[In, Out], B)
    Implicit
    This member is added by an implicit conversion from Stateless[In, Out] toArrowAssoc[Stateless[In, Out]] performed by method ArrowAssoc in scala.Predef.
    Definition Classes
    ArrowAssoc
    Annotations
    @deprecated
    Deprecated

    (Since version 2.13.0) Use -> instead. If you still wish to display it as one character, consider using a font with programming ligatures such as Fira Code.

Inherited from Handler[In, Out]

Inherited from Parser[In, Out]

Inherited from AnyRef

Inherited from Any

Inherited by implicit conversion ParserFollowedByOps fromStateless[In, Out] to ParserFollowedByOps[In, Out]

Inherited by implicit conversion ParserFollowedByOps fromStateless[In, Out] to ParserFollowedByOps[In, Out]

Inherited by implicit conversion any2stringadd fromStateless[In, Out] to any2stringadd[Stateless[In, Out]]

Inherited by implicit conversion StringFormat fromStateless[In, Out] to StringFormat[Stateless[In, Out]]

Inherited by implicit conversion Ensuring fromStateless[In, Out] to Ensuring[Stateless[In, Out]]

Inherited by implicit conversion ArrowAssoc fromStateless[In, Out] to ArrowAssoc[Stateless[In, Out]]

Abstract Members

Consumer Methods

Transformation / Combinator Methods

Ungrouped