dhall-1.19.1: A configuration language guaranteed to terminate

Safe Haskell | None
Language | Haskell2010

Dhall

Contents

- Input
- Types
- Miscellaneous
- Re-exports

Description

Please read the Dhall.Tutorial module, which contains a tutorial explaining how to use the language, the compiler, and this library

Synopsis

- input :: Type a -> Text -> IO a
- inputWithSettings :: InputSettings -> Type a -> Text -> IO a
- inputFile :: Type a -> FilePath -> IO a
- inputFileWithSettings :: EvaluateSettings -> Type a -> FilePath -> IO a
- inputExpr :: Text -> IO (Expr Src X)
- inputExprWithSettings :: InputSettings -> Text -> IO (Expr Src X)
- rootDirectory :: Functor f => LensLike' f InputSettings FilePath
- sourceName :: Functor f => LensLike' f InputSettings FilePath
- startingContext :: (Functor f, HasEvaluateSettings s) => LensLike' f s (Context (Expr Src X))
- normalizer :: (Functor f, HasEvaluateSettings s) => LensLike' f s (ReifiedNormalizer X)
- standardVersion :: (Functor f, HasEvaluateSettings s) => LensLike' f s StandardVersion
- defaultInputSettings :: InputSettings
- data InputSettings
- defaultEvaluateSettings :: EvaluateSettings
- data EvaluateSettings
- class HasEvaluateSettings s
- detailed :: IO a -> IO a
- data Type a = Type {
  - extract :: Expr Src X -> Maybe a
  - expected :: Expr Src X
  }
- newtype RecordType a = RecordType (Product (Const (Map Text (Expr Src X))) (Compose ((->) (Expr Src X)) Maybe) a)
- data InputType a = InputType {
  - embed :: a -> Expr Src X
  - declared :: Expr Src X
  }
- class Interpret a where
  - autoWith :: InterpretOptions -> Type a
- data InvalidType = InvalidType
- auto :: Interpret a => Type a
- genericAuto :: (Generic a, GenericInterpret (Rep a)) => Type a
- data InterpretOptions = InterpretOptions {
  - fieldModifier :: Text -> Text
  - constructorModifier :: Text -> Text
  }
- defaultInterpretOptions :: InterpretOptions
- bool :: Type Bool
- natural :: Type Natural
- integer :: Type Integer
- scientific :: Type Scientific
- double :: Type Double
- lazyText :: Type Text
- strictText :: Type Text
- maybe :: Type a -> Type (Maybe a)
- sequence :: Type a -> Type (Seq a)
- list :: Type a -> Type [a]
- vector :: Type a -> Type (Vector a)
- unit :: Type ()
- string :: Type String
- pair :: Type a -> Type b -> Type (a, b)
- record :: RecordType a -> Type a
- field :: Text -> Type a -> RecordType a
- class GenericInterpret f where
  - genericAutoWith :: InterpretOptions -> State Int (Type (f a))
- class GenericInject f where
  - genericInjectWith :: InterpretOptions -> State Int (InputType (f a))
- class Inject a where
  - injectWith :: InterpretOptions -> InputType a
- inject :: Inject a => InputType a
- newtype RecordInputType a = RecordInputType (Map Text (InputType a))
- inputFieldWith :: Text -> InputType a -> RecordInputType a
- inputField :: Inject a => Text -> RecordInputType a
- inputRecord :: RecordInputType a -> InputType a
- rawInput :: Alternative f => Type a -> Expr s X -> f a
- (>$<) :: Contravariant f => (a -> b) -> f b -> f a
- (>*<) :: Divisible f => f a -> f b -> f (a, b)
- data Natural
- data Seq a
- data Text
- data Vector a
- class Generic a

# Input

input Source #

Arguments

:: Type a | The type of value to decode from Dhall to Haskell
-> Text | The Dhall program
-> IO a | The decoded value in Haskell

Type-check and evaluate a Dhall program, decoding the result into Haskell

The first argument determines the type of value that you decode:

    >>> input integer "+2"
    2
    >>> input (vector double) "[1.0, 2.0]"
    [1.0,2.0]

Use `auto` to automatically select which type to decode based on the inferred return type:

    >>> input auto "True" :: IO Bool
    True

This uses the settings from `defaultInputSettings`.

inputWithSettings Source #

Arguments

:: InputSettings |
-> Type a | The type of value to decode from Dhall to Haskell
-> Text | The Dhall program
-> IO a | The decoded value in Haskell

Extend `input` with a root directory to resolve imports relative to, a file to mention in errors as the source, a custom typing context, and a custom normalization process.

Since: 1.16

inputFile Source #

Arguments

:: Type a | The type of value to decode from Dhall to Haskell
-> FilePath | The path to the Dhall program.
-> IO a | The decoded value in Haskell.

Type-check and evaluate a Dhall program that is read from the file-system.

This uses the settings from `defaultEvaluateSettings`.

Since: 1.16

inputFileWithSettings Source #

Arguments

:: EvaluateSettings |
-> Type a | The type of value to decode from Dhall to Haskell
-> FilePath | The path to the Dhall program.
-> IO a | The decoded value in Haskell.

Extend `inputFile` with a custom typing context and a custom normalization process.

Since: 1.16

inputExpr Source #

Arguments

:: Text | The Dhall program
-> IO (Expr Src X) | The fully normalized AST

Similar to `input`, but without interpreting the Dhall `Expr` into a Haskell type.

Uses the settings from `defaultInputSettings`.

inputExprWithSettings Source #

Arguments

:: InputSettings |
-> Text | The Dhall program
-> IO (Expr Src X) | The fully normalized AST

Extend `inputExpr` with a root directory to resolve imports relative to, a file to mention in errors as the source, a custom typing context, and a custom normalization process.

Since: 1.16

rootDirectory :: Functor f => LensLike' f InputSettings FilePath Source #

Access the directory to resolve imports relative to.

Since: 1.16

sourceName :: Functor f => LensLike' f InputSettings FilePath Source #

Access the name of the source to report locations from; this is only used in error messages, so it's okay if this is a best guess or something symbolic.

Since: 1.16

startingContext :: (Functor f, HasEvaluateSettings s) => LensLike' f s (Context (Expr Src X)) Source #

Access the starting context used for evaluation and type-checking.

Since: 1.16

normalizer :: (Functor f, HasEvaluateSettings s) => LensLike' f s (ReifiedNormalizer X) Source #

Access the custom normalizer.

Since: 1.16

standardVersion :: (Functor f, HasEvaluateSettings s) => LensLike' f s StandardVersion Source #

Access the standard version (used primarily when encoding or decoding Dhall expressions to and from a binary representation)

Since: 1.17

defaultInputSettings :: InputSettings Source #

Default input settings: resolves imports relative to `.` (the current working directory), report errors as coming from `(input)`, and default evaluation settings from `defaultEvaluateSettings`.

Since: 1.16

data InputSettings Source #

Since: 1.16

Instances

HasEvaluateSettings InputSettings Source # |
Instance details Defined in Dhall Methods evaluateSettings :: Functor f => LensLike' f InputSettings EvaluateSettings

defaultEvaluateSettings :: EvaluateSettings Source #

Default evaluation settings: no extra entries in the initial context, and no special normalizer behaviour.

Since: 1.16

data EvaluateSettings Source #

Since: 1.16

Instances

HasEvaluateSettings EvaluateSettings Source # |
Instance details Defined in Dhall Methods evaluateSettings :: Functor f => LensLike' f EvaluateSettings EvaluateSettings

class HasEvaluateSettings s Source #

Since: 1.16

Minimal complete definition

evaluateSettings

Instances

HasEvaluateSettings EvaluateSettings Source # |
Instance details Defined in Dhall Methods evaluateSettings :: Functor f => LensLike' f EvaluateSettings EvaluateSettings
HasEvaluateSettings InputSettings Source # |
Instance details Defined in Dhall Methods evaluateSettings :: Functor f => LensLike' f InputSettings EvaluateSettings

detailed :: IO a -> IO a Source #

Use this to provide more detailed error messages

    > input auto "True" :: IO Integer
     *** Exception: Error: Expression doesn't match annotation

     True : Integer

     (input):1:1

    > detailed (input auto "True") :: IO Integer
     *** Exception: Error: Expression doesn't match annotation

     Explanation: You can annotate an expression with its type or kind using the
     ❰:❱ symbol, like this:

         ┌───────┐
         │ x : t │  ❰x❱ is an expression and ❰t❱ is the annotated type or kind of ❰x❱
         └───────┘

     The type checker verifies that the expression's type or kind matches the
     provided annotation

     For example, all of the following are valid annotations that the type checker
     accepts:

         ┌─────────────┐
         │ 1 : Natural │  ❰1❱ is an expression that has type ❰Natural❱, so the type
         └─────────────┘  checker accepts the annotation

         ┌───────────────────────┐
         │ Natural/even 2 : Bool │  ❰Natural/even 2❱ has type ❰Bool❱, so the type
         └───────────────────────┘  checker accepts the annotation

         ┌────────────────────┐
         │ List : Type → Type │  ❰List❱ is an expression that has kind ❰Type → Type❱,
         └────────────────────┘  so the type checker accepts the annotation

         ┌──────────────────┐
         │ List Text : Type │  ❰List Text❱ is an expression that has kind ❰Type❱, so
         └──────────────────┘  the type checker accepts the annotation

     However, the following annotations are not valid and the type checker will
     reject them:

         ┌──────────┐
         │ 1 : Text │  The type checker rejects this because ❰1❱ does not have type
         └──────────┘  ❰Text❱

         ┌─────────────┐
         │ List : Type │  ❰List❱ does not have kind ❰Type❱
         └─────────────┘

     You or the interpreter annotated this expression:

     ↳ True

     ... with this type or kind:

     ↳ Integer

     ... but the inferred type or kind of the expression is actually:

     ↳ Bool

     Some common reasons why you might get this error:

     ● The Haskell Dhall interpreter implicitly inserts a top-level annotation
       matching the expected type

       For example, if you run the following Haskell code:

         ┌───────────────────────────────┐
         │ >>> input auto "1" :: IO Text │
         └───────────────────────────────┘

       ... then the interpreter will actually type check the following annotated
       expression:

         ┌──────────┐
         │ 1 : Text │
         └──────────┘

       ... and then type-checking will fail

     ────────────────────────────────────────────────────────────────────────────────

     True : Integer

     (input):1:1

# Types

data Type a Source #

A `(Type a)` represents a way to marshal a value of type `'a'` from Dhall into Haskell

You can produce `Type`s either explicitly:

    example :: Type (Vector Text)
    example = vector text

... or implicitly using `auto`:

    example :: Type (Vector Text)
    example = auto

You can consume `Type`s using the `input` function:

    input :: Type a -> Text -> IO a

Constructors

Type |

Fields

- extract :: Expr Src X -> Maybe a

  Extracts Haskell value from the Dhall expression

- expected :: Expr Src X

  Dhall type of the Haskell value

Instances

Functor Type Source # |
Instance details Defined in Dhall Methods fmap :: (a -> b) -> Type a -> Type b Source # (<$) :: a -> Type b -> Type a Source #

newtype RecordType a Source #

The `RecordType` applicative functor allows you to build a `Type` parser from a Dhall record.

For example, let's take the following Haskell data type:

    data Project = Project
      { projectName :: Text
      , projectDescription :: Text
      , projectStars :: Natural
      }

And assume that we have the following Dhall record that we would like to parse as a `Project`:

    { name =
        "dhall-haskell"
    , description =
        "A configuration language guaranteed to terminate"
    , stars =
        289
    }

Our parser has type `Type` `Project`, but we can't build that out of any smaller parsers, as `Type`s cannot be combined (they are only `Functor`s). However, we can use a `RecordType` to build a `Type` for `Project`:

    project :: Type Project
    project =
      record
        ( Project <$> field "name" string
                  <*> field "description" string
                  <*> field "stars" natural
        )

Constructors

RecordType (Product (Const (Map Text (Expr Src X))) (Compose ((->) (Expr Src X)) Maybe) a) |

Instances

Functor RecordType Source # |
Instance details Defined in Dhall Methods fmap :: (a -> b) -> RecordType a -> RecordType b Source # (<$) :: a -> RecordType b -> RecordType a Source #
Applicative RecordType Source # |
Instance details Defined in Dhall Methods pure :: a -> RecordType a Source # (<*>) :: RecordType (a -> b) -> RecordType a -> RecordType b Source # liftA2 :: (a -> b -> c) -> RecordType a -> RecordType b -> RecordType c Source # (*>) :: RecordType a -> RecordType b -> RecordType b Source # (<*) :: RecordType a -> RecordType b -> RecordType a Source #

data InputType a Source #

An `(InputType a)` represents a way to marshal a value of type `'a'` from Haskell into Dhall

Constructors

InputType |

Fields

- embed :: a -> Expr Src X

  Embeds a Haskell value as a Dhall expression

- declared :: Expr Src X

  Dhall type of the Haskell value

Instances

Contravariant InputType Source # |
Instance details Defined in Dhall Methods contramap :: (a -> b) -> InputType b -> InputType a Source # (>$) :: b -> InputType b -> InputType a Source #

class Interpret a where Source #

Any value that implements `Interpret` can be automatically decoded based on the inferred return type of `input`

    >>> input auto "[1, 2, 3]" :: IO (Vector Natural)
    [1,2,3]

This class auto-generates a default implementation for records that implement `Generic`. This does not auto-generate an instance for recursive types.

Minimal complete definition

Nothing

Methods

autoWith :: InterpretOptions -> Type a Source #

autoWith :: (Generic a, GenericInterpret (Rep a)) => InterpretOptions -> Type a Source #

Instances

Interpret Bool Source # |
Instance details Defined in Dhall Methods autoWith :: InterpretOptions -> Type Bool Source #
Interpret Double Source # |
Instance details Defined in Dhall Methods autoWith :: InterpretOptions -> Type Double Source #
Interpret Integer Source # |
Instance details Defined in Dhall Methods autoWith :: InterpretOptions -> Type Integer Source #
Interpret Natural Source # |
Instance details Defined in Dhall Methods autoWith :: InterpretOptions -> Type Natural Source #
Interpret Text Source # |
Instance details Defined in Dhall Methods autoWith :: InterpretOptions -> Type Text Source #
Interpret Scientific Source # |
Instance details Defined in Dhall Methods autoWith :: InterpretOptions -> Type Scientific Source #
Interpret Text Source # |
Instance details Defined in Dhall Methods autoWith :: InterpretOptions -> Type Text Source #
Interpret [Char] Source # |
Instance details Defined in Dhall Methods autoWith :: InterpretOptions -> Type [Char] Source #
Interpret a => Interpret [a] Source # |
Instance details Defined in Dhall Methods autoWith :: InterpretOptions -> Type [a] Source #
Interpret a => Interpret (Maybe a) Source # |
Instance details Defined in Dhall Methods autoWith :: InterpretOptions -> Type (Maybe a) Source #
Interpret a => Interpret (Seq a) Source # |
Instance details Defined in Dhall Methods autoWith :: InterpretOptions -> Type (Seq a) Source #
Interpret a => Interpret (Vector a) Source # |
Instance details Defined in Dhall Methods autoWith :: InterpretOptions -> Type (Vector a) Source #
(Inject a, Interpret b) => Interpret (a -> b) Source # |
Instance details Defined in Dhall Methods autoWith :: InterpretOptions -> Type (a -> b) Source #
(Interpret a, Interpret b) => Interpret (a, b) Source # |
Instance details Defined in Dhall Methods autoWith :: InterpretOptions -> Type (a, b) Source #

data InvalidType Source #

Every `Type` must obey the contract that if an expression's type matches the the `expected` type then the `extract` function must succeed. If not, then this exception is thrown

This exception indicates that an invalid `Type` was provided to the `input` function

Constructors

InvalidType |

Instances

Show InvalidType Source # |
Instance details Defined in Dhall Methods showsPrec :: Int -> InvalidType -> ShowS Source # show :: InvalidType -> String Source # showList :: [InvalidType] -> ShowS Source #
Exception InvalidType Source # |
Instance details Defined in Dhall Methods toException :: InvalidType -> SomeException Source # fromException :: SomeException -> Maybe InvalidType Source # displayException :: InvalidType -> String Source #

auto :: Interpret a => Type a Source #

Use the default options for interpreting a configuration file

    auto = autoWith defaultInterpretOptions

genericAuto :: (Generic a, GenericInterpret (Rep a)) => Type a Source #

`genericAuto` is the default implementation for `auto` if you derive `Interpret`. The difference is that you can use `genericAuto` without having to explicitly provide an `Interpret` instance for a type as long as the type derives `Generic`

data InterpretOptions Source #

Use these options to tweak how Dhall derives a generic implementation of `Interpret`

Constructors

InterpretOptions |

Fields

- fieldModifier :: Text -> Text

  Function used to transform Haskell field names into their corresponding Dhall field names

- constructorModifier :: Text -> Text

  Function used to transform Haskell constructor names into their corresponding Dhall alternative names

defaultInterpretOptions :: InterpretOptions Source #

Default interpret options, which you can tweak or override, like this:

    autoWith
        (defaultInterpretOptions { fieldModifier = Data.Text.Lazy.dropWhile (== '_') })

bool :: Type Bool Source #

Decode a `Expr`

    >>> input bool "True"
    True

natural :: Type Natural Source #

Decode a `Expr`

    >>> input natural "42"
    42

integer :: Type Integer Source #

Decode an `Expr`

    >>> input integer "+42"
    42

scientific :: Type Scientific Source #

Decode a `Scientific`

    >>> input scientific "1e100"
    1.0e100

double :: Type Double Source #

Decode a `Expr`

    >>> input double "42.0"
    42.0

lazyText :: Type Text Source #

Decode lazy `Expr`

    >>> input lazyText "\"Test\""
    "Test"

strictText :: Type Text Source #

Decode strict `Expr`

    >>> input strictText "\"Test\""
    "Test"

maybe :: Type a -> Type (Maybe a) Source #

Decode a `Maybe`

    >>> input (maybe natural) "Some 1"
    Just 1

sequence :: Type a -> Type (Seq a) Source #

Decode a `Seq` - >>> input (sequence natural) "[1, 2, 3]" fromList [1,2,3]

list :: Type a -> Type [a] Source #

Decode a list

    >>> input (list natural) "[1, 2, 3]"
    [1,2,3]

vector :: Type a -> Type (Vector a) Source #

Decode a `Vector`

    >>> input (vector natural) "[1, 2, 3]"
    [1,2,3]

unit :: Type () Source #

Decode `()` from an empty record.

    >>> input unit "{=}"  -- GHC doesn't print the result if it is ()

string :: Type String Source #

Decode a `String`

    >>> input string "\"ABC\""
    "ABC"

pair :: Type a -> Type b -> Type (a, b) Source #

Given a pair of `Type`s, decode a tuple-record into their pairing.

    >>> input (pair natural bool) "{ _1 = 42, _2 = False }"
    (42,False)

record :: RecordType a -> Type a Source #

Run a `RecordType` parser to build a `Type` parser.

field :: Text -> Type a -> RecordType a Source #

Parse a single field of a record.

class GenericInterpret f where Source #

This is the underlying class that powers the `Interpret` class's support for automatically deriving a generic implementation

Methods

genericAutoWith :: InterpretOptions -> State Int (Type (f a)) Source #

Instances

GenericInterpret (V1 :: Type -> Type) Source # |
Instance details Defined in Dhall Methods genericAutoWith :: InterpretOptions -> State Int (Type0 (V1 a)) Source #
GenericInterpret (U1 :: Type -> Type) Source # |
Instance details Defined in Dhall Methods genericAutoWith :: InterpretOptions -> State Int (Type0 (U1 a)) Source #
(Constructor c, GenericInterpret f, GenericInterpret (g :+: h)) => GenericInterpret (M1 C c f :+: (g :+: h)) Source # |
Instance details Defined in Dhall Methods genericAutoWith :: InterpretOptions -> State Int (Type ((M1 C c f :+: (g :+: h)) a)) Source #
(Constructor c1, Constructor c2, GenericInterpret f1, GenericInterpret f2) => GenericInterpret (M1 C c1 f1 :+: M1 C c2 f2) Source # |
Instance details Defined in Dhall Methods genericAutoWith :: InterpretOptions -> State Int (Type ((M1 C c1 f1 :+: M1 C c2 f2) a)) Source #
(GenericInterpret (f :+: g), GenericInterpret (h :+: i)) => GenericInterpret ((f :+: g) :+: (h :+: i)) Source # |
Instance details Defined in Dhall Methods genericAutoWith :: InterpretOptions -> State Int (Type (((f :+: g) :+: (h :+: i)) a)) Source #
(Constructor c, GenericInterpret (f :+: g), GenericInterpret h) => GenericInterpret ((f :+: g) :+: M1 C c h) Source # |
Instance details Defined in Dhall Methods genericAutoWith :: InterpretOptions -> State Int (Type (((f :+: g) :+: M1 C c h) a)) Source #
(GenericInterpret f, GenericInterpret g) => GenericInterpret (f :*: g) Source # |
Instance details Defined in Dhall Methods genericAutoWith :: InterpretOptions -> State Int (Type ((f :*: g) a)) Source #
GenericInterpret f => GenericInterpret (M1 D d f) Source # |
Instance details Defined in Dhall Methods genericAutoWith :: InterpretOptions -> State Int (Type (M1 D d f a)) Source #
GenericInterpret f => GenericInterpret (M1 C c f) Source # |
Instance details Defined in Dhall Methods genericAutoWith :: InterpretOptions -> State Int (Type (M1 C c f a)) Source #
(Selector s, Interpret a) => GenericInterpret (M1 S s (K1 i a :: Type -> Type)) Source # |
Instance details Defined in Dhall Methods genericAutoWith :: InterpretOptions -> State Int (Type0 (M1 S s (K1 i a) a0)) Source #

class GenericInject f where Source #

This is the underlying class that powers the `Interpret` class's support for automatically deriving a generic implementation

Methods

genericInjectWith :: InterpretOptions -> State Int (InputType (f a)) Source #

Instances

GenericInject (U1 :: Type -> Type) Source # |
Instance details Defined in Dhall Methods genericInjectWith :: InterpretOptions -> State Int (InputType (U1 a)) Source #
(Constructor c, GenericInject f, GenericInject (g :+: h)) => GenericInject (M1 C c f :+: (g :+: h)) Source # |
Instance details Defined in Dhall Methods genericInjectWith :: InterpretOptions -> State Int (InputType ((M1 C c f :+: (g :+: h)) a)) Source #
(Constructor c1, Constructor c2, GenericInject f1, GenericInject f2) => GenericInject (M1 C c1 f1 :+: M1 C c2 f2) Source # |
Instance details Defined in Dhall Methods genericInjectWith :: InterpretOptions -> State Int (InputType ((M1 C c1 f1 :+: M1 C c2 f2) a)) Source #
(GenericInject (f :+: g), GenericInject (h :+: i)) => GenericInject ((f :+: g) :+: (h :+: i)) Source # |
Instance details Defined in Dhall Methods genericInjectWith :: InterpretOptions -> State Int (InputType (((f :+: g) :+: (h :+: i)) a)) Source #
(Constructor c, GenericInject (f :+: g), GenericInject h) => GenericInject ((f :+: g) :+: M1 C c h) Source # |
Instance details Defined in Dhall Methods genericInjectWith :: InterpretOptions -> State Int (InputType (((f :+: g) :+: M1 C c h) a)) Source #
(GenericInject f, GenericInject g) => GenericInject (f :*: g) Source # |
Instance details Defined in Dhall Methods genericInjectWith :: InterpretOptions -> State Int (InputType ((f :*: g) a)) Source #
GenericInject f => GenericInject (M1 D d f) Source # |
Instance details Defined in Dhall Methods genericInjectWith :: InterpretOptions -> State Int (InputType (M1 D d f a)) Source #
GenericInject f => GenericInject (M1 C c f) Source # |
Instance details Defined in Dhall Methods genericInjectWith :: InterpretOptions -> State Int (InputType (M1 C c f a)) Source #
(Selector s, Inject a) => GenericInject (M1 S s (K1 i a :: Type -> Type)) Source # |
Instance details Defined in Dhall Methods genericInjectWith :: InterpretOptions -> State Int (InputType (M1 S s (K1 i a) a0)) Source #

class Inject a where Source #

This class is used by `Interpret` instance for functions:

    instance (Inject a, Interpret b) => Interpret (a -> b)

You can convert Dhall functions with "simple" inputs (i.e. instances of this class) into Haskell functions. This works by:

- Marshaling the input to the Haskell function into a Dhall expression (i.e. `x :: Expr Src X`)
- Applying the Dhall function (i.e. `f :: Expr Src X`) to the Dhall input (i.e. `App f x`)
- Normalizing the syntax tree (i.e. `normalize (App f x)`)
- Marshaling the resulting Dhall expression back into a Haskell value

Minimal complete definition

Nothing

Methods

injectWith :: InterpretOptions -> InputType a Source #

injectWith :: (Generic a, GenericInject (Rep a)) => InterpretOptions -> InputType a Source #

Instances

Inject Bool Source # |
Instance details Defined in Dhall Methods injectWith :: InterpretOptions -> InputType Bool Source #
Inject Double Source # |
Instance details Defined in Dhall Methods injectWith :: InterpretOptions -> InputType Double Source #
Inject Int Source # |
Instance details Defined in Dhall Methods injectWith :: InterpretOptions -> InputType Int Source #
Inject Integer Source # |
Instance details Defined in Dhall Methods injectWith :: InterpretOptions -> InputType Integer Source #
Inject Natural Source # |
Instance details Defined in Dhall Methods injectWith :: InterpretOptions -> InputType Natural Source #
Inject Word8 Source # |
Instance details Defined in Dhall Methods injectWith :: InterpretOptions -> InputType Word8 Source #
Inject Word16 Source # |
Instance details Defined in Dhall Methods injectWith :: InterpretOptions -> InputType Word16 Source #
Inject Word32 Source # |
Instance details Defined in Dhall Methods injectWith :: InterpretOptions -> InputType Word32 Source #
Inject Word64 Source # |
Instance details Defined in Dhall Methods injectWith :: InterpretOptions -> InputType Word64 Source #
Inject () Source # |
Instance details Defined in Dhall Methods injectWith :: InterpretOptions -> InputType () Source #
Inject Text Source # |
Instance details Defined in Dhall Methods injectWith :: InterpretOptions -> InputType Text Source #
Inject Text Source # |
Instance details Defined in Dhall Methods injectWith :: InterpretOptions -> InputType Text Source #
Inject a => Inject [a] Source # |
Instance details Defined in Dhall Methods injectWith :: InterpretOptions -> InputType [a] Source #
Inject a => Inject (Maybe a) Source # |
Instance details Defined in Dhall Methods injectWith :: InterpretOptions -> InputType (Maybe a) Source #
Inject a => Inject (Seq a) Source # |
Instance details Defined in Dhall Methods injectWith :: InterpretOptions -> InputType (Seq a) Source #
Inject a => Inject (Set a) Source # |
Instance details Defined in Dhall Methods injectWith :: InterpretOptions -> InputType (Set a) Source #
Inject a => Inject (Vector a) Source # |
Instance details Defined in Dhall Methods injectWith :: InterpretOptions -> InputType (Vector a) Source #
(Inject a, Inject b) => Inject (a, b) Source # |
Instance details Defined in Dhall Methods injectWith :: InterpretOptions -> InputType (a, b) Source #

inject :: Inject a => InputType a Source #

Use the default options for injecting a value

    inject = inject defaultInterpretOptions

newtype RecordInputType a Source #

Constructors

RecordInputType (Map Text (InputType a)) |

Instances

Contravariant RecordInputType Source # |
Instance details Defined in Dhall Methods contramap :: (a -> b) -> RecordInputType b -> RecordInputType a Source # (>$) :: b -> RecordInputType b -> RecordInputType a Source #
Divisible RecordInputType Source # |
Instance details Defined in Dhall Methods divide :: (a -> (b, c)) -> RecordInputType b -> RecordInputType c -> RecordInputType a Source # conquer :: RecordInputType a Source #

inputFieldWith :: Text -> InputType a -> RecordInputType a Source #

inputField :: Inject a => Text -> RecordInputType a Source #

inputRecord :: RecordInputType a -> InputType a Source #

# Miscellaneous

rawInput Source #

Arguments

:: Alternative f |
=> Type a | The type of value to decode from Dhall to Haskell
-> Expr s X | a closed form Dhall program, which evaluates to the expected type
-> f a | The decoded value in Haskell

Use this function to extract Haskell values directly from Dhall AST. The intended use case is to allow easy extraction of Dhall values for making the function `normalizeWith` easier to use.

For other use cases, use `input` from `Dhall` module. It will give you a much better user experience.

(>$<) :: Contravariant f => (a -> b) -> f b -> f a infixl 4 Source #

This is an infix alias for `contramap`.

(>*<) :: Divisible f => f a -> f b -> f (a, b) infixr 5 Source #

The `RecordInputType` divisible (contravariant) functor allows you to build an `InputType` injector for a Dhall record.

For example, let's take the following Haskell data type:

    data Project = Project
      { projectName :: Text
      , projectDescription :: Text
      , projectStars :: Natural
      }

And assume that we have the following Dhall record that we would like to parse as a `Project`:

    { name =
        "dhall-haskell"
    , description =
        "A configuration language guaranteed to terminate"
    , stars =
        289
    }

Our injector has type `InputType` `Project`, but we can't build that out of any smaller injectors, as `InputType`s cannot be combined (they are only `Contravariant`s). However, we can use an `InputRecordType` to build an `InputType` for `Project`:

    injectProject :: InputType Project
    injectProject =
      inputRecord
        (  adapt >$< inputFieldWith "name" inject
                 >*< inputFieldWith "description" inject
                 >*< inputFieldWith "stars" inject
        )
      where
        adapt (Project{..}) = (projectName, (projectDescription, projectStars))

Or, since we are simply using the `Inject` instance to inject each field, we could write

    injectProject :: InputType Project
    injectProject =
      inputRecord
        (  adapt >$< inputField "name"
                 >*< inputField "description"
                 >*< inputField "stars"
        )
      where
        adapt (Project{..}) = (projectName, (projectDescription, projectStars))

Infix `divided`

# Re-exports

data Natural Source #

Type representing arbitrary-precision non-negative integers.

    >>> 2^100 :: Natural
    1267650600228229401496703205376

Operations whose result would be negative ``throw` (`Underflow` :: `ArithException`)`,

    >>> -1 :: Natural
    *** Exception: arithmetic underflow

Since: base-4.8.0.0

Instances

Enum Natural | Since: base-4.8.0.0

Instance details

Defined in GHC.Enum

Methods

succ :: Natural -> Natural Source #

pred :: Natural -> Natural Source #

toEnum :: Int -> Natural Source #

fromEnum :: Natural -> Int Source #

enumFrom :: Natural -> [Natural] Source #

enumFromThen :: Natural -> Natural -> [Natural] Source #

enumFromTo :: Natural -> Natural -> [Natural] Source #

enumFromThenTo :: Natural -> Natural -> Natural -> [Natural] Source #

Eq Natural | Since: base-4.8.0.0
Instance details Defined in GHC.Natural Methods (==) :: Natural -> Natural -> Bool Source # (/=) :: Natural -> Natural -> Bool Source #
Integral Natural | Since: base-4.8.0.0
Instance details Defined in GHC.Real Methods quot :: Natural -> Natural -> Natural Source # rem :: Natural -> Natural -> Natural Source # div :: Natural -> Natural -> Natural Source # mod :: Natural -> Natural -> Natural Source # quotRem :: Natural -> Natural -> (Natural, Natural) Source # divMod :: Natural -> Natural -> (Natural, Natural) Source # toInteger :: Natural -> Integer Source #
Data Natural | Since: base-4.8.0.0

Instance details

Defined in Data.Data

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Natural -> c Natural Source #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Natural Source #

toConstr :: Natural -> Constr Source #

dataTypeOf :: Natural -> DataType Source #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Natural) Source #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Natural) Source #

gmapT :: (forall b. Data b => b -> b) -> Natural -> Natural Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Natural -> r Source #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Natural -> r Source #

gmapQ :: (forall d. Data d => d -> u) -> Natural -> [u] Source #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Natural -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Natural -> m Natural Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Natural -> m Natural Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Natural -> m Natural Source #

Num Natural | Note that `Natural`'s `Num` instance isn't a ring: no element but 0 has an additive inverse. It is a semiring though. Since: base-4.8.0.0
Instance details Defined in GHC.Num Methods (+) :: Natural -> Natural -> Natural Source # (-) :: Natural -> Natural -> Natural Source # (*) :: Natural -> Natural -> Natural Source # negate :: Natural -> Natural Source # abs :: Natural -> Natural Source # signum :: Natural -> Natural Source # fromInteger :: Integer -> Natural Source #
Ord Natural | Since: base-4.8.0.0
Instance details Defined in GHC.Natural Methods compare :: Natural -> Natural -> Ordering Source # (<) :: Natural -> Natural -> Bool Source # (<=) :: Natural -> Natural -> Bool Source # (>) :: Natural -> Natural -> Bool Source # (>=) :: Natural -> Natural -> Bool Source # max :: Natural -> Natural -> Natural Source # min :: Natural -> Natural -> Natural Source #
Read Natural | Since: base-4.8.0.0
Instance details Defined in GHC.Read Methods readsPrec :: Int -> ReadS Natural Source # readList :: ReadS [Natural] Source # readPrec :: ReadPrec Natural Source # readListPrec :: ReadPrec [Natural] Source #
Real Natural | Since: base-4.8.0.0
Instance details Defined in GHC.Real Methods toRational :: Natural -> Rational Source #
Show Natural | Since: base-4.8.0.0
Instance details Defined in GHC.Show Methods showsPrec :: Int -> Natural -> ShowS Source # show :: Natural -> String Source # showList :: [Natural] -> ShowS Source #
Ix Natural | Since: base-4.8.0.0
Instance details Defined in GHC.Arr Methods range :: (Natural, Natural) -> [Natural] Source # index :: (Natural, Natural) -> Natural -> Int Source # unsafeIndex :: (Natural, Natural) -> Natural -> Int inRange :: (Natural, Natural) -> Natural -> Bool Source # rangeSize :: (Natural, Natural) -> Int Source # unsafeRangeSize :: (Natural, Natural) -> Int
Lift Natural |
Instance details Defined in Language.Haskell.TH.Syntax Methods lift :: Natural -> Q Exp Source #
Pretty Natural |
Instance details Defined in Data.Text.Prettyprint.Doc.Internal Methods pretty :: Natural -> Doc ann Source # prettyList :: [Natural] -> Doc ann Source #
Serialise Natural | Since: serialise-0.2.0.0
Instance details Defined in Codec.Serialise.Class Methods encode :: Natural -> Encoding Source # decode :: Decoder s Natural Source # encodeList :: [Natural] -> Encoding Source # decodeList :: Decoder s [Natural] Source #
Hashable Natural |
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> Natural -> Int hash :: Natural -> Int
Subtractive Natural |
Instance details Defined in Basement.Numerical.Subtractive Associated Types type Difference Natural :: Type Methods (-) :: Natural -> Natural -> Difference Natural
Inject Natural Source # |
Instance details Defined in Dhall Methods injectWith :: InterpretOptions -> InputType Natural Source #
Interpret Natural Source # |
Instance details Defined in Dhall Methods autoWith :: InterpretOptions -> Type Natural Source #
type Difference Natural |
Instance details Defined in Basement.Numerical.Subtractive type Difference Natural = Maybe Natural

data Seq a Source #

General-purpose finite sequences.

Instances

Monad Seq |
Instance details Defined in Data.Sequence.Internal Methods (>>=) :: Seq a -> (a -> Seq b) -> Seq b Source # (>>) :: Seq a -> Seq b -> Seq b Source # return :: a -> Seq a Source # fail :: String -> Seq a Source #
Functor Seq |
Instance details Defined in Data.Sequence.Internal Methods fmap :: (a -> b) -> Seq a -> Seq b Source # (<$) :: a -> Seq b -> Seq a Source #
MonadFix Seq | Since: containers-0.5.11
Instance details Defined in Data.Sequence.Internal Methods mfix :: (a -> Seq a) -> Seq a Source #
Applicative Seq | Since: containers-0.5.4
Instance details Defined in Data.Sequence.Internal Methods pure :: a -> Seq a Source # (<*>) :: Seq (a -> b) -> Seq a -> Seq b Source # liftA2 :: (a -> b -> c) -> Seq a -> Seq b -> Seq c Source # (*>) :: Seq a -> Seq b -> Seq b Source # (<*) :: Seq a -> Seq b -> Seq a Source #
Foldable Seq |

Instance details

Defined in Data.Sequence.Internal

Methods

fold :: Monoid m => Seq m -> m Source #

foldMap :: Monoid m => (a -> m) -> Seq a -> m Source #

foldr :: (a -> b -> b) -> b -> Seq a -> b Source #

foldr' :: (a -> b -> b) -> b -> Seq a -> b Source #

foldl :: (b -> a -> b) -> b -> Seq a -> b Source #

foldl' :: (b -> a -> b) -> b -> Seq a -> b Source #

foldr1 :: (a -> a -> a) -> Seq a -> a Source #

foldl1 :: (a -> a -> a) -> Seq a -> a Source #

toList :: Seq a -> [a] Source #

null :: Seq a -> Bool Source #

length :: Seq a -> Int Source #

elem :: Eq a => a -> Seq a -> Bool Source #

maximum :: Ord a => Seq a -> a Source #

minimum :: Ord a => Seq a -> a Source #

sum :: Num a => Seq a -> a Source #

product :: Num a => Seq a -> a Source #

Traversable Seq |
Instance details Defined in Data.Sequence.Internal Methods traverse :: Applicative f => (a -> f b) -> Seq a -> f (Seq b) Source # sequenceA :: Applicative f => Seq (f a) -> f (Seq a) Source # mapM :: Monad m => (a -> m b) -> Seq a -> m (Seq b) Source # sequence :: Monad m => Seq (m a) -> m (Seq a) Source #
Eq1 Seq | Since: containers-0.5.9
Instance details Defined in Data.Sequence.Internal Methods liftEq :: (a -> b -> Bool) -> Seq a -> Seq b -> Bool Source #
Ord1 Seq | Since: containers-0.5.9
Instance details Defined in Data.Sequence.Internal Methods liftCompare :: (a -> b -> Ordering) -> Seq a -> Seq b -> Ordering Source #
Read1 Seq | Since: containers-0.5.9
Instance details Defined in Data.Sequence.Internal Methods liftReadsPrec :: (Int -> ReadS a) -> ReadS [a] -> Int -> ReadS (Seq a) Source # liftReadList :: (Int -> ReadS a) -> ReadS [a] -> ReadS [Seq a] Source # liftReadPrec :: ReadPrec a -> ReadPrec [a] -> ReadPrec (Seq a) Source # liftReadListPrec :: ReadPrec a -> ReadPrec [a] -> ReadPrec [Seq a] Source #
Show1 Seq | Since: containers-0.5.9
Instance details Defined in Data.Sequence.Internal Methods liftShowsPrec :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> Int -> Seq a -> ShowS Source # liftShowList :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> [Seq a] -> ShowS Source #

MonadZip Seq

     mzipWith = zipWith

     munzip = unzip

Instance details Defined in Data.Sequence.Internal Methods mzip :: Seq a -> Seq b -> Seq (a, b) Source # mzipWith :: (a -> b -> c) -> Seq a -> Seq b -> Seq c Source # munzip :: Seq (a, b) -> (Seq a, Seq b) Source #
Alternative Seq | Since: containers-0.5.4
Instance details Defined in Data.Sequence.Internal Methods empty :: Seq a Source # (<|>) :: Seq a -> Seq a -> Seq a Source # some :: Seq a -> Seq [a] Source # many :: Seq a -> Seq [a] Source #
MonadPlus Seq |
Instance details Defined in Data.Sequence.Internal Methods mzero :: Seq a Source # mplus :: Seq a -> Seq a -> Seq a Source #
UnzipWith Seq |
Instance details Defined in Data.Sequence.Internal Methods unzipWith' :: (x -> (a, b)) -> Seq x -> (Seq a, Seq b)
IsList (Seq a) |
Instance details Defined in Data.Sequence.Internal Associated Types type Item (Seq a) :: Type Source # Methods fromList :: [Item (Seq a)] -> Seq a Source # fromListN :: Int -> [Item (Seq a)] -> Seq a Source # toList :: Seq a -> [Item (Seq a)] Source #
Eq a => Eq (Seq a) |
Instance details Defined in Data.Sequence.Internal Methods (==) :: Seq a -> Seq a -> Bool Source # (/=) :: Seq a -> Seq a -> Bool Source #
Data a => Data (Seq a) |

Instance details

Defined in Data.Sequence.Internal

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Seq a -> c (Seq a) Source #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Seq a) Source #

toConstr :: Seq a -> Constr Source #

dataTypeOf :: Seq a -> DataType Source #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Seq a)) Source #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Seq a)) Source #

gmapT :: (forall b. Data b => b -> b) -> Seq a -> Seq a Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Seq a -> r Source #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Seq a -> r Source #

gmapQ :: (forall d. Data d => d -> u) -> Seq a -> [u] Source #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Seq a -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Seq a -> m (Seq a) Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Seq a -> m (Seq a) Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Seq a -> m (Seq a) Source #

Ord a => Ord (Seq a) |
Instance details Defined in Data.Sequence.Internal Methods compare :: Seq a -> Seq a -> Ordering Source # (<) :: Seq a -> Seq a -> Bool Source # (<=) :: Seq a -> Seq a -> Bool Source # (>) :: Seq a -> Seq a -> Bool Source # (>=) :: Seq a -> Seq a -> Bool Source # max :: Seq a -> Seq a -> Seq a Source # min :: Seq a -> Seq a -> Seq a Source #
Read a => Read (Seq a) |
Instance details Defined in Data.Sequence.Internal Methods readsPrec :: Int -> ReadS (Seq a) Source # readList :: ReadS [Seq a] Source # readPrec :: ReadPrec (Seq a) Source # readListPrec :: ReadPrec [Seq a] Source #
Show a => Show (Seq a) |
Instance details Defined in Data.Sequence.Internal Methods showsPrec :: Int -> Seq a -> ShowS Source # show :: Seq a -> String Source # showList :: [Seq a] -> ShowS Source #
a ~ Char => IsString (Seq a) | Since: containers-0.5.7
Instance details Defined in Data.Sequence.Internal Methods fromString :: String -> Seq a Source #
Semigroup (Seq a) | Since: containers-0.5.7
Instance details Defined in Data.Sequence.Internal Methods (<>) :: Seq a -> Seq a -> Seq a Source # sconcat :: NonEmpty (Seq a) -> Seq a Source # stimes :: Integral b => b -> Seq a -> Seq a Source #
Monoid (Seq a) |
Instance details Defined in Data.Sequence.Internal Methods mempty :: Seq a Source # mappend :: Seq a -> Seq a -> Seq a Source # mconcat :: [Seq a] -> Seq a Source #
NFData a => NFData (Seq a) |
Instance details Defined in Data.Sequence.Internal Methods rnf :: Seq a -> () Source #
Serialise a => Serialise (Seq a) | Since: serialise-0.2.0.0
Instance details Defined in Codec.Serialise.Class Methods encode :: Seq a -> Encoding Source # decode :: Decoder s (Seq a) Source # encodeList :: [Seq a] -> Encoding Source # decodeList :: Decoder s [Seq a] Source #
Inject a => Inject (Seq a) Source # |
Instance details Defined in Dhall Methods injectWith :: InterpretOptions -> InputType (Seq a) Source #
Interpret a => Interpret (Seq a) Source # |
Instance details Defined in Dhall Methods autoWith :: InterpretOptions -> Type (Seq a) Source #
type Item (Seq a) |
Instance details Defined in Data.Sequence.Internal type Item (Seq a) = a

data Text Source #

A space efficient, packed, unboxed Unicode text type.

Instances

FoldCase Text |
Instance details Defined in Data.CaseInsensitive.Internal Methods foldCase :: Text -> Text Source # foldCaseList :: [Text] -> [Text]
Stream Text |

Instance details

Defined in Text.Megaparsec.Stream

Associated Types

type Token Text :: Type Source #

type Tokens Text :: Type Source #

Methods

tokenToChunk :: Proxy Text -> Token Text -> Tokens Text Source #

tokensToChunk :: Proxy Text -> [Token Text] -> Tokens Text Source #

chunkToTokens :: Proxy Text -> Tokens Text -> [Token Text] Source #

chunkLength :: Proxy Text -> Tokens Text -> Int Source #

chunkEmpty :: Proxy Text -> Tokens Text -> Bool Source #

take1_ :: Text -> Maybe (Token Text, Text) Source #

takeN_ :: Int -> Text -> Maybe (Tokens Text, Text) Source #

takeWhile_ :: (Token Text -> Bool) -> Text -> (Tokens Text, Text) Source #

showTokens :: Proxy Text -> NonEmpty (Token Text) -> String Source #

reachOffset :: Int -> PosState Text -> (SourcePos, String, PosState Text) Source #

reachOffsetNoLine :: Int -> PosState Text -> (SourcePos, PosState Text) Source #

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.

Instance details Defined in Data.Text.Prettyprint.Doc.Internal Methods pretty :: Text -> Doc ann Source # prettyList :: [Text] -> Doc ann Source #
Serialise Text | Since: serialise-0.2.0.0
Instance details Defined in Codec.Serialise.Class Methods encode :: Text -> Encoding Source # decode :: Decoder s Text Source # encodeList :: [Text] -> Encoding Source # decodeList :: Decoder s [Text] Source #
Hashable Text |
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> Text -> Int hash :: Text -> Int
Chunk Text |
Instance details Defined in Data.Attoparsec.Internal.Types Associated Types type ChunkElem Text :: Type Methods nullChunk :: Text -> Bool pappendChunk :: State Text -> Text -> State Text atBufferEnd :: Text -> State Text -> Pos bufferElemAt :: Text -> Pos -> State Text -> Maybe (ChunkElem Text, Int) chunkElemToChar :: Text -> ChunkElem Text -> Char
Inject Text Source # |
Instance details Defined in Dhall Methods injectWith :: InterpretOptions -> InputType Text Source #
Interpret Text Source # |
Instance details Defined in Dhall Methods autoWith :: InterpretOptions -> Type Text Source #
MonadParsec Void Text Parser Source # |

Instance details

Defined in Dhall.Parser.Combinators

Methods

failure :: Maybe (ErrorItem (Token Text)) -> Set (ErrorItem (Token Text)) -> Parser a Source #

fancyFailure :: Set (ErrorFancy Void) -> Parser a Source #

label :: String -> Parser a -> Parser a Source #

hidden :: Parser a -> Parser a Source #

try :: Parser a -> Parser a Source #

lookAhead :: Parser a -> Parser a Source #

notFollowedBy :: Parser a -> Parser () Source #

withRecovery :: (ParseError Text Void -> Parser a) -> Parser a -> Parser a Source #

observing :: Parser a -> Parser (Either (ParseError Text Void) a) Source #

eof :: Parser () Source #

token :: (Token Text -> Maybe a) -> Set (ErrorItem (Token Text)) -> Parser a Source #

tokens :: (Tokens Text -> Tokens Text -> Bool) -> Tokens Text -> Parser (Tokens Text) Source #

takeWhileP :: Maybe String -> (Token Text -> Bool) -> Parser (Tokens Text) Source #

takeWhile1P :: Maybe String -> (Token Text -> Bool) -> Parser (Tokens Text) Source #

takeP :: Maybe String -> Int -> Parser (Tokens Text) Source #

getParserState :: Parser (State Text) Source #

updateParserState :: (State Text -> State Text) -> Parser () Source #

Monad m => Stream Text m Char |
Instance details Defined in Text.Parsec.Prim Methods uncons :: Text -> m (Maybe (Char, Text)) Source #
type Item Text |
Instance details Defined in Data.Text type Item Text = Char
type Tokens Text |
Instance details Defined in Text.Megaparsec.Stream type Tokens Text = Text
type Token Text |
Instance details Defined in Text.Megaparsec.Stream type Token Text = Char
type State Text |
Instance details Defined in Data.Attoparsec.Internal.Types type State Text = Buffer
type ChunkElem Text |
Instance details Defined in Data.Attoparsec.Internal.Types type ChunkElem Text = Char

data Vector a Source #

Boxed vectors, supporting efficient slicing.

Instances

Monad Vector |
Instance details Defined in Data.Vector Methods (>>=) :: Vector a -> (a -> Vector b) -> Vector b Source # (>>) :: Vector a -> Vector b -> Vector b Source # return :: a -> Vector a Source # fail :: String -> Vector a Source #
Functor Vector |
Instance details Defined in Data.Vector Methods fmap :: (a -> b) -> Vector a -> Vector b Source # (<$) :: a -> Vector b -> Vector a Source #
MonadFail Vector |
Instance details Defined in Data.Vector Methods fail :: String -> Vector a Source #
Applicative Vector |
Instance details Defined in Data.Vector Methods pure :: a -> Vector a Source # (<*>) :: Vector (a -> b) -> Vector a -> Vector b Source # liftA2 :: (a -> b -> c) -> Vector a -> Vector b -> Vector c Source # (*>) :: Vector a -> Vector b -> Vector b Source # (<*) :: Vector a -> Vector b -> Vector a Source #
Foldable Vector |

Instance details

Defined in Data.Vector

Methods

fold :: Monoid m => Vector m -> m Source #

foldMap :: Monoid m => (a -> m) -> Vector a -> m Source #

foldr :: (a -> b -> b) -> b -> Vector a -> b Source #

foldr' :: (a -> b -> b) -> b -> Vector a -> b Source #

foldl :: (b -> a -> b) -> b -> Vector a -> b Source #

foldl' :: (b -> a -> b) -> b -> Vector a -> b Source #

foldr1 :: (a -> a -> a) -> Vector a -> a Source #

foldl1 :: (a -> a -> a) -> Vector a -> a Source #

toList :: Vector a -> [a] Source #

null :: Vector a -> Bool Source #

length :: Vector a -> Int Source #

elem :: Eq a => a -> Vector a -> Bool Source #

maximum :: Ord a => Vector a -> a Source #

minimum :: Ord a => Vector a -> a Source #

sum :: Num a => Vector a -> a Source #

product :: Num a => Vector a -> a Source #

Traversable Vector |
Instance details Defined in Data.Vector Methods traverse :: Applicative f => (a -> f b) -> Vector a -> f (Vector b) Source # sequenceA :: Applicative f => Vector (f a) -> f (Vector a) Source # mapM :: Monad m => (a -> m b) -> Vector a -> m (Vector b) Source # sequence :: Monad m => Vector (m a) -> m (Vector a) Source #
Eq1 Vector |
Instance details Defined in Data.Vector Methods liftEq :: (a -> b -> Bool) -> Vector a -> Vector b -> Bool Source #
Ord1 Vector |
Instance details Defined in Data.Vector Methods liftCompare :: (a -> b -> Ordering) -> Vector a -> Vector b -> Ordering Source #
Read1 Vector |
Instance details Defined in Data.Vector Methods liftReadsPrec :: (Int -> ReadS a) -> ReadS [a] -> Int -> ReadS (Vector a) Source # liftReadList :: (Int -> ReadS a) -> ReadS [a] -> ReadS [Vector a] Source # liftReadPrec :: ReadPrec a -> ReadPrec [a] -> ReadPrec (Vector a) Source # liftReadListPrec :: ReadPrec a -> ReadPrec [a] -> ReadPrec [Vector a] Source #
Show1 Vector |
Instance details Defined in Data.Vector Methods liftShowsPrec :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> Int -> Vector a -> ShowS Source # liftShowList :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> [Vector a] -> ShowS Source #
MonadZip Vector |
Instance details Defined in Data.Vector Methods mzip :: Vector a -> Vector b -> Vector (a, b) Source # mzipWith :: (a -> b -> c) -> Vector a -> Vector b -> Vector c Source # munzip :: Vector (a, b) -> (Vector a, Vector b) Source #
Alternative Vector |
Instance details Defined in Data.Vector Methods empty :: Vector a Source # (<|>) :: Vector a -> Vector a -> Vector a Source # some :: Vector a -> Vector [a] Source # many :: Vector a -> Vector [a] Source #
MonadPlus Vector |
Instance details Defined in Data.Vector Methods mzero :: Vector a Source # mplus :: Vector a -> Vector a -> Vector a Source #
Vector Vector a |

Instance details

Defined in Data.Vector

Methods

basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) a -> m (Vector a) Source #

basicUnsafeThaw :: PrimMonad m => Vector a -> m (Mutable Vector (PrimState m) a) Source #

basicLength :: Vector a -> Int Source #

basicUnsafeSlice :: Int -> Int -> Vector a -> Vector a Source #

basicUnsafeIndexM :: Monad m => Vector a -> Int -> m a Source #

basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) a -> Vector a -> m () Source #

elemseq :: Vector a -> a -> b -> b Source #

IsList (Vector a) |
Instance details Defined in Data.Vector Associated Types type Item (Vector a) :: Type Source # Methods fromList :: [Item (Vector a)] -> Vector a Source # fromListN :: Int -> [Item (Vector a)] -> Vector a Source # toList :: Vector a -> [Item (Vector a)] Source #
Eq a => Eq (Vector a) |
Instance details Defined in Data.Vector Methods (==) :: Vector a -> Vector a -> Bool Source # (/=) :: Vector a -> Vector a -> Bool Source #
Data a => Data (Vector a) |

Instance details

Defined in Data.Vector

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Vector a -> c (Vector a) Source #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Vector a) Source #

toConstr :: Vector a -> Constr Source #

dataTypeOf :: Vector a -> DataType Source #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Vector a)) Source #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Vector a)) Source #

gmapT :: (forall b. Data b => b -> b) -> Vector a -> Vector a Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Vector a -> r Source #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Vector a -> r Source #

gmapQ :: (forall d. Data d => d -> u) -> Vector a -> [u] Source #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Vector a -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Vector a -> m (Vector a) Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Vector a -> m (Vector a) Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Vector a -> m (Vector a) Source #

Ord a => Ord (Vector a) |
Instance details Defined in Data.Vector Methods compare :: Vector a -> Vector a -> Ordering Source # (<) :: Vector a -> Vector a -> Bool Source # (<=) :: Vector a -> Vector a -> Bool Source # (>) :: Vector a -> Vector a -> Bool Source # (>=) :: Vector a -> Vector a -> Bool Source # max :: Vector a -> Vector a -> Vector a Source # min :: Vector a -> Vector a -> Vector a Source #
Read a => Read (Vector a) |
Instance details Defined in Data.Vector Methods readsPrec :: Int -> ReadS (Vector a) Source # readList :: ReadS [Vector a] Source # readPrec :: ReadPrec (Vector a) Source # readListPrec :: ReadPrec [Vector a] Source #
Show a => Show (Vector a) |
Instance details Defined in Data.Vector Methods showsPrec :: Int -> Vector a -> ShowS Source # show :: Vector a -> String Source # showList :: [Vector a] -> ShowS Source #
Semigroup (Vector a) |
Instance details Defined in Data.Vector Methods (<>) :: Vector a -> Vector a -> Vector a Source # sconcat :: NonEmpty (Vector a) -> Vector a Source # stimes :: Integral b => b -> Vector a -> Vector a Source #
Monoid (Vector a) |
Instance details Defined in Data.Vector Methods mempty :: Vector a Source # mappend :: Vector a -> Vector a -> Vector a Source # mconcat :: [Vector a] -> Vector a Source #
NFData a => NFData (Vector a) |
Instance details Defined in Data.Vector Methods rnf :: Vector a -> () Source #
Serialise a => Serialise (Vector a) | Since: serialise-0.2.0.0
Instance details Defined in Codec.Serialise.Class Methods encode :: Vector a -> Encoding Source # decode :: Decoder s (Vector a) Source # encodeList :: [Vector a] -> Encoding Source # decodeList :: Decoder s [Vector a] Source #
Inject a => Inject (Vector a) Source # |
Instance details Defined in Dhall Methods injectWith :: InterpretOptions -> InputType (Vector a) Source #
Interpret a => Interpret (Vector a) Source # |
Instance details Defined in Dhall Methods autoWith :: InterpretOptions -> Type (Vector a) Source #
type Mutable Vector |
Instance details Defined in Data.Vector type Mutable Vector = MVector
type Item (Vector a) |
Instance details Defined in Data.Vector type Item (Vector a) = a

class Generic a Source #

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 Bool |
Instance details Defined in GHC.Generics Associated Types type Rep Bool :: Type -> Type Source # Methods from :: Bool -> Rep Bool x Source # to :: Rep Bool x -> Bool Source #
Generic Ordering |
Instance details Defined in GHC.Generics Associated Types type Rep Ordering :: Type -> Type Source # Methods from :: Ordering -> Rep Ordering x Source # to :: Rep Ordering x -> Ordering Source #
Generic Exp |
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep Exp :: Type -> Type Source # Methods from :: Exp -> Rep Exp x Source # to :: Rep Exp x -> Exp Source #
Generic Match |
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep Match :: Type -> Type Source # Methods from :: Match -> Rep Match x Source # to :: Rep Match x -> Match Source #
Generic Clause |
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep Clause :: Type -> Type Source # Methods from :: Clause -> Rep Clause x Source # to :: Rep Clause x -> Clause Source #
Generic Pat |
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep Pat :: Type -> Type Source # Methods from :: Pat -> Rep Pat x Source # to :: Rep Pat x -> Pat Source #
Generic Type |
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep Type :: Type -> Type Source # Methods from :: Type -> Rep Type x Source # to :: Rep Type x -> Type Source #
Generic Dec |
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep Dec :: Type -> Type Source # Methods from :: Dec -> Rep Dec x Source # to :: Rep Dec x -> Dec Source #
Generic Name |
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep Name :: Type -> Type Source # Methods from :: Name -> Rep Name x Source # to :: Rep Name x -> Name Source #
Generic FunDep |
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep FunDep :: Type -> Type Source # Methods from :: FunDep -> Rep FunDep x Source # to :: Rep FunDep x -> FunDep Source #
Generic InjectivityAnn |
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep InjectivityAnn :: Type -> Type Source # Methods from :: InjectivityAnn -> Rep InjectivityAnn x Source # to :: Rep InjectivityAnn x -> InjectivityAnn Source #
Generic Overlap |
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep Overlap :: Type -> Type Source # Methods from :: Overlap -> Rep Overlap x Source # to :: Rep Overlap x -> Overlap Source #
Generic () |
Instance details Defined in GHC.Generics Associated Types type Rep () :: Type -> Type Source # Methods from :: () -> Rep () x Source # to :: Rep () x -> () Source #
Generic Void |
Instance details Defined in Data.Void Associated Types type Rep Void :: Type -> Type Source # Methods from :: Void -> Rep Void x Source # to :: Rep Void x -> Void Source #
Generic Version |
Instance details Defined in Data.Version Associated Types type Rep Version :: Type -> Type Source # Methods from :: Version -> Rep Version x Source # to :: Rep Version x -> Version Source #
Generic ExitCode |
Instance details Defined in GHC.IO.Exception Associated Types type Rep ExitCode :: Type -> Type Source # Methods from :: ExitCode -> Rep ExitCode x Source # to :: Rep ExitCode x -> ExitCode Source #
Generic All |
Instance details Defined in Data.Semigroup.Internal Associated Types type Rep All :: Type -> Type Source # Methods from :: All -> Rep All x Source # to :: Rep All x -> All Source #
Generic Any |
Instance details Defined in Data.Semigroup.Internal Associated Types type Rep Any :: Type -> Type Source # Methods from :: Any -> Rep Any x Source # to :: Rep Any x -> Any Source #
Generic Fixity |
Instance details Defined in GHC.Generics Associated Types type Rep Fixity :: Type -> Type Source # Methods from :: Fixity -> Rep Fixity x Source # to :: Rep Fixity x -> Fixity Source #
Generic Associativity |
Instance details Defined in GHC.Generics Associated Types type Rep Associativity :: Type -> Type Source # Methods from :: Associativity -> Rep Associativity x Source # to :: Rep Associativity x -> Associativity Source #
Generic SourceUnpackedness |
Instance details Defined in GHC.Generics Associated Types type Rep SourceUnpackedness :: Type -> Type Source # Methods from :: SourceUnpackedness -> Rep SourceUnpackedness x Source # to :: Rep SourceUnpackedness x -> SourceUnpackedness Source #
Generic SourceStrictness |
Instance details Defined in GHC.Generics Associated Types type Rep SourceStrictness :: Type -> Type Source # Methods from :: SourceStrictness -> Rep SourceStrictness x Source # to :: Rep SourceStrictness x -> SourceStrictness Source #
Generic DecidedStrictness |
Instance details Defined in GHC.Generics Associated Types type Rep DecidedStrictness :: Type -> Type Source # Methods from :: DecidedStrictness -> Rep DecidedStrictness x Source # to :: Rep DecidedStrictness x -> DecidedStrictness Source #
Generic Extension |
Instance details Defined in GHC.LanguageExtensions.Type Associated Types type Rep Extension :: Type -> Type Source # Methods from :: Extension -> Rep Extension x Source # to :: Rep Extension x -> Extension Source #
Generic ForeignSrcLang |
Instance details Defined in GHC.ForeignSrcLang.Type Associated Types type Rep ForeignSrcLang :: Type -> Type Source # Methods from :: ForeignSrcLang -> Rep ForeignSrcLang x Source # to :: Rep ForeignSrcLang x -> ForeignSrcLang Source #
Generic URI |
Instance details Defined in Network.URI Associated Types type Rep URI :: Type -> Type Source # Methods from :: URI -> Rep URI x Source # to :: Rep URI x -> URI Source #
Generic InvalidPosException |
Instance details Defined in Text.Megaparsec.Pos Associated Types type Rep InvalidPosException :: Type -> Type Source # Methods from :: InvalidPosException -> Rep InvalidPosException x Source # to :: Rep InvalidPosException x -> InvalidPosException Source #
Generic SourcePos |
Instance details Defined in Text.Megaparsec.Pos Associated Types type Rep SourcePos :: Type -> Type Source # Methods from :: SourcePos -> Rep SourcePos x Source # to :: Rep SourcePos x -> SourcePos Source #
Generic Doc |
Instance details Defined in Text.PrettyPrint.HughesPJ Associated Types type Rep Doc :: Type -> Type Source # Methods from :: Doc -> Rep Doc x Source # to :: Rep Doc x -> Doc Source #
Generic TextDetails |
Instance details Defined in Text.PrettyPrint.Annotated.HughesPJ Associated Types type Rep TextDetails :: Type -> Type Source # Methods from :: TextDetails -> Rep TextDetails x Source # to :: Rep TextDetails x -> TextDetails Source #
Generic Style |
Instance details Defined in Text.PrettyPrint.Annotated.HughesPJ Associated Types type Rep Style :: Type -> Type Source # Methods from :: Style -> Rep Style x Source # to :: Rep Style x -> Style Source #
Generic Mode |
Instance details Defined in Text.PrettyPrint.Annotated.HughesPJ Associated Types type Rep Mode :: Type -> Type Source # Methods from :: Mode -> Rep Mode x Source # to :: Rep Mode x -> Mode Source #
Generic ModName |
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep ModName :: Type -> Type Source # Methods from :: ModName -> Rep ModName x Source # to :: Rep ModName x -> ModName Source #
Generic PkgName |
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep PkgName :: Type -> Type Source # Methods from :: PkgName -> Rep PkgName x Source # to :: Rep PkgName x -> PkgName Source #
Generic Module |
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep Module :: Type -> Type Source # Methods from :: Module -> Rep Module x Source # to :: Rep Module x -> Module Source #
Generic OccName |
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep OccName :: Type -> Type Source # Methods from :: OccName -> Rep OccName x Source # to :: Rep OccName x -> OccName Source #
Generic NameFlavour |
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep NameFlavour :: Type -> Type Source # Methods from :: NameFlavour -> Rep NameFlavour x Source # to :: Rep NameFlavour x -> NameFlavour Source #
Generic NameSpace |
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep NameSpace :: Type -> Type Source # Methods from :: NameSpace -> Rep NameSpace x Source # to :: Rep NameSpace x -> NameSpace Source #
Generic Loc |
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep Loc :: Type -> Type Source # Methods from :: Loc -> Rep Loc x Source # to :: Rep Loc x -> Loc Source #
Generic Info |
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep Info :: Type -> Type Source # Methods from :: Info -> Rep Info x Source # to :: Rep Info x -> Info Source #
Generic ModuleInfo |
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep ModuleInfo :: Type -> Type Source # Methods from :: ModuleInfo -> Rep ModuleInfo x Source # to :: Rep ModuleInfo x -> ModuleInfo Source #
Generic Fixity |
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep Fixity :: Type -> Type Source # Methods from :: Fixity -> Rep Fixity x Source # to :: Rep Fixity x -> Fixity Source #
Generic FixityDirection |
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep FixityDirection :: Type -> Type Source # Methods from :: FixityDirection -> Rep FixityDirection x Source # to :: Rep FixityDirection x -> FixityDirection Source #
Generic Lit |
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep Lit :: Type -> Type Source # Methods from :: Lit -> Rep Lit x Source # to :: Rep Lit x -> Lit Source #
Generic Body |
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep Body :: Type -> Type Source # Methods from :: Body -> Rep Body x Source # to :: Rep Body x -> Body Source #
Generic Guard |
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep Guard :: Type -> Type Source # Methods from :: Guard -> Rep Guard x Source # to :: Rep Guard x -> Guard Source #
Generic Stmt |
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep Stmt :: Type -> Type Source # Methods from :: Stmt -> Rep Stmt x Source # to :: Rep Stmt x -> Stmt Source #
Generic Range |
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep Range :: Type -> Type Source # Methods from :: Range -> Rep Range x Source # to :: Rep Range x -> Range Source #
Generic DerivClause |
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep DerivClause :: Type -> Type Source # Methods from :: DerivClause -> Rep DerivClause x Source # to :: Rep DerivClause x -> DerivClause Source #
Generic DerivStrategy |
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep DerivStrategy :: Type -> Type Source # Methods from :: DerivStrategy -> Rep DerivStrategy x Source # to :: Rep DerivStrategy x -> DerivStrategy Source #
Generic TypeFamilyHead |
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep TypeFamilyHead :: Type -> Type Source # Methods from :: TypeFamilyHead -> Rep TypeFamilyHead x Source # to :: Rep TypeFamilyHead x -> TypeFamilyHead Source #
Generic TySynEqn |
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep TySynEqn :: Type -> Type Source # Methods from :: TySynEqn -> Rep TySynEqn x Source # to :: Rep TySynEqn x -> TySynEqn Source #
Generic Foreign |
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep Foreign :: Type -> Type Source # Methods from :: Foreign -> Rep Foreign x Source # to :: Rep Foreign x -> Foreign Source #
Generic Callconv |
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep Callconv :: Type -> Type Source # Methods from :: Callconv -> Rep Callconv x Source # to :: Rep Callconv x -> Callconv Source #
Generic Safety |
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep Safety :: Type -> Type Source # Methods from :: Safety -> Rep Safety x Source # to :: Rep Safety x -> Safety Source #
Generic Pragma |
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep Pragma :: Type -> Type Source # Methods from :: Pragma -> Rep Pragma x Source # to :: Rep Pragma x -> Pragma Source #
Generic Inline |
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep Inline :: Type -> Type Source # Methods from :: Inline -> Rep Inline x Source # to :: Rep Inline x -> Inline Source #
Generic RuleMatch |
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep RuleMatch :: Type -> Type Source # Methods from :: RuleMatch -> Rep RuleMatch x Source # to :: Rep RuleMatch x -> RuleMatch Source #
Generic Phases |
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep Phases :: Type -> Type Source # Methods from :: Phases -> Rep Phases x Source # to :: Rep Phases x -> Phases Source #
Generic RuleBndr |
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep RuleBndr :: Type -> Type Source # Methods from :: RuleBndr -> Rep RuleBndr x Source # to :: Rep RuleBndr x -> RuleBndr Source #
Generic AnnTarget |
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep AnnTarget :: Type -> Type Source # Methods from :: AnnTarget -> Rep AnnTarget x Source # to :: Rep AnnTarget x -> AnnTarget Source #
Generic SourceUnpackedness |
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep SourceUnpackedness :: Type -> Type Source # Methods from :: SourceUnpackedness -> Rep SourceUnpackedness x Source # to :: Rep SourceUnpackedness x -> SourceUnpackedness Source #
Generic SourceStrictness |
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep SourceStrictness :: Type -> Type Source # Methods from :: SourceStrictness -> Rep SourceStrictness x Source # to :: Rep SourceStrictness x -> SourceStrictness Source #
Generic DecidedStrictness |
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep DecidedStrictness :: Type -> Type Source # Methods from :: DecidedStrictness -> Rep DecidedStrictness x Source # to :: Rep DecidedStrictness x -> DecidedStrictness Source #
Generic Con |
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep Con :: Type -> Type Source # Methods from :: Con -> Rep Con x Source # to :: Rep Con x -> Con Source #
Generic Bang |
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep Bang :: Type -> Type Source # Methods from :: Bang -> Rep Bang x Source # to :: Rep Bang x -> Bang Source #
Generic PatSynDir |
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep PatSynDir :: Type -> Type Source # Methods from :: PatSynDir -> Rep PatSynDir x Source # to :: Rep PatSynDir x -> PatSynDir Source #
Generic PatSynArgs |
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep PatSynArgs :: Type -> Type Source # Methods from :: PatSynArgs -> Rep PatSynArgs x Source # to :: Rep PatSynArgs x -> PatSynArgs Source #
Generic TyVarBndr |
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep TyVarBndr :: Type -> Type Source # Methods from :: TyVarBndr -> Rep TyVarBndr x Source # to :: Rep TyVarBndr x -> TyVarBndr Source #
Generic FamilyResultSig |
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep FamilyResultSig :: Type -> Type Source # Methods from :: FamilyResultSig -> Rep FamilyResultSig x Source # to :: Rep FamilyResultSig x -> FamilyResultSig Source #
Generic TyLit |
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep TyLit :: Type -> Type Source # Methods from :: TyLit -> Rep TyLit x Source # to :: Rep TyLit x -> TyLit Source #
Generic Role |
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep Role :: Type -> Type Source # Methods from :: Role -> Rep Role x Source # to :: Rep Role x -> Role Source #
Generic AnnLookup |
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep AnnLookup :: Type -> Type Source # Methods from :: AnnLookup -> Rep AnnLookup x Source # to :: Rep AnnLookup x -> AnnLookup Source #
Generic Var Source # |
Instance details Defined in Dhall.Core Associated Types type Rep Var :: Type -> Type Source # Methods from :: Var -> Rep Var x Source # to :: Rep Var x -> Var Source #
Generic Const Source # |
Instance details Defined in Dhall.Core Associated Types type Rep Const :: Type -> Type Source # Methods from :: Const -> Rep Const x Source # to :: Rep Const x -> Const Source #
Generic Import Source # |
Instance details Defined in Dhall.Core Associated Types type Rep Import :: Type -> Type Source # Methods from :: Import -> Rep Import x Source # to :: Rep Import x -> Import Source #
Generic ImportHashed Source # |
Instance details Defined in Dhall.Core Associated Types type Rep ImportHashed :: Type -> Type Source # Methods from :: ImportHashed -> Rep ImportHashed x Source # to :: Rep ImportHashed x -> ImportHashed Source #
Generic ImportMode Source # |
Instance details Defined in Dhall.Core Associated Types type Rep ImportMode :: Type -> Type Source # Methods from :: ImportMode -> Rep ImportMode x Source # to :: Rep ImportMode x -> ImportMode Source #
Generic ImportType Source # |
Instance details Defined in Dhall.Core Associated Types type Rep ImportType :: Type -> Type Source # Methods from :: ImportType -> Rep ImportType x Source # to :: Rep ImportType x -> ImportType Source #
Generic URL Source # |
Instance details Defined in Dhall.Core Associated Types type Rep URL :: Type -> Type Source # Methods from :: URL -> Rep URL x Source # to :: Rep URL x -> URL Source #
Generic Scheme Source # |
Instance details Defined in Dhall.Core Associated Types type Rep Scheme :: Type -> Type Source # Methods from :: Scheme -> Rep Scheme x Source # to :: Rep Scheme x -> Scheme Source #
Generic FilePrefix Source # |
Instance details Defined in Dhall.Core Associated Types type Rep FilePrefix :: Type -> Type Source # Methods from :: FilePrefix -> Rep FilePrefix x Source # to :: Rep FilePrefix x -> FilePrefix Source #
Generic File Source # |
Instance details Defined in Dhall.Core Associated Types type Rep File :: Type -> Type Source # Methods from :: File -> Rep File x Source # to :: Rep File x -> File Source #
Generic Directory Source # |
Instance details Defined in Dhall.Core Associated Types type Rep Directory :: Type -> Type Source # Methods from :: Directory -> Rep Directory x Source # to :: Rep Directory x -> Directory Source #
Generic Half |
Instance details Defined in Numeric.Half Associated Types type Rep Half :: Type -> Type Source # Methods from :: Half -> Rep Half x Source # to :: Rep Half x -> Half Source #
Generic CompressionLevel |
Instance details Defined in Codec.Compression.Zlib.Stream Associated Types type Rep CompressionLevel :: Type -> Type Source # Methods from :: CompressionLevel -> Rep CompressionLevel x Source # to :: Rep CompressionLevel x -> CompressionLevel Source #
Generic CompressionStrategy |
Instance details Defined in Codec.Compression.Zlib.Stream Associated Types type Rep CompressionStrategy :: Type -> Type Source # Methods from :: CompressionStrategy -> Rep CompressionStrategy x Source # to :: Rep CompressionStrategy x -> CompressionStrategy Source #
Generic Format |
Instance details Defined in Codec.Compression.Zlib.Stream Associated Types type Rep Format :: Type -> Type Source # Methods from :: Format -> Rep Format x Source # to :: Rep Format x -> Format Source #
Generic MemoryLevel |
Instance details Defined in Codec.Compression.Zlib.Stream Associated Types type Rep MemoryLevel :: Type -> Type Source # Methods from :: MemoryLevel -> Rep MemoryLevel x Source # to :: Rep MemoryLevel x -> MemoryLevel Source #
Generic Method |
Instance details Defined in Codec.Compression.Zlib.Stream Associated Types type Rep Method :: Type -> Type Source # Methods from :: Method -> Rep Method x Source # to :: Rep Method x -> Method Source #
Generic WindowBits |
Instance details Defined in Codec.Compression.Zlib.Stream Associated Types type Rep WindowBits :: Type -> Type Source # Methods from :: WindowBits -> Rep WindowBits x Source # to :: Rep WindowBits x -> WindowBits Source #
Generic [a] |
Instance details Defined in GHC.Generics Associated Types type Rep [a] :: Type -> Type Source # Methods from :: [a] -> Rep [a] x Source # to :: Rep [a] x -> [a] Source #
Generic (Maybe a) |
Instance details Defined in GHC.Generics Associated Types type Rep (Maybe a) :: Type -> Type Source # Methods from :: Maybe a -> Rep (Maybe a) x Source # to :: Rep (Maybe a) x -> Maybe a Source #
Generic (Par1 p) |
Instance details Defined in GHC.Generics Associated Types type Rep (Par1 p) :: Type -> Type Source # Methods from :: Par1 p -> Rep (Par1 p) x Source # to :: Rep (Par1 p) x -> Par1 p Source #
Generic (Complex a) |
Instance details Defined in Data.Complex Associated Types type Rep (Complex a) :: Type -> Type Source # Methods from :: Complex a -> Rep (Complex a) x Source # to :: Rep (Complex a) x -> Complex a Source #
Generic (Min a) |
Instance details Defined in Data.Semigroup Associated Types type Rep (Min a) :: Type -> Type Source # Methods from :: Min a -> Rep (Min a) x Source # to :: Rep (Min a) x -> Min a Source #
Generic (Max a) |
Instance details Defined in Data.Semigroup Associated Types type Rep (Max a) :: Type -> Type Source # Methods from :: Max a -> Rep (Max a) x Source # to :: Rep (Max a) x -> Max a Source #
Generic (First a) |
Instance details Defined in Data.Semigroup Associated Types type Rep (First a) :: Type -> Type Source # Methods from :: First a -> Rep (First a) x Source # to :: Rep (First a) x -> First a Source #
Generic (Last a) |
Instance details Defined in Data.Semigroup Associated Types type Rep (Last a) :: Type -> Type Source # Methods from :: Last a -> Rep (Last a) x Source # to :: Rep (Last a) x -> Last a Source #
Generic (WrappedMonoid m) |
Instance details Defined in Data.Semigroup Associated Types type Rep (WrappedMonoid m) :: Type -> Type Source # Methods from :: WrappedMonoid m -> Rep (WrappedMonoid m) x Source # to :: Rep (WrappedMonoid m) x -> WrappedMonoid m Source #
Generic (Option a) |
Instance details Defined in Data.Semigroup Associated Types type Rep (Option a) :: Type -> Type Source # Methods from :: Option a -> Rep (Option a) x Source # to :: Rep (Option a) x -> Option a Source #
Generic (ZipList a) |
Instance details Defined in Control.Applicative Associated Types type Rep (ZipList a) :: Type -> Type Source # Methods from :: ZipList a -> Rep (ZipList a) x Source # to :: Rep (ZipList a) x -> ZipList a Source #
Generic (Identity a) |
Instance details Defined in Data.Functor.Identity Associated Types type Rep (Identity a) :: Type -> Type Source # Methods from :: Identity a -> Rep (Identity a) x Source # to :: Rep (Identity a) x -> Identity a Source #
Generic (First a) |
Instance details Defined in Data.Monoid Associated Types type Rep (First a) :: Type -> Type Source # Methods from :: First a -> Rep (First a) x Source # to :: Rep (First a) x -> First a Source #
Generic (Last a) |
Instance details Defined in Data.Monoid Associated Types type Rep (Last a) :: Type -> Type Source # Methods from :: Last a -> Rep (Last a) x Source # to :: Rep (Last a) x -> Last a Source #
Generic (Dual a) |
Instance details Defined in Data.Semigroup.Internal Associated Types type Rep (Dual a) :: Type -> Type Source # Methods from :: Dual a -> Rep (Dual a) x Source # to :: Rep (Dual a) x -> Dual a Source #
Generic (Endo a) |
Instance details Defined in Data.Semigroup.Internal Associated Types type Rep (Endo a) :: Type -> Type Source # Methods from :: Endo a -> Rep (Endo a) x Source # to :: Rep (Endo a) x -> Endo a Source #
Generic (Sum a) |
Instance details Defined in Data.Semigroup.Internal Associated Types type Rep (Sum a) :: Type -> Type Source # Methods from :: Sum a -> Rep (Sum a) x Source # to :: Rep (Sum a) x -> Sum a Source #
Generic (Product a) |
Instance details Defined in Data.Semigroup.Internal Associated Types type Rep (Product a) :: Type -> Type Source # Methods from :: Product a -> Rep (Product a) x Source # to :: Rep (Product a) x -> Product a Source #
Generic (Down a) |
Instance details Defined in GHC.Generics Associated Types type Rep (Down a) :: Type -> Type Source # Methods from :: Down a -> Rep (Down a) x Source # to :: Rep (Down a) x -> Down a Source #
Generic (NonEmpty a) |
Instance details Defined in GHC.Generics Associated Types type Rep (NonEmpty a) :: Type -> Type Source # Methods from :: NonEmpty a -> Rep (NonEmpty a) x Source # to :: Rep (NonEmpty a) x -> NonEmpty a Source #
Generic (Tree a) |
Instance details Defined in Data.Tree Associated Types type Rep (Tree a) :: Type -> Type Source # Methods from :: Tree a -> Rep (Tree a) x Source # to :: Rep (Tree a) x -> Tree a Source #
Generic (FingerTree a) |
Instance details Defined in Data.Sequence.Internal Associated Types type Rep (FingerTree a) :: Type -> Type Source # Methods from :: FingerTree a -> Rep (FingerTree a) x Source # to :: Rep (FingerTree a) x -> FingerTree a Source #
Generic (Digit a) |
Instance details Defined in Data.Sequence.Internal Associated Types type Rep (Digit a) :: Type -> Type Source # Methods from :: Digit a -> Rep (Digit a) x Source # to :: Rep (Digit a) x -> Digit a Source #
Generic (Node a) |
Instance details Defined in Data.Sequence.Internal Associated Types type Rep (Node a) :: Type -> Type Source # Methods from :: Node a -> Rep (Node a) x Source # to :: Rep (Node a) x -> Node a Source #
Generic (Elem a) |
Instance details Defined in Data.Sequence.Internal Associated Types type Rep (Elem a) :: Type -> Type Source # Methods from :: Elem a -> Rep (Elem a) x Source # to :: Rep (Elem a) x -> Elem a Source #
Generic (ViewL a) |
Instance details Defined in Data.Sequence.Internal Associated Types type Rep (ViewL a) :: Type -> Type Source # Methods from :: ViewL a -> Rep (ViewL a) x Source # to :: Rep (ViewL a) x -> ViewL a Source #
Generic (ViewR a) |
Instance details Defined in Data.Sequence.Internal Associated Types type Rep (ViewR a) :: Type -> Type Source # Methods from :: ViewR a -> Rep (ViewR a) x Source # to :: Rep (ViewR a) x -> ViewR a Source #
Generic (HistoriedResponse body) |
Instance details Defined in Network.HTTP.Client Associated Types type Rep (HistoriedResponse body) :: Type -> Type Source # Methods from :: HistoriedResponse body -> Rep (HistoriedResponse body) x Source # to :: Rep (HistoriedResponse body) x -> HistoriedResponse body Source #
Generic (ErrorItem t) |
Instance details Defined in Text.Megaparsec.Error Associated Types type Rep (ErrorItem t) :: Type -> Type Source # Methods from :: ErrorItem t -> Rep (ErrorItem t) x Source # to :: Rep (ErrorItem t) x -> ErrorItem t Source #
Generic (ErrorFancy e) |
Instance details Defined in Text.Megaparsec.Error Associated Types type Rep (ErrorFancy e) :: Type -> Type Source # Methods from :: ErrorFancy e -> Rep (ErrorFancy e) x Source # to :: Rep (ErrorFancy e) x -> ErrorFancy e Source #
Generic (State s) |
Instance details Defined in Text.Megaparsec.State Associated Types type Rep (State s) :: Type -> Type Source # Methods from :: State s -> Rep (State s) x Source # to :: Rep (State s) x -> State s Source #
Generic (PosState s) |
Instance details Defined in Text.Megaparsec.State Associated Types type Rep (PosState s) :: Type -> Type Source # Methods from :: PosState s -> Rep (PosState s) x Source # to :: Rep (PosState s) x -> PosState s Source #
Generic (Doc a) |
Instance details Defined in Text.PrettyPrint.Annotated.HughesPJ Associated Types type Rep (Doc a) :: Type -> Type Source # Methods from :: Doc a -> Rep (Doc a) x Source # to :: Rep (Doc a) x -> Doc a Source #
Generic (Doc ann) |
Instance details Defined in Data.Text.Prettyprint.Doc.Internal Associated Types type Rep (Doc ann) :: Type -> Type Source # Methods from :: Doc ann -> Rep (Doc ann) x Source # to :: Rep (Doc ann) x -> Doc ann Source #
Generic (SimpleDocStream ann) |
Instance details Defined in Data.Text.Prettyprint.Doc.Internal Associated Types type Rep (SimpleDocStream ann) :: Type -> Type Source # Methods from :: SimpleDocStream ann -> Rep (SimpleDocStream ann) x Source # to :: Rep (SimpleDocStream ann) x -> SimpleDocStream ann Source #
Generic (Set a) Source # |
Instance details Defined in Dhall.Set Associated Types type Rep (Set a) :: Type -> Type Source # Methods from :: Set a -> Rep (Set a) x Source # to :: Rep (Set a) x -> Set a Source #
Generic (Either a b) |
Instance details Defined in GHC.Generics Associated Types type Rep (Either a b) :: Type -> Type Source # Methods from :: Either a b -> Rep (Either a b) x Source # to :: Rep (Either a b) x -> Either a b Source #
Generic (V1 p) |
Instance details Defined in GHC.Generics Associated Types type Rep (V1 p) :: Type -> Type Source # Methods from :: V1 p -> Rep (V1 p) x Source # to :: Rep (V1 p) x -> V1 p Source #
Generic (U1 p) |
Instance details Defined in GHC.Generics Associated Types type Rep (U1 p) :: Type -> Type Source # Methods from :: U1 p -> Rep (U1 p) x Source # to :: Rep (U1 p) x -> U1 p Source #
Generic (a, b) |
Instance details Defined in GHC.Generics Associated Types type Rep (a, b) :: Type -> Type Source # Methods from :: (a, b) -> Rep (a, b) x Source # to :: Rep (a, b) x -> (a, b) Source #
Generic (Arg a b) |
Instance details Defined in Data.Semigroup Associated Types type Rep (Arg a b) :: Type -> Type Source # Methods from :: Arg a b -> Rep (Arg a b) x Source # to :: Rep (Arg a b) x -> Arg a b Source #
Generic (WrappedMonad m a) |
Instance details Defined in Control.Applicative Associated Types type Rep (WrappedMonad m a) :: Type -> Type Source # Methods from :: WrappedMonad m a -> Rep (WrappedMonad m a) x Source # to :: Rep (WrappedMonad m a) x -> WrappedMonad m a Source #
Generic (Proxy t) |
Instance details Defined in GHC.Generics Associated Types type Rep (Proxy t) :: Type -> Type Source # Methods from :: Proxy t -> Rep (Proxy t) x Source # to :: Rep (Proxy t) x -> Proxy t Source #
Generic (ParseError s e) |
Instance details Defined in Text.Megaparsec.Error Associated Types type Rep (ParseError s e) :: Type -> Type Source # Methods from :: ParseError s e -> Rep (ParseError s e) x Source # to :: Rep (ParseError s e) x -> ParseError s e Source #
Generic (ParseErrorBundle s e) |
Instance details Defined in Text.Megaparsec.Error Associated Types type Rep (ParseErrorBundle s e) :: Type -> Type Source # Methods from :: ParseErrorBundle s e -> Rep (ParseErrorBundle s e) x Source # to :: Rep (ParseErrorBundle s e) x -> ParseErrorBundle s e Source #
Generic (Expr s a) Source # |
Instance details Defined in Dhall.Core Associated Types type Rep (Expr s a) :: Type -> Type Source # Methods from :: Expr s a -> Rep (Expr s a) x Source # to :: Rep (Expr s a) x -> Expr s a Source #
Generic (Chunks s a) Source # |
Instance details Defined in Dhall.Core Associated Types type Rep (Chunks s a) :: Type -> Type Source # Methods from :: Chunks s a -> Rep (Chunks s a) x Source # to :: Rep (Chunks s a) x -> Chunks s a Source #
Generic (Binding s a) Source # |
Instance details Defined in Dhall.Core Associated Types type Rep (Binding s a) :: Type -> Type Source # Methods from :: Binding s a -> Rep (Binding s a) x Source # to :: Rep (Binding s a) x -> Binding s a Source #
Generic (Rec1 f p) |
Instance details Defined in GHC.Generics Associated Types type Rep (Rec1 f p) :: Type -> Type Source # Methods from :: Rec1 f p -> Rep (Rec1 f p) x Source # to :: Rep (Rec1 f p) x -> Rec1 f p Source #
Generic (URec (Ptr ()) p) |
Instance details Defined in GHC.Generics Associated Types type Rep (URec (Ptr ()) p) :: Type -> Type Source # Methods from :: URec (Ptr ()) p -> Rep (URec (Ptr ()) p) x Source # to :: Rep (URec (Ptr ()) p) x -> URec (Ptr ()) p Source #
Generic (URec Char p) |
Instance details Defined in GHC.Generics Associated Types type Rep (URec Char p) :: Type -> Type Source # Methods from :: URec Char p -> Rep (URec Char p) x Source # to :: Rep (URec Char p) x -> URec Char p Source #
Generic (URec Double p) |
Instance details Defined in GHC.Generics Associated Types type Rep (URec Double p) :: Type -> Type Source # Methods from :: URec Double p -> Rep (URec Double p) x Source # to :: Rep (URec Double p) x -> URec Double p Source #
Generic (URec Float p) |
Instance details Defined in GHC.Generics Associated Types type Rep (URec Float p) :: Type -> Type Source # Methods from :: URec Float p -> Rep (URec Float p) x Source # to :: Rep (URec Float p) x -> URec Float p Source #
Generic (URec Int p) |
Instance details Defined in GHC.Generics Associated Types type Rep (URec Int p) :: Type -> Type Source # Methods from :: URec Int p -> Rep (URec Int p) x Source # to :: Rep (URec Int p) x -> URec Int p Source #
Generic (URec Word p) |
Instance details Defined in GHC.Generics Associated Types type Rep (URec Word p) :: Type -> Type Source # Methods from :: URec Word p -> Rep (URec Word p) x Source # to :: Rep (URec Word p) x -> URec Word p Source #
Generic (a, b, c) |
Instance details Defined in GHC.Generics Associated Types type Rep (a, b, c) :: Type -> Type Source # Methods from :: (a, b, c) -> Rep (a, b, c) x Source # to :: Rep (a, b, c) x -> (a, b, c) Source #
Generic (WrappedArrow a b c) |
Instance details Defined in Control.Applicative Associated Types type Rep (WrappedArrow a b c) :: Type -> Type Source # Methods from :: WrappedArrow a b c -> Rep (WrappedArrow a b c) x Source # to :: Rep (WrappedArrow a b c) x -> WrappedArrow a b c Source #
Generic (Const a b) |
Instance details Defined in Data.Functor.Const Associated Types type Rep (Const a b) :: Type -> Type Source # Methods from :: Const a b -> Rep (Const a b) x Source # to :: Rep (Const a b) x -> Const a b Source #
Generic (Ap f a) |
Instance details Defined in Data.Monoid Associated Types type Rep (Ap f a) :: Type -> Type Source # Methods from :: Ap f a -> Rep (Ap f a) x Source # to :: Rep (Ap f a) x -> Ap f a Source #
Generic (Alt f a) |
Instance details Defined in Data.Semigroup.Internal Associated Types type Rep (Alt f a) :: Type -> Type Source # Methods from :: Alt f a -> Rep (Alt f a) x Source # to :: Rep (Alt f a) x -> Alt f a Source #
Generic (K1 i c p) |
Instance details Defined in GHC.Generics Associated Types type Rep (K1 i c p) :: Type -> Type Source # Methods from :: K1 i c p -> Rep (K1 i c p) x Source # to :: Rep (K1 i c p) x -> K1 i c p Source #
Generic ((f :+: g) p) |
Instance details Defined in GHC.Generics Associated Types type Rep ((f :+: g) p) :: Type -> Type Source # Methods from :: (f :+: g) p -> Rep ((f :+: g) p) x Source # to :: Rep ((f :+: g) p) x -> (f :+: g) p Source #
Generic ((f :*: g) p) |
Instance details Defined in GHC.Generics Associated Types type Rep ((f :*: g) p) :: Type -> Type Source # Methods from :: (f :*: g) p -> Rep ((f :*: g) p) x Source # to :: Rep ((f :*: g) p) x -> (f :*: g) p Source #
Generic (a, b, c, d) |
Instance details Defined in GHC.Generics Associated Types type Rep (a, b, c, d) :: Type -> Type Source # Methods from :: (a, b, c, d) -> Rep (a, b, c, d) x Source # to :: Rep (a, b, c, d) x -> (a, b, c, d) Source #
Generic (Product f g a) |
Instance details Defined in Data.Functor.Product Associated Types type Rep (Product f g a) :: Type -> Type Source # Methods from :: Product f g a -> Rep (Product f g a) x Source # to :: Rep (Product f g a) x -> Product f g a Source #
Generic (Sum f g a) |
Instance details Defined in Data.Functor.Sum Associated Types type Rep (Sum f g a) :: Type -> Type Source # Methods from :: Sum f g a -> Rep (Sum f g a) x Source # to :: Rep (Sum f g a) x -> Sum f g a Source #
Generic (M1 i c f p) |
Instance details Defined in GHC.Generics Associated Types type Rep (M1 i c f p) :: Type -> Type Source # Methods from :: M1 i c f p -> Rep (M1 i c f p) x Source # to :: Rep (M1 i c f p) x -> M1 i c f p Source #
Generic ((f :.: g) p) |
Instance details Defined in GHC.Generics Associated Types type Rep ((f :.: g) p) :: Type -> Type Source # Methods from :: (f :.: g) p -> Rep ((f :.: g) p) x Source # to :: Rep ((f :.: g) p) x -> (f :.: g) p Source #
Generic (a, b, c, d, e) |
Instance details Defined in GHC.Generics Associated Types type Rep (a, b, c, d, e) :: Type -> Type Source # Methods from :: (a, b, c, d, e) -> Rep (a, b, c, d, e) x Source # to :: Rep (a, b, c, d, e) x -> (a, b, c, d, e) Source #
Generic (Compose f g a) |
Instance details Defined in Data.Functor.Compose Associated Types type Rep (Compose f g a) :: Type -> Type Source # Methods from :: Compose f g a -> Rep (Compose f g a) x Source # to :: Rep (Compose f g a) x -> Compose f g a Source #
Generic (a, b, c, d, e, f) |
Instance details Defined in GHC.Generics Associated Types type Rep (a, b, c, d, e, f) :: Type -> Type Source # Methods from :: (a, b, c, d, e, f) -> Rep (a, b, c, d, e, f) x Source # to :: Rep (a, b, c, d, e, f) x -> (a, b, c, d, e, f) Source #
Generic (a, b, c, d, e, f, g) |
Instance details Defined in GHC.Generics Associated Types type Rep (a, b, c, d, e, f, g) :: Type -> Type Source # Methods from :: (a, b, c, d, e, f, g) -> Rep (a, b, c, d, e, f, g) x Source # to :: Rep (a, b, c, d, e, f, g) x -> (a, b, c, d, e, f, g) Source #