File: .lake/packages/lean4/src/lean/lake/Lake/Util/Log.lean

full_name: Lake.instReprVerbosity
code: inductive Verbosity
| quiet
| normal
| verbose
deriving Repr, DecidableEq, Ord
goal: Repr Lake.Verbosity

full_name: Lake.Verbosity
code: inductive Verbosity
| quiet
| normal
| verbose
deriving Repr, DecidableEq, Ord
goal: Type

full_name: Lake.Verbosity.verbose
code: inductive Verbosity
| quiet
| normal
| verbose
deriving Repr, DecidableEq, Ord
goal: Lake.Verbosity

full_name: Lake.instDecidableEqVerbosity
code: inductive Verbosity
| quiet
| normal
| verbose
deriving Repr, DecidableEq, Ord
goal: DecidableEq Lake.Verbosity

full_name: Lake.instOrdVerbosity
code: inductive Verbosity
| quiet
| normal
| verbose
deriving Repr, DecidableEq, Ord
goal: Ord Lake.Verbosity

full_name: Lake.Verbosity.normal
code: inductive Verbosity
| quiet
| normal
| verbose
deriving Repr, DecidableEq, Ord
goal: Lake.Verbosity

full_name: Lake.Verbosity.quiet
code: inductive Verbosity
| quiet
| normal
| verbose
deriving Repr, DecidableEq, Ord
goal: Lake.Verbosity

full_name: Lake.instLTVerbosity
code: instance : LT Verbosity 
goal: LT Lake.Verbosity

full_name: Lake.instLEVerbosity
code: instance : LE Verbosity 
goal: LE Lake.Verbosity

full_name: Lake.instMinVerbosity
code: instance : Min Verbosity 
goal: Min Lake.Verbosity

full_name: Lake.instMaxVerbosity
code: instance : Max Verbosity 
goal: Max Lake.Verbosity

full_name: Lake.instInhabitedVerbosity
code: instance : Inhabited Verbosity 
goal: Inhabited Lake.Verbosity

full_name: Lake.AnsiMode.auto
code: /-- Whether to ANSI escape codes. -/
inductive AnsiMode
/--
Automatically determine whether to use ANSI escape codes
based on whether the stream written to is a terminal.
-/
| auto
/-- Use ANSI escape codes. -/
| ansi
/-- Do not use ANSI escape codes. -/
| noAnsi
goal: Lake.AnsiMode

full_name: Lake.AnsiMode
code: /-- Whether to ANSI escape codes. -/
inductive AnsiMode
/--
Automatically determine whether to use ANSI escape codes
based on whether the stream written to is a terminal.
-/
| auto
/-- Use ANSI escape codes. -/
| ansi
/-- Do not use ANSI escape codes. -/
| noAnsi
goal: Type

full_name: Lake.AnsiMode.ansi
code: /-- Whether to ANSI escape codes. -/
inductive AnsiMode
/--
Automatically determine whether to use ANSI escape codes
based on whether the stream written to is a terminal.
-/
| auto
/-- Use ANSI escape codes. -/
| ansi
/-- Do not use ANSI escape codes. -/
| noAnsi
goal: Lake.AnsiMode

full_name: Lake.AnsiMode.noAnsi
code: /-- Whether to ANSI escape codes. -/
inductive AnsiMode
/--
Automatically determine whether to use ANSI escape codes
based on whether the stream written to is a terminal.
-/
| auto
/-- Use ANSI escape codes. -/
| ansi
/-- Do not use ANSI escape codes. -/
| noAnsi
goal: Lake.AnsiMode

full_name: Lake.AnsiMode.isEnabled
code: /-- Returns whether to ANSI escape codes with the stream `out`. -/
def AnsiMode.isEnabled (out : IO.FS.Stream) : AnsiMode → BaseIO Bool

goal: Lake.AnsiMode → BaseIO Bool

full_name: Lake.Ansi.chalk
code: /--
Wrap text in ANSI escape sequences to make it bold and color it the ANSI `colorCode`.
Resets all terminal font attributes at the end of the text.
-/
def Ansi.chalk (colorCode text : String) : String 
goal: String

full_name: Lake.OutStream.stdout
code: /-- A pure representation of output stream. -/
inductive OutStream
| stdout
| stderr
| stream (s : IO.FS.Stream)
goal: Lake.OutStream

full_name: Lake.OutStream.stream
code: /-- A pure representation of output stream. -/
inductive OutStream
| stdout
| stderr
| stream (s : IO.FS.Stream)
goal: Lake.OutStream

full_name: Lake.OutStream
code: /-- A pure representation of output stream. -/
inductive OutStream
| stdout
| stderr
| stream (s : IO.FS.Stream)
goal: Type

full_name: Lake.OutStream.stderr
code: /-- A pure representation of output stream. -/
inductive OutStream
| stdout
| stderr
| stream (s : IO.FS.Stream)
goal: Lake.OutStream

full_name: Lake.OutStream.get
code: /-- Returns the real output stream associated with `OutStream`. -/
def OutStream.get : OutStream → BaseIO IO.FS.Stream

goal: Lake.OutStream → BaseIO IO.FS.Stream

full_name: Lake.instCoeStreamOutStream
code: instance : Coe IO.FS.Stream OutStream 
goal: Coe IO.FS.Stream Lake.OutStream

full_name: Lake.instCoeHandleOutStream
code: instance : Coe IO.FS.Handle OutStream 
goal: Coe IO.FS.Handle Lake.OutStream

full_name: Lake.instReprLogLevel
code: inductive LogLevel
| trace
| info
| warning
| error
deriving Inhabited, Repr, DecidableEq, Ord, ToJson, FromJson
goal: Repr Lake.LogLevel

full_name: Lake.instDecidableEqLogLevel
code: inductive LogLevel
| trace
| info
| warning
| error
deriving Inhabited, Repr, DecidableEq, Ord, ToJson, FromJson
goal: DecidableEq Lake.LogLevel

full_name: Lake.LogLevel.error
code: inductive LogLevel
| trace
| info
| warning
| error
deriving Inhabited, Repr, DecidableEq, Ord, ToJson, FromJson
goal: Lake.LogLevel

full_name: Lake.LogLevel.trace
code: inductive LogLevel
| trace
| info
| warning
| error
deriving Inhabited, Repr, DecidableEq, Ord, ToJson, FromJson
goal: Lake.LogLevel

full_name: Lake.instOrdLogLevel
code: inductive LogLevel
| trace
| info
| warning
| error
deriving Inhabited, Repr, DecidableEq, Ord, ToJson, FromJson
goal: Ord Lake.LogLevel

full_name: Lake.instInhabitedLogLevel
code: inductive LogLevel
| trace
| info
| warning
| error
deriving Inhabited, Repr, DecidableEq, Ord, ToJson, FromJson
goal: Inhabited Lake.LogLevel

full_name: Lake.LogLevel.warning
code: inductive LogLevel
| trace
| info
| warning
| error
deriving Inhabited, Repr, DecidableEq, Ord, ToJson, FromJson
goal: Lake.LogLevel

full_name: Lake.LogLevel
code: inductive LogLevel
| trace
| info
| warning
| error
deriving Inhabited, Repr, DecidableEq, Ord, ToJson, FromJson
goal: Type

full_name: Lake.LogLevel.info
code: inductive LogLevel
| trace
| info
| warning
| error
deriving Inhabited, Repr, DecidableEq, Ord, ToJson, FromJson
goal: Lake.LogLevel

full_name: Lake.instToJsonLogLevel
code: ToJson
goal: Lean.ToJson Lake.LogLevel

full_name: Lake.instFromJsonLogLevel
code: FromJson
goal: Lean.FromJson Lake.LogLevel

full_name: Lake.instLTLogLevel
code: instance : LT LogLevel 
goal: LT Lake.LogLevel

full_name: Lake.instLELogLevel
code: instance : LE LogLevel 
goal: LE Lake.LogLevel

full_name: Lake.instMinLogLevel
code: instance : Min LogLevel 
goal: Min Lake.LogLevel

full_name: Lake.instMaxLogLevel
code: instance : Max LogLevel 
goal: Max Lake.LogLevel

full_name: Lake.LogLevel.icon
code: /-- Unicode icon for representing the log level. -/
def LogLevel.icon : LogLevel → Char

goal: Lake.LogLevel → Char

full_name: Lake.LogLevel.ansiColor
code: /-- ANSI escape code for coloring text of at the log level. -/
def LogLevel.ansiColor : LogLevel → String

goal: Lake.LogLevel → String

full_name: Lake.LogLevel.toString
code: protected def LogLevel.toString : LogLevel → String

goal: Lake.LogLevel → String

full_name: Lake.LogLevel.ofMessageSeverity
code: protected def LogLevel.ofMessageSeverity : MessageSeverity → LogLevel

goal: Lean.MessageSeverity → Lake.LogLevel

full_name: Lake.instToStringLogLevel
code: instance : ToString LogLevel 
goal: ToString Lake.LogLevel

full_name: Lake.Verbosity.minLogLv
code: def Verbosity.minLogLv : Verbosity → LogLevel

goal: Lake.Verbosity → Lake.LogLevel

full_name: Lake.LogEntry.level
code: structure LogEntry where
  level : LogLevel
  message : String
  deriving Inhabited, ToJson, FromJson
goal: Lake.LogLevel

full_name: Lake.instInhabitedLogEntry
code: structure LogEntry where
  level : LogLevel
  message : String
  deriving Inhabited, ToJson, FromJson
goal: Inhabited Lake.LogEntry

full_name: Lake.LogEntry.message
code: structure LogEntry where
  level : LogLevel
  message : String
  deriving Inhabited, ToJson, FromJson
goal: String

full_name: Lake.LogEntry
code: structure LogEntry where
  level : LogLevel
  message : String
  deriving Inhabited, ToJson, FromJson
goal: Type

full_name: Lake.instToJsonLogEntry
code: ToJson
goal: Lean.ToJson Lake.LogEntry

full_name: Lake.instFromJsonLogEntry
code: FromJson
goal: Lean.FromJson Lake.LogEntry

full_name: Lake.LogEntry.toString
code: protected def LogEntry.toString (self : LogEntry) (useAnsi := false) : String 
goal: String

full_name: Lake.instToStringLogEntry
code: instance : ToString LogEntry 
goal: ToString Lake.LogEntry

full_name: Lake.MonadLog
code: class MonadLog (m : Type u → Type v) where
  logEntry (e : LogEntry) : m PUnit
goal: Type v

full_name: Lake.MonadLog.logEntry
code: class MonadLog (m : Type u → Type v) where
  logEntry (e : LogEntry) : m PUnit
goal: m PUnit

full_name: Lake.logVerbose
code: @[inline] def logVerbose [Monad m] [MonadLog m] (message : String) : m PUnit 
goal: m PUnit

full_name: Lake.logInfo
code: @[inline] def logInfo [Monad m] [MonadLog m] (message : String) : m PUnit 
goal: m PUnit

full_name: Lake.logWarning
code: @[inline] def logWarning [MonadLog m] (message : String) : m PUnit 
goal: m PUnit

full_name: Lake.logError
code: @[inline] def logError  [MonadLog m] (message : String) : m PUnit 
goal: m PUnit

full_name: Lake.logSerialMessage
code: @[specialize] def logSerialMessage (msg : SerialMessage) [MonadLog m] : m PUnit 
goal: m PUnit

full_name: Lake.logToIO
code: @[deprecated] def logToIO (e : LogEntry) (minLv : LogLevel)  : BaseIO PUnit 
goal: BaseIO PUnit

full_name: Lake.logToStream
code: def logToStream
  (e : LogEntry) (out : IO.FS.Stream) (minLv : LogLevel) (useAnsi : Bool)
: BaseIO PUnit 
goal: BaseIO PUnit

full_name: Lake.MonadLog.nop
code: abbrev nop [Pure m] : MonadLog m 
goal: Lake.MonadLog m

full_name: Lake.MonadLog.instInhabitedOfPure
code: instance [Pure m] : Inhabited (MonadLog m) 
goal: Inhabited (Lake.MonadLog m)

full_name: Lake.MonadLog.lift
code: abbrev lift [MonadLiftT m n] (self : MonadLog m) : MonadLog n 
goal: Lake.MonadLog n

full_name: Lake.MonadLog.instOfMonadLift
code: instance [MonadLift m n] [methods : MonadLog m] : MonadLog n 
goal: Lake.MonadLog n

full_name: Lake.MonadLog.io
code: @[deprecated] abbrev io [MonadLiftT BaseIO m] (minLv := LogLevel.info) : MonadLog m 
goal: Lake.MonadLog m

full_name: Lake.MonadLog.stream
code: abbrev stream [MonadLiftT BaseIO m]
  (out : IO.FS.Stream) (minLv := LogLevel.info) (useAnsi := false)
: MonadLog m 
goal: Lake.MonadLog m

full_name: Lake.OutStream.logEntry
code: def OutStream.logEntry
  (self : OutStream) (e : LogEntry)
  (minLv : LogLevel := .info) (ansiMode := AnsiMode.auto)
: BaseIO PUnit 
goal: BaseIO PUnit

full_name: Lake.OutStream.logger
code: abbrev OutStream.logger [MonadLiftT BaseIO m]
  (out : OutStream) (minLv := LogLevel.info) (ansiMode := AnsiMode.auto)
: MonadLog m 
goal: Lake.MonadLog m

full_name: Lake.MonadLog.stdout
code: abbrev MonadLog.stdout
  [MonadLiftT BaseIO m] (minLv := LogLevel.info) (ansiMode := AnsiMode.auto)
: MonadLog m 
goal: Lake.MonadLog m

full_name: Lake.MonadLog.stderr
code: abbrev MonadLog.stderr
  [MonadLiftT BaseIO m] (minLv := LogLevel.info) (ansiMode := AnsiMode.auto)
: MonadLog m 
goal: Lake.MonadLog m

full_name: Lake.OutStream.getLogger
code: @[inline] def OutStream.getLogger [MonadLiftT BaseIO m]
  (out : OutStream) (minLv := LogLevel.info) (ansiMode := AnsiMode.auto)
: BaseIO (MonadLog m) 
goal: BaseIO (Lake.MonadLog m)

full_name: Lake.MonadLogT
code: /-- A monad equipped with a `MonadLog` instance -/
abbrev MonadLogT (m : Type u → Type v) (n : Type v → Type w) 
goal: Type (max v w)

full_name: Lake.MonadLogT.instInhabitedOfPure
code: instance [Pure n] [Inhabited α] : Inhabited (MonadLogT m n α) 
goal: Inhabited (Lake.MonadLogT m n α)

full_name: Lake.MonadLogT.instMonadLogOfMonadOfMonadLiftT
code: instance [Monad n] [MonadLiftT m n] : MonadLog (MonadLogT m n) 
goal: Lake.MonadLog (Lake.MonadLogT m n)

full_name: Lake.MonadLogT.adaptMethods
code: @[inline] def adaptMethods [Monad n]
(f : MonadLog m → MonadLog m') (self : MonadLogT m' n α) : MonadLogT m n α 
goal: Lake.MonadLogT m n α

full_name: Lake.MonadLogT.ignoreLog
code: @[inline] def ignoreLog [Pure m] (self : MonadLogT m n α) : n α 
goal: n α

full_name: Lake.Log
code: structure Log where
  entries : Array LogEntry
goal: Type

full_name: Lake.Log.entries
code: structure Log where
  entries : Array LogEntry
goal: Array Lake.LogEntry

full_name: Lake.instToJsonLog
code: instance : ToJson Log 
goal: Lean.ToJson Lake.Log

full_name: Lake.instFromJsonLog
code: instance : FromJson Log 
goal: Lean.FromJson Lake.Log

full_name: Lake.Log.Pos
code: /-- A position in a `Log` (i.e., an array index). Can be past the log's end. -/
structure Log.Pos where
  val : Nat
  deriving Inhabited
goal: Type

full_name: Lake.Log.Pos.val
code: /-- A position in a `Log` (i.e., an array index). Can be past the log's end. -/
structure Log.Pos where
  val : Nat
  deriving Inhabited
goal: Nat

full_name: Lake.Log.instInhabitedPos
code: /-- A position in a `Log` (i.e., an array index). Can be past the log's end. -/
structure Log.Pos where
  val : Nat
  deriving Inhabited
goal: Inhabited Lake.Log.Pos

full_name: Lake.instOfNatPos
code: instance : OfNat Log.Pos (nat_lit 0) 
goal: OfNat Lake.Log.Pos 0

full_name: Lake.Log.empty
code: @[inline] def empty : Log 
goal: Lake.Log

full_name: Lake.Log.instEmptyCollection
code: instance : EmptyCollection Log 
goal: EmptyCollection Lake.Log

full_name: Lake.Log.size
code: @[inline] def size (log : Log) : Nat 
goal: Nat

full_name: Lake.Log.isEmpty
code: @[inline] def isEmpty (log : Log) : Bool 
goal: Bool

full_name: Lake.Log.hasEntries
code: @[inline] def hasEntries (log : Log) : Bool 
goal: Bool

full_name: Lake.Log.endPos
code: @[inline] def endPos (log : Log) : Log.Pos 
goal: Lake.Log.Pos

full_name: Lake.Log.push
code: @[inline] def push (log : Log) (e : LogEntry) : Log 
goal: Lake.Log

full_name: Lake.Log.append
code: @[inline] def append (log : Log) (o : Log) : Log 
goal: Lake.Log

full_name: Lake.Log.instAppend
code: instance : Append Log 
goal: Append Lake.Log

full_name: Lake.Log.extract
code: /-- Takes log entries between `start` (inclusive) and `stop` (exclusive). -/
@[inline] def extract (log : Log) (start stop : Log.Pos)  : Log 
goal: Lake.Log

full_name: Lake.Log.dropFrom
code: /-- Removes log entries after `pos` (inclusive). -/
@[inline] def dropFrom (log : Log) (pos : Log.Pos) : Log 
goal: Lake.Log

full_name: Lake.Log.takeFrom
code: /-- Takes log entries before `pos` (exclusive). -/
@[inline] def takeFrom (log : Log) (pos : Log.Pos) : Log 
goal: Lake.Log

full_name: Lake.Log.split
code: /--
Splits the log into two from `pos`.
The first log is from the start to `pos` (exclusive),
and the second log is from `pos` (inclusive) to the end.
-/
@[inline] def split (log : Log) (pos : Log.Pos) : Log × Log 
goal: Lake.Log × Lake.Log

full_name: Lake.Log.toString
code: def toString (log : Log) : String 
goal: String

full_name: Lake.Log.instToString
code: instance : ToString Log 
goal: ToString Lake.Log

full_name: Lake.Log.replay
code: @[inline] def replay [Monad m] [logger : MonadLog m] (log : Log) : m PUnit 
goal: m PUnit

full_name: Lake.Log.filter
code: @[inline] def filter (f : LogEntry → Bool) (log : Log) : Log 
goal: Lake.Log

full_name: Lake.Log.any
code: @[inline] def any (f : LogEntry → Bool) (log : Log) : Bool 
goal: Bool

full_name: Lake.Log.maxLv
code: /-- The max log level of entries in this log. If empty, returns `trace`. -/
def maxLv (log : Log) : LogLevel 
goal: Lake.LogLevel

full_name: Lake.pushLogEntry
code: /-- Add a `LogEntry` to the end of the monad's `Log`. -/
@[inline] def pushLogEntry
  [MonadStateOf Log m] (e : LogEntry)
: m PUnit 
goal: m PUnit

full_name: Lake.MonadLog.ofMonadState
code: abbrev MonadLog.ofMonadState [MonadStateOf Log m] : MonadLog m 
goal: Lake.MonadLog m

full_name: Lake.getLog
code: /-- Returns the monad's log. -/
@[inline] def getLog [MonadStateOf Log m] : m Log 
goal: m Lake.Log

full_name: Lake.getLogPos
code: /-- Returns the current end position of the monad's log (i.e., its size). -/
@[inline] def getLogPos [Functor m] [MonadStateOf Log m] : m Log.Pos 
goal: m Lake.Log.Pos

full_name: Lake.takeLog
code: /-- Removes the section monad's log starting and returns it. -/
@[inline] def takeLog [MonadStateOf Log m] : m Log 
goal: m Lake.Log

full_name: Lake.takeLogFrom
code: /--
Removes the monad's log starting at `pos` and returns it.
Useful for extracting logged errors after catching an error position
from an `ELogT` (e.g., `LogIO`).
-/
@[inline] def takeLogFrom [MonadStateOf Log m] (pos : Log.Pos) : m Log 
goal: m Lake.Log

full_name: Lake.dropLogFrom
code: /--
Backtracks the monad's log to `pos`.
Useful for discarding logged errors after catching an error position
from an `ELogT` (e.g., `LogIO`).
-/
@[inline] def dropLogFrom [MonadStateOf Log m] (pos : Log.Pos) : m PUnit 
goal: m PUnit

full_name: Lake.extractLog
code: /-- Returns the log from `x` while leaving it intact in the monad. -/
@[inline] def extractLog [Monad m] [MonadStateOf Log m] (x : m PUnit) : m Log 
goal: m Lake.Log

full_name: Lake.withExtractLog
code: /-- Returns the log from `x` and its result while leaving it intact in the monad. -/
@[inline] def withExtractLog [Monad m] [MonadStateOf Log m] (x : m α) : m (α × Log) 
goal: m (α × Lake.Log)

full_name: Lake.withLogErrorPos
code: /-- Performs `x` and backtracks any error to the log position before `x`. -/
@[inline] def withLogErrorPos
  [Monad m] [MonadStateOf Log m] [MonadExceptOf Log.Pos m] (self : m α)
: m α 
goal: m α

full_name: Lake.errorWithLog
code: /-- Performs `x` and groups all logs generated into an error block. -/
@[inline] def errorWithLog
  [Monad m] [MonadStateOf Log m] [MonadExceptOf Log.Pos m] (self : m PUnit)
: m β 
goal: m β

full_name: Lake.withLoggedIO
code: /-- Captures IO in `x` into an informational log entry. -/
@[inline] def withLoggedIO
  [Monad m] [MonadLiftT BaseIO m] [MonadLog m] [MonadFinally m] (x : m α)
: m α 
goal: m α

full_name: Lake.ELog.error
code: /-- Throw with the logged error `message`. -/
@[inline] protected def ELog.error
  [Monad m] [MonadLog m] [MonadStateOf Log m] [MonadExceptOf Log.Pos m]
  (msg : String)
: m α 
goal: m α

full_name: Lake.ELog.monadError
code: /-- `Alternative` instance for monads with `Log` state and `Log.Pos` errors. -/
abbrev ELog.monadError
  [Monad m] [MonadLog m] [MonadStateOf Log m] [MonadExceptOf Log.Pos m]
: MonadError m 
goal: Lake.MonadError m

full_name: Lake.ELog.failure
code: /-- Fail without logging anything. -/
@[inline] protected def ELog.failure
  [Monad m] [MonadStateOf Log m] [MonadExceptOf Log.Pos m]
: m α 
goal: m α

full_name: Lake.ELog.orElse
code: /-- Performs `x`. If it fails, drop its log and perform `y`. -/
@[inline] protected def ELog.orElse
  [Monad m] [MonadStateOf Log m] [MonadExceptOf Log.Pos m]
  (x : m α) (y : Unit → m α)
: m α 
goal: m α

full_name: Lake.ELog.alternative
code: /-- `Alternative` instance for monads with `Log` state and `Log.Pos` errors. -/
abbrev ELog.alternative
  [Monad m] [MonadStateOf Log m] [MonadExceptOf Log.Pos m]
: Alternative m 
goal: Alternative m

full_name: Lake.LogT
code: /-- A monad equipped with a log. -/
abbrev LogT (m : Type → Type) 
goal: Type

full_name: Lake.instMonadLogLogTOfMonad
code: instance [Monad m] : MonadLog (LogT m) 
goal: Lake.MonadLog (Lake.LogT m)

full_name: Lake.LogT.run
code: abbrev run [Functor m] (self : LogT m α) (log : Log := {})  : m (α × Log) 
goal: m (α × Lake.Log)

full_name: Lake.LogT.run'
code: abbrev run' [Functor m] (self : LogT m α) (log : Log := {}) :  m α 
goal: m α

full_name: Lake.LogT.takeAndRun
code: /--
Run `self` with the log taken from the state of the monad `n`.

**Warning:** If lifting `self` from `m` to `n` fails, the log will be lost.
Thus, this is best used when the lift cannot fail.
-/
@[inline] def takeAndRun
  [Monad n] [MonadStateOf Log n] [MonadLiftT m n] [MonadFinally n]
  (self : LogT m α)
: n α 
goal: n α

full_name: Lake.LogT.replayLog
code: /--
Runs `self` in `n` and then replays the entries of the resulting log
using the new monad's `logger`.
-/
@[inline] def replayLog [Monad n] [logger : MonadLog n] [MonadLiftT m n] (self : LogT m α) : n α 
goal: n α

full_name: Lake.ELogT
code: /-- A monad equipped with a log and the ability to error at some log position. -/
abbrev ELogT (m : Type → Type) 
goal: Type

full_name: Lake.ELogResult
code: abbrev ELogResult (α) 
goal: Type u_1

full_name: Lake.instMonadLogELogTOfMonad
code: instance [Monad m] : MonadLog (ELogT m) 
goal: Lake.MonadLog (Lake.ELogT m)

full_name: Lake.instMonadErrorELogTOfMonad
code: instance [Monad m] : MonadError (ELogT m) 
goal: Lake.MonadError (Lake.ELogT m)

full_name: Lake.instAlternativeELogTOfMonad
code: instance [Monad m] : Alternative (ELogT m) 
goal: Alternative (Lake.ELogT m)

full_name: Lake.ELogT.run
code: abbrev run (self : ELogT m α) (log : Log := {})  : m (ELogResult α) 
goal: m (Lake.ELogResult α)

full_name: Lake.ELogT.run'
code: abbrev run' [Functor m] (self : ELogT m α) (log : Log := {}) :  m (Except Log.Pos α) 
goal: m (Except Lake.Log.Pos α)

full_name: Lake.ELogT.toLogT
code: abbrev toLogT [Functor m] (self : ELogT m α) : LogT m (Except Log.Pos α) 
goal: Lake.LogT m (Except Lake.Log.Pos α)

full_name: Lake.ELogT.toLogT?
code: abbrev toLogT? [Functor m] (self : ELogT m α) : LogT m (Option α) 
goal: Lake.LogT m (Option α)

full_name: Lake.ELogT.run?
code: abbrev run? [Functor m] (self : ELogT m α) (log : Log := {}) : m (Option α × Log) 
goal: m (Option α × Lake.Log)

full_name: Lake.ELogT.run?'
code: abbrev run?' [Functor m] (self : ELogT m α) (log : Log := {}) : m (Option α) 
goal: m (Option α)

full_name: Lake.ELogT.catchLog
code: @[inline] def catchLog [Monad m] (f : Log → LogT m α) (self : ELogT m α) : LogT m α 
goal: Lake.LogT m α

full_name: Lake.ELogT.captureLog
code: @[deprecated run?] abbrev captureLog 
goal: m (Option α × Lake.Log)

full_name: Lake.ELogT.takeAndRun
code: /--
Run `self` with the log taken from the state of the monad `n`,

**Warning:** If lifting `self` from `m` to `n` fails, the log will be lost.
Thus, this is best used when the lift cannot fail. Note  excludes the
native log position failure of `ELogT`, which are lifted safely.
-/
@[inline] def takeAndRun
  [Monad n] [MonadStateOf Log n] [MonadExceptOf Log.Pos n] [MonadLiftT m n]
  (self : ELogT m α)
: n α 
goal: n α

full_name: Lake.ELogT.replayLog?
code: /--
Runs `self` in `n` and then replays the entries of the resulting log
using the new monad's `logger`. Translates an exception in this monad
to a `none` result.
-/
@[inline] def replayLog? [Monad n] [logger : MonadLog n] [MonadLiftT m n] (self : ELogT m α) : n (Option α) 
goal: n (Option α)

full_name: Lake.ELogT.replayLog
code: /--
Runs `self` in `n` and then replays the entries of the resulting log
using the new monad's `logger`. Translates an exception in this monad to
a `failure` in the new monad.
-/
@[inline] def replayLog [Alternative n] [Monad n] [logger : MonadLog n] [MonadLiftT m n] (self : ELogT m α) : n α 
goal: n α

full_name: Lake.LogIO
code: /-- A monad equipped with a log, a log error position, and the ability to perform I/O. -/
abbrev LogIO 
goal: Type

full_name: Lake.instMonadLiftIOLogIO
code: instance : MonadLift IO LogIO 
goal: MonadLift IO Lake.LogIO

full_name: Lake.LogIO.captureLog
code: @[deprecated ELogT.run?] abbrev captureLog 
goal: m (Option α × Lake.Log)

full_name: Lake.LogIO.toBaseIO.replay
code: /--
Runs a `LogIO` action in `BaseIO`.
Prints log entries of at least `minLv` to `out`.
-/
@[inline] def toBaseIO (self : LogIO α)
  (minLv := LogLevel.info) (ansiMode := AnsiMode.auto) (out := OutStream.stderr)
: BaseIO (Option α) 
goal: BaseIO Unit

full_name: Lake.LogIO.toBaseIO
code: /--
Runs a `LogIO` action in `BaseIO`.
Prints log entries of at least `minLv` to `out`.
-/
@[inline] def toBaseIO (self : LogIO α)
  (minLv := LogLevel.info) (ansiMode := AnsiMode.auto) (out := OutStream.stderr)
: BaseIO (Option α) 
goal: BaseIO (Option α)