quox/lib/Quox/Definition.idr

module Quox.Definition

import public Quox.No
import public Quox.Syntax
import public Data.SortedMap
import public Quox.Loc
import Control.Eff
import Decidable.Decidable


public export
data DefBody =
    Concrete (Term 0 0)
  | Postulate

namespace DefBody
  public export
  (.term0) : DefBody -> Maybe (Term 0 0)
  (Concrete t).term0 = Just t
  (Postulate).term0  = Nothing


public export
record Definition where
  constructor MkDef
  qty   : GQty
  type0 : Term 0 0
  body0 : DefBody
  loc_  : Loc

public export %inline
mkPostulate : GQty -> (type0 : Term 0 0) -> Loc -> Definition
mkPostulate qty type0 loc_ = MkDef {qty, type0, body0 = Postulate, loc_}

public export %inline
mkDef : GQty -> (type0, term0 : Term 0 0) -> Loc -> Definition
mkDef qty type0 term0 loc_ = MkDef {qty, type0, body0 = Concrete term0, loc_}

export Located Definition where def.loc = def.loc_
export Relocatable Definition where setLoc loc = {loc_ := loc}


parameters {d, n : Nat}
  public export %inline
  (.type) : Definition -> Term d n
  g.type = g.type0 // shift0 d // shift0 n

  public export %inline
  (.term) : Definition -> Maybe (Term d n)
  g.term = g.body0.term0 <&> \t => t // shift0 d // shift0 n

  public export %inline
  toElim : Definition -> Maybe $ Elim d n
  toElim def = pure $ Ann !def.term def.type def.loc


public export %inline
isZero : Definition -> Bool
isZero g = g.qty.fst == Zero


public export
data DefEnvTag = DEFS

public export
Definitions : Type
Definitions = SortedMap Name Definition

public export
DefsReader : Type -> Type
DefsReader = ReaderL DEFS Definitions

public export
DefsState : Type -> Type
DefsState = StateL DEFS Definitions

export
defs : Has DefsReader fs => Eff fs Definitions
defs = askAt DEFS


public export %inline
lookupElim : {d, n : Nat} -> Name -> Definitions -> Maybe (Elim d n)
lookupElim x defs = toElim !(lookup x defs)