File: .lake/packages/lean4/src/lean/lake/Lake/Toml/Decode.lean

full_name: Lake.«instMonadLiftExceptArray_.lake»
code: instance : MonadLift (Except ε) (Except (Array ε)) 
goal: MonadLift (Except ε) (Except (Array ε))

full_name: Lake.ensureDecode
code: /-- Run the decode action. If there were errors, throw. Otherwise, return the result. -/
@[inline] def ensureDecode (x : StateM (Array ε) α) : Except (Array ε) α 
goal: Except (Array ε) α

full_name: Lake.tryDecodeD
code: /-- Run the decode action. If it fails, add the errors to the state and return `default`. -/
@[inline] def tryDecodeD (default : α) (x : Except (Array ε) α) : StateM (Array ε) α 
goal: StateM (Array ε) α

full_name: Lake.tryDecode
code: /-- Run the decode action. If it fails, add the errors to the state and return `Inhabited.default`. -/
@[inline] def tryDecode [Inhabited α] (x : Except (Array ε) α) : StateM (Array ε) α 
goal: StateM (Array ε) α

full_name: Lake.optDecodeD
code: /--
If the value is not `none`, run the decode action.
If it fails, add the errors to the state and return `default`.
-/
@[inline] def optDecodeD (default : β)  (a? : Option α) (f : α → Except (Array ε) β) : StateM (Array ε) β 
goal: StateM (Array ε) β

full_name: Lake.optDecode
code: /--
If the value is not `none`, run the decode action.
If it fails, add the errors to the state and return `Inhabited.default`.
-/
@[inline] def optDecode [Inhabited β] (a? : Option α) (f : α → Except (Array ε) β) : StateM (Array ε) β 
goal: StateM (Array ε) β

full_name: Lake.optDecode?
code: /--
If the value is not `none`, run the decode action.
If it fails, add the errors to the state and return `none`.
Otherwise, return the the result in `some`.
-/
@[inline] def optDecode? (a? : Option α)  (f : α → Except (Array ε) β) : StateM (Array ε) (Option β) 
goal: StateM (Array ε) (Option β)

full_name: Lake.mergeErrors
code: /--
If either action errors, throw the concatenated errors.
Otherwise, if no errors, combine the results with `f`.
-/
def mergeErrors (x₁ : Except (Array ε) α) (x₂ : Except (Array ε) β) (f : α → β → γ) : Except (Array ε) γ 
goal: Except (Array ε) γ

full_name: Lake.Toml.DecodeError.ref
code: structure Toml.DecodeError where
  ref : Syntax
  msg : String
goal: Lean.Syntax

full_name: Lake.Toml.DecodeError
code: structure Toml.DecodeError where
  ref : Syntax
  msg : String
goal: Type

full_name: Lake.Toml.DecodeError.msg
code: structure Toml.DecodeError where
  ref : Syntax
  msg : String
goal: String

full_name: Lake.DecodeToml
code: class DecodeToml (α : Type u) where
  decode (v : Value) : Except (Array DecodeError) α
goal: Type u

full_name: Lake.DecodeToml.decode
code: class DecodeToml (α : Type u) where
  decode (v : Value) : Except (Array DecodeError) α
goal: Except (Array Lake.Toml.DecodeError) α

full_name: Lake.decodeToml
code: abbrev decodeToml [DecodeToml α] (v : Value) : Except (Array DecodeError) α 
goal: Except (Array Lake.Toml.DecodeError) α

full_name: Lake.Toml.decodeArray
code: /-- Decode an array of TOML values, merging any errors from the elements into a single array. -/
def decodeArray [dec : DecodeToml α] (vs : Array Value) : Except (Array DecodeError) (Array α) 
goal: Except (Array Lake.Toml.DecodeError) (Array α)

full_name: Lake.Toml.instDecodeTomlValue
code: instance : DecodeToml Value 
goal: Lake.DecodeToml Lake.Toml.Value

full_name: Lake.Toml.Value.decodeString
code: @[inline] def decodeString : Value → Except DecodeError String

goal: Lake.Toml.Value → Except Lake.Toml.DecodeError String

full_name: Lake.Toml.Value.instDecodeTomlString
code: instance : DecodeToml String 
goal: Lake.DecodeToml String

full_name: Lake.Toml.Value.instDecodeTomlFilePath
code: instance : DecodeToml System.FilePath 
goal: Lake.DecodeToml System.FilePath

full_name: Lake.Toml.Value.decodeName
code: @[inline] def decodeName (v : Value) : Except DecodeError Name 
goal: Except Lake.Toml.DecodeError Lean.Name

full_name: Lake.Toml.Value.instDecodeTomlName
code: instance : DecodeToml Lean.Name 
goal: Lake.DecodeToml Lean.Name

full_name: Lake.Toml.Value.decodeInt
code: @[inline] def decodeInt : Value → Except DecodeError Int

goal: Lake.Toml.Value → Except Lake.Toml.DecodeError Int

full_name: Lake.Toml.Value.instDecodeTomlInt
code: instance : DecodeToml Int 
goal: Lake.DecodeToml Int

full_name: Lake.Toml.Value.decodeNat
code: @[inline] def decodeNat : Value → Except DecodeError Nat

goal: Lake.Toml.Value → Except Lake.Toml.DecodeError Nat

full_name: Lake.Toml.Value.instDecodeTomlNat
code: instance : DecodeToml Nat 
goal: Lake.DecodeToml Nat

full_name: Lake.Toml.Value.decodeFloat
code: @[inline] def decodeFloat : Value → Except DecodeError Float

goal: Lake.Toml.Value → Except Lake.Toml.DecodeError Float

full_name: Lake.Toml.Value.instDecodeTomlFloat
code: instance : DecodeToml Float 
goal: Lake.DecodeToml Float

full_name: Lake.Toml.Value.decodeBool
code: @[inline] def decodeBool : Value → Except DecodeError Bool

goal: Lake.Toml.Value → Except Lake.Toml.DecodeError Bool

full_name: Lake.Toml.Value.instDecodeTomlBool
code: instance : DecodeToml Bool 
goal: Lake.DecodeToml Bool

full_name: Lake.Toml.Value.decodeDateTime
code: @[inline] def decodeDateTime : Value → Except DecodeError DateTime

goal: Lake.Toml.Value → Except Lake.Toml.DecodeError Lake.Toml.DateTime

full_name: Lake.Toml.Value.instDecodeTomlDateTime
code: instance : DecodeToml DateTime 
goal: Lake.DecodeToml Lake.Toml.DateTime

full_name: Lake.Toml.Value.decodeValueArray
code: @[inline] def decodeValueArray : Value → Except DecodeError (Array Value)

goal: Lake.Toml.Value → Except Lake.Toml.DecodeError (Array Lake.Toml.Value)

full_name: Lake.Toml.Value.decodeArray
code: @[inline] protected def decodeArray [dec : DecodeToml α] (v : Value) : Except (Array DecodeError) (Array α) 
goal: Except (Array Lake.Toml.DecodeError) (Array α)

full_name: Lake.Toml.Value.instDecodeTomlArray
code: instance [DecodeToml α] : DecodeToml (Array α) 
goal: Lake.DecodeToml (Array α)

full_name: Lake.Toml.Value.decodeArrayOrSingleton
code: @[inline] def decodeArrayOrSingleton [dec : DecodeToml α] : Value → Except (Array DecodeError) (Array α)

goal: Lake.Toml.Value → Except (Array Lake.Toml.DecodeError) (Array α)

full_name: Lake.Toml.Value.decodeTable
code: @[inline] def decodeTable : Value → Except DecodeError Table

goal: Lake.Toml.Value → Except Lake.Toml.DecodeError Lake.Toml.Table

full_name: Lake.Toml.Value.instDecodeTomlTable
code: instance : DecodeToml Table 
goal: Lake.DecodeToml Lake.Toml.Table

full_name: Lake.Toml.Table.decodeValue
code: @[inline] def decodeValue (t : Table) (k : Name) (ref := Syntax.missing) : Except DecodeError Value 
goal: Except Lake.Toml.DecodeError Lake.Toml.Value

full_name: Lake.Toml.Table.decode
code: def decode [dec : DecodeToml α] (t : Table) (k : Name) (ref := Syntax.missing) : Except (Array DecodeError) α 
goal: Except (Array Lake.Toml.DecodeError) α

full_name: Lake.Toml.Table.decodeNameMap
code: def decodeNameMap [dec : DecodeToml α] (t : Toml.Table) : Except (Array DecodeError) (NameMap α) 
goal: Except (Array Lake.Toml.DecodeError) (Lean.NameMap α)

full_name: Lake.Toml.Table.instDecodeTomlNameMap
code: instance [DecodeToml α] : DecodeToml (NameMap α) 
goal: Lake.DecodeToml (Lean.NameMap α)

full_name: Lake.Toml.Table.tryDecode
code: @[inline] protected def tryDecode [Inhabited α] [dec : DecodeToml α] (t : Table) (k : Name) (ref := Syntax.missing) : StateM (Array DecodeError) α 
goal: StateM (Array Lake.Toml.DecodeError) α

full_name: Lake.Toml.Table.tryDecode?
code: @[inline] protected def tryDecode? [dec : DecodeToml α] (t : Table) (k : Name) : StateM (Array DecodeError) (Option α) 
goal: StateM (Array Lake.Toml.DecodeError) (Option α)

full_name: Lake.Toml.Table.tryDecodeD
code: @[inline] protected def tryDecodeD [dec : DecodeToml α] (k : Name) (default : α) (t : Table) : StateM (Array DecodeError) α 
goal: StateM (Array Lake.Toml.DecodeError) α