Init

abstract def showFullKey: Show[Init.this.ScopedKey[_]]

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

final def !=(arg0: AnyRef): Boolean

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: AnyRef): Boolean

final def ==(arg0: Any): Boolean

object Initialize extends AnyRef

object SettingsDefinition extends AnyRef

def Undefined(definingKey: Init.this.ScopedKey[_], referencedKey: Init.this.ScopedKey[_]): Undefined

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

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

def addLocal(init: Seq[Init.this.Setting[_]])(implicit scopeLocal: (Init.this.ScopedKey[_]) ⇒ Seq[Init.this.Setting[_]]): Seq[Init.this.Setting[_]]

def app[HL <: HList, T](inputs: KList[Initialize, HL])(f: (HL) ⇒ T): 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, Id]

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

def clone(): AnyRef

def compile(sMap: ScopedMap): CompiledMap

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

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

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[Init.this.ScopedKey[_], Flattened]

final def getClass(): java.lang.Class[_]

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

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

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

def hashCode(): Int

final def isInstanceOf[T0]: Boolean

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

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 refinedDistance(delegates: (Scope) ⇒ Seq[Scope], a: Init.this.ScopedKey[_], b: Init.this.ScopedKey[_]): Option[Int]

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

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

def sort(cMap: CompiledMap): Seq[Init.this.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]

final def wait(): Unit

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

final def wait(arg0: Long): Unit