Packages

sealed trait Stack[T] extends AnyRef

Stacks represent stackable elements of type T. It is assumed that T-typed elements can be stacked in some meaningful way; examples are functions (function composition) Filters (chaining), and ServiceFactories (through transformers). T-typed values are also meant to compose: the stack itself materializes into a T-typed value.

Stacks are persistent, allowing for nondestructive transformations; they are designed to represent 'template' stacks which can be configured in various ways before materializing the stack itself.

Note: Stacks are advanced and sometimes subtle. For expert use only!

Linear Supertypes
Ordering
  1. Alphabetic
  2. By Inheritance
Inherited
  1. Stack
  2. AnyRef
  3. Any
  1. Hide All
  2. Show All
Visibility
  1. Public
  2. All

Abstract Value Members

  1. abstract val head: Head

    The head field of the Stack composes all associated metadata of the topmost element of the stack.

    The head field of the Stack composes all associated metadata of the topmost element of the stack.

    Note

    head does not give access to the value T, use make instead.

    See also

    Stack.Head

Concrete Value Members

  1. final def !=(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  2. final def ##(): Int
    Definition Classes
    AnyRef → Any
  3. def ++(right: Stack[T]): Stack[T]

    Produce a new stack representing the concatenation of this with right.

    Produce a new stack representing the concatenation of this with right. Note that this replaces the terminating element of this.

  4. def +:(stk: Stackable[T]): Stack[T]

    A copy of this Stack with stk prepended.

  5. final def ==(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  6. final def asInstanceOf[T0]: T0
    Definition Classes
    Any
  7. def clone(): AnyRef
    Attributes
    protected[lang]
    Definition Classes
    AnyRef
    Annotations
    @throws( ... ) @native()
  8. def concat(right: Stack[T]): Stack[T]

    Produce a new stack representing the concatenation of this with right.

    Produce a new stack representing the concatenation of this with right. Note that this replaces the terminating element of this.

    Alias for Stack.++.

  9. def contains(role: Role): Boolean

    Returns whether the stack contains a given role or not.

  10. final def eq(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  11. def equals(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  12. final def exists(pred: (Stack[T]) ⇒ Boolean): Boolean

    Traverse the stack, until you find that pred has been evaluated to true.

    Traverse the stack, until you find that pred has been evaluated to true. If pred finds an element, return true, otherwise, false.

    Annotations
    @tailrec()
  13. def finalize(): Unit
    Attributes
    protected[lang]
    Definition Classes
    AnyRef
    Annotations
    @throws( classOf[java.lang.Throwable] )
  14. final def foreach(fn: (Stack[T]) ⇒ Unit): Unit

    Traverse the stack, invoking fn on each element.

    Traverse the stack, invoking fn on each element.

    Annotations
    @tailrec()
  15. final def getClass(): Class[_]
    Definition Classes
    AnyRef → Any
    Annotations
    @native()
  16. def hashCode(): Int
    Definition Classes
    AnyRef → Any
    Annotations
    @native()
  17. def insertAfter[U](target: Role, insertion: U)(implicit csf: CanStackFrom[U, T]): Stack[T]

    Insert the given Stackable after the stack elements matching the argument role.

    Insert the given Stackable after the stack elements matching the argument role. If no elements match the role, then an unmodified stack is returned. insertion must conform to typeclass CanStackFrom.

  18. def insertAfter(target: Role, insertion: Stackable[T]): Stack[T]

    Insert the given Stackable after the stack elements matching the argument role.

    Insert the given Stackable after the stack elements matching the argument role. If no elements match the role, then an unmodified stack is returned.

  19. def insertBefore[U](target: Role, insertion: U)(implicit csf: CanStackFrom[U, T]): Stack[T]

    Insert the given Stackable before the stack elements matching the argument role.

    Insert the given Stackable before the stack elements matching the argument role. If no elements match the role, then an unmodified stack is returned. insertion must conform to typeclass CanStackFrom.

  20. def insertBefore(target: Role, insertion: Stackable[T]): Stack[T]

    Insert the given Stackable before the stack elements matching the argument role.

    Insert the given Stackable before the stack elements matching the argument role. If no elements match the role, then an unmodified stack is returned.

  21. final def isInstanceOf[T0]: Boolean
    Definition Classes
    Any
  22. def make(params: Params): T

    Materialize the current stack with the given parameters, producing a T-typed value representing the current configuration.

  23. def map(fn: (Head, T) ⇒ T): Stack[T]

    Transform one stack to another by applying fn on each element.

  24. final def ne(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  25. final def notify(): Unit
    Definition Classes
    AnyRef
    Annotations
    @native()
  26. final def notifyAll(): Unit
    Definition Classes
    AnyRef
    Annotations
    @native()
  27. def prepend[U](role: Role, element: U)(implicit csf: CanStackFrom[U, T]): Stack[T]

    A copy of this Stack with element prepended using the given Stack.Role.

  28. def prepend(stk: Stackable[T]): Stack[T]

    A copy of this Stack with stk prepended.

    A copy of this Stack with stk prepended.

    An alias for Stack.+:.

  29. def remove(target: Role): Stack[T]

    Remove all nodes in the stack that match the target role.

    Remove all nodes in the stack that match the target role. Leaf nodes are not removable.

  30. def replace[U](target: Role, replacement: U)(implicit csf: CanStackFrom[U, T]): Stack[T]

    Replace any stack elements matching the argument role with a given Stackable.

    Replace any stack elements matching the argument role with a given Stackable. If no elements match the role, then an unmodified stack is returned. replacement must conform to typeclass CanStackFrom.

  31. def replace(target: Role, replacement: Stackable[T]): Stack[T]

    Replace any stack elements matching the argument role with a given Stackable.

    Replace any stack elements matching the argument role with a given Stackable. If no elements match the role, then an unmodified stack is returned.

  32. final def synchronized[T0](arg0: ⇒ T0): T0
    Definition Classes
    AnyRef
  33. def tails: Iterator[Stack[T]]

    Enumerate each well-formed stack contained within this stack.

  34. def toString(): String
    Definition Classes
    Stack → AnyRef → Any
  35. def transform(fn: (Stack[T]) ⇒ Stack[T]): Stack[T]

    Transform one stack to another by applying fn on each element; the map traverses on the element produced by fn, not the original stack.

    Transform one stack to another by applying fn on each element; the map traverses on the element produced by fn, not the original stack. Prefer using map over transform.

    Attributes
    protected
  36. final def wait(): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  37. final def wait(arg0: Long, arg1: Int): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  38. final def wait(arg0: Long): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws( ... ) @native()

Inherited from AnyRef

Inherited from Any

Ungrouped