packages feed

ghc-exactprint 0.5.8.2 → 0.6

raw patch · 4 files changed

+43/−25 lines, 4 filesdep +faildep ~basePVP ok

version bump matches the API change (PVP)

Dependencies added: fail

Dependency ranges changed: base

API changes (from Hackage documentation)

- Language.Haskell.GHC.ExactPrint.Annotater: instance (HsExtension.DataId name, Language.Haskell.GHC.ExactPrint.Annotater.Annotate arg) => Language.Haskell.GHC.ExactPrint.Annotater.Annotate (HsTypes.HsImplicitBndrs name (SrcLoc.Located arg))
- Language.Haskell.GHC.ExactPrint.Annotater: instance GHC.Show.Show (HsTypes.LHsTyVarBndr name) => GHC.Show.Show (Language.Haskell.GHC.ExactPrint.Annotater.ResTyGADTHook name)
- Language.Haskell.GHC.ExactPrint.Annotater: instance HsExtension.DataId name => Data.Data.Data (Language.Haskell.GHC.ExactPrint.Annotater.ResTyGADTHook name)
- Language.Haskell.GHC.ExactPrint.Annotater: instance HsExtension.DataId name => Language.Haskell.GHC.ExactPrint.Annotater.Annotate (HsTypes.AmbiguousFieldOcc name)
- Language.Haskell.GHC.ExactPrint.Annotater: instance HsExtension.DataId name => Language.Haskell.GHC.ExactPrint.Annotater.Annotate (HsTypes.FieldOcc name)
- Language.Haskell.GHC.ExactPrint.Annotater: instance Language.Haskell.GHC.ExactPrint.Annotater.Annotate (GHC.Base.Maybe CoAxiom.Role)
- Language.Haskell.GHC.ExactPrint.Annotater: instance Language.Haskell.GHC.ExactPrint.Annotater.Annotate (HsDecls.VectDecl HsExtension.GhcPs)
- Language.Haskell.GHC.ExactPrint.Annotater: instance Language.Haskell.GHC.ExactPrint.Annotater.Annotate (HsTypes.HsAppType HsExtension.GhcPs)
- Language.Haskell.GHC.ExactPrint.Annotater: instance Language.Haskell.GHC.ExactPrint.Annotater.Annotate (Language.Haskell.GHC.ExactPrint.Annotater.ResTyGADTHook HsExtension.GhcPs)
- Language.Haskell.GHC.ExactPrint.Annotater: instance Language.Haskell.GHC.ExactPrint.Annotater.Annotate BasicTypes.DerivStrategy
- Language.Haskell.GHC.ExactPrint.Annotater: instance Outputable.Outputable (Language.Haskell.GHC.ExactPrint.Annotater.ResTyGADTHook HsExtension.GhcPs)
- Language.Haskell.GHC.ExactPrint.Transform: [runTransformT] :: TransformT m a -> RWST () [String] (Anns, Int) m a
- Language.Haskell.GHC.ExactPrint.Transform: instance Language.Haskell.GHC.ExactPrint.Transform.HasTransform (Language.Haskell.GHC.ExactPrint.Transform.TransformT Data.Functor.Identity.Identity)
+ Language.Haskell.GHC.ExactPrint.Annotater: instance Data.Data.Data Language.Haskell.GHC.ExactPrint.Annotater.ResTyGADTHook
+ Language.Haskell.GHC.ExactPrint.Annotater: instance Language.Haskell.GHC.ExactPrint.Annotater.Annotate (GHC.Maybe.Maybe CoAxiom.Role)
+ Language.Haskell.GHC.ExactPrint.Annotater: instance Language.Haskell.GHC.ExactPrint.Annotater.Annotate (HsDecls.DerivStrategy HsExtension.GhcPs)
+ Language.Haskell.GHC.ExactPrint.Annotater: instance Language.Haskell.GHC.ExactPrint.Annotater.Annotate (HsTypes.AmbiguousFieldOcc HsExtension.GhcPs)
+ Language.Haskell.GHC.ExactPrint.Annotater: instance Language.Haskell.GHC.ExactPrint.Annotater.Annotate (HsTypes.FieldOcc HsExtension.GhcPs)
+ Language.Haskell.GHC.ExactPrint.Annotater: instance Language.Haskell.GHC.ExactPrint.Annotater.Annotate Language.Haskell.GHC.ExactPrint.Annotater.ResTyGADTHook
+ Language.Haskell.GHC.ExactPrint.Annotater: instance Language.Haskell.GHC.ExactPrint.Annotater.Annotate arg => Language.Haskell.GHC.ExactPrint.Annotater.Annotate (HsTypes.HsImplicitBndrs HsExtension.GhcPs (SrcLoc.Located arg))
+ Language.Haskell.GHC.ExactPrint.Annotater: instance Outputable.Outputable Language.Haskell.GHC.ExactPrint.Annotater.ResTyGADTHook
+ Language.Haskell.GHC.ExactPrint.Transform: [unTransformT] :: TransformT m a -> RWST () [String] (Anns, Int) m a
+ Language.Haskell.GHC.ExactPrint.Transform: hoistTransform :: (forall x. m x -> n x) -> TransformT m a -> TransformT n a
+ Language.Haskell.GHC.ExactPrint.Transform: instance Control.Monad.Fail.MonadFail m => Control.Monad.Fail.MonadFail (Language.Haskell.GHC.ExactPrint.Transform.TransformT m)
+ Language.Haskell.GHC.ExactPrint.Transform: instance GHC.Base.Monad m => Language.Haskell.GHC.ExactPrint.Transform.HasTransform (Language.Haskell.GHC.ExactPrint.Transform.TransformT m)
+ Language.Haskell.GHC.ExactPrint.Transform: runTransformT :: Anns -> TransformT m a -> m (a, (Anns, Int), [String])
- Language.Haskell.GHC.ExactPrint: Ann :: !DeltaPos -> ![(Comment, DeltaPos)] -> ![(Comment, DeltaPos)] -> ![(KeywordId, DeltaPos)] -> !(Maybe [SrcSpan]) -> !(Maybe AnnKey) -> Annotation
+ Language.Haskell.GHC.ExactPrint: Ann :: !DeltaPos -> ![(Comment, DeltaPos)] -> ![(Comment, DeltaPos)] -> ![(KeywordId, DeltaPos)] -> !Maybe [SrcSpan] -> !Maybe AnnKey -> Annotation
- Language.Haskell.GHC.ExactPrint: [annCapturedSpan] :: Annotation -> !(Maybe AnnKey)
+ Language.Haskell.GHC.ExactPrint: [annCapturedSpan] :: Annotation -> !Maybe AnnKey
- Language.Haskell.GHC.ExactPrint: [annSortKey] :: Annotation -> !(Maybe [SrcSpan])
+ Language.Haskell.GHC.ExactPrint: [annSortKey] :: Annotation -> !Maybe [SrcSpan]
- Language.Haskell.GHC.ExactPrint: addAnnotationsForPretty :: (Annotate a) => [Comment] -> Located a -> Anns -> Anns
+ Language.Haskell.GHC.ExactPrint: addAnnotationsForPretty :: Annotate a => [Comment] -> Located a -> Anns -> Anns
- Language.Haskell.GHC.ExactPrint.Annotate: annotate :: (Annotate ast) => Located ast -> Annotated ()
+ Language.Haskell.GHC.ExactPrint.Annotate: annotate :: Annotate ast => Located ast -> Annotated ()
- Language.Haskell.GHC.ExactPrint.Annotate: withSortKeyContextsHelper :: (Monad m) => (Annotated () -> m ()) -> ListContexts -> [(SrcSpan, Annotated ())] -> m ()
+ Language.Haskell.GHC.ExactPrint.Annotate: withSortKeyContextsHelper :: Monad m => (Annotated () -> m ()) -> ListContexts -> [(SrcSpan, Annotated ())] -> m ()
- Language.Haskell.GHC.ExactPrint.AnnotateTypes: annotationsToComments :: forall m_aGvn. MonadFree AnnotationF m_aGvn => [AnnKeywordId] -> m_aGvn ()
+ Language.Haskell.GHC.ExactPrint.AnnotateTypes: annotationsToComments :: forall m_aLQ4. MonadFree AnnotationF m_aLQ4 => [AnnKeywordId] -> m_aLQ4 ()
- Language.Haskell.GHC.ExactPrint.AnnotateTypes: countAnns :: forall m_aGsb. MonadFree AnnotationF m_aGsb => AnnKeywordId -> m_aGsb Int
+ Language.Haskell.GHC.ExactPrint.AnnotateTypes: countAnns :: forall m_aLMG. MonadFree AnnotationF m_aLMG => AnnKeywordId -> m_aLMG Int
- Language.Haskell.GHC.ExactPrint.AnnotateTypes: getSrcSpanForKw :: forall m_aGui. MonadFree AnnotationF m_aGui => SrcSpan -> AnnKeywordId -> m_aGui SrcSpan
+ Language.Haskell.GHC.ExactPrint.AnnotateTypes: getSrcSpanForKw :: forall m_aLOV. MonadFree AnnotationF m_aLOV => SrcSpan -> AnnKeywordId -> m_aLOV SrcSpan
- Language.Haskell.GHC.ExactPrint.AnnotateTypes: ifInContext :: forall m_aGzA. MonadFree AnnotationF m_aGzA => Set AstContext -> Annotated () -> Annotated () -> m_aGzA ()
+ Language.Haskell.GHC.ExactPrint.AnnotateTypes: ifInContext :: forall m_aLUx. MonadFree AnnotationF m_aLUx => Set AstContext -> Annotated () -> Annotated () -> m_aLUx ()
- Language.Haskell.GHC.ExactPrint.AnnotateTypes: markAnnBeforeAnn :: forall m_aGCM. MonadFree AnnotationF m_aGCM => AnnKeywordId -> AnnKeywordId -> m_aGCM ()
+ Language.Haskell.GHC.ExactPrint.AnnotateTypes: markAnnBeforeAnn :: forall m_aLXV. MonadFree AnnotationF m_aLXV => AnnKeywordId -> AnnKeywordId -> m_aLXV ()
- Language.Haskell.GHC.ExactPrint.AnnotateTypes: markEOF :: forall m_aFBK. MonadFree AnnotationF m_aFBK => m_aFBK ()
+ Language.Haskell.GHC.ExactPrint.AnnotateTypes: markEOF :: forall m_aKSa. MonadFree AnnotationF m_aKSa => m_aKSa ()
- Language.Haskell.GHC.ExactPrint.AnnotateTypes: markExternal :: forall m_aGmO. MonadFree AnnotationF m_aGmO => SrcSpan -> AnnKeywordId -> String -> m_aGmO ()
+ Language.Haskell.GHC.ExactPrint.AnnotateTypes: markExternal :: forall m_aLGZ. MonadFree AnnotationF m_aLGZ => SrcSpan -> AnnKeywordId -> String -> m_aLGZ ()
- Language.Haskell.GHC.ExactPrint.AnnotateTypes: markInside :: forall m_aGlN. MonadFree AnnotationF m_aGlN => AnnKeywordId -> m_aGlN ()
+ Language.Haskell.GHC.ExactPrint.AnnotateTypes: markInside :: forall m_aLFU. MonadFree AnnotationF m_aLFU => AnnKeywordId -> m_aLFU ()
- Language.Haskell.GHC.ExactPrint.AnnotateTypes: markInstead :: forall m_aGjF. MonadFree AnnotationF m_aGjF => AnnKeywordId -> KeywordId -> m_aGjF ()
+ Language.Haskell.GHC.ExactPrint.AnnotateTypes: markInstead :: forall m_aLDE. MonadFree AnnotationF m_aLDE => AnnKeywordId -> KeywordId -> m_aLDE ()
- Language.Haskell.GHC.ExactPrint.AnnotateTypes: markMany :: forall m_aGnV. MonadFree AnnotationF m_aGnV => AnnKeywordId -> m_aGnV ()
+ Language.Haskell.GHC.ExactPrint.AnnotateTypes: markMany :: forall m_aLIa. MonadFree AnnotationF m_aLIa => AnnKeywordId -> m_aLIa ()
- Language.Haskell.GHC.ExactPrint.AnnotateTypes: markManyOptional :: forall m_aGoW. MonadFree AnnotationF m_aGoW => AnnKeywordId -> m_aGoW ()
+ Language.Haskell.GHC.ExactPrint.AnnotateTypes: markManyOptional :: forall m_aLJf. MonadFree AnnotationF m_aLJf => AnnKeywordId -> m_aLJf ()
- Language.Haskell.GHC.ExactPrint.AnnotateTypes: markOffsetPrim :: forall m_aGpX. MonadFree AnnotationF m_aGpX => AnnKeywordId -> Int -> Maybe String -> m_aGpX ()
+ Language.Haskell.GHC.ExactPrint.AnnotateTypes: markOffsetPrim :: forall m_aLKk. MonadFree AnnotationF m_aLKk => AnnKeywordId -> Int -> Maybe String -> m_aLKk ()
- Language.Haskell.GHC.ExactPrint.AnnotateTypes: markOffsetPrimOptional :: forall m_aGr4. MonadFree AnnotationF m_aGr4 => AnnKeywordId -> Int -> Maybe String -> m_aGr4 ()
+ Language.Haskell.GHC.ExactPrint.AnnotateTypes: markOffsetPrimOptional :: forall m_aLLv. MonadFree AnnotationF m_aLLv => AnnKeywordId -> Int -> Maybe String -> m_aLLv ()
- Language.Haskell.GHC.ExactPrint.AnnotateTypes: markOutside :: forall m_aGkJ. MonadFree AnnotationF m_aGkJ => AnnKeywordId -> KeywordId -> m_aGkJ ()
+ Language.Haskell.GHC.ExactPrint.AnnotateTypes: markOutside :: forall m_aLEM. MonadFree AnnotationF m_aLEM => AnnKeywordId -> KeywordId -> m_aLEM ()
- Language.Haskell.GHC.ExactPrint.AnnotateTypes: markPPOptional :: forall m_aGiB. MonadFree AnnotationF m_aGiB => AnnKeywordId -> Maybe String -> m_aGiB ()
+ Language.Haskell.GHC.ExactPrint.AnnotateTypes: markPPOptional :: forall m_aLCw. MonadFree AnnotationF m_aLCw => AnnKeywordId -> Maybe String -> m_aLCw ()
- Language.Haskell.GHC.ExactPrint.AnnotateTypes: markPrim :: forall m_aGhx. MonadFree AnnotationF m_aGhx => AnnKeywordId -> Maybe String -> m_aGhx ()
+ Language.Haskell.GHC.ExactPrint.AnnotateTypes: markPrim :: forall m_aLBo. MonadFree AnnotationF m_aLBo => AnnKeywordId -> Maybe String -> m_aLBo ()
- Language.Haskell.GHC.ExactPrint.AnnotateTypes: setContextLevel :: forall m_aGxp. MonadFree AnnotationF m_aGxp => Set AstContext -> Int -> Annotated () -> m_aGxp ()
+ Language.Haskell.GHC.ExactPrint.AnnotateTypes: setContextLevel :: forall m_aLSe. MonadFree AnnotationF m_aLSe => Set AstContext -> Int -> Annotated () -> m_aLSe ()
- Language.Haskell.GHC.ExactPrint.AnnotateTypes: storeOriginalSrcSpan :: forall m_aGtd. MonadFree AnnotationF m_aGtd => SrcSpan -> AnnKey -> m_aGtd AnnKey
+ Language.Haskell.GHC.ExactPrint.AnnotateTypes: storeOriginalSrcSpan :: forall m_aLNM. MonadFree AnnotationF m_aLNM => SrcSpan -> AnnKey -> m_aLNM AnnKey
- Language.Haskell.GHC.ExactPrint.AnnotateTypes: tellContext :: forall m_aGBL. MonadFree AnnotationF m_aGBL => Set AstContext -> m_aGBL ()
+ Language.Haskell.GHC.ExactPrint.AnnotateTypes: tellContext :: forall m_aLWQ. MonadFree AnnotationF m_aLWQ => Set AstContext -> m_aLWQ ()
- Language.Haskell.GHC.ExactPrint.AnnotateTypes: unsetContext :: forall m_aGyw. MonadFree AnnotationF m_aGyw => AstContext -> Annotated () -> m_aGyw ()
+ Language.Haskell.GHC.ExactPrint.AnnotateTypes: unsetContext :: forall m_aLTp. MonadFree AnnotationF m_aLTp => AstContext -> Annotated () -> m_aLTp ()
- Language.Haskell.GHC.ExactPrint.AnnotateTypes: withSortKey :: forall m_aGwo. MonadFree AnnotationF m_aGwo => [(SrcSpan, Annotated ())] -> m_aGwo ()
+ Language.Haskell.GHC.ExactPrint.AnnotateTypes: withSortKey :: forall m_aLR9. MonadFree AnnotationF m_aLR9 => [(SrcSpan, Annotated ())] -> m_aLR9 ()
- Language.Haskell.GHC.ExactPrint.AnnotateTypes: withSortKeyContexts :: forall m_aGAH. MonadFree AnnotationF m_aGAH => ListContexts -> [(SrcSpan, Annotated ())] -> m_aGAH ()
+ Language.Haskell.GHC.ExactPrint.AnnotateTypes: withSortKeyContexts :: forall m_aLVI. MonadFree AnnotationF m_aLVI => ListContexts -> [(SrcSpan, Annotated ())] -> m_aLVI ()
- Language.Haskell.GHC.ExactPrint.AnnotateTypes: withSortKeyContextsHelper :: (Monad m) => (Annotated () -> m ()) -> ListContexts -> [(SrcSpan, Annotated ())] -> m ()
+ Language.Haskell.GHC.ExactPrint.AnnotateTypes: withSortKeyContextsHelper :: Monad m => (Annotated () -> m ()) -> ListContexts -> [(SrcSpan, Annotated ())] -> m ()
- Language.Haskell.GHC.ExactPrint.Annotater: annotate :: (Annotate ast) => Located ast -> Annotated ()
+ Language.Haskell.GHC.ExactPrint.Annotater: annotate :: Annotate ast => Located ast -> Annotated ()
- Language.Haskell.GHC.ExactPrint.Annotater: withSortKeyContextsHelper :: (Monad m) => (Annotated () -> m ()) -> ListContexts -> [(SrcSpan, Annotated ())] -> m ()
+ Language.Haskell.GHC.ExactPrint.Annotater: withSortKeyContextsHelper :: Monad m => (Annotated () -> m ()) -> ListContexts -> [(SrcSpan, Annotated ())] -> m ()
- Language.Haskell.GHC.ExactPrint.Preprocess: getPreprocessedSrcDirect :: (GhcMonad m) => CppOptions -> FilePath -> m (String, DynFlags)
+ Language.Haskell.GHC.ExactPrint.Preprocess: getPreprocessedSrcDirect :: GhcMonad m => CppOptions -> FilePath -> m (String, DynFlags)
- Language.Haskell.GHC.ExactPrint.Pretty: addAnnotationsForPretty :: (Annotate a) => [Comment] -> Located a -> Anns -> Anns
+ Language.Haskell.GHC.ExactPrint.Pretty: addAnnotationsForPretty :: Annotate a => [Comment] -> Located a -> Anns -> Anns
- Language.Haskell.GHC.ExactPrint.Transform: addTrailingComma :: (Data a) => Located a -> DeltaPos -> Anns -> Anns
+ Language.Haskell.GHC.ExactPrint.Transform: addTrailingComma :: Data a => Located a -> DeltaPos -> Anns -> Anns
- Language.Haskell.GHC.ExactPrint.Transform: balanceTrailingComments :: (Monad m) => (Data a, Data b) => Located a -> Located b -> TransformT m [(Comment, DeltaPos)]
+ Language.Haskell.GHC.ExactPrint.Transform: balanceTrailingComments :: Monad m => (Data a, Data b) => Located a -> Located b -> TransformT m [(Comment, DeltaPos)]
- Language.Haskell.GHC.ExactPrint.Transform: captureOrder :: (Data a) => Located a -> [Located b] -> Anns -> Anns
+ Language.Haskell.GHC.ExactPrint.Transform: captureOrder :: Data a => Located a -> [Located b] -> Anns -> Anns
- Language.Haskell.GHC.ExactPrint.Transform: getAnnsT :: (Monad m) => TransformT m Anns
+ Language.Haskell.GHC.ExactPrint.Transform: getAnnsT :: Monad m => TransformT m Anns
- Language.Haskell.GHC.ExactPrint.Transform: getEntryDP :: (Data a) => Anns -> Located a -> DeltaPos
+ Language.Haskell.GHC.ExactPrint.Transform: getEntryDP :: Data a => Anns -> Located a -> DeltaPos
- Language.Haskell.GHC.ExactPrint.Transform: hsDecls :: (HasDecls t, (Monad m)) => t -> TransformT m [LHsDecl GhcPs]
+ Language.Haskell.GHC.ExactPrint.Transform: hsDecls :: (HasDecls t, Monad m) => t -> TransformT m [LHsDecl GhcPs]
- Language.Haskell.GHC.ExactPrint.Transform: hsDeclsPatBind :: (Monad m) => LHsBind GhcPs -> TransformT m [LHsDecl GhcPs]
+ Language.Haskell.GHC.ExactPrint.Transform: hsDeclsPatBind :: Monad m => LHsBind GhcPs -> TransformT m [LHsDecl GhcPs]
- Language.Haskell.GHC.ExactPrint.Transform: hsDeclsPatBindD :: (Monad m) => LHsDecl GhcPs -> TransformT m [LHsDecl GhcPs]
+ Language.Haskell.GHC.ExactPrint.Transform: hsDeclsPatBindD :: Monad m => LHsDecl GhcPs -> TransformT m [LHsDecl GhcPs]
- Language.Haskell.GHC.ExactPrint.Transform: hsDeclsValBinds :: (Monad m) => HsLocalBinds GhcPs -> TransformT m [LHsDecl GhcPs]
+ Language.Haskell.GHC.ExactPrint.Transform: hsDeclsValBinds :: Monad m => HsLocalBinds GhcPs -> TransformT m [LHsDecl GhcPs]
- Language.Haskell.GHC.ExactPrint.Transform: insertAfter :: (HasDecls (Located ast)) => Located old -> Located ast -> LHsDecl GhcPs -> Transform (Located ast)
+ Language.Haskell.GHC.ExactPrint.Transform: insertAfter :: HasDecls (Located ast) => Located old -> Located ast -> LHsDecl GhcPs -> Transform (Located ast)
- Language.Haskell.GHC.ExactPrint.Transform: insertAtEnd :: (HasDecls (Located ast)) => Located ast -> LHsDecl GhcPs -> Transform (Located ast)
+ Language.Haskell.GHC.ExactPrint.Transform: insertAtEnd :: HasDecls (Located ast) => Located ast -> LHsDecl GhcPs -> Transform (Located ast)
- Language.Haskell.GHC.ExactPrint.Transform: insertAtStart :: (HasDecls (Located ast)) => Located ast -> LHsDecl GhcPs -> Transform (Located ast)
+ Language.Haskell.GHC.ExactPrint.Transform: insertAtStart :: HasDecls (Located ast) => Located ast -> LHsDecl GhcPs -> Transform (Located ast)
- Language.Haskell.GHC.ExactPrint.Transform: insertBefore :: (HasDecls (Located ast)) => Located old -> Located ast -> LHsDecl GhcPs -> Transform (Located ast)
+ Language.Haskell.GHC.ExactPrint.Transform: insertBefore :: HasDecls (Located ast) => Located old -> Located ast -> LHsDecl GhcPs -> Transform (Located ast)
- Language.Haskell.GHC.ExactPrint.Transform: logDataWithAnnsTr :: (Monad m) => (Data a) => String -> a -> TransformT m ()
+ Language.Haskell.GHC.ExactPrint.Transform: logDataWithAnnsTr :: Monad m => Data a => String -> a -> TransformT m ()
- Language.Haskell.GHC.ExactPrint.Transform: logTr :: (Monad m) => String -> TransformT m ()
+ Language.Haskell.GHC.ExactPrint.Transform: logTr :: Monad m => String -> TransformT m ()
- Language.Haskell.GHC.ExactPrint.Transform: modifyAnnsT :: (Monad m) => (Anns -> Anns) -> TransformT m ()
+ Language.Haskell.GHC.ExactPrint.Transform: modifyAnnsT :: Monad m => (Anns -> Anns) -> TransformT m ()
- Language.Haskell.GHC.ExactPrint.Transform: modifyValD :: forall m t. (HasTransform m) => SrcSpan -> Decl -> (Match -> [Decl] -> m ([Decl], Maybe t)) -> m (Decl, Maybe t)
+ Language.Haskell.GHC.ExactPrint.Transform: modifyValD :: forall m t. HasTransform m => SrcSpan -> Decl -> (Match -> [Decl] -> m ([Decl], Maybe t)) -> m (Decl, Maybe t)
- Language.Haskell.GHC.ExactPrint.Transform: putAnnsT :: (Monad m) => Anns -> TransformT m ()
+ Language.Haskell.GHC.ExactPrint.Transform: putAnnsT :: Monad m => Anns -> TransformT m ()
- Language.Haskell.GHC.ExactPrint.Transform: replaceDecls :: (HasDecls t, (Monad m)) => t -> [LHsDecl GhcPs] -> TransformT m t
+ Language.Haskell.GHC.ExactPrint.Transform: replaceDecls :: (HasDecls t, Monad m) => t -> [LHsDecl GhcPs] -> TransformT m t
- Language.Haskell.GHC.ExactPrint.Transform: replaceDeclsPatBind :: (Monad m) => LHsBind GhcPs -> [LHsDecl GhcPs] -> TransformT m (LHsBind GhcPs)
+ Language.Haskell.GHC.ExactPrint.Transform: replaceDeclsPatBind :: Monad m => LHsBind GhcPs -> [LHsDecl GhcPs] -> TransformT m (LHsBind GhcPs)
- Language.Haskell.GHC.ExactPrint.Transform: replaceDeclsPatBindD :: (Monad m) => LHsDecl GhcPs -> [LHsDecl GhcPs] -> TransformT m (LHsDecl GhcPs)
+ Language.Haskell.GHC.ExactPrint.Transform: replaceDeclsPatBindD :: Monad m => LHsDecl GhcPs -> [LHsDecl GhcPs] -> TransformT m (LHsDecl GhcPs)
- Language.Haskell.GHC.ExactPrint.Transform: replaceDeclsValbinds :: (Monad m) => HsLocalBinds GhcPs -> [LHsDecl GhcPs] -> TransformT m (HsLocalBinds GhcPs)
+ Language.Haskell.GHC.ExactPrint.Transform: replaceDeclsValbinds :: Monad m => HsLocalBinds GhcPs -> [LHsDecl GhcPs] -> TransformT m (HsLocalBinds GhcPs)
- Language.Haskell.GHC.ExactPrint.Transform: setEntryDP :: (Data a) => Located a -> DeltaPos -> Anns -> Anns
+ Language.Haskell.GHC.ExactPrint.Transform: setEntryDP :: Data a => Located a -> DeltaPos -> Anns -> Anns
- Language.Haskell.GHC.ExactPrint.Transform: setPrecedingLines :: (Data a) => Located a -> Int -> Int -> Anns -> Anns
+ Language.Haskell.GHC.ExactPrint.Transform: setPrecedingLines :: Data a => Located a -> Int -> Int -> Anns -> Anns
- Language.Haskell.GHC.ExactPrint.Transform: setPrecedingLinesDeclT :: (Monad m) => LHsDecl GhcPs -> Int -> Int -> TransformT m ()
+ Language.Haskell.GHC.ExactPrint.Transform: setPrecedingLinesDeclT :: Monad m => LHsDecl GhcPs -> Int -> Int -> TransformT m ()
- Language.Haskell.GHC.ExactPrint.Transform: uniqueSrcSpanT :: (Monad m) => TransformT m SrcSpan
+ Language.Haskell.GHC.ExactPrint.Transform: uniqueSrcSpanT :: Monad m => TransformT m SrcSpan
- Language.Haskell.GHC.ExactPrint.Types: ACS :: !(Map a Int) -> ACS' a
+ Language.Haskell.GHC.ExactPrint.Types: ACS :: !Map a Int -> ACS' a
- Language.Haskell.GHC.ExactPrint.Types: Ann :: !DeltaPos -> ![(Comment, DeltaPos)] -> ![(Comment, DeltaPos)] -> ![(KeywordId, DeltaPos)] -> !(Maybe [SrcSpan]) -> !(Maybe AnnKey) -> Annotation
+ Language.Haskell.GHC.ExactPrint.Types: Ann :: !DeltaPos -> ![(Comment, DeltaPos)] -> ![(Comment, DeltaPos)] -> ![(KeywordId, DeltaPos)] -> !Maybe [SrcSpan] -> !Maybe AnnKey -> Annotation
- Language.Haskell.GHC.ExactPrint.Types: Comment :: !String -> !SrcSpan -> !(Maybe AnnKeywordId) -> Comment
+ Language.Haskell.GHC.ExactPrint.Types: Comment :: !String -> !SrcSpan -> !Maybe AnnKeywordId -> Comment
- Language.Haskell.GHC.ExactPrint.Types: LC :: !(Set AstContext) -> ListContexts
+ Language.Haskell.GHC.ExactPrint.Types: LC :: !Set AstContext -> ListContexts
- Language.Haskell.GHC.ExactPrint.Types: [acs] :: ACS' a -> !(Map a Int)
+ Language.Haskell.GHC.ExactPrint.Types: [acs] :: ACS' a -> !Map a Int
- Language.Haskell.GHC.ExactPrint.Types: [annCapturedSpan] :: Annotation -> !(Maybe AnnKey)
+ Language.Haskell.GHC.ExactPrint.Types: [annCapturedSpan] :: Annotation -> !Maybe AnnKey
- Language.Haskell.GHC.ExactPrint.Types: [annSortKey] :: Annotation -> !(Maybe [SrcSpan])
+ Language.Haskell.GHC.ExactPrint.Types: [annSortKey] :: Annotation -> !Maybe [SrcSpan]
- Language.Haskell.GHC.ExactPrint.Types: [commentOrigin] :: Comment -> !(Maybe AnnKeywordId)
+ Language.Haskell.GHC.ExactPrint.Types: [commentOrigin] :: Comment -> !Maybe AnnKeywordId
- Language.Haskell.GHC.ExactPrint.Types: [lcOnly, lcInitial, lcMiddle, lcLast] :: ListContexts -> !(Set AstContext)
+ Language.Haskell.GHC.ExactPrint.Types: [lcOnly, lcInitial, lcMiddle, lcLast] :: ListContexts -> !Set AstContext
- Language.Haskell.GHC.ExactPrint.Types: annGetConstr :: (Data a) => a -> AnnConName
+ Language.Haskell.GHC.ExactPrint.Types: annGetConstr :: Data a => a -> AnnConName
- Language.Haskell.GHC.ExactPrint.Types: mkAnnKey :: (Data a) => Located a -> AnnKey
+ Language.Haskell.GHC.ExactPrint.Types: mkAnnKey :: Data a => Located a -> AnnKey
- Language.Haskell.GHC.ExactPrint.Utils: getAnnotationEP :: (Data a) => Located a -> Anns -> Maybe Annotation
+ Language.Haskell.GHC.ExactPrint.Utils: getAnnotationEP :: Data a => Located a -> Anns -> Maybe Annotation
- Language.Haskell.GHC.ExactPrint.Utils: inAcs :: (Ord a) => Set a -> ACS' a -> Bool
+ Language.Haskell.GHC.ExactPrint.Utils: inAcs :: Ord a => Set a -> ACS' a -> Bool
- Language.Haskell.GHC.ExactPrint.Utils: isExactName :: (Data name) => name -> Bool
+ Language.Haskell.GHC.ExactPrint.Utils: isExactName :: Data name => name -> Bool
- Language.Haskell.GHC.ExactPrint.Utils: setAcsWithLevel :: (Ord a) => Set a -> Int -> ACS' a -> ACS' a
+ Language.Haskell.GHC.ExactPrint.Utils: setAcsWithLevel :: Ord a => Set a -> Int -> ACS' a -> ACS' a
- Language.Haskell.GHC.ExactPrint.Utils: showGhc :: (Outputable a) => a -> String
+ Language.Haskell.GHC.ExactPrint.Utils: showGhc :: Outputable a => a -> String
- Language.Haskell.GHC.ExactPrint.Utils: unsetAcs :: (Ord a) => a -> ACS' a -> ACS' a
+ Language.Haskell.GHC.ExactPrint.Utils: unsetAcs :: Ord a => a -> ACS' a -> ACS' a

Files

ChangeLog view
@@ -1,3 +1,10 @@+2019-03-01 v0.6+        * Remove orphan MonadFail Identity instance+	* MonadFail TransformT instance is defined unconditionally+	* Generalise HasTransform (TransformT Identity) to+	Monad m => HasTransform (TransformT m)+	* Add hoistTransform function+  The 0.6 changes are all thanks to @phadej 2018-10-27 v0.5.8.2 	* Support GHC 8.4.4 by selecting correct source directory 2018-09-23 v0.5.8.1
ghc-exactprint.cabal view
@@ -1,5 +1,5 @@ name:                ghc-exactprint-version:             0.5.8.2+version:             0.6 synopsis:            ExactPrint for GHC description:         Using the API Annotations available from GHC 7.10.2, this                      library provides a means to round trip any code that can@@ -37,6 +37,8 @@                    , GHC == 8.4.3                    , GHC == 8.4.4                    , GHC == 8.6.1+                   , GHC == 8.6.2+                   , GHC == 8.6.3 extra-source-files:  ChangeLog                      src-ghc710/Language/Haskell/GHC/ExactPrint/*.hs                      tests/examples/failing/*.hs@@ -90,7 +92,7 @@   -- other-modules:   -- other-extensions:   GHC-Options:         -Wall-  build-depends:       base >=4.7 && <4.13+  build-depends:       base >=4.8 && <4.13                      , bytestring >= 0.10.6                      , containers >= 0.5                      , directory >= 1.2@@ -100,6 +102,11 @@                      , mtl       >= 2.2.1                      , syb       >= 0.5                      , free      >= 4.12++  if !impl (ghc >= 8.0)+    build-depends:+      fail >= 4.9 && <4.10+   if impl (ghc >= 7.11)       build-depends: ghc-boot   hs-source-dirs:      src@@ -167,6 +174,9 @@                      , silently   >= 1.2                      , filemanip  >= 0.3                      -- for the lib only+  if !impl (ghc >= 8.0)+    build-depends:+      fail >= 4.9 && <4.10   if flag (dev)       build-depends: free   else
src/Language/Haskell/GHC/ExactPrint/Transform.hs view
@@ -23,7 +23,9 @@         -- * The Transform Monad           Transform         , TransformT(..)+        , hoistTransform         , runTransform+        , runTransformT         , runTransformFrom         , runTransformFromT @@ -92,11 +94,8 @@ import Language.Haskell.GHC.ExactPrint.Types import Language.Haskell.GHC.ExactPrint.Utils -#if __GLASGOW_HASKELL__ > 804-import Control.Monad.Fail-#endif import Control.Monad.RWS-+import qualified Control.Monad.Fail as Fail  import qualified Bag           as GHC import qualified FastString    as GHC@@ -124,37 +123,39 @@ type Transform = TransformT Identity  -- |Monad transformer version of 'Transform' monad-newtype TransformT m a = TransformT { runTransformT :: RWST () [String] (Anns,Int) m a }+newtype TransformT m a = TransformT { unTransformT :: RWST () [String] (Anns,Int) m a }                 deriving (Monad,Applicative,Functor                          ,MonadReader ()                          ,MonadWriter [String]                          ,MonadState (Anns,Int)                          ,MonadTrans-#if __GLASGOW_HASKELL__ > 804-                         ,MonadFail-#endif                          ) -#if __GLASGOW_HASKELL__ > 804-instance MonadFail Identity where-  fail x = Control.Monad.Fail.fail x-#endif+instance Fail.MonadFail m => Fail.MonadFail (TransformT m) where+    fail msg = TransformT $ RWST $ \_ _ -> Fail.fail msg  -- | Run a transformation in the 'Transform' monad, returning the updated -- annotations and any logging generated via 'logTr' runTransform :: Anns -> Transform a -> (a,(Anns,Int),[String]) runTransform ans f = runTransformFrom 0 ans f +runTransformT :: Anns -> TransformT m a -> m (a,(Anns,Int),[String])+runTransformT ans f = runTransformFromT 0 ans f+ -- | Run a transformation in the 'Transform' monad, returning the updated -- annotations and any logging generated via 'logTr', allocating any new -- SrcSpans from the provided initial value. runTransformFrom :: Int -> Anns -> Transform a -> (a,(Anns,Int),[String])-runTransformFrom seed ans f = runRWS (runTransformT f) () (ans,seed)+runTransformFrom seed ans f = runRWS (unTransformT f) () (ans,seed)  -- |Run a monad transformer stack for the 'TransformT' monad transformer runTransformFromT :: Int -> Anns -> TransformT m a -> m (a,(Anns,Int),[String])-runTransformFromT seed ans f = runRWST (runTransformT f) () (ans,seed)+runTransformFromT seed ans f = runRWST (unTransformT f) () (ans,seed) +-- | Change inner monad of 'TransformT'.+hoistTransform :: (forall x. m x -> n x) -> TransformT m a -> TransformT n a+hoistTransform nt (TransformT m) = TransformT (mapRWST nt m)+ -- |Log a string to the output of the Monad logTr :: (Monad m) => String -> TransformT m () logTr str = tell [str]@@ -1296,8 +1297,8 @@ class (Monad m) => (HasTransform m) where   liftT :: Transform a -> m a -instance HasTransform (TransformT Identity) where-  liftT = id+instance Monad m => HasTransform (TransformT m) where+  liftT = hoistTransform (return . runIdentity)  -- --------------------------------------------------------------------- 
tests/Test/Transform.hs view
@@ -435,7 +435,7 @@           return ((newDecl : d),Nothing)         replaceDecls lp [d1', d2] -  let (lp',(ans',_),_w) = runTransform (mergeAnns ans declAnns') doAddLocal+  (lp',(ans',_),_w) <- runTransformT (mergeAnns ans declAnns') doAddLocal   -- putStrLn $ "log:\n" ++ intercalate "\n" _w   return (ans',lp') @@ -523,7 +523,7 @@            return ([d2],Nothing)          replaceDecls lp [s1,d1',d3] -  let (lp',(ans',_),_w) = runTransform ans doAddLocal+  (lp',(ans',_),_w) <- runTransformT ans doAddLocal   -- putStrLn $ "log\n" ++ intercalate "\n" _w   return (ans',lp') @@ -550,7 +550,7 @@            return ((newDecl : decls),Nothing)         replaceDecls lp [d1', d2] -  let (lp',(ans',_),_w) = runTransform (mergeAnns ans declAnns') doAddLocal+  (lp',(ans',_),_w) <- runTransformT (mergeAnns ans declAnns') doAddLocal   -- putStrLn $ "log:\n" ++ intercalate "\n" _w   return (ans',lp') -- ---------------------------------------------------------------------@@ -576,7 +576,7 @@          transferEntryDPT s1' (head ds')  -- required in HaRe.          replaceDecls lp (d1':ds') -  let (lp',(ans',_),_w) = runTransform ans doRmDecl+  (lp',(ans',_),_w) <- runTransformT ans doRmDecl   return (ans',lp')  -- ---------------------------------------------------------------------@@ -613,7 +613,7 @@           replaceDecls lp [d1',sd1,d2] -  let (lp',(ans',_),_w) = runTransform ans doRmDecl+  (lp',(ans',_),_w) <- runTransformT ans doRmDecl   -- putStrLn $ "log:\n" ++ intercalate "\n" _w   return (ans',lp') @@ -635,7 +635,7 @@           replaceDecls lp [d1',sd1] -  let (lp',(ans',_),_w) = runTransform ans doRmDecl+  (lp',(ans',_),_w) <- runTransformT ans doRmDecl   return (ans',lp')  -- ---------------------------------------------------------------------@@ -688,7 +688,7 @@           replaceDecls lp [d1'] -  let (lp',(ans',_),_w) = runTransform ans doRmDecl+  (lp',(ans',_),_w) <- runTransformT ans doRmDecl   -- putStrLn $ "log:" ++ intercalate "\n" _w   return (ans',lp')