Node

Instance Constructors

new Node(head: Head, mk: (Params, Stack[T]) ⇒ Stack[T], next: Stack[T])

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 with right.
Produce a new stack representing the concatenation of this with right. Note that this replaces the terminating element of this.

Definition Classes
Stack
def +:(stk: Stackable[T]): Stack[T]

A copy of this Stack with stk prepended.
A copy of this Stack with stk prepended.

Definition Classes
Stack
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 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.++.

Definition Classes
Stack
def contains(role: Role): Boolean

Returns whether the stack contains a given role or not.
Returns whether the stack contains a given role or not.

Definition Classes
Stack
final def eq(arg0: AnyRef): Boolean

Definition Classes
AnyRef
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.

Definition Classes
Stack
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.

Definition Classes
Stack
Annotations
@tailrec()
final def getClass(): Class[_]

Definition Classes
AnyRef → Any
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.

Definition Classes
Node → Stack
Note
head does not give access to the value T, use make instead.
See also
Stack.Head
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.

Definition Classes
Stack
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.

Definition Classes
Stack
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.

Definition Classes
Stack
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.

Definition Classes
Stack
final def isInstanceOf[T0]: Boolean

Definition Classes
Any
def make(params: Params): T

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

Definition Classes
Node → Stack
val mk: (Params, Stack[T]) ⇒ Stack[T]
final def ne(arg0: AnyRef): Boolean

Definition Classes
AnyRef
val next: Stack[T]
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.+:.

Definition Classes
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.

Definition Classes
Stack
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.

Definition Classes
Stack
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.

Definition Classes
Stack
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
def tails: Iterator[Stack[T]]

Enumerate each well-formed stack contained within this stack.
Enumerate each well-formed stack contained within this stack.

Definition Classes
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 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.

Attributes
protected
Definition Classes
Stack
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( ... )

Related Docs: object Node | package Stack

case class Node[T](head: Head, mk: (Params, Stack[T]) ⇒ Stack[T], next: Stack[T]) extends Stack[T] with Product with Serializable

Instance Constructors

new Node(head: Head, mk: (Params, Stack[T]) ⇒ Stack[T], next: Stack[T])

Value Members

final def !=(arg0: Any): Boolean

final def ##(): Int

def ++(right: Stack[T]): Stack[T]

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

final def ==(arg0: Any): Boolean

final def asInstanceOf[T0]: T0

def clone(): AnyRef

def concat(right: Stack[T]): Stack[T]

def contains(role: Role): Boolean

final def eq(arg0: AnyRef): Boolean

final def exists(pred: (Stack[T]) ⇒ Boolean): Boolean

def finalize(): Unit

final def foreach(fn: (Stack[T]) ⇒ Unit): Unit

final def getClass(): Class[_]

val head: Head

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

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

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

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

final def isInstanceOf[T0]: Boolean

def make(params: Params): T

val mk: (Params, Stack[T]) ⇒ Stack[T]

final def ne(arg0: AnyRef): Boolean

val next: Stack[T]

final def notify(): Unit

final def notifyAll(): Unit

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

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

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

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

final def synchronized[T0](arg0: ⇒ T0): T0

def tails: Iterator[Stack[T]]

def toString(): String

def transform(fn: (Stack[T]) ⇒ Stack[T]): Stack[T]

final def wait(): Unit

final def wait(arg0: Long, arg1: Int): Unit

final def wait(arg0: Long): Unit

Inherited from Serializable

Inherited from Serializable

Inherited from Product

Inherited from Equals

Inherited from Stack[T]

Inherited from AnyRef

Inherited from Any

Ungrouped