Logger

abstract def log: LOG[L]

abstract def over: A

final def !=(arg0: AnyRef): Boolean

final def !=(arg0: Any): Boolean

final def ##(): Int

def :++->(e: LOG[L]): Logger[L, A]

Append the given value to the current log.

def :+->(e: L): Logger[L, A]

Append the given value to the current log.

def :+->>(e: (A) ⇒ LOG[L]): Logger[L, A]

Append the given value to the current log by applying to the underlying value.

def :->>(e: (A) ⇒ L): Logger[L, A]

Append the given value to the current log by applying to the underlying value.

def <-++:(e: LOG[L]): Logger[L, A]

Prepend the given value to the current log.

def <-+:(e: L): Logger[L, A]

Prepend the given value to the current log.

def <<-+:(e: (A) ⇒ LOG[L]): Logger[L, A]

Prepend the given value to the current log by applying to the underlying value.

def <<-:(e: (A) ⇒ L): Logger[L, A]

Prepend the given value to the current log by applying to the underlying value.

final def ==(arg0: AnyRef): Boolean

final def ==(arg0: Any): Boolean

final def asInstanceOf[T0]: T0

def clone(): AnyRef

def effectEachLog(k: (L) ⇒ Unit): Logger[L, A]

Runs the given side-effect on each element of the log, then returns this underlying value.

def effectLog(k: (LOG[L]) ⇒ Unit): Logger[L, A]

Runs the given side-effect on the log, then returns this underlying value.

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def finalize(): Unit

def flatMap[B](f: (A) ⇒ Logger[L, B]): Logger[L, B]

def flushEachLog(k: (L) ⇒ Unit): Logger[L, A]

Runs the given side-effect on each element of the log, then returns this underlying value with an empty log.

def flushLog(k: (LOG[L]) ⇒ Unit): Logger[L, A]

Runs the given side-effect on the log, then returns this underlying value with an empty log.

def foreach(f: (A) ⇒ Unit): Unit

final def getClass(): Class[_]

def hashCode(): Int

final def isInstanceOf[T0]: Boolean

def map[B](f: (A) ⇒ B): Logger[L, B]

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def printEachLog(implicit s: Show[L]): Logger[L, A]

Prints each element of the log, then returns this underlying value.

def printFlushEachLog(implicit s: Show[L]): Logger[L, A]

Prints each element of the log, then returns this underlying value with an empty log.

def printFlushLog(implicit s: Show[L]): Logger[L, A]

Prints the log, then returns this underlying value with an empty log.

def printLog(implicit s: Show[L]): Logger[L, A]

Prints the log, then returns this underlying value.

def resetLog: Logger[L, A]

Set the log to be empty.

def setLog(l: LOG[L]): Logger[L, A]

Set the log to the given value, losing any previous value.

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

def toString(): String

val value: Writer[LOG[L], A]

final def wait(): Unit

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

final def wait(arg0: Long): Unit

def withEachLog(k: (L) ⇒ L): Logger[L, A]

Transform each log value by the given function.

def withLog(k: (LOG[L]) ⇒ LOG[L]): Logger[L, A]

Transform the log by the given function.