blob: 2aff1764fea02b50185e2ef30f3567f79c8c1431 [file]
/-
Copyright (c) 2020 Microsoft Corporation. All rights reserved.
Released under Apache 2.0 license as described in the file LICENSE.
Authors: Leonardo de Moura
-/
import Lean.Meta.Basic
namespace Lean.Meta
namespace Match
structure DiscrInfo where
/-- `some h` if the discriminant is annotated with `h:` -/
hName? : Option Name := none
deriving Inhabited
/--
A "matcher" auxiliary declaration has the following structure:
- `numParams` parameters
- motive
- `numDiscrs` discriminators (aka major premises)
- `altNumParams.size` alternatives (aka minor premises) where alternative `i` has `altNumParams[i]` parameters
- `uElimPos?` is `some pos` when the matcher can eliminate in different universe levels, and
`pos` is the position of the universe level parameter that specifies the elimination universe.
It is `none` if the matcher only eliminates into `Prop`. -/
structure MatcherInfo where
numParams : Nat
numDiscrs : Nat
altNumParams : Array Nat
uElimPos? : Option Nat
/--
`discrInfos[i] = { hName? := some h }` if the i-th discriminant was annotated with `h :`.
-/
discrInfos : Array DiscrInfo
def MatcherInfo.numAlts (info : MatcherInfo) : Nat :=
info.altNumParams.size
def MatcherInfo.arity (info : MatcherInfo) : Nat :=
info.numParams + 1 + info.numDiscrs + info.numAlts
def MatcherInfo.getFirstDiscrPos (info : MatcherInfo) : Nat :=
info.numParams + 1
def MatcherInfo.getDiscrRange (info : MatcherInfo) : Std.Range :=
{ start := info.getFirstDiscrPos, stop := info.getFirstDiscrPos + info.numDiscrs }
def MatcherInfo.getFirstAltPos (info : MatcherInfo) : Nat :=
info.numParams + 1 + info.numDiscrs
def MatcherInfo.getAltRange (info : MatcherInfo) : Std.Range :=
{ start := info.getFirstAltPos, stop := info.getFirstAltPos + info.numAlts }
def MatcherInfo.getMotivePos (info : MatcherInfo) : Nat :=
info.numParams
def getNumEqsFromDiscrInfos (infos : Array DiscrInfo) : Nat := Id.run do
let mut r := 0
for info in infos do
if info.hName?.isSome then
r := r + 1
return r
def MatcherInfo.getNumDiscrEqs (info : MatcherInfo) : Nat :=
getNumEqsFromDiscrInfos info.discrInfos
namespace Extension
structure Entry where
name : Name
info : MatcherInfo
structure State where
map : SMap Name MatcherInfo := {}
instance : Inhabited State := ⟨{}⟩
def State.addEntry (s : State) (e : Entry) : State := { s with map := s.map.insert e.name e.info }
def State.switch (s : State) : State := { s with map := s.map.switch }
builtin_initialize extension : SimplePersistentEnvExtension Entry State ←
registerSimplePersistentEnvExtension {
addEntryFn := State.addEntry
addImportedFn := fun es => (mkStateFromImportedEntries State.addEntry {} es).switch
}
def addMatcherInfo (env : Environment) (matcherName : Name) (info : MatcherInfo) : Environment :=
extension.addEntry env { name := matcherName, info := info }
def getMatcherInfo? (env : Environment) (declName : Name) : Option MatcherInfo :=
(extension.getState env).map.find? declName
end Extension
def addMatcherInfo (matcherName : Name) (info : MatcherInfo) : MetaM Unit :=
modifyEnv fun env => Extension.addMatcherInfo env matcherName info
end Match
export Match (MatcherInfo)
def getMatcherInfoCore? (env : Environment) (declName : Name) : Option MatcherInfo :=
Match.Extension.getMatcherInfo? env declName
def getMatcherInfo? [Monad m] [MonadEnv m] (declName : Name) : m (Option MatcherInfo) :=
return getMatcherInfoCore? (← getEnv) declName
@[export lean_is_matcher]
def isMatcherCore (env : Environment) (declName : Name) : Bool :=
getMatcherInfoCore? env declName |>.isSome
def isMatcher [Monad m] [MonadEnv m] (declName : Name) : m Bool :=
return isMatcherCore (← getEnv) declName
def isMatcherAppCore? (env : Environment) (e : Expr) : Option MatcherInfo :=
let fn := e.getAppFn
if fn.isConst then
if let some matcherInfo := getMatcherInfoCore? env fn.constName! then
if e.getAppNumArgs ≥ matcherInfo.arity then some matcherInfo else none
else
none
else
none
def isMatcherAppCore (env : Environment) (e : Expr) : Bool :=
isMatcherAppCore? env e |>.isSome
def isMatcherApp [Monad m] [MonadEnv m] (e : Expr) : m Bool :=
return isMatcherAppCore (← getEnv) e
structure MatcherApp where
matcherName : Name
matcherLevels : Array Level
uElimPos? : Option Nat
params : Array Expr
motive : Expr
discrs : Array Expr
altNumParams : Array Nat
alts : Array Expr
remaining : Array Expr
def matchMatcherApp? [Monad m] [MonadEnv m] (e : Expr) : m (Option MatcherApp) := do
match e.getAppFn with
| Expr.const declName declLevels =>
match (← getMatcherInfo? declName) with
| none => return none
| some info =>
let args := e.getAppArgs
if args.size < info.arity then
return none
else
return some {
matcherName := declName
matcherLevels := declLevels.toArray
uElimPos? := info.uElimPos?
params := args.extract 0 info.numParams
motive := args[info.getMotivePos]!
discrs := args[info.numParams + 1 : info.numParams + 1 + info.numDiscrs]
altNumParams := info.altNumParams
alts := args[info.numParams + 1 + info.numDiscrs : info.numParams + 1 + info.numDiscrs + info.numAlts]
remaining := args[info.numParams + 1 + info.numDiscrs + info.numAlts : args.size]
}
| _ => return none
def MatcherApp.toExpr (matcherApp : MatcherApp) : Expr :=
let result := mkAppN (mkConst matcherApp.matcherName matcherApp.matcherLevels.toList) matcherApp.params
let result := mkApp result matcherApp.motive
let result := mkAppN result matcherApp.discrs
let result := mkAppN result matcherApp.alts
mkAppN result matcherApp.remaining
end Lean.Meta