{-# LANGUAGE DeriveFunctor #-}
{-# LANGUAGE DeriveDataTypeable #-}
module Refact.Types where

import Data.Data

-- | A generic SrcSpan, usually this is converted immediately to a native
-- representation. (For example a GHC SrcSpan or a HSE SrcSpan)
data SrcSpan = SrcSpan
                { SrcSpan -> Int
startLine :: {-# UNPACK #-} !Int
                , SrcSpan -> Int
startCol  :: {-# UNPACK #-} !Int
                , SrcSpan -> Int
endLine   :: {-# UNPACK #-} !Int
                , SrcSpan -> Int
endCol    :: {-# UNPACK #-} !Int }
                deriving (ReadPrec [SrcSpan]
ReadPrec SrcSpan
Int -> ReadS SrcSpan
ReadS [SrcSpan]
(Int -> ReadS SrcSpan)
-> ReadS [SrcSpan]
-> ReadPrec SrcSpan
-> ReadPrec [SrcSpan]
-> Read SrcSpan
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [SrcSpan]
$creadListPrec :: ReadPrec [SrcSpan]
readPrec :: ReadPrec SrcSpan
$creadPrec :: ReadPrec SrcSpan
readList :: ReadS [SrcSpan]
$creadList :: ReadS [SrcSpan]
readsPrec :: Int -> ReadS SrcSpan
$creadsPrec :: Int -> ReadS SrcSpan
Read, Int -> SrcSpan -> ShowS
[SrcSpan] -> ShowS
SrcSpan -> String
(Int -> SrcSpan -> ShowS)
-> (SrcSpan -> String) -> ([SrcSpan] -> ShowS) -> Show SrcSpan
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [SrcSpan] -> ShowS
$cshowList :: [SrcSpan] -> ShowS
show :: SrcSpan -> String
$cshow :: SrcSpan -> String
showsPrec :: Int -> SrcSpan -> ShowS
$cshowsPrec :: Int -> SrcSpan -> ShowS
Show, SrcSpan -> SrcSpan -> Bool
(SrcSpan -> SrcSpan -> Bool)
-> (SrcSpan -> SrcSpan -> Bool) -> Eq SrcSpan
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: SrcSpan -> SrcSpan -> Bool
$c/= :: SrcSpan -> SrcSpan -> Bool
== :: SrcSpan -> SrcSpan -> Bool
$c== :: SrcSpan -> SrcSpan -> Bool
Eq, Eq SrcSpan
Eq SrcSpan =>
(SrcSpan -> SrcSpan -> Ordering)
-> (SrcSpan -> SrcSpan -> Bool)
-> (SrcSpan -> SrcSpan -> Bool)
-> (SrcSpan -> SrcSpan -> Bool)
-> (SrcSpan -> SrcSpan -> Bool)
-> (SrcSpan -> SrcSpan -> SrcSpan)
-> (SrcSpan -> SrcSpan -> SrcSpan)
-> Ord SrcSpan
SrcSpan -> SrcSpan -> Bool
SrcSpan -> SrcSpan -> Ordering
SrcSpan -> SrcSpan -> SrcSpan
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: SrcSpan -> SrcSpan -> SrcSpan
$cmin :: SrcSpan -> SrcSpan -> SrcSpan
max :: SrcSpan -> SrcSpan -> SrcSpan
$cmax :: SrcSpan -> SrcSpan -> SrcSpan
>= :: SrcSpan -> SrcSpan -> Bool
$c>= :: SrcSpan -> SrcSpan -> Bool
> :: SrcSpan -> SrcSpan -> Bool
$c> :: SrcSpan -> SrcSpan -> Bool
<= :: SrcSpan -> SrcSpan -> Bool
$c<= :: SrcSpan -> SrcSpan -> Bool
< :: SrcSpan -> SrcSpan -> Bool
$c< :: SrcSpan -> SrcSpan -> Bool
compare :: SrcSpan -> SrcSpan -> Ordering
$ccompare :: SrcSpan -> SrcSpan -> Ordering
$cp1Ord :: Eq SrcSpan
Ord, Typeable SrcSpan
Constr
DataType
Typeable SrcSpan =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> SrcSpan -> c SrcSpan)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c SrcSpan)
-> (SrcSpan -> Constr)
-> (SrcSpan -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c SrcSpan))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SrcSpan))
-> ((forall b. Data b => b -> b) -> SrcSpan -> SrcSpan)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> SrcSpan -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> SrcSpan -> r)
-> (forall u. (forall d. Data d => d -> u) -> SrcSpan -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> SrcSpan -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> SrcSpan -> m SrcSpan)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> SrcSpan -> m SrcSpan)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> SrcSpan -> m SrcSpan)
-> Data SrcSpan
SrcSpan -> Constr
SrcSpan -> DataType
(forall b. Data b => b -> b) -> SrcSpan -> SrcSpan
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SrcSpan -> c SrcSpan
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SrcSpan
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> SrcSpan -> u
forall u. (forall d. Data d => d -> u) -> SrcSpan -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SrcSpan -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SrcSpan -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> SrcSpan -> m SrcSpan
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SrcSpan -> m SrcSpan
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SrcSpan
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SrcSpan -> c SrcSpan
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c SrcSpan)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SrcSpan)
$cSrcSpan :: Constr
$tSrcSpan :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> SrcSpan -> m SrcSpan
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SrcSpan -> m SrcSpan
gmapMp :: (forall d. Data d => d -> m d) -> SrcSpan -> m SrcSpan
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SrcSpan -> m SrcSpan
gmapM :: (forall d. Data d => d -> m d) -> SrcSpan -> m SrcSpan
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> SrcSpan -> m SrcSpan
gmapQi :: Int -> (forall d. Data d => d -> u) -> SrcSpan -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> SrcSpan -> u
gmapQ :: (forall d. Data d => d -> u) -> SrcSpan -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> SrcSpan -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SrcSpan -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SrcSpan -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SrcSpan -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SrcSpan -> r
gmapT :: (forall b. Data b => b -> b) -> SrcSpan -> SrcSpan
$cgmapT :: (forall b. Data b => b -> b) -> SrcSpan -> SrcSpan
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SrcSpan)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SrcSpan)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c SrcSpan)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c SrcSpan)
dataTypeOf :: SrcSpan -> DataType
$cdataTypeOf :: SrcSpan -> DataType
toConstr :: SrcSpan -> Constr
$ctoConstr :: SrcSpan -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SrcSpan
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SrcSpan
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SrcSpan -> c SrcSpan
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SrcSpan -> c SrcSpan
$cp1Data :: Typeable SrcSpan
Data, Typeable)


-- | Types of expressions which we are able to replace.
data RType = Expr | Decl | Type | Pattern | Stmt | ModuleName | Bind | Match | Import
           deriving (ReadPrec [RType]
ReadPrec RType
Int -> ReadS RType
ReadS [RType]
(Int -> ReadS RType)
-> ReadS [RType]
-> ReadPrec RType
-> ReadPrec [RType]
-> Read RType
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [RType]
$creadListPrec :: ReadPrec [RType]
readPrec :: ReadPrec RType
$creadPrec :: ReadPrec RType
readList :: ReadS [RType]
$creadList :: ReadS [RType]
readsPrec :: Int -> ReadS RType
$creadsPrec :: Int -> ReadS RType
Read, Eq RType
Eq RType =>
(RType -> RType -> Ordering)
-> (RType -> RType -> Bool)
-> (RType -> RType -> Bool)
-> (RType -> RType -> Bool)
-> (RType -> RType -> Bool)
-> (RType -> RType -> RType)
-> (RType -> RType -> RType)
-> Ord RType
RType -> RType -> Bool
RType -> RType -> Ordering
RType -> RType -> RType
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: RType -> RType -> RType
$cmin :: RType -> RType -> RType
max :: RType -> RType -> RType
$cmax :: RType -> RType -> RType
>= :: RType -> RType -> Bool
$c>= :: RType -> RType -> Bool
> :: RType -> RType -> Bool
$c> :: RType -> RType -> Bool
<= :: RType -> RType -> Bool
$c<= :: RType -> RType -> Bool
< :: RType -> RType -> Bool
$c< :: RType -> RType -> Bool
compare :: RType -> RType -> Ordering
$ccompare :: RType -> RType -> Ordering
$cp1Ord :: Eq RType
Ord, Int -> RType -> ShowS
[RType] -> ShowS
RType -> String
(Int -> RType -> ShowS)
-> (RType -> String) -> ([RType] -> ShowS) -> Show RType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [RType] -> ShowS
$cshowList :: [RType] -> ShowS
show :: RType -> String
$cshow :: RType -> String
showsPrec :: Int -> RType -> ShowS
$cshowsPrec :: Int -> RType -> ShowS
Show, RType -> RType -> Bool
(RType -> RType -> Bool) -> (RType -> RType -> Bool) -> Eq RType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: RType -> RType -> Bool
$c/= :: RType -> RType -> Bool
== :: RType -> RType -> Bool
$c== :: RType -> RType -> Bool
Eq, Typeable RType
Constr
DataType
Typeable RType =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> RType -> c RType)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c RType)
-> (RType -> Constr)
-> (RType -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c RType))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c RType))
-> ((forall b. Data b => b -> b) -> RType -> RType)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> RType -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> RType -> r)
-> (forall u. (forall d. Data d => d -> u) -> RType -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> RType -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> RType -> m RType)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> RType -> m RType)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> RType -> m RType)
-> Data RType
RType -> Constr
RType -> DataType
(forall b. Data b => b -> b) -> RType -> RType
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> RType -> c RType
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c RType
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> RType -> u
forall u. (forall d. Data d => d -> u) -> RType -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> RType -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> RType -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> RType -> m RType
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> RType -> m RType
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c RType
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> RType -> c RType
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c RType)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c RType)
$cImport :: Constr
$cMatch :: Constr
$cBind :: Constr
$cModuleName :: Constr
$cStmt :: Constr
$cPattern :: Constr
$cType :: Constr
$cDecl :: Constr
$cExpr :: Constr
$tRType :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> RType -> m RType
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> RType -> m RType
gmapMp :: (forall d. Data d => d -> m d) -> RType -> m RType
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> RType -> m RType
gmapM :: (forall d. Data d => d -> m d) -> RType -> m RType
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> RType -> m RType
gmapQi :: Int -> (forall d. Data d => d -> u) -> RType -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> RType -> u
gmapQ :: (forall d. Data d => d -> u) -> RType -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> RType -> [u]
gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> RType -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> RType -> r
gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> RType -> r
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> RType -> r
gmapT :: (forall b. Data b => b -> b) -> RType -> RType
$cgmapT :: (forall b. Data b => b -> b) -> RType -> RType
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c RType)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c RType)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c RType)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c RType)
dataTypeOf :: RType -> DataType
$cdataTypeOf :: RType -> DataType
toConstr :: RType -> Constr
$ctoConstr :: RType -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c RType
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c RType
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> RType -> c RType
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> RType -> c RType
$cp1Data :: Typeable RType
Data, Typeable)

-- | Supported refactorings
data Refactoring a =
  Replace  {
      Refactoring a -> RType
rtype :: RType -- ^ Type of expression to be replaced
    , Refactoring a -> a
pos :: a  -- ^ Expression to replace
    , Refactoring a -> [(String, a)]
subts :: [(String, a)] -- ^ Substitutions to make
    , Refactoring a -> String
orig  :: String -- ^ Replacement template
    }
  | ModifyComment {
      pos :: a
    , Refactoring a -> String
newComment :: String
    }
  | InsertComment {
      pos :: a
    , newComment :: String
    }
  | Delete {
      rtype :: RType
    , pos :: a
    }

  | -- |  Takes the position of a import decl and removes the as keyword
    RemoveAsKeyword
      {
      pos :: a
      }
--  | Rename {
--      nameSubts :: [(String, String)]
--    }
  deriving (Int -> Refactoring a -> ShowS
[Refactoring a] -> ShowS
Refactoring a -> String
(Int -> Refactoring a -> ShowS)
-> (Refactoring a -> String)
-> ([Refactoring a] -> ShowS)
-> Show (Refactoring a)
forall a. Show a => Int -> Refactoring a -> ShowS
forall a. Show a => [Refactoring a] -> ShowS
forall a. Show a => Refactoring a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Refactoring a] -> ShowS
$cshowList :: forall a. Show a => [Refactoring a] -> ShowS
show :: Refactoring a -> String
$cshow :: forall a. Show a => Refactoring a -> String
showsPrec :: Int -> Refactoring a -> ShowS
$cshowsPrec :: forall a. Show a => Int -> Refactoring a -> ShowS
Show, ReadPrec [Refactoring a]
ReadPrec (Refactoring a)
Int -> ReadS (Refactoring a)
ReadS [Refactoring a]
(Int -> ReadS (Refactoring a))
-> ReadS [Refactoring a]
-> ReadPrec (Refactoring a)
-> ReadPrec [Refactoring a]
-> Read (Refactoring a)
forall a. Read a => ReadPrec [Refactoring a]
forall a. Read a => ReadPrec (Refactoring a)
forall a. Read a => Int -> ReadS (Refactoring a)
forall a. Read a => ReadS [Refactoring a]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [Refactoring a]
$creadListPrec :: forall a. Read a => ReadPrec [Refactoring a]
readPrec :: ReadPrec (Refactoring a)
$creadPrec :: forall a. Read a => ReadPrec (Refactoring a)
readList :: ReadS [Refactoring a]
$creadList :: forall a. Read a => ReadS [Refactoring a]
readsPrec :: Int -> ReadS (Refactoring a)
$creadsPrec :: forall a. Read a => Int -> ReadS (Refactoring a)
Read, a -> Refactoring b -> Refactoring a
(a -> b) -> Refactoring a -> Refactoring b
(forall a b. (a -> b) -> Refactoring a -> Refactoring b)
-> (forall a b. a -> Refactoring b -> Refactoring a)
-> Functor Refactoring
forall a b. a -> Refactoring b -> Refactoring a
forall a b. (a -> b) -> Refactoring a -> Refactoring b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: a -> Refactoring b -> Refactoring a
$c<$ :: forall a b. a -> Refactoring b -> Refactoring a
fmap :: (a -> b) -> Refactoring a -> Refactoring b
$cfmap :: forall a b. (a -> b) -> Refactoring a -> Refactoring b
Functor, Refactoring a -> Refactoring a -> Bool
(Refactoring a -> Refactoring a -> Bool)
-> (Refactoring a -> Refactoring a -> Bool) -> Eq (Refactoring a)
forall a. Eq a => Refactoring a -> Refactoring a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Refactoring a -> Refactoring a -> Bool
$c/= :: forall a. Eq a => Refactoring a -> Refactoring a -> Bool
== :: Refactoring a -> Refactoring a -> Bool
$c== :: forall a. Eq a => Refactoring a -> Refactoring a -> Bool
Eq, Eq (Refactoring a)
Eq (Refactoring a) =>
(Refactoring a -> Refactoring a -> Ordering)
-> (Refactoring a -> Refactoring a -> Bool)
-> (Refactoring a -> Refactoring a -> Bool)
-> (Refactoring a -> Refactoring a -> Bool)
-> (Refactoring a -> Refactoring a -> Bool)
-> (Refactoring a -> Refactoring a -> Refactoring a)
-> (Refactoring a -> Refactoring a -> Refactoring a)
-> Ord (Refactoring a)
Refactoring a -> Refactoring a -> Bool
Refactoring a -> Refactoring a -> Ordering
Refactoring a -> Refactoring a -> Refactoring a
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall a. Ord a => Eq (Refactoring a)
forall a. Ord a => Refactoring a -> Refactoring a -> Bool
forall a. Ord a => Refactoring a -> Refactoring a -> Ordering
forall a. Ord a => Refactoring a -> Refactoring a -> Refactoring a
min :: Refactoring a -> Refactoring a -> Refactoring a
$cmin :: forall a. Ord a => Refactoring a -> Refactoring a -> Refactoring a
max :: Refactoring a -> Refactoring a -> Refactoring a
$cmax :: forall a. Ord a => Refactoring a -> Refactoring a -> Refactoring a
>= :: Refactoring a -> Refactoring a -> Bool
$c>= :: forall a. Ord a => Refactoring a -> Refactoring a -> Bool
> :: Refactoring a -> Refactoring a -> Bool
$c> :: forall a. Ord a => Refactoring a -> Refactoring a -> Bool
<= :: Refactoring a -> Refactoring a -> Bool
$c<= :: forall a. Ord a => Refactoring a -> Refactoring a -> Bool
< :: Refactoring a -> Refactoring a -> Bool
$c< :: forall a. Ord a => Refactoring a -> Refactoring a -> Bool
compare :: Refactoring a -> Refactoring a -> Ordering
$ccompare :: forall a. Ord a => Refactoring a -> Refactoring a -> Ordering
$cp1Ord :: forall a. Ord a => Eq (Refactoring a)
Ord, Typeable (Refactoring a)
Constr
DataType
Typeable (Refactoring a) =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Refactoring a -> c (Refactoring a))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Refactoring a))
-> (Refactoring a -> Constr)
-> (Refactoring a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (Refactoring a)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (Refactoring a)))
-> ((forall b. Data b => b -> b) -> Refactoring a -> Refactoring a)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Refactoring a -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Refactoring a -> r)
-> (forall u. (forall d. Data d => d -> u) -> Refactoring a -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> Refactoring a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> Refactoring a -> m (Refactoring a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> Refactoring a -> m (Refactoring a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> Refactoring a -> m (Refactoring a))
-> Data (Refactoring a)
Refactoring a -> Constr
Refactoring a -> DataType
(forall d. Data d => c (t d)) -> Maybe (c (Refactoring a))
(forall b. Data b => b -> b) -> Refactoring a -> Refactoring a
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Refactoring a -> c (Refactoring a)
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Refactoring a)
forall a. Data a => Typeable (Refactoring a)
forall a. Data a => Refactoring a -> Constr
forall a. Data a => Refactoring a -> DataType
forall a.
Data a =>
(forall b. Data b => b -> b) -> Refactoring a -> Refactoring a
forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> Refactoring a -> u
forall a u.
Data a =>
(forall d. Data d => d -> u) -> Refactoring a -> [u]
forall a r r'.
Data a =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Refactoring a -> r
forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Refactoring a -> r
forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d)
-> Refactoring a -> m (Refactoring a)
forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> Refactoring a -> m (Refactoring a)
forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Refactoring a)
forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Refactoring a -> c (Refactoring a)
forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Refactoring a))
forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Refactoring a))
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> Refactoring a -> u
forall u. (forall d. Data d => d -> u) -> Refactoring a -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Refactoring a -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Refactoring a -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> Refactoring a -> m (Refactoring a)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> Refactoring a -> m (Refactoring a)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Refactoring a)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Refactoring a -> c (Refactoring a)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Refactoring a))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Refactoring a))
$cRemoveAsKeyword :: Constr
$cDelete :: Constr
$cInsertComment :: Constr
$cModifyComment :: Constr
$cReplace :: Constr
$tRefactoring :: DataType
gmapMo :: (forall d. Data d => d -> m d)
-> Refactoring a -> m (Refactoring a)
$cgmapMo :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> Refactoring a -> m (Refactoring a)
gmapMp :: (forall d. Data d => d -> m d)
-> Refactoring a -> m (Refactoring a)
$cgmapMp :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> Refactoring a -> m (Refactoring a)
gmapM :: (forall d. Data d => d -> m d)
-> Refactoring a -> m (Refactoring a)
$cgmapM :: forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d)
-> Refactoring a -> m (Refactoring a)
gmapQi :: Int -> (forall d. Data d => d -> u) -> Refactoring a -> u
$cgmapQi :: forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> Refactoring a -> u
gmapQ :: (forall d. Data d => d -> u) -> Refactoring a -> [u]
$cgmapQ :: forall a u.
Data a =>
(forall d. Data d => d -> u) -> Refactoring a -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Refactoring a -> r
$cgmapQr :: forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Refactoring a -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Refactoring a -> r
$cgmapQl :: forall a r r'.
Data a =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Refactoring a -> r
gmapT :: (forall b. Data b => b -> b) -> Refactoring a -> Refactoring a
$cgmapT :: forall a.
Data a =>
(forall b. Data b => b -> b) -> Refactoring a -> Refactoring a
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Refactoring a))
$cdataCast2 :: forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Refactoring a))
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c (Refactoring a))
$cdataCast1 :: forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Refactoring a))
dataTypeOf :: Refactoring a -> DataType
$cdataTypeOf :: forall a. Data a => Refactoring a -> DataType
toConstr :: Refactoring a -> Constr
$ctoConstr :: forall a. Data a => Refactoring a -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Refactoring a)
$cgunfold :: forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Refactoring a)
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Refactoring a -> c (Refactoring a)
$cgfoldl :: forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Refactoring a -> c (Refactoring a)
$cp1Data :: forall a. Data a => Typeable (Refactoring a)
Data, Typeable )