Init

abstract def showFullKey: Show[ScopedKey[_]]

The Show instance used when a detailed String needs to be generated.

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

object DefaultSetting

object Initialize

object SettingsDefinition

def Undefined(defining: Setting[_], referencedKey: ScopedKey[_]): Undefined

def Uninitialized(validKeys: Seq[ScopedKey[_]], delegates: (Scope) ⇒ Seq[Scope], keys: Seq[Undefined], runtime: Boolean)(implicit display: Show[ScopedKey[_]]): Uninitialized

def add[T](m: ScopedMap, s: Setting[T]): ScopedMap

def addLocal(init: Seq[Setting[_]])(implicit scopeLocal: ScopeLocal): Seq[Setting[_]]

def app[K[L[x]], T](inputs: K[Initialize])(f: (K[Types.Id]) ⇒ T)(implicit alist: AList[K]): Initialize[T]

def append[T](ss: Seq[Setting[T]], s: Setting[T]): Seq[Setting[T]]

def asFunction[T](s: Settings[Scope]): (ScopedKey[T]) ⇒ T

final def asInstanceOf[T0]: T0

def asTransform(s: Settings[Scope]): ~>[ScopedKey, Types.Id]

def bind[S, T](in: Initialize[S])(f: (S) ⇒ Initialize[T]): Initialize[T]

lazy val capturedTransformations: Initialize[~>[Initialize, Initialize]]

The result of this initialization is the composition of applied transformations.

def clone(): AnyRef

def compile(sMap: ScopedMap): CompiledMap

def compiled(init: Seq[Setting[_]], actual: Boolean = true)(implicit delegates: (Scope) ⇒ Seq[Scope], scopeLocal: ScopeLocal, display: Show[ScopedKey[_]]): CompiledMap

def definedAtString(settings: Seq[Setting[_]]): String

def delegate(sMap: ScopedMap)(implicit delegates: (Scope) ⇒ Seq[Scope], display: Show[ScopedKey[_]]): ScopedMap

final def derive[T](s: Setting[T], allowDynamic: Boolean = false, filter: (Scope) ⇒ Boolean = const(true), trigger: (AttributeKey[_]) ⇒ Boolean = const(true), default: Boolean = false): Setting[T]

Constructs a derived setting that will be automatically defined in every scope where one of its dependencies is explicitly defined and the where the scope matches filter.

def deriveAllowed[T](s: Setting[T], allowDynamic: Boolean): Option[String]

def empty(implicit delegates: (Scope) ⇒ Seq[Scope]): Settings[Scope]

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def finalize(): Unit

def flattenLocals(compiled: CompiledMap): Map[ScopedKey[_], Flattened]

final def getClass(): Class[_]

def getValue[T](s: Settings[Scope], k: ScopedKey[T]): T

def grouped(init: Seq[Setting[_]]): ScopedMap

def guessIntendedScope(validKeys: Seq[ScopedKey[_]], delegates: (Scope) ⇒ Seq[Scope], key: ScopedKey[_]): Option[ScopedKey[_]]

def hashCode(): Int

final def isInstanceOf[T0]: Boolean

def make(init: Seq[Setting[_]])(implicit delegates: (Scope) ⇒ Seq[Scope], scopeLocal: ScopeLocal, display: Show[ScopedKey[_]]): Settings[Scope]

def map[S, T](in: Initialize[S])(f: (S) ⇒ T): Initialize[T]

def mapScope(f: (Scope) ⇒ Scope): MapScoped

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def optional[T, U](i: Initialize[T])(f: (Option[T]) ⇒ U): Initialize[U]

def pure[T](value: () ⇒ T): Initialize[T]

def refinedDistance(delegates: (Scope) ⇒ Seq[Scope], a: ScopedKey[_], b: ScopedKey[_]): Option[Int]

def setting[T](key: ScopedKey[T], init: Initialize[T], pos: SourcePosition = NoPosition): Setting[T]

def showUndefined(u: Undefined, validKeys: Seq[ScopedKey[_]], delegates: (Scope) ⇒ Seq[Scope])(implicit display: Show[ScopedKey[_]]): String

def sort(cMap: CompiledMap): Seq[Compiled[_]]

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

def toString(): String

def uniform[S, T](inputs: Seq[Initialize[S]])(f: (Seq[S]) ⇒ T): Initialize[T]

def update[T](key: ScopedKey[T])(f: (T) ⇒ T): Setting[T]

def value[T](value: ⇒ T): Initialize[T]

def valueStrict[T](value: T): Initialize[T]

final def wait(): Unit

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

final def wait(arg0: Long): Unit

def Undefined(definingKey: ScopedKey[_], referencedKey: ScopedKey[_], derived: Boolean): Undefined

final def derive[T](s: Setting[T], allowDynamic: Boolean, filter: (Scope) ⇒ Boolean, trigger: (AttributeKey[_]) ⇒ Boolean): Setting[T]