Constant folding for primitives that have special runtime support.

def Lean.Compiler.mkLcProof (p : Lean.Expr) : Lean.Expr

@[inline, reducible]

abbrev Lean.Compiler.BinFoldFn : Type

@[inline, reducible]

abbrev Lean.Compiler.UnFoldFn : Type

def Lean.Compiler.mkUIntTypeName (nbytes : Nat) : Lake.Name

structure Lean.Compiler.NumScalarTypeInfo : Type

• nbits : Nat
• id : Lake.Name
• ofNatFn : Lake.Name
• toNatFn : Lake.Name
• size : Nat

def Lean.Compiler.numScalarTypes : List Lean.Compiler.NumScalarTypeInfo

def Lean.Compiler.isOfNat (fn : Lake.Name) : Bool

def Lean.Compiler.isToNat (fn : Lake.Name) : Bool

def Lean.Compiler.getInfoFromFn (fn : Lake.Name) : List Lean.Compiler.NumScalarTypeInfo → Option Lean.Compiler.NumScalarTypeInfo

Equations

• Lean.Compiler.getInfoFromFn fn [] = none
• Lean.Compiler.getInfoFromFn fn (info :: infos) = if (info.ofNatFn == fn) = true then some info else Lean.Compiler.getInfoFromFn fn infos

def Lean.Compiler.getInfoFromVal : Lean.Expr → Option Lean.Compiler.NumScalarTypeInfo

@[export lean_get_num_lit]

def Lean.Compiler.getNumLit : Lean.Expr → Option Nat

Equations

• Lean.Compiler.getNumLit (Lean.Expr.lit (Lean.Literal.natVal n)) = some n
• Lean.Compiler.getNumLit (Lean.Expr.app (Lean.Expr.const fn us) a) = if Lean.Compiler.isOfNat fn = true then Lean.Compiler.getNumLit a else none
• Lean.Compiler.getNumLit x = none

def Lean.Compiler.mkUIntLit (info : Lean.Compiler.NumScalarTypeInfo) (n : Nat) : Lean.Expr

def Lean.Compiler.mkUInt32Lit (n : Nat) : Lean.Expr

def Lean.Compiler.foldBinUInt (fn : Lean.Compiler.NumScalarTypeInfo → Bool → Nat → Nat → Nat) (beforeErasure : Bool) (a₁ : Lean.Expr) (a₂ : Lean.Expr) : Option Lean.Expr

def Lean.Compiler.foldUIntAdd (beforeErasure : Bool) (a₁ : Lean.Expr) (a₂ : Lean.Expr) : Option Lean.Expr

def Lean.Compiler.foldUIntMul (beforeErasure : Bool) (a₁ : Lean.Expr) (a₂ : Lean.Expr) : Option Lean.Expr

def Lean.Compiler.foldUIntDiv (beforeErasure : Bool) (a₁ : Lean.Expr) (a₂ : Lean.Expr) : Option Lean.Expr

def Lean.Compiler.foldUIntMod (beforeErasure : Bool) (a₁ : Lean.Expr) (a₂ : Lean.Expr) : Option Lean.Expr

def Lean.Compiler.foldUIntSub (beforeErasure : Bool) (a₁ : Lean.Expr) (a₂ : Lean.Expr) : Option Lean.Expr

def Lean.Compiler.preUIntBinFoldFns : List (Lake.Name × Lean.Compiler.BinFoldFn)

def Lean.Compiler.uintBinFoldFns : List (Lake.Name × Lean.Compiler.BinFoldFn)

def Lean.Compiler.foldNatBinOp (fn : Nat → Nat → Nat) (a₁ : Lean.Expr) (a₂ : Lean.Expr) : Option Lean.Expr

def Lean.Compiler.foldNatAdd : Bool → Lean.Expr → Lean.Expr → Option Lean.Expr

def Lean.Compiler.foldNatMul : Bool → Lean.Expr → Lean.Expr → Option Lean.Expr

def Lean.Compiler.foldNatDiv : Bool → Lean.Expr → Lean.Expr → Option Lean.Expr

def Lean.Compiler.foldNatMod : Bool → Lean.Expr → Lean.Expr → Option Lean.Expr

def Lean.Compiler.natPowThreshold : Nat

def Lean.Compiler.foldNatPow : Bool → Lean.Expr → Lean.Expr → Option Lean.Expr

def Lean.Compiler.mkNatEq (a : Lean.Expr) (b : Lean.Expr) : Lean.Expr

def Lean.Compiler.mkNatLt (a : Lean.Expr) (b : Lean.Expr) : Lean.Expr

def Lean.Compiler.mkNatLe (a : Lean.Expr) (b : Lean.Expr) : Lean.Expr

def Lean.Compiler.toDecidableExpr (beforeErasure : Bool) (pred : Lean.Expr) (r : Bool) : Lean.Expr

def Lean.Compiler.foldNatBinPred (mkPred : Lean.Expr → Lean.Expr → Lean.Expr) (fn : Nat → Nat → Bool) (beforeErasure : Bool) (a₁ : Lean.Expr) (a₂ : Lean.Expr) : Option Lean.Expr

def Lean.Compiler.foldNatDecEq (beforeErasure : Bool) (a₁ : Lean.Expr) (a₂ : Lean.Expr) : Option Lean.Expr

def Lean.Compiler.foldNatDecLt (beforeErasure : Bool) (a₁ : Lean.Expr) (a₂ : Lean.Expr) : Option Lean.Expr

def Lean.Compiler.foldNatDecLe (beforeErasure : Bool) (a₁ : Lean.Expr) (a₂ : Lean.Expr) : Option Lean.Expr

def Lean.Compiler.foldNatBinBoolPred (fn : Nat → Nat → Bool) (a₁ : Lean.Expr) (a₂ : Lean.Expr) : Option Lean.Expr

def Lean.Compiler.foldNatBeq : Bool → Lean.Expr → Lean.Expr → Option Lean.Expr

def Lean.Compiler.foldNatBle : Bool → Lean.Expr → Lean.Expr → Option Lean.Expr

def Lean.Compiler.foldNatBlt : Bool → Lean.Expr → Lean.Expr → Option Lean.Expr

def Lean.Compiler.natFoldFns : List (Lake.Name × Lean.Compiler.BinFoldFn)

def Lean.Compiler.getBoolLit : Lean.Expr → Option Bool

def Lean.Compiler.foldStrictAnd : Bool → Lean.Expr → Lean.Expr → Option Lean.Expr

def Lean.Compiler.foldStrictOr : Bool → Lean.Expr → Lean.Expr → Option Lean.Expr

def Lean.Compiler.boolFoldFns : List (Lake.Name × Lean.Compiler.BinFoldFn)

def Lean.Compiler.binFoldFns : List (Lake.Name × Lean.Compiler.BinFoldFn)

def Lean.Compiler.foldNatSucc : Bool → Lean.Expr → Option Lean.Expr

def Lean.Compiler.foldCharOfNat (beforeErasure : Bool) (a : Lean.Expr) : Option Lean.Expr

def Lean.Compiler.foldToNat : Bool → Lean.Expr → Option Lean.Expr

def Lean.Compiler.uintFoldToNatFns : List (Lake.Name × Lean.Compiler.UnFoldFn)

def Lean.Compiler.unFoldFns : List (Lake.Name × Lean.Compiler.UnFoldFn)

def Lean.Compiler.findBinFoldFn (fn : Lake.Name) : Option Lean.Compiler.BinFoldFn

def Lean.Compiler.findUnFoldFn (fn : Lake.Name) : Option Lean.Compiler.UnFoldFn

@[export lean_fold_bin_op]

def Lean.Compiler.foldBinOp (beforeErasure : Bool) (f : Lean.Expr) (a : Lean.Expr) (b : Lean.Expr) : Option Lean.Expr

@[export lean_fold_un_op]

def Lean.Compiler.foldUnOp (beforeErasure : Bool) (f : Lean.Expr) (a : Lean.Expr) : Option Lean.Expr