Wingman.GHC

Documentation

tcTyVar_maybe :: Type -> Maybe Var

instantiateType :: Type -> ([TyVar], Type)

cloneTyVar :: TyVar -> TyVar

isFunction :: Type -> Bool

Is this a function type?

tacticsSplitFunTy :: Type -> ([TyVar], ThetaType, [Type], Type)

Split a function, also splitting out its quantified variables and theta context.

tacticsThetaTy :: Type -> ThetaType

Rip the theta context out of a regular type.

tacticsGetDataCons :: Type -> Maybe ([DataCon], [Type])

Get the data cons of a type, if it has any.

freshTyvars :: MonadState TacticState m => Type -> m Type

Instantiate all of the quantified type variables in a type with fresh skolems.

getRecordFields :: ConLike -> Maybe [(OccName, CType)]

Given a datacon, extract its record fields' names and types. Returns nothing if the datacon is not a record.

algebraicTyCon :: Type -> Maybe TyCon

Is this an algebraic type?

eqRdrName :: RdrName -> RdrName -> Bool

We can't compare RdrName for equality directly. Instead, sloppily compare them by their OccNames.

sloppyEqOccName :: OccName -> OccName -> Bool

Compare two OccNames for unqualified equality.

containsHsVar :: Data a => RdrName -> a -> Bool

Does this thing contain any references to HsVars with the given RdrName?

containsHole :: Data a => a -> Bool

Does this thing contain any holes?

isHole :: OccName -> Bool

Check if an OccName is a hole

allOccNames :: Data a => a -> Set OccName

Get all of the referenced occnames.

pattern AMatch :: HsMatchContext (NameOrRdrName (IdP GhcPs)) -> [Pat GhcPs] -> HsExpr GhcPs -> Match GhcPs (LHsExpr GhcPs)

Unpack the relevant parts of a Match

pattern SingleLet :: IdP GhcPs -> [Pat GhcPs] -> HsExpr GhcPs -> HsExpr GhcPs -> HsExpr GhcPs

pattern Lambda :: [Pat GhcPs] -> HsExpr GhcPs -> HsExpr GhcPs

A pattern over the otherwise (extremely) messy AST for lambdas.

pattern UnguardedRHSs :: LHsExpr p -> GRHSs p (LHsExpr p)

A GRHS that caontains no guards.

pattern SinglePatMatch :: PatCompattable p => Pat p -> LHsExpr p -> Match p (LHsExpr p)

A match with a single pattern. Case matches are always SinglePatMatches.

unpackMatches :: PatCompattable p => [Match p (LHsExpr p)] -> Maybe [(Pat p, LHsExpr p)]

Helper function for defining the Case pattern.

pattern Case :: PatCompattable p => HsExpr p -> [(Pat p, LHsExpr p)] -> HsExpr p

A pattern over the otherwise (extremely) messy AST for lambdas.

pattern LamCase :: PatCompattable p => [(Pat p, LHsExpr p)] -> HsExpr p

Like Case, but for lambda cases.

lambdaCaseable :: Type -> Maybe Bool

Can ths type be lambda-cased?

Return: Nothing if no Just False if it can't be homomorphic Just True if it can

class PatCompattable p where

Methods

fromPatCompat :: PatCompat p -> Pat p

toPatCompat :: Pat p -> PatCompat p

Instances

PatCompattable GhcPs

Defined in Wingman.GHC

Methods

fromPatCompat :: PatCompat GhcPs -> Pat GhcPs

toPatCompat :: Pat GhcPs -> PatCompat GhcPs

PatCompattable GhcTc

Defined in Wingman.GHC

Methods

fromPatCompat :: PatCompat GhcTc -> Pat GhcTc

toPatCompat :: Pat GhcTc -> PatCompat GhcTc

type PatCompat pass = LPat pass

pattern TopLevelRHS :: OccName -> [PatCompat GhcTc] -> LHsExpr GhcTc -> HsLocalBindsLR GhcTc GhcTc -> Match GhcTc (LHsExpr GhcTc)

Should make sure it's a fun bind

dataConExTys :: DataCon -> [TyCoVar]

unXPat :: Pat GhcPs -> Pat GhcPs

In GHC 8.8, sometimes patterns are wrapped in XPat. The nitty gritty details are explained at https://blog.shaynefletcher.org/2020/03/ghc-haskell-pats-and-lpats.html

We need to remove these in order to succesfull find patterns.

liftMaybe :: Monad m => Maybe a -> MaybeT m a

typeCheck :: HscEnv -> TcGblEnv -> HsExpr GhcTc -> IO (Maybe Type)

Get the type of an HsExpr GhcTc. This is slow and you should prefer to not use it, but sometimes it can't be helped.

mkFunTys' :: [Type] -> Type -> Type

normalizeType :: Context -> Type -> Type

Expand type and data families

expandTyFam :: Context -> Type -> Type

Expand type families

tryUnifyUnivarsButNotSkolems :: Set TyVar -> CType -> CType -> Maybe TCvSubst

Like tcUnifyTy, but takes a list of skolems to prevent unification of.

updateSubst :: TCvSubst -> TacticState -> TacticState

methodHypothesis :: PredType -> Maybe [HyInfo CType]

Get the class methods of a PredType, correctly dealing with instantiation of quantified class types.