def Lean.Options : Type

Equations

• Lean.Options = Lean.KVMap

def Lean.Options.empty : Lean.Options

Equations

• Lean.Options.empty = { entries := [] }

instance Lean.instInhabitedOptions : Inhabited Lean.Options

Equations

• Lean.instInhabitedOptions = { default := { entries := [] } }

instance Lean.instToStringOptions : ToString Lean.Options

Equations

• Lean.instToStringOptions = inferInstanceAs (ToString Lean.KVMap)

instance Lean.instForInOptionsProdNameDataValue {m : Type u_1 → Type u_2} : ForIn m Lean.Options (Lean.Name × Lean.DataValue)

Equations

• Lean.instForInOptionsProdNameDataValue = inferInstanceAs (ForIn m Lean.KVMap (Lean.Name × Lean.DataValue))

instance Lean.instBEqOptions : BEq Lean.Options

Equations

• Lean.instBEqOptions = inferInstanceAs (BEq Lean.KVMap)

structure Lean.OptionDecl : Type

• declName : autoParam Lean.Name _auto✝
• defValue : Lean.DataValue
• group : String
• descr : String

instance Lean.instInhabitedOptionDecl : Inhabited Lean.OptionDecl

Equations

• Lean.instInhabitedOptionDecl = { default := Lean.OptionDecl.mk default default default }

def Lean.OptionDecls : Type

Equations

• Lean.OptionDecls = Lean.NameMap Lean.OptionDecl

instance Lean.instInhabitedOptionDecls : Inhabited Lean.OptionDecls

Equations

• Lean.instInhabitedOptionDecls = { default := ∅ }

@[export lean_register_option]

def Lean.registerOption (name : Lean.Name) (decl : Lean.OptionDecl) : IO Unit

Equations

• One or more equations did not get rendered due to their size.

def Lean.getOptionDecls : IO Lean.OptionDecls

Equations

• Lean.getOptionDecls = ST.Ref.get Lean.optionDeclsRef

@[export lean_get_option_decls_array]

def Lean.getOptionDeclsArray : IO (Array (Lean.Name × Lean.OptionDecl))

Equations

• Lean.getOptionDeclsArray = do let decls ← Lean.getOptionDecls pure (Lean.RBMap.fold (fun r k v => Array.push r (k, v)) #[] decls)

def Lean.getOptionDecl (name : Lean.Name) : IO Lean.OptionDecl

Equations

• One or more equations did not get rendered due to their size.

def Lean.getOptionDefaultValue (name : Lean.Name) : IO Lean.DataValue

Equations

• Lean.getOptionDefaultValue name = do let decl ← Lean.getOptionDecl name pure decl.defValue

def Lean.getOptionDescr (name : Lean.Name) : IO String

Equations

• Lean.getOptionDescr name = do let decl ← Lean.getOptionDecl name pure decl.descr

def Lean.setOptionFromString (opts : Lean.Options) (entry : String) : IO Lean.Options

Equations

• One or more equations did not get rendered due to their size.

class Lean.MonadOptions (m : Type → Type) : Type

• getOptions : m Lean.Options

instance Lean.instMonadOptions {m : Type → Type} {n : Type → Type} [inst : MonadLift m n] [inst : Lean.MonadOptions m] : Lean.MonadOptions n

Equations

• Lean.instMonadOptions = { getOptions := liftM Lean.getOptions }

def Lean.getBoolOption {m : Type → Type} [inst : Monad m] [inst : Lean.MonadOptions m] (k : Lean.Name) (defValue : optParam Bool false) : m Bool

Equations

• Lean.getBoolOption k defValue = do let opts ← Lean.getOptions pure (Lean.KVMap.getBool opts k defValue)

def Lean.getNatOption {m : Type → Type} [inst : Monad m] [inst : Lean.MonadOptions m] (k : Lean.Name) (defValue : optParam Nat 0) : m Nat

Equations

• Lean.getNatOption k defValue = do let opts ← Lean.getOptions pure (Lean.KVMap.getNat opts k defValue)

class Lean.MonadWithOptions (m : Type → Type) : Type 1

• withOptions : {α : Type} → (Lean.Options → Lean.Options) → m α → m α

instance Lean.instMonadWithOptions {m : Type → Type} {n : Type → Type} [inst : MonadFunctor m n] [inst : Lean.MonadWithOptions m] : Lean.MonadWithOptions n

Equations

• Lean.instMonadWithOptions = { withOptions := fun {α} f x => monadMap (fun {β} => Lean.withOptions f) x }

Remark: _inPattern is an internal option for communicating to the delaborator that the term being delaborated should be treated as a pattern.

def Lean.withInPattern {m : Type → Type} {α : Type} [inst : Lean.MonadWithOptions m] (x : m α) : m α

Equations

• Lean.withInPattern x = Lean.withOptions (fun o => Lean.KVMap.setBool o `_inPattern true) x

def Lean.Options.getInPattern (o : Lean.Options) : Bool

Equations

• Lean.Options.getInPattern o = Lean.KVMap.getBool o `_inPattern

structure Lean.Option (α : Type) : Type

• name : Lean.Name
• defValue : α

A strongly-typed reference to an option.

instance Lean.instInhabitedOption : {a : Type} → [inst : Inhabited a] → Inhabited (Lean.Option a)

Equations

• Lean.instInhabitedOption = { default := { name := default, defValue := default } }

structure Lean.Option.Decl (α : Type) : Type

• defValue : α
• group : String
• descr : String

def Lean.Option.get? {α : Type} [inst : Lean.KVMap.Value α] (opts : Lean.Options) (opt : Lean.Option α) : Option α

Equations

• Lean.Option.get? opts opt = Lean.KVMap.get? opts opt.name

def Lean.Option.get {α : Type} [inst : Lean.KVMap.Value α] (opts : Lean.Options) (opt : Lean.Option α) : α

Equations

• Lean.Option.get opts opt = Lean.KVMap.get opts opt.name opt.defValue

def Lean.Option.set {α : Type} [inst : Lean.KVMap.Value α] (opts : Lean.Options) (opt : Lean.Option α) (val : α) : Lean.Options

Equations

• Lean.Option.set opts opt val = Lean.KVMap.set opts opt.name val

def Lean.Option.setIfNotSet {α : Type} [inst : Lean.KVMap.Value α] (opts : Lean.Options) (opt : Lean.Option α) (val : α) : Lean.Options

Similar to set, but update opts only if it doesn't already contains an setting for opt.name

Equations

• Lean.Option.setIfNotSet opts opt val = if Lean.KVMap.contains opts opt.name = true then opts else Lean.Option.set opts opt val

def Lean.Option.register {α : Type} [inst : Lean.KVMap.Value α] (name : Lean.Name) (decl : Lean.Option.Decl α) (ref : autoParam Lean.Name _auto✝) : IO (Lean.Option α)

Equations

• One or more equations did not get rendered due to their size.

def Lean.Option.registerBuiltinOption : Lean.ParserDescr

Equations

• One or more equations did not get rendered due to their size.

def Lean.Option.registerOption : Lean.ParserDescr

Equations

• One or more equations did not get rendered due to their size.