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!
- Alphabetic
- By Inheritance
- Stack
- AnyRef
- Any
- Hide All
- Show All
- Public
- All
Abstract Value Members
-
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 valueT
, usemake
instead.- See also
-
abstract
def
make(params: Params): T
Materialize the current stack with the given parameters, producing a
T
-typed value representing the current configuration.
Concrete Value Members
-
final
def
!=(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
-
final
def
##(): Int
- Definition Classes
- AnyRef → Any
-
def
++(right: Stack[T]): Stack[T]
Produce a new stack representing the concatenation of
this
withright
.Produce a new stack representing the concatenation of
this
withright
. Note that this replaces the terminating element ofthis
. -
def
+:(stk: Stackable[T]): Stack[T]
A copy of this Stack with
stk
prepended. -
final
def
==(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
-
final
def
asInstanceOf[T0]: T0
- Definition Classes
- Any
-
def
clone(): AnyRef
- Attributes
- protected[java.lang]
- Definition Classes
- AnyRef
- Annotations
- @throws( ... )
-
def
concat(right: Stack[T]): Stack[T]
Produce a new stack representing the concatenation of
this
withright
.Produce a new stack representing the concatenation of
this
withright
. Note that this replaces the terminating element ofthis
.Alias for Stack.++.
-
def
contains(role: Role): Boolean
Returns whether the stack contains a given role or not.
-
final
def
eq(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
-
def
equals(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
-
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()
-
def
finalize(): Unit
- Attributes
- protected[java.lang]
- Definition Classes
- AnyRef
- Annotations
- @throws( classOf[java.lang.Throwable] )
-
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()
-
final
def
getClass(): Class[_]
- Definition Classes
- AnyRef → Any
-
def
hashCode(): Int
- Definition Classes
- AnyRef → Any
-
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. -
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.
-
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. -
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.
-
final
def
isInstanceOf[T0]: Boolean
- Definition Classes
- Any
-
final
def
ne(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
-
final
def
notify(): Unit
- Definition Classes
- AnyRef
-
final
def
notifyAll(): Unit
- Definition Classes
- AnyRef
-
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.+:.
-
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. -
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. -
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.
-
final
def
synchronized[T0](arg0: ⇒ T0): T0
- Definition Classes
- AnyRef
-
def
tails: Iterator[Stack[T]]
Enumerate each well-formed stack contained within this stack.
-
def
toString(): String
- Definition Classes
- Stack → AnyRef → Any
-
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 byfn
, not the original stack.Transform one stack to another by applying
fn
on each element; the map traverses on the element produced byfn
, not the original stack.- Attributes
- protected
-
final
def
wait(): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws( ... )
-
final
def
wait(arg0: Long, arg1: Int): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws( ... )
-
final
def
wait(arg0: Long): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws( ... )