Prettyprinter.Generics

Documentation

ppGeneric :: (Generic a, GPretty (Rep a)) => a -> Doc ann

Prettyprint using Data instance.

>>> :{
test = Test
  { testSet         = Just $ Set.fromList [1..3]
  , testMap         =
      Map.fromList [("foo", Set.fromList [1.5]), ("foo", Set.fromList [2.5, 3, 4])]
  , testIntSet      = IntSet.fromList [1, 2, 4, 5, 7]
  , testIntMap      = IntMap.fromList $ zip [1..] ["3", "2foo", "11"]
  , testInt         = 42
  , testComplexMap  = Map.fromList
      [ ( Nothing
        , IntMap.fromList $ zip [0..] $ map Set.fromList
            [ ["foo", "bar"]
            , ["baz"]
            , ["quux", "frob"]
            ]
        )
      , ( Just (Set.fromList [1])
        , IntMap.fromList $ zip [0..] $ map Set.fromList
            [ ["quux"]
            , ["fizz", "buzz"]
            ]
        )
      , ( Just (Set.fromList [3, 4])
        , IntMap.fromList $ zip [0..] $ map Set.fromList
            [ ["quux", "5"]
            , []
            , ["fizz", "buzz"]
            ]
        )
      ]
  , testComplexMap2 =
      Map.singleton
        (Just (Set.fromList [1..5]))
        (Map.fromList
           [ (NonEmpty.fromList [1, 2],  Vector.fromList ["foo", "bar", "baz"])
           , (NonEmpty.fromList [3],     Vector.fromList ["quux"])
           , (NonEmpty.fromList [4..10], Vector.fromList ["must", "put", "something", "in", "here"])
           ])
  }
:}

>>> ppGeneric test
Test
  { testSet         -> Just ({1, 2, 3})
  , testMap         -> {foo -> {2.5, 3.0, 4.0}}
  , testIntSet      -> {1, 2, 4, 5, 7}
  , testIntMap      -> {1 -> 3, 2 -> 2foo, 3 -> 11}
  , testInt         -> 42
  , testComplexMap  ->
      { Nothing -> {0 -> {bar, foo}, 1 -> {baz}, 2 -> {frob, quux}}
      , Just ({1}) -> {0 -> {quux}, 1 -> {buzz, fizz}}
      , Just ({3, 4}) -> {0 -> {5, quux}, 1 -> {}, 2 -> {buzz, fizz}}
      }
  , testComplexMap2 ->
      { Just ({1, 2, 3, 4, 5}) ->
          { [1, 2] -> [foo, bar, baz]
          , [3] -> [quux]
          , [4, 5, 6, 7, 8, 9, 10] -> [must, put, something, in, here]
          } }
  }

class PPGenericOverride a where

A class to override Pretty when calling ppGeneric without introducing orphans for standard types.

Methods

ppGenericOverride :: a -> MetaDoc ann

Instances

PPGenericOverride Int16

Defined in Prettyprinter.Generics

Methods

ppGenericOverride :: Int16 -> MetaDoc ann

PPGenericOverride Int32

Defined in Prettyprinter.Generics

Methods

ppGenericOverride :: Int32 -> MetaDoc ann

PPGenericOverride Int64

Defined in Prettyprinter.Generics

Methods

ppGenericOverride :: Int64 -> MetaDoc ann

PPGenericOverride Int8

Defined in Prettyprinter.Generics

Methods

ppGenericOverride :: Int8 -> MetaDoc ann

PPGenericOverride CallStack

Defined in Prettyprinter.Generics

Methods

ppGenericOverride :: CallStack -> MetaDoc ann

PPGenericOverride Word16

Defined in Prettyprinter.Generics

Methods

ppGenericOverride :: Word16 -> MetaDoc ann

PPGenericOverride Word32

Defined in Prettyprinter.Generics

Methods

ppGenericOverride :: Word32 -> MetaDoc ann

PPGenericOverride Word64

Defined in Prettyprinter.Generics

Methods

ppGenericOverride :: Word64 -> MetaDoc ann

PPGenericOverride Word8

Defined in Prettyprinter.Generics

Methods

ppGenericOverride :: Word8 -> MetaDoc ann

PPGenericOverride ByteString

Defined in Prettyprinter.Generics

Methods

ppGenericOverride :: ByteString -> MetaDoc ann

PPGenericOverride ByteString

Defined in Prettyprinter.Generics

Methods

ppGenericOverride :: ByteString -> MetaDoc ann

PPGenericOverride ShortByteString

Defined in Prettyprinter.Generics

Methods

ppGenericOverride :: ShortByteString -> MetaDoc ann

PPGenericOverride IntSet

Defined in Prettyprinter.Generics

Methods

ppGenericOverride :: IntSet -> MetaDoc ann

PPGenericOverride AnnTarget

Defined in Prettyprinter.Generics

Methods

ppGenericOverride :: AnnTarget -> MetaDoc ann

PPGenericOverride Bang

Defined in Prettyprinter.Generics

Methods

ppGenericOverride :: Bang -> MetaDoc ann

PPGenericOverride Body

Defined in Prettyprinter.Generics

Methods

ppGenericOverride :: Body -> MetaDoc ann

PPGenericOverride Bytes

Defined in Prettyprinter.Generics

Methods

ppGenericOverride :: Bytes -> MetaDoc ann

PPGenericOverride Callconv

Defined in Prettyprinter.Generics

Methods

ppGenericOverride :: Callconv -> MetaDoc ann

PPGenericOverride Clause

Defined in Prettyprinter.Generics

Methods

ppGenericOverride :: Clause -> MetaDoc ann

PPGenericOverride Con

Defined in Prettyprinter.Generics

Methods

ppGenericOverride :: Con -> MetaDoc ann

PPGenericOverride Dec

Defined in Prettyprinter.Generics

Methods

ppGenericOverride :: Dec -> MetaDoc ann

PPGenericOverride DerivClause

Defined in Prettyprinter.Generics

Methods

ppGenericOverride :: DerivClause -> MetaDoc ann

PPGenericOverride DerivStrategy

Defined in Prettyprinter.Generics

Methods

ppGenericOverride :: DerivStrategy -> MetaDoc ann

PPGenericOverride Exp

Defined in Prettyprinter.Generics

Methods

ppGenericOverride :: Exp -> MetaDoc ann

PPGenericOverride FamilyResultSig

Defined in Prettyprinter.Generics

Methods

ppGenericOverride :: FamilyResultSig -> MetaDoc ann

PPGenericOverride Fixity

Defined in Prettyprinter.Generics

Methods

ppGenericOverride :: Fixity -> MetaDoc ann

PPGenericOverride FixityDirection

Defined in Prettyprinter.Generics

Methods

ppGenericOverride :: FixityDirection -> MetaDoc ann

PPGenericOverride Foreign

Defined in Prettyprinter.Generics

Methods

ppGenericOverride :: Foreign -> MetaDoc ann

PPGenericOverride FunDep

Defined in Prettyprinter.Generics

Methods

ppGenericOverride :: FunDep -> MetaDoc ann

PPGenericOverride Guard

Defined in Prettyprinter.Generics

Methods

ppGenericOverride :: Guard -> MetaDoc ann

PPGenericOverride Info

Defined in Prettyprinter.Generics

Methods

ppGenericOverride :: Info -> MetaDoc ann

PPGenericOverride InjectivityAnn

Defined in Prettyprinter.Generics

Methods

ppGenericOverride :: InjectivityAnn -> MetaDoc ann

PPGenericOverride Inline

Defined in Prettyprinter.Generics

Methods

ppGenericOverride :: Inline -> MetaDoc ann

PPGenericOverride Lit

Defined in Prettyprinter.Generics

Methods

ppGenericOverride :: Lit -> MetaDoc ann

PPGenericOverride Match

Defined in Prettyprinter.Generics

Methods

ppGenericOverride :: Match -> MetaDoc ann

PPGenericOverride ModName

Defined in Prettyprinter.Generics

Methods

ppGenericOverride :: ModName -> MetaDoc ann

PPGenericOverride Name

Defined in Prettyprinter.Generics

Methods

ppGenericOverride :: Name -> MetaDoc ann

PPGenericOverride NameFlavour

Defined in Prettyprinter.Generics

Methods

ppGenericOverride :: NameFlavour -> MetaDoc ann

PPGenericOverride NameSpace

Defined in Prettyprinter.Generics

Methods

ppGenericOverride :: NameSpace -> MetaDoc ann

PPGenericOverride OccName

Defined in Prettyprinter.Generics

Methods

ppGenericOverride :: OccName -> MetaDoc ann

PPGenericOverride Overlap

Defined in Prettyprinter.Generics

Methods

ppGenericOverride :: Overlap -> MetaDoc ann

PPGenericOverride Pat

Defined in Prettyprinter.Generics

Methods

ppGenericOverride :: Pat -> MetaDoc ann

PPGenericOverride PatSynArgs

Defined in Prettyprinter.Generics

Methods

ppGenericOverride :: PatSynArgs -> MetaDoc ann

PPGenericOverride PatSynDir

Defined in Prettyprinter.Generics

Methods

ppGenericOverride :: PatSynDir -> MetaDoc ann

PPGenericOverride Phases

Defined in Prettyprinter.Generics

Methods

ppGenericOverride :: Phases -> MetaDoc ann

PPGenericOverride PkgName

Defined in Prettyprinter.Generics

Methods

ppGenericOverride :: PkgName -> MetaDoc ann

PPGenericOverride Pragma

Defined in Prettyprinter.Generics

Methods

ppGenericOverride :: Pragma -> MetaDoc ann

PPGenericOverride Range

Defined in Prettyprinter.Generics

Methods

ppGenericOverride :: Range -> MetaDoc ann

PPGenericOverride Role

Defined in Prettyprinter.Generics

Methods

ppGenericOverride :: Role -> MetaDoc ann

PPGenericOverride RuleBndr

Defined in Prettyprinter.Generics

Methods

ppGenericOverride :: RuleBndr -> MetaDoc ann

PPGenericOverride RuleMatch

Defined in Prettyprinter.Generics

Methods

ppGenericOverride :: RuleMatch -> MetaDoc ann

PPGenericOverride Safety

Defined in Prettyprinter.Generics

Methods

ppGenericOverride :: Safety -> MetaDoc ann

PPGenericOverride SourceStrictness

Defined in Prettyprinter.Generics

Methods

ppGenericOverride :: SourceStrictness -> MetaDoc ann

PPGenericOverride SourceUnpackedness

Defined in Prettyprinter.Generics

Methods

ppGenericOverride :: SourceUnpackedness -> MetaDoc ann

PPGenericOverride Specificity

Defined in Prettyprinter.Generics

Methods

ppGenericOverride :: Specificity -> MetaDoc ann

PPGenericOverride Stmt

Defined in Prettyprinter.Generics

Methods

ppGenericOverride :: Stmt -> MetaDoc ann

PPGenericOverride TyLit

Defined in Prettyprinter.Generics

Methods

ppGenericOverride :: TyLit -> MetaDoc ann

PPGenericOverride TySynEqn

Defined in Prettyprinter.Generics

Methods

ppGenericOverride :: TySynEqn -> MetaDoc ann

PPGenericOverride Type

Defined in Prettyprinter.Generics

Methods

ppGenericOverride :: Type -> MetaDoc ann

PPGenericOverride TypeFamilyHead

Defined in Prettyprinter.Generics

Methods

ppGenericOverride :: TypeFamilyHead -> MetaDoc ann

PPGenericOverride Text

Defined in Prettyprinter.Generics

Methods

ppGenericOverride :: Text -> MetaDoc ann

PPGenericOverride Text

Defined in Prettyprinter.Generics

Methods

ppGenericOverride :: Text -> MetaDoc ann

PPGenericOverride String

Defined in Prettyprinter.Generics

Methods

ppGenericOverride :: String -> MetaDoc ann

PPGenericOverride Integer

Defined in Prettyprinter.Generics

Methods

ppGenericOverride :: Integer -> MetaDoc ann

PPGenericOverride Natural

Defined in Prettyprinter.Generics

Methods

ppGenericOverride :: Natural -> MetaDoc ann

PPGenericOverride ()

Defined in Prettyprinter.Generics

Methods

ppGenericOverride :: () -> MetaDoc ann

PPGenericOverride Bool

Defined in Prettyprinter.Generics

Methods

ppGenericOverride :: Bool -> MetaDoc ann

PPGenericOverride Char

Defined in Prettyprinter.Generics

Methods

ppGenericOverride :: Char -> MetaDoc ann

PPGenericOverride Double

Defined in Prettyprinter.Generics

Methods

ppGenericOverride :: Double -> MetaDoc ann

PPGenericOverride Float

Defined in Prettyprinter.Generics

Methods

ppGenericOverride :: Float -> MetaDoc ann

PPGenericOverride Int

Defined in Prettyprinter.Generics

Methods

ppGenericOverride :: Int -> MetaDoc ann

PPGenericOverride Word

Defined in Prettyprinter.Generics

Methods

ppGenericOverride :: Word -> MetaDoc ann

Pretty a => PPGenericOverride a

Fall back to standard Pretty instance when no override is available.

Defined in Prettyprinter.Generics

Methods

ppGenericOverride :: a -> MetaDoc ann

PPGenericOverride (ForeignPtr a)

Defined in Prettyprinter.Generics

Methods

ppGenericOverride :: ForeignPtr a -> MetaDoc ann

PPGenericOverride a => PPGenericOverride (Ratio a)

Defined in Prettyprinter.Generics

Methods

ppGenericOverride :: Ratio a -> MetaDoc ann

PPGenericOverride v => PPGenericOverride (IntMap v)

Defined in Prettyprinter.Generics

Methods

ppGenericOverride :: IntMap v -> MetaDoc ann

PPGenericOverride v => PPGenericOverride (Set v)

Defined in Prettyprinter.Generics

Methods

ppGenericOverride :: Set v -> MetaDoc ann

PPGenericOverride (Doc Void)

Defined in Prettyprinter.Generics

Methods

ppGenericOverride :: Doc Void -> MetaDoc ann

PPGenericOverride a => PPGenericOverride (TyVarBndr a)

Defined in Prettyprinter.Generics

Methods

ppGenericOverride :: TyVarBndr a -> MetaDoc ann

PPGenericOverride v => PPGenericOverride (HashSet v)

Defined in Prettyprinter.Generics

Methods

ppGenericOverride :: HashSet v -> MetaDoc ann

PPGenericOverride v => PPGenericOverride (Vector v)

Defined in Prettyprinter.Generics

Methods

ppGenericOverride :: Vector v -> MetaDoc ann

PPGenericOverride k => PPGenericOverride (NonEmpty k)

Defined in Prettyprinter.Generics

Methods

ppGenericOverride :: NonEmpty k -> MetaDoc ann

PPGenericOverride v => PPGenericOverride (Maybe v)

Defined in Prettyprinter.Generics

Methods

ppGenericOverride :: Maybe v -> MetaDoc ann

(PPGenericOverride k, PPGenericOverride v) => PPGenericOverride [(k, v)]

Defined in Prettyprinter.Generics

Methods

ppGenericOverride :: [(k, v)] -> MetaDoc ann

PPGenericOverride v => PPGenericOverride [v]

Defined in Prettyprinter.Generics

Methods

ppGenericOverride :: [v] -> MetaDoc ann

(PPGenericOverride k, PPGenericOverride v) => PPGenericOverride (Bimap k v)

Defined in Prettyprinter.Generics

Methods

ppGenericOverride :: Bimap k v -> MetaDoc ann

(PPGenericOverride k, PPGenericOverride v) => PPGenericOverride (Map k v)

Defined in Prettyprinter.Generics

Methods

ppGenericOverride :: Map k v -> MetaDoc ann

(PPGenericOverride k, PPGenericOverride v) => PPGenericOverride (HashMap k v)

Defined in Prettyprinter.Generics

Methods

ppGenericOverride :: HashMap k v -> MetaDoc ann

(PPGenericOverride a, PPGenericOverride b) => PPGenericOverride (a, b)

Defined in Prettyprinter.Generics

Methods

ppGenericOverride :: (a, b) -> MetaDoc ann

(PPGenericOverride a, PPGenericOverride b, PPGenericOverride c) => PPGenericOverride (a, b, c)

Defined in Prettyprinter.Generics

Methods

ppGenericOverride :: (a, b, c) -> MetaDoc ann

PPGenericOverride (f (g a)) => PPGenericOverride (Compose f g a)

Defined in Prettyprinter.Generics

Methods

ppGenericOverride :: Compose f g a -> MetaDoc ann

class Pretty a where

Overloaded conversion to Doc.

Laws:

1. output should be pretty. :-)

Minimal complete definition

pretty

Methods

pretty :: a -> Doc ann

>>> pretty 1 <+> pretty "hello" <+> pretty 1.234
1 hello 1.234

prettyList :: [a] -> Doc ann

prettyList is only used to define the instance Pretty a => Pretty [a]. In normal circumstances only the pretty function is used.

>>> prettyList [1, 23, 456]
[1, 23, 456]

Instances

Pretty Void

Finding a good example for printing something that does not exist is hard, so here is an example of printing a list full of nothing.

>>> pretty ([] :: [Void])
[]

Defined in Prettyprinter.Internal

Methods

pretty :: Void -> Doc ann

prettyList :: [Void] -> Doc ann

Pretty Int16

Defined in Prettyprinter.Internal

Methods

pretty :: Int16 -> Doc ann

prettyList :: [Int16] -> Doc ann

Pretty Int32

Defined in Prettyprinter.Internal

Methods

pretty :: Int32 -> Doc ann

prettyList :: [Int32] -> Doc ann

Pretty Int64

Defined in Prettyprinter.Internal

Methods

pretty :: Int64 -> Doc ann

prettyList :: [Int64] -> Doc ann

Pretty Int8

Defined in Prettyprinter.Internal

Methods

pretty :: Int8 -> Doc ann

prettyList :: [Int8] -> Doc ann

Pretty Word16

Defined in Prettyprinter.Internal

Methods

pretty :: Word16 -> Doc ann

prettyList :: [Word16] -> Doc ann

Pretty Word32

Defined in Prettyprinter.Internal

Methods

pretty :: Word32 -> Doc ann

prettyList :: [Word32] -> Doc ann

Pretty Word64

Defined in Prettyprinter.Internal

Methods

pretty :: Word64 -> Doc ann

prettyList :: [Word64] -> Doc ann

Pretty Word8

Defined in Prettyprinter.Internal

Methods

pretty :: Word8 -> Doc ann

prettyList :: [Word8] -> Doc ann

Pretty Text

Automatically converts all newlines to line.

>>> pretty ("hello\nworld" :: Text)
hello
world

Note that line can be undone by group:

>>> group (pretty ("hello\nworld" :: Text))
hello world

Manually use hardline if you definitely want newlines.

Defined in Prettyprinter.Internal

Methods

pretty :: Text -> Doc ann

prettyList :: [Text] -> Doc ann

Pretty Text

(lazy Doc instance, identical to the strict version)

Defined in Prettyprinter.Internal

Methods

pretty :: Text -> Doc ann

prettyList :: [Text] -> Doc ann

Pretty Integer

>>> pretty (2^123 :: Integer)
10633823966279326983230456482242756608

Defined in Prettyprinter.Internal

Methods

pretty :: Integer -> Doc ann

prettyList :: [Integer] -> Doc ann

Pretty Natural

Defined in Prettyprinter.Internal

Methods

pretty :: Natural -> Doc ann

prettyList :: [Natural] -> Doc ann

Pretty ()

>>> pretty ()
()

The argument is not used:

>>> pretty (error "Strict?" :: ())
()

Defined in Prettyprinter.Internal

Methods

pretty :: () -> Doc ann

prettyList :: [()] -> Doc ann

Pretty Bool

>>> pretty True
True

Defined in Prettyprinter.Internal

Methods

pretty :: Bool -> Doc ann

prettyList :: [Bool] -> Doc ann

Pretty Char

Instead of (pretty 'n'), consider using line as a more readable alternative.

>>> pretty 'f' <> pretty 'o' <> pretty 'o'
foo
>>> pretty ("string" :: String)
string

Defined in Prettyprinter.Internal

Methods

pretty :: Char -> Doc ann

prettyList :: [Char] -> Doc ann

Pretty Double

>>> pretty (exp 1 :: Double)
2.71828182845904...

Defined in Prettyprinter.Internal

Methods

pretty :: Double -> Doc ann

prettyList :: [Double] -> Doc ann

Pretty Float

>>> pretty (pi :: Float)
3.1415927

Defined in Prettyprinter.Internal

Methods

pretty :: Float -> Doc ann

prettyList :: [Float] -> Doc ann

Pretty Int

>>> pretty (123 :: Int)
123

Defined in Prettyprinter.Internal

Methods

pretty :: Int -> Doc ann

prettyList :: [Int] -> Doc ann

Pretty Word

Defined in Prettyprinter.Internal

Methods

pretty :: Word -> Doc ann

prettyList :: [Word] -> Doc ann

Pretty a => Pretty (Identity a)

>>> pretty (Identity 1)
1

Defined in Prettyprinter.Internal

Methods

pretty :: Identity a -> Doc ann

prettyList :: [Identity a] -> Doc ann

Pretty a => Pretty (NonEmpty a)

Defined in Prettyprinter.Internal

Methods

pretty :: NonEmpty a -> Doc ann

prettyList :: [NonEmpty a] -> Doc ann

Pretty a => Pretty (Maybe a)

Ignore Nothings, print Just contents.

>>> pretty (Just True)
True
>>> braces (pretty (Nothing :: Maybe Bool))
{}

>>> pretty [Just 1, Nothing, Just 3, Nothing]
[1, 3]

Defined in Prettyprinter.Internal

Methods

pretty :: Maybe a -> Doc ann

prettyList :: [Maybe a] -> Doc ann

Pretty a => Pretty [a]

>>> pretty [1,2,3]
[1, 2, 3]

Defined in Prettyprinter.Internal

Methods

pretty :: [a] -> Doc ann

prettyList :: [[a]] -> Doc ann

(Pretty k, Pretty v) => Pretty (MapEntry k v)

Defined in Prettyprinter.Combinators

Methods

pretty :: MapEntry k v -> Doc ann

prettyList :: [MapEntry k v] -> Doc ann

(Pretty a1, Pretty a2) => Pretty (a1, a2)

>>> pretty (123, "hello")
(123, hello)

Defined in Prettyprinter.Internal

Methods

pretty :: (a1, a2) -> Doc ann

prettyList :: [(a1, a2)] -> Doc ann

Pretty a => Pretty (Const a b)

Defined in Prettyprinter.Internal

Methods

pretty :: Const a b -> Doc ann

prettyList :: [Const a b] -> Doc ann

(Pretty a1, Pretty a2, Pretty a3) => Pretty (a1, a2, a3)

>>> pretty (123, "hello", False)
(123, hello, False)

Defined in Prettyprinter.Internal

Methods

pretty :: (a1, a2, a3) -> Doc ann

prettyList :: [(a1, a2, a3)] -> Doc ann

class Generic a

Representable types of kind *. This class is derivable in GHC with the DeriveGeneric flag on.

A Generic instance must satisfy the following laws:

from . to ≡ id
to . from ≡ id

Minimal complete definition

from, to

Instances

Generic All

Defined in Data.Semigroup.Internal

Associated Types

type Rep All :: Type -> Type

Methods

from :: All -> Rep All x

to :: Rep All x -> All

Generic Any

Defined in Data.Semigroup.Internal

Associated Types

type Rep Any :: Type -> Type

Methods

from :: Any -> Rep Any x

to :: Rep Any x -> Any

Generic Version

Defined in Data.Version

Associated Types

type Rep Version :: Type -> Type

Methods

from :: Version -> Rep Version x

to :: Rep Version x -> Version

Generic Void

Defined in Data.Void

Associated Types

type Rep Void :: Type -> Type

Methods

from :: Void -> Rep Void x

to :: Rep Void x -> Void

Generic Fingerprint

Defined in GHC.Generics

Associated Types

type Rep Fingerprint :: Type -> Type

Methods

from :: Fingerprint -> Rep Fingerprint x

to :: Rep Fingerprint x -> Fingerprint

Generic Associativity

Defined in GHC.Generics

Associated Types

type Rep Associativity :: Type -> Type

Methods

from :: Associativity -> Rep Associativity x

to :: Rep Associativity x -> Associativity

Generic DecidedStrictness

Defined in GHC.Generics

Associated Types

type Rep DecidedStrictness :: Type -> Type

Methods

from :: DecidedStrictness -> Rep DecidedStrictness x

to :: Rep DecidedStrictness x -> DecidedStrictness

Generic Fixity

Defined in GHC.Generics

Associated Types

type Rep Fixity :: Type -> Type

Methods

from :: Fixity -> Rep Fixity x

to :: Rep Fixity x -> Fixity

Generic SourceStrictness

Defined in GHC.Generics

Associated Types

type Rep SourceStrictness :: Type -> Type

Methods

from :: SourceStrictness -> Rep SourceStrictness x

to :: Rep SourceStrictness x -> SourceStrictness

Generic SourceUnpackedness

Defined in GHC.Generics

Associated Types

type Rep SourceUnpackedness :: Type -> Type

Methods

from :: SourceUnpackedness -> Rep SourceUnpackedness x

to :: Rep SourceUnpackedness x -> SourceUnpackedness

Generic ExitCode

Defined in GHC.IO.Exception

Associated Types

type Rep ExitCode :: Type -> Type

Methods

from :: ExitCode -> Rep ExitCode x

to :: Rep ExitCode x -> ExitCode

Generic SrcLoc

Defined in GHC.Generics

Associated Types

type Rep SrcLoc :: Type -> Type

Methods

from :: SrcLoc -> Rep SrcLoc x

to :: Rep SrcLoc x -> SrcLoc

Generic GeneralCategory

Defined in GHC.Generics

Associated Types

type Rep GeneralCategory :: Type -> Type

Methods

from :: GeneralCategory -> Rep GeneralCategory x

to :: Rep GeneralCategory x -> GeneralCategory

Generic ForeignSrcLang

Defined in GHC.ForeignSrcLang.Type

Associated Types

type Rep ForeignSrcLang :: Type -> Type

Methods

from :: ForeignSrcLang -> Rep ForeignSrcLang x

to :: Rep ForeignSrcLang x -> ForeignSrcLang

Generic Extension

Defined in GHC.LanguageExtensions.Type

Associated Types

type Rep Extension :: Type -> Type

Methods

from :: Extension -> Rep Extension x

to :: Rep Extension x -> Extension

Generic Ordering

Defined in GHC.Generics

Associated Types

type Rep Ordering :: Type -> Type

Methods

from :: Ordering -> Rep Ordering x

to :: Rep Ordering x -> Ordering

Generic Mode

Defined in Text.PrettyPrint.Annotated.HughesPJ

Associated Types

type Rep Mode :: Type -> Type

Methods

from :: Mode -> Rep Mode x

to :: Rep Mode x -> Mode

Generic Style

Defined in Text.PrettyPrint.Annotated.HughesPJ

Associated Types

type Rep Style :: Type -> Type

Methods

from :: Style -> Rep Style x

to :: Rep Style x -> Style

Generic TextDetails

Defined in Text.PrettyPrint.Annotated.HughesPJ

Associated Types

type Rep TextDetails :: Type -> Type

Methods

from :: TextDetails -> Rep TextDetails x

to :: Rep TextDetails x -> TextDetails

Generic Doc

Defined in Text.PrettyPrint.HughesPJ

Associated Types

type Rep Doc :: Type -> Type

Methods

from :: Doc -> Rep Doc x

to :: Rep Doc x -> Doc

Generic AnnLookup

Defined in Language.Haskell.TH.Syntax

Associated Types

type Rep AnnLookup :: Type -> Type

Methods

from :: AnnLookup -> Rep AnnLookup x

to :: Rep AnnLookup x -> AnnLookup

Generic AnnTarget

Defined in Language.Haskell.TH.Syntax

Associated Types

type Rep AnnTarget :: Type -> Type

Methods

from :: AnnTarget -> Rep AnnTarget x

to :: Rep AnnTarget x -> AnnTarget

Generic Bang

Defined in Language.Haskell.TH.Syntax

Associated Types

type Rep Bang :: Type -> Type

Methods

from :: Bang -> Rep Bang x

to :: Rep Bang x -> Bang

Generic Body

Defined in Language.Haskell.TH.Syntax

Associated Types

type Rep Body :: Type -> Type

Methods

from :: Body -> Rep Body x

to :: Rep Body x -> Body

Generic Bytes

Defined in Language.Haskell.TH.Syntax

Associated Types

type Rep Bytes :: Type -> Type

Methods

from :: Bytes -> Rep Bytes x

to :: Rep Bytes x -> Bytes

Generic Callconv

Defined in Language.Haskell.TH.Syntax

Associated Types

type Rep Callconv :: Type -> Type

Methods

from :: Callconv -> Rep Callconv x

to :: Rep Callconv x -> Callconv

Generic Clause

Defined in Language.Haskell.TH.Syntax

Associated Types

type Rep Clause :: Type -> Type

Methods

from :: Clause -> Rep Clause x

to :: Rep Clause x -> Clause

Generic Con

Defined in Language.Haskell.TH.Syntax

Associated Types

type Rep Con :: Type -> Type

Methods

from :: Con -> Rep Con x

to :: Rep Con x -> Con

Generic Dec

Defined in Language.Haskell.TH.Syntax

Associated Types

type Rep Dec :: Type -> Type

Methods

from :: Dec -> Rep Dec x

to :: Rep Dec x -> Dec

Generic DecidedStrictness

Defined in Language.Haskell.TH.Syntax

Associated Types

type Rep DecidedStrictness :: Type -> Type

Methods

from :: DecidedStrictness -> Rep DecidedStrictness x

to :: Rep DecidedStrictness x -> DecidedStrictness

Generic DerivClause

Defined in Language.Haskell.TH.Syntax

Associated Types

type Rep DerivClause :: Type -> Type

Methods

from :: DerivClause -> Rep DerivClause x

to :: Rep DerivClause x -> DerivClause

Generic DerivStrategy

Defined in Language.Haskell.TH.Syntax

Associated Types

type Rep DerivStrategy :: Type -> Type

Methods

from :: DerivStrategy -> Rep DerivStrategy x

to :: Rep DerivStrategy x -> DerivStrategy

Generic DocLoc

Defined in Language.Haskell.TH.Syntax

Associated Types

type Rep DocLoc :: Type -> Type

Methods

from :: DocLoc -> Rep DocLoc x

to :: Rep DocLoc x -> DocLoc

Generic Exp

Defined in Language.Haskell.TH.Syntax

Associated Types

type Rep Exp :: Type -> Type

Methods

from :: Exp -> Rep Exp x

to :: Rep Exp x -> Exp

Generic FamilyResultSig

Defined in Language.Haskell.TH.Syntax

Associated Types

type Rep FamilyResultSig :: Type -> Type

Methods

from :: FamilyResultSig -> Rep FamilyResultSig x

to :: Rep FamilyResultSig x -> FamilyResultSig

Generic Fixity

Defined in Language.Haskell.TH.Syntax

Associated Types

type Rep Fixity :: Type -> Type

Methods

from :: Fixity -> Rep Fixity x

to :: Rep Fixity x -> Fixity

Generic FixityDirection

Defined in Language.Haskell.TH.Syntax

Associated Types

type Rep FixityDirection :: Type -> Type

Methods

from :: FixityDirection -> Rep FixityDirection x

to :: Rep FixityDirection x -> FixityDirection

Generic Foreign

Defined in Language.Haskell.TH.Syntax

Associated Types

type Rep Foreign :: Type -> Type

Methods

from :: Foreign -> Rep Foreign x

to :: Rep Foreign x -> Foreign

Generic FunDep

Defined in Language.Haskell.TH.Syntax

Associated Types

type Rep FunDep :: Type -> Type

Methods

from :: FunDep -> Rep FunDep x

to :: Rep FunDep x -> FunDep

Generic Guard

Defined in Language.Haskell.TH.Syntax

Associated Types

type Rep Guard :: Type -> Type

Methods

from :: Guard -> Rep Guard x

to :: Rep Guard x -> Guard

Generic Info

Defined in Language.Haskell.TH.Syntax

Associated Types

type Rep Info :: Type -> Type

Methods

from :: Info -> Rep Info x

to :: Rep Info x -> Info

Generic InjectivityAnn

Defined in Language.Haskell.TH.Syntax

Associated Types

type Rep InjectivityAnn :: Type -> Type

Methods

from :: InjectivityAnn -> Rep InjectivityAnn x

to :: Rep InjectivityAnn x -> InjectivityAnn

Generic Inline

Defined in Language.Haskell.TH.Syntax

Associated Types

type Rep Inline :: Type -> Type

Methods

from :: Inline -> Rep Inline x

to :: Rep Inline x -> Inline

Generic Lit

Defined in Language.Haskell.TH.Syntax

Associated Types

type Rep Lit :: Type -> Type

Methods

from :: Lit -> Rep Lit x

to :: Rep Lit x -> Lit

Generic Loc

Defined in Language.Haskell.TH.Syntax

Associated Types

type Rep Loc :: Type -> Type

Methods

from :: Loc -> Rep Loc x

to :: Rep Loc x -> Loc

Generic Match

Defined in Language.Haskell.TH.Syntax

Associated Types

type Rep Match :: Type -> Type

Methods

from :: Match -> Rep Match x

to :: Rep Match x -> Match

Generic ModName

Defined in Language.Haskell.TH.Syntax

Associated Types

type Rep ModName :: Type -> Type

Methods

from :: ModName -> Rep ModName x

to :: Rep ModName x -> ModName

Generic Module

Defined in Language.Haskell.TH.Syntax

Associated Types

type Rep Module :: Type -> Type

Methods

from :: Module -> Rep Module x

to :: Rep Module x -> Module

Generic ModuleInfo

Defined in Language.Haskell.TH.Syntax

Associated Types

type Rep ModuleInfo :: Type -> Type

Methods

from :: ModuleInfo -> Rep ModuleInfo x

to :: Rep ModuleInfo x -> ModuleInfo

Generic Name

Defined in Language.Haskell.TH.Syntax

Associated Types

type Rep Name :: Type -> Type

Methods

from :: Name -> Rep Name x

to :: Rep Name x -> Name

Generic NameFlavour

Defined in Language.Haskell.TH.Syntax

Associated Types

type Rep NameFlavour :: Type -> Type

Methods

from :: NameFlavour -> Rep NameFlavour x

to :: Rep NameFlavour x -> NameFlavour

Generic NameSpace

Defined in Language.Haskell.TH.Syntax

Associated Types

type Rep NameSpace :: Type -> Type

Methods

from :: NameSpace -> Rep NameSpace x

to :: Rep NameSpace x -> NameSpace

Generic OccName

Defined in Language.Haskell.TH.Syntax

Associated Types

type Rep OccName :: Type -> Type

Methods

from :: OccName -> Rep OccName x

to :: Rep OccName x -> OccName

Generic Overlap

Defined in Language.Haskell.TH.Syntax

Associated Types

type Rep Overlap :: Type -> Type

Methods

from :: Overlap -> Rep Overlap x

to :: Rep Overlap x -> Overlap

Generic Pat

Defined in Language.Haskell.TH.Syntax

Associated Types

type Rep Pat :: Type -> Type

Methods

from :: Pat -> Rep Pat x

to :: Rep Pat x -> Pat

Generic PatSynArgs

Defined in Language.Haskell.TH.Syntax

Associated Types

type Rep PatSynArgs :: Type -> Type

Methods

from :: PatSynArgs -> Rep PatSynArgs x

to :: Rep PatSynArgs x -> PatSynArgs

Generic PatSynDir

Defined in Language.Haskell.TH.Syntax

Associated Types

type Rep PatSynDir :: Type -> Type

Methods

from :: PatSynDir -> Rep PatSynDir x

to :: Rep PatSynDir x -> PatSynDir

Generic Phases

Defined in Language.Haskell.TH.Syntax

Associated Types

type Rep Phases :: Type -> Type

Methods

from :: Phases -> Rep Phases x

to :: Rep Phases x -> Phases

Generic PkgName

Defined in Language.Haskell.TH.Syntax

Associated Types

type Rep PkgName :: Type -> Type

Methods

from :: PkgName -> Rep PkgName x

to :: Rep PkgName x -> PkgName

Generic Pragma

Defined in Language.Haskell.TH.Syntax

Associated Types

type Rep Pragma :: Type -> Type

Methods

from :: Pragma -> Rep Pragma x

to :: Rep Pragma x -> Pragma

Generic Range

Defined in Language.Haskell.TH.Syntax

Associated Types

type Rep Range :: Type -> Type

Methods

from :: Range -> Rep Range x

to :: Rep Range x -> Range

Generic Role

Defined in Language.Haskell.TH.Syntax

Associated Types

type Rep Role :: Type -> Type

Methods

from :: Role -> Rep Role x

to :: Rep Role x -> Role

Generic RuleBndr

Defined in Language.Haskell.TH.Syntax

Associated Types

type Rep RuleBndr :: Type -> Type

Methods

from :: RuleBndr -> Rep RuleBndr x

to :: Rep RuleBndr x -> RuleBndr

Generic RuleMatch

Defined in Language.Haskell.TH.Syntax

Associated Types

type Rep RuleMatch :: Type -> Type

Methods

from :: RuleMatch -> Rep RuleMatch x

to :: Rep RuleMatch x -> RuleMatch

Generic Safety

Defined in Language.Haskell.TH.Syntax

Associated Types

type Rep Safety :: Type -> Type

Methods

from :: Safety -> Rep Safety x

to :: Rep Safety x -> Safety

Generic SourceStrictness

Defined in Language.Haskell.TH.Syntax

Associated Types

type Rep SourceStrictness :: Type -> Type

Methods

from :: SourceStrictness -> Rep SourceStrictness x

to :: Rep SourceStrictness x -> SourceStrictness

Generic SourceUnpackedness

Defined in Language.Haskell.TH.Syntax

Associated Types

type Rep SourceUnpackedness :: Type -> Type

Methods

from :: SourceUnpackedness -> Rep SourceUnpackedness x

to :: Rep SourceUnpackedness x -> SourceUnpackedness

Generic Specificity

Defined in Language.Haskell.TH.Syntax

Associated Types

type Rep Specificity :: Type -> Type

Methods

from :: Specificity -> Rep Specificity x

to :: Rep Specificity x -> Specificity

Generic Stmt

Defined in Language.Haskell.TH.Syntax

Associated Types

type Rep Stmt :: Type -> Type

Methods

from :: Stmt -> Rep Stmt x

to :: Rep Stmt x -> Stmt

Generic TyLit

Defined in Language.Haskell.TH.Syntax

Associated Types

type Rep TyLit :: Type -> Type

Methods

from :: TyLit -> Rep TyLit x

to :: Rep TyLit x -> TyLit

Generic TySynEqn

Defined in Language.Haskell.TH.Syntax

Associated Types

type Rep TySynEqn :: Type -> Type

Methods

from :: TySynEqn -> Rep TySynEqn x

to :: Rep TySynEqn x -> TySynEqn

Generic Type

Defined in Language.Haskell.TH.Syntax

Associated Types

type Rep Type :: Type -> Type

Methods

from :: Type -> Rep Type x

to :: Rep Type x -> Type

Generic TypeFamilyHead

Defined in Language.Haskell.TH.Syntax

Associated Types

type Rep TypeFamilyHead :: Type -> Type

Methods

from :: TypeFamilyHead -> Rep TypeFamilyHead x

to :: Rep TypeFamilyHead x -> TypeFamilyHead

Generic ()

Defined in GHC.Generics

Associated Types

type Rep () :: Type -> Type

Methods

from :: () -> Rep () x

to :: Rep () x -> ()

Generic Bool

Defined in GHC.Generics

Associated Types

type Rep Bool :: Type -> Type

Methods

from :: Bool -> Rep Bool x

to :: Rep Bool x -> Bool

Generic (ZipList a)

Defined in Control.Applicative

Associated Types

type Rep (ZipList a) :: Type -> Type

Methods

from :: ZipList a -> Rep (ZipList a) x

to :: Rep (ZipList a) x -> ZipList a

Generic (Complex a)

Defined in Data.Complex

Associated Types

type Rep (Complex a) :: Type -> Type

Methods

from :: Complex a -> Rep (Complex a) x

to :: Rep (Complex a) x -> Complex a

Generic (Identity a)

Defined in Data.Functor.Identity

Associated Types

type Rep (Identity a) :: Type -> Type

Methods

from :: Identity a -> Rep (Identity a) x

to :: Rep (Identity a) x -> Identity a

Generic (First a)

Defined in Data.Monoid

Associated Types

type Rep (First a) :: Type -> Type

Methods

from :: First a -> Rep (First a) x

to :: Rep (First a) x -> First a

Generic (Last a)

Defined in Data.Monoid

Associated Types

type Rep (Last a) :: Type -> Type

Methods

from :: Last a -> Rep (Last a) x

to :: Rep (Last a) x -> Last a

Generic (Down a)

Defined in GHC.Generics

Associated Types

type Rep (Down a) :: Type -> Type

Methods

from :: Down a -> Rep (Down a) x

to :: Rep (Down a) x -> Down a

Generic (First a)

Defined in Data.Semigroup

Associated Types

type Rep (First a) :: Type -> Type

Methods

from :: First a -> Rep (First a) x

to :: Rep (First a) x -> First a

Generic (Last a)

Defined in Data.Semigroup

Associated Types

type Rep (Last a) :: Type -> Type

Methods

from :: Last a -> Rep (Last a) x

to :: Rep (Last a) x -> Last a

Generic (Max a)

Defined in Data.Semigroup

Associated Types

type Rep (Max a) :: Type -> Type

Methods

from :: Max a -> Rep (Max a) x

to :: Rep (Max a) x -> Max a

Generic (Min a)

Defined in Data.Semigroup

Associated Types

type Rep (Min a) :: Type -> Type

Methods

from :: Min a -> Rep (Min a) x

to :: Rep (Min a) x -> Min a

Generic (WrappedMonoid m)

Defined in Data.Semigroup

Associated Types

type Rep (WrappedMonoid m) :: Type -> Type

Methods

from :: WrappedMonoid m -> Rep (WrappedMonoid m) x

to :: Rep (WrappedMonoid m) x -> WrappedMonoid m

Generic (Dual a)

Defined in Data.Semigroup.Internal

Associated Types

type Rep (Dual a) :: Type -> Type

Methods

from :: Dual a -> Rep (Dual a) x

to :: Rep (Dual a) x -> Dual a

Generic (Endo a)

Defined in Data.Semigroup.Internal

Associated Types

type Rep (Endo a) :: Type -> Type

Methods

from :: Endo a -> Rep (Endo a) x

to :: Rep (Endo a) x -> Endo a

Generic (Product a)

Defined in Data.Semigroup.Internal

Associated Types

type Rep (Product a) :: Type -> Type

Methods

from :: Product a -> Rep (Product a) x

to :: Rep (Product a) x -> Product a

Generic (Sum a)

Defined in Data.Semigroup.Internal

Associated Types

type Rep (Sum a) :: Type -> Type

Methods

from :: Sum a -> Rep (Sum a) x

to :: Rep (Sum a) x -> Sum a

Generic (Par1 p)

Defined in GHC.Generics

Associated Types

type Rep (Par1 p) :: Type -> Type

Methods

from :: Par1 p -> Rep (Par1 p) x

to :: Rep (Par1 p) x -> Par1 p

Generic (Digit a)

Defined in Data.Sequence.Internal

Associated Types

type Rep (Digit a) :: Type -> Type

Methods

from :: Digit a -> Rep (Digit a) x

to :: Rep (Digit a) x -> Digit a

Generic (Elem a)

Defined in Data.Sequence.Internal

Associated Types

type Rep (Elem a) :: Type -> Type

Methods

from :: Elem a -> Rep (Elem a) x

to :: Rep (Elem a) x -> Elem a

Generic (FingerTree a)

Defined in Data.Sequence.Internal

Associated Types

type Rep (FingerTree a) :: Type -> Type

Methods

from :: FingerTree a -> Rep (FingerTree a) x

to :: Rep (FingerTree a) x -> FingerTree a

Generic (Node a)

Defined in Data.Sequence.Internal

Associated Types

type Rep (Node a) :: Type -> Type

Methods

from :: Node a -> Rep (Node a) x

to :: Rep (Node a) x -> Node a

Generic (ViewL a)

Defined in Data.Sequence.Internal

Associated Types

type Rep (ViewL a) :: Type -> Type

Methods

from :: ViewL a -> Rep (ViewL a) x

to :: Rep (ViewL a) x -> ViewL a

Generic (ViewR a)

Defined in Data.Sequence.Internal

Associated Types

type Rep (ViewR a) :: Type -> Type

Methods

from :: ViewR a -> Rep (ViewR a) x

to :: Rep (ViewR a) x -> ViewR a

Generic (Tree a)

Defined in Data.Tree

Associated Types

type Rep (Tree a) :: Type -> Type

Methods

from :: Tree a -> Rep (Tree a) x

to :: Rep (Tree a) x -> Tree a

Generic (Doc a)

Defined in Text.PrettyPrint.Annotated.HughesPJ

Associated Types

type Rep (Doc a) :: Type -> Type

Methods

from :: Doc a -> Rep (Doc a) x

to :: Rep (Doc a) x -> Doc a

Generic (Doc ann)

Defined in Prettyprinter.Internal

Associated Types

type Rep (Doc ann) :: Type -> Type

Methods

from :: Doc ann -> Rep (Doc ann) x

to :: Rep (Doc ann) x -> Doc ann

Generic (SimpleDocStream ann)

Defined in Prettyprinter.Internal

Associated Types

type Rep (SimpleDocStream ann) :: Type -> Type

Methods

from :: SimpleDocStream ann -> Rep (SimpleDocStream ann) x

to :: Rep (SimpleDocStream ann) x -> SimpleDocStream ann

Generic (TyVarBndr flag)

Defined in Language.Haskell.TH.Syntax

Associated Types

type Rep (TyVarBndr flag) :: Type -> Type

Methods

from :: TyVarBndr flag -> Rep (TyVarBndr flag) x

to :: Rep (TyVarBndr flag) x -> TyVarBndr flag

Generic (NonEmpty a)

Defined in GHC.Generics

Associated Types

type Rep (NonEmpty a) :: Type -> Type

Methods

from :: NonEmpty a -> Rep (NonEmpty a) x

to :: Rep (NonEmpty a) x -> NonEmpty a

Generic (Maybe a)

Defined in GHC.Generics

Associated Types

type Rep (Maybe a) :: Type -> Type

Methods

from :: Maybe a -> Rep (Maybe a) x

to :: Rep (Maybe a) x -> Maybe a

Generic (a)

Defined in GHC.Generics

Associated Types

type Rep (a) :: Type -> Type

Methods

from :: (a) -> Rep (a) x

to :: Rep (a) x -> (a)

Generic [a]

Defined in GHC.Generics

Associated Types

type Rep [a] :: Type -> Type

Methods

from :: [a] -> Rep [a] x

to :: Rep [a] x -> [a]

Generic (WrappedMonad m a)

Defined in Control.Applicative

Associated Types

type Rep (WrappedMonad m a) :: Type -> Type

Methods

from :: WrappedMonad m a -> Rep (WrappedMonad m a) x

to :: Rep (WrappedMonad m a) x -> WrappedMonad m a

Generic (Either a b)

Defined in GHC.Generics

Associated Types

type Rep (Either a b) :: Type -> Type

Methods

from :: Either a b -> Rep (Either a b) x

to :: Rep (Either a b) x -> Either a b

Generic (Proxy t)

Defined in GHC.Generics

Associated Types

type Rep (Proxy t) :: Type -> Type

Methods

from :: Proxy t -> Rep (Proxy t) x

to :: Rep (Proxy t) x -> Proxy t

Generic (Arg a b)

Defined in Data.Semigroup

Associated Types

type Rep (Arg a b) :: Type -> Type

Methods

from :: Arg a b -> Rep (Arg a b) x

to :: Rep (Arg a b) x -> Arg a b

Generic (U1 p)

Defined in GHC.Generics

Associated Types

type Rep (U1 p) :: Type -> Type

Methods

from :: U1 p -> Rep (U1 p) x

to :: Rep (U1 p) x -> U1 p

Generic (V1 p)

Defined in GHC.Generics

Associated Types

type Rep (V1 p) :: Type -> Type

Methods

from :: V1 p -> Rep (V1 p) x

to :: Rep (V1 p) x -> V1 p

Generic (Bimap a b)

Defined in Data.Bimap

Associated Types

type Rep (Bimap a b) :: Type -> Type

Methods

from :: Bimap a b -> Rep (Bimap a b) x

to :: Rep (Bimap a b) x -> Bimap a b

Generic (a, b)

Defined in GHC.Generics

Associated Types

type Rep (a, b) :: Type -> Type

Methods

from :: (a, b) -> Rep (a, b) x

to :: Rep (a, b) x -> (a, b)

Generic (WrappedArrow a b c)

Defined in Control.Applicative

Associated Types

type Rep (WrappedArrow a b c) :: Type -> Type

Methods

from :: WrappedArrow a b c -> Rep (WrappedArrow a b c) x

to :: Rep (WrappedArrow a b c) x -> WrappedArrow a b c

Generic (Const a b)

Defined in Data.Functor.Const

Associated Types

type Rep (Const a b) :: Type -> Type

Methods

from :: Const a b -> Rep (Const a b) x

to :: Rep (Const a b) x -> Const a b

Generic (Ap f a)

Defined in Data.Monoid

Associated Types

type Rep (Ap f a) :: Type -> Type

Methods

from :: Ap f a -> Rep (Ap f a) x

to :: Rep (Ap f a) x -> Ap f a

Generic (Alt f a)

Defined in Data.Semigroup.Internal

Associated Types

type Rep (Alt f a) :: Type -> Type

Methods

from :: Alt f a -> Rep (Alt f a) x

to :: Rep (Alt f a) x -> Alt f a

Generic (Rec1 f p)

Defined in GHC.Generics

Associated Types

type Rep (Rec1 f p) :: Type -> Type

Methods

from :: Rec1 f p -> Rep (Rec1 f p) x

to :: Rep (Rec1 f p) x -> Rec1 f p

Generic (URec (Ptr ()) p)

Defined in GHC.Generics

Associated Types

type Rep (URec (Ptr ()) p) :: Type -> Type

Methods

from :: URec (Ptr ()) p -> Rep (URec (Ptr ()) p) x

to :: Rep (URec (Ptr ()) p) x -> URec (Ptr ()) p

Generic (URec Char p)

Defined in GHC.Generics

Associated Types

type Rep (URec Char p) :: Type -> Type

Methods

from :: URec Char p -> Rep (URec Char p) x

to :: Rep (URec Char p) x -> URec Char p

Generic (URec Double p)

Defined in GHC.Generics

Associated Types

type Rep (URec Double p) :: Type -> Type

Methods

from :: URec Double p -> Rep (URec Double p) x

to :: Rep (URec Double p) x -> URec Double p

Generic (URec Float p)

Defined in GHC.Generics

Associated Types

type Rep (URec Float p) :: Type -> Type

Methods

from :: URec Float p -> Rep (URec Float p) x

to :: Rep (URec Float p) x -> URec Float p

Generic (URec Int p)

Defined in GHC.Generics

Associated Types

type Rep (URec Int p) :: Type -> Type

Methods

from :: URec Int p -> Rep (URec Int p) x

to :: Rep (URec Int p) x -> URec Int p

Generic (URec Word p)

Defined in GHC.Generics

Associated Types

type Rep (URec Word p) :: Type -> Type

Methods

from :: URec Word p -> Rep (URec Word p) x

to :: Rep (URec Word p) x -> URec Word p

Generic (a, b, c)

Defined in GHC.Generics

Associated Types

type Rep (a, b, c) :: Type -> Type

Methods

from :: (a, b, c) -> Rep (a, b, c) x

to :: Rep (a, b, c) x -> (a, b, c)

Generic ((f :*: g) p)

Defined in GHC.Generics

Associated Types

type Rep ((f :*: g) p) :: Type -> Type

Methods

from :: (f :*: g) p -> Rep ((f :*: g) p) x

to :: Rep ((f :*: g) p) x -> (f :*: g) p

Generic ((f :+: g) p)

Defined in GHC.Generics

Associated Types

type Rep ((f :+: g) p) :: Type -> Type

Methods

from :: (f :+: g) p -> Rep ((f :+: g) p) x

to :: Rep ((f :+: g) p) x -> (f :+: g) p

Generic (K1 i c p)

Defined in GHC.Generics

Associated Types

type Rep (K1 i c p) :: Type -> Type

Methods

from :: K1 i c p -> Rep (K1 i c p) x

to :: Rep (K1 i c p) x -> K1 i c p

Generic (a, b, c, d)

Defined in GHC.Generics

Associated Types

type Rep (a, b, c, d) :: Type -> Type

Methods

from :: (a, b, c, d) -> Rep (a, b, c, d) x

to :: Rep (a, b, c, d) x -> (a, b, c, d)

Generic (Compose f g a)

Defined in Data.Functor.Compose

Associated Types

type Rep (Compose f g a) :: Type -> Type

Methods

from :: Compose f g a -> Rep (Compose f g a) x

to :: Rep (Compose f g a) x -> Compose f g a

Generic ((f :.: g) p)

Defined in GHC.Generics

Associated Types

type Rep ((f :.: g) p) :: Type -> Type

Methods

from :: (f :.: g) p -> Rep ((f :.: g) p) x

to :: Rep ((f :.: g) p) x -> (f :.: g) p

Generic (M1 i c f p)

Defined in GHC.Generics

Associated Types

type Rep (M1 i c f p) :: Type -> Type

Methods

from :: M1 i c f p -> Rep (M1 i c f p) x

to :: Rep (M1 i c f p) x -> M1 i c f p

Generic (a, b, c, d, e)

Defined in GHC.Generics

Associated Types

type Rep (a, b, c, d, e) :: Type -> Type

Methods

from :: (a, b, c, d, e) -> Rep (a, b, c, d, e) x

to :: Rep (a, b, c, d, e) x -> (a, b, c, d, e)

Generic (a, b, c, d, e, f)

Defined in GHC.Generics

Associated Types

type Rep (a, b, c, d, e, f) :: Type -> Type

Methods

from :: (a, b, c, d, e, f) -> Rep (a, b, c, d, e, f) x

to :: Rep (a, b, c, d, e, f) x -> (a, b, c, d, e, f)

Generic (a, b, c, d, e, f, g)

Defined in GHC.Generics

Associated Types

type Rep (a, b, c, d, e, f, g) :: Type -> Type

Methods

from :: (a, b, c, d, e, f, g) -> Rep (a, b, c, d, e, f, g) x

to :: Rep (a, b, c, d, e, f, g) x -> (a, b, c, d, e, f, g)

Generic (a, b, c, d, e, f, g, h)

Defined in GHC.Generics

Associated Types

type Rep (a, b, c, d, e, f, g, h) :: Type -> Type

Methods

from :: (a, b, c, d, e, f, g, h) -> Rep (a, b, c, d, e, f, g, h) x

to :: Rep (a, b, c, d, e, f, g, h) x -> (a, b, c, d, e, f, g, h)

Generic (a, b, c, d, e, f, g, h, i)

Defined in GHC.Generics

Associated Types

type Rep (a, b, c, d, e, f, g, h, i) :: Type -> Type

Methods

from :: (a, b, c, d, e, f, g, h, i) -> Rep (a, b, c, d, e, f, g, h, i) x

to :: Rep (a, b, c, d, e, f, g, h, i) x -> (a, b, c, d, e, f, g, h, i)

Generic (a, b, c, d, e, f, g, h, i, j)

Defined in GHC.Generics

Associated Types

type Rep (a, b, c, d, e, f, g, h, i, j) :: Type -> Type

Methods

from :: (a, b, c, d, e, f, g, h, i, j) -> Rep (a, b, c, d, e, f, g, h, i, j) x

to :: Rep (a, b, c, d, e, f, g, h, i, j) x -> (a, b, c, d, e, f, g, h, i, j)

Generic (a, b, c, d, e, f, g, h, i, j, k)

Defined in GHC.Generics

Associated Types

type Rep (a, b, c, d, e, f, g, h, i, j, k) :: Type -> Type

Methods

from :: (a, b, c, d, e, f, g, h, i, j, k) -> Rep (a, b, c, d, e, f, g, h, i, j, k) x

to :: Rep (a, b, c, d, e, f, g, h, i, j, k) x -> (a, b, c, d, e, f, g, h, i, j, k)

Generic (a, b, c, d, e, f, g, h, i, j, k, l)

Defined in GHC.Generics

Associated Types

type Rep (a, b, c, d, e, f, g, h, i, j, k, l) :: Type -> Type

Methods

from :: (a, b, c, d, e, f, g, h, i, j, k, l) -> Rep (a, b, c, d, e, f, g, h, i, j, k, l) x

to :: Rep (a, b, c, d, e, f, g, h, i, j, k, l) x -> (a, b, c, d, e, f, g, h, i, j, k, l)

Generic (a, b, c, d, e, f, g, h, i, j, k, l, m)

Defined in GHC.Generics

Associated Types

type Rep (a, b, c, d, e, f, g, h, i, j, k, l, m) :: Type -> Type

Methods

from :: (a, b, c, d, e, f, g, h, i, j, k, l, m) -> Rep (a, b, c, d, e, f, g, h, i, j, k, l, m) x

to :: Rep (a, b, c, d, e, f, g, h, i, j, k, l, m) x -> (a, b, c, d, e, f, g, h, i, j, k, l, m)

Generic (a, b, c, d, e, f, g, h, i, j, k, l, m, n)

Defined in GHC.Generics

Associated Types

type Rep (a, b, c, d, e, f, g, h, i, j, k, l, m, n) :: Type -> Type

Methods

from :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> Rep (a, b, c, d, e, f, g, h, i, j, k, l, m, n) x

to :: Rep (a, b, c, d, e, f, g, h, i, j, k, l, m, n) x -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n)

Generic (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o)

Defined in GHC.Generics

Associated Types

type Rep (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) :: Type -> Type

Methods

from :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> Rep (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) x

to :: Rep (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) x -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o)