dhall-1.32.0: A configuration language guaranteed to terminate

Safe Haskell | None
Language | Haskell2010

Dhall

Contents

- Input
- Decoders
- 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 :: Decoder a -> Text -> IO a
- inputWithSettings :: InputSettings -> Decoder a -> Text -> IO a
- inputFile :: Decoder a -> FilePath -> IO a
- inputFileWithSettings :: EvaluateSettings -> Decoder a -> FilePath -> IO a
- inputExpr :: Text -> IO (Expr Src Void)
- inputExprWithSettings :: InputSettings -> Text -> IO (Expr Src Void)
- 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 Void))
- substitutions :: (Functor f, HasEvaluateSettings s) => LensLike' f s (Substitutions Src Void)
- normalizer :: (Functor f, HasEvaluateSettings s) => LensLike' f s (Maybe (ReifiedNormalizer Void))
- defaultInputSettings :: InputSettings
- data InputSettings
- defaultEvaluateSettings :: EvaluateSettings
- data EvaluateSettings
- class HasEvaluateSettings s
- detailed :: IO a -> IO a
- data Decoder a = Decoder {
  - extract :: Expr Src Void -> Extractor Src Void a
  - expected :: Expr Src Void
  }
- newtype RecordDecoder a = RecordDecoder (Product (Const (Map Text (Expr Src Void))) (Compose ((->) (Expr Src Void)) (Extractor Src Void)) a)
- newtype UnionDecoder a = UnionDecoder (Compose (Map Text) Decoder a)
- data Encoder a = Encoder {
  - embed :: a -> Expr Src Void
  - declared :: Expr Src Void
  }
- class FromDhall a where
  - autoWith :: InputNormalizer -> Decoder a
- type Interpret = FromDhall
- data InvalidDecoder s a = InvalidDecoder {
  - invalidDecoderExpected :: Expr s a
  - invalidDecoderExpression :: Expr s a
  }
- newtype ExtractErrors s a = ExtractErrors {
  - getErrors :: NonEmpty (ExtractError s a)
  }
- data ExtractError s a
  - = TypeMismatch (InvalidDecoder s a)
  - | ExtractError Text
- type Extractor s a = Validation (ExtractErrors s a)
- type MonadicExtractor s a = Either (ExtractErrors s a)
- typeError :: Expr s a -> Expr s a -> Extractor s a b
- extractError :: Text -> Extractor s a b
- toMonadic :: Extractor s a b -> MonadicExtractor s a b
- fromMonadic :: MonadicExtractor s a b -> Extractor s a b
- auto :: FromDhall a => Decoder a
- genericAuto :: (Generic a, GenericFromDhall (Rep a)) => Decoder a
- genericAutoWith :: (Generic a, GenericFromDhall (Rep a)) => InterpretOptions -> Decoder a
- data InterpretOptions = InterpretOptions {
  - fieldModifier :: Text -> Text
  - constructorModifier :: Text -> Text
  - singletonConstructors :: SingletonConstructors
  }
- newtype InputNormalizer = InputNormalizer {
  - getInputNormalizer :: ReifiedNormalizer Void
  }
- defaultInputNormalizer :: InputNormalizer
- data SingletonConstructors
  - = Bare
  - | Wrapped
  - | Smart
- defaultInterpretOptions :: InterpretOptions
- bool :: Decoder Bool
- natural :: Decoder Natural
- integer :: Decoder Integer
- scientific :: Decoder Scientific
- double :: Decoder Double
- lazyText :: Decoder Text
- strictText :: Decoder Text
- maybe :: Decoder a -> Decoder (Maybe a)
- sequence :: Decoder a -> Decoder (Seq a)
- list :: Decoder a -> Decoder [a]
- vector :: Decoder a -> Decoder (Vector a)
- function :: Encoder a -> Decoder b -> Decoder (a -> b)
- functionWith :: InputNormalizer -> Encoder a -> Decoder b -> Decoder (a -> b)
- setFromDistinctList :: (Ord a, Show a) => Decoder a -> Decoder (Set a)
- setIgnoringDuplicates :: Ord a => Decoder a -> Decoder (Set a)
- hashSetFromDistinctList :: (Hashable a, Ord a, Show a) => Decoder a -> Decoder (HashSet a)
- hashSetIgnoringDuplicates :: (Hashable a, Ord a) => Decoder a -> Decoder (HashSet a)
- map :: Ord k => Decoder k -> Decoder v -> Decoder (Map k v)
- hashMap :: (Eq k, Hashable k) => Decoder k -> Decoder v -> Decoder (HashMap k v)
- pairFromMapEntry :: Decoder k -> Decoder v -> Decoder (k, v)
- unit :: Decoder ()
- void :: Decoder Void
- string :: Decoder String
- pair :: Decoder a -> Decoder b -> Decoder (a, b)
- record :: RecordDecoder a -> Decoder a
- field :: Text -> Decoder a -> RecordDecoder a
- union :: UnionDecoder a -> Decoder a
- constructor :: Text -> Decoder a -> UnionDecoder a
- class GenericFromDhall f where
  - genericAutoWithNormalizer :: InputNormalizer -> InterpretOptions -> State Int (Decoder (f a))
- class GenericToDhall f where
  - genericToDhallWithNormalizer :: InputNormalizer -> InterpretOptions -> State Int (Encoder (f a))
- class ToDhall a where
  - injectWith :: InputNormalizer -> Encoder a
- type Inject = ToDhall
- inject :: ToDhall a => Encoder a
- genericToDhall :: (Generic a, GenericToDhall (Rep a)) => Encoder a
- genericToDhallWith :: (Generic a, GenericToDhall (Rep a)) => InterpretOptions -> Encoder a
- newtype RecordEncoder a = RecordEncoder (Map Text (Encoder a))
- encodeFieldWith :: Text -> Encoder a -> RecordEncoder a
- encodeField :: ToDhall a => Text -> RecordEncoder a
- recordEncoder :: RecordEncoder a -> Encoder a
- newtype UnionEncoder a = UnionEncoder (Product (Const (Map Text (Expr Src Void))) (Op (Text, Expr Src Void)) a)
- encodeConstructorWith :: Text -> Encoder a -> UnionEncoder a
- encodeConstructor :: ToDhall a => Text -> UnionEncoder a
- unionEncoder :: UnionEncoder a -> Encoder a
- (>|<) :: UnionEncoder a -> UnionEncoder b -> UnionEncoder (Either a b)
- rawInput :: Alternative f => Decoder a -> Expr s Void -> 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

:: Decoder a | The decoder for the Dhall value
-> 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 |
-> Decoder a | The decoder for the Dhall value
-> 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

:: Decoder a | The decoder for the Dhall value
-> 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 |
-> Decoder a | The decoder for the Dhall value
-> 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 Void) | 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 Void) | 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 Void)) Source #

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

Since: 1.16

substitutions :: (Functor f, HasEvaluateSettings s) => LensLike' f s (Substitutions Src Void) Source #

Access the custom substitutions.

Since: 1.30

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

Access the custom normalizer.

Since: 1.16

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

Instances details

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

Instances details

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

Instances details

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

# Decoders

data Decoder a Source #

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

You can produce `Decoder`s either explicitly:

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

... or implicitly using `auto`:

    example :: Decoder (Vector Text)
    example = auto

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

    input :: Decoder a -> Text -> IO a

Constructors

Decoder |

Fields

- extract :: Expr Src Void -> Extractor Src Void a

  Extracts Haskell value from the Dhall expression

- expected :: Expr Src Void

  Dhall type of the Haskell value

#### Instances

Instances details

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

newtype RecordDecoder a Source #

The `RecordDecoder` applicative functor allows you to build a `Decoder` 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 decoder has type `Decoder` `Project`, but we can't build that out of any smaller decoders, as `Decoder`s cannot be combined (they are only `Functor`s). However, we can use a `RecordDecoder` to build a `Decoder` for `Project`:

    >>> :{
    project :: Decoder Project
    project =
      record
        ( Project <$> field "name" strictText
                  <*> field "description" strictText
                  <*> field "stars" natural
        )
    :}

Constructors

RecordDecoder (Product (Const (Map Text (Expr Src Void))) (Compose ((->) (Expr Src Void)) (Extractor Src Void)) a) |

#### Instances

Instances details

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

newtype UnionDecoder a Source #

The `UnionDecoder` monoid allows you to build a `Decoder` from a Dhall union

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

    >>> :{
    data Status = Queued Natural
                | Result Text
                | Errored Text
    :}

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

    < Result : Text
    | Queued : Natural
    | Errored : Text
    >.Result "Finish successfully"

Our decoder has type `Decoder` `Status`, but we can't build that out of any smaller decoders, as `Decoder`s cannot be combined (they are only `Functor`s). However, we can use a `UnionDecoder` to build a `Decoder` for `Status`:

    >>> :{
    status :: Decoder Status
    status = union
      (  ( Queued  <$> constructor "Queued"  natural )
      <> ( Result  <$> constructor "Result"  strictText )
      <> ( Errored <$> constructor "Errored" strictText )
      )
    :}

Constructors

UnionDecoder (Compose (Map Text) Decoder a) |

#### Instances

Instances details

Functor UnionDecoder Source # |
Instance details Defined in Dhall Methods fmap :: (a -> b) -> UnionDecoder a -> UnionDecoder b Source # (<$) :: a -> UnionDecoder b -> UnionDecoder a Source #
Semigroup (UnionDecoder a) Source # |
Instance details Defined in Dhall Methods (<>) :: UnionDecoder a -> UnionDecoder a -> UnionDecoder a Source # sconcat :: NonEmpty (UnionDecoder a) -> UnionDecoder a Source # stimes :: Integral b => b -> UnionDecoder a -> UnionDecoder a Source #
Monoid (UnionDecoder a) Source # |
Instance details Defined in Dhall Methods mempty :: UnionDecoder a Source # mappend :: UnionDecoder a -> UnionDecoder a -> UnionDecoder a Source # mconcat :: [UnionDecoder a] -> UnionDecoder a Source #

data Encoder a Source #

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

Constructors

Encoder |

Fields

- embed :: a -> Expr Src Void

  Embeds a Haskell value as a Dhall expression

- declared :: Expr Src Void

  Dhall type of the Haskell value

#### Instances

Instances details

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

class FromDhall a where Source #

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

    >>> input auto "[1, 2, 3]" :: IO (Vector Natural)
    [1,2,3]
    >>> input auto "toMap { a = False, b = True }" :: IO (Map Text Bool)
    fromList [("a",False),("b",True)]

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

The default instance can be tweaked using `genericAutoWith` and custom `InterpretOptions`, or using DerivingVia and `Codec` from Dhall.Deriving.

Minimal complete definition

Nothing

Methods

autoWith :: InputNormalizer -> Decoder a Source #

default autoWith :: (Generic a, GenericFromDhall (Rep a)) => InputNormalizer -> Decoder a Source #

#### Instances

Instances details

FromDhall Bool Source # |
Instance details Defined in Dhall Methods autoWith :: InputNormalizer -> Decoder Bool Source #
FromDhall Double Source # |
Instance details Defined in Dhall Methods autoWith :: InputNormalizer -> Decoder Double Source #
FromDhall Integer Source # |
Instance details Defined in Dhall Methods autoWith :: InputNormalizer -> Decoder Integer Source #
FromDhall Natural Source # |
Instance details Defined in Dhall Methods autoWith :: InputNormalizer -> Decoder Natural Source #
FromDhall () Source # |
Instance details Defined in Dhall Methods autoWith :: InputNormalizer -> Decoder () Source #
FromDhall Scientific Source # |
Instance details Defined in Dhall Methods autoWith :: InputNormalizer -> Decoder Scientific Source #
FromDhall Text Source # |
Instance details Defined in Dhall Methods autoWith :: InputNormalizer -> Decoder Text Source #
FromDhall Void Source # |
Instance details Defined in Dhall Methods autoWith :: InputNormalizer -> Decoder Void Source #
FromDhall Text Source # |
Instance details Defined in Dhall Methods autoWith :: InputNormalizer -> Decoder Text Source #
FromDhall [Char] Source # |
Instance details Defined in Dhall Methods autoWith :: InputNormalizer -> Decoder [Char] Source #
FromDhall a => FromDhall [a] Source # |
Instance details Defined in Dhall Methods autoWith :: InputNormalizer -> Decoder [a] Source #
FromDhall a => FromDhall (Maybe a) Source # |
Instance details Defined in Dhall Methods autoWith :: InputNormalizer -> Decoder (Maybe a) Source #
FromDhall a => FromDhall (Seq a) Source # |
Instance details Defined in Dhall Methods autoWith :: InputNormalizer -> Decoder (Seq a) Source #
(FromDhall a, Ord a, Show a) => FromDhall (Set a) Source # | Note that this instance will throw errors in the presence of duplicates in the list. To ignore duplicates, use `setIgnoringDuplicates`.
Instance details Defined in Dhall Methods autoWith :: InputNormalizer -> Decoder (Set a) Source #

(Functor f, FromDhall (f (Result f))) => FromDhall (Fix f) Source #

You can use this instance to marshal recursive types from Dhall to Haskell.

Here is an example use of this instance:

    {-# LANGUAGE DeriveAnyClass     #-}
    {-# LANGUAGE DeriveFoldable     #-}
    {-# LANGUAGE DeriveFunctor      #-}
    {-# LANGUAGE DeriveTraversable  #-}
    {-# LANGUAGE DeriveGeneric      #-}
    {-# LANGUAGE KindSignatures     #-}
    {-# LANGUAGE QuasiQuotes        #-}
    {-# LANGUAGE StandaloneDeriving #-}
    {-# LANGUAGE TypeFamilies       #-}
    {-# LANGUAGE TemplateHaskell    #-}

    import Data.Fix (Fix(..))
    import Data.Text (Text)
    import Dhall (FromDhall)
    import GHC.Generics (Generic)
    import Numeric.Natural (Natural)

    import qualified Data.Fix                 as Fix
    import qualified Data.Functor.Foldable    as Foldable
    import qualified Data.Functor.Foldable.TH as TH
    import qualified Dhall
    import qualified NeatInterpolation

    data Expr
        = Lit Natural
        | Add Expr Expr
        | Mul Expr Expr
        deriving (Show)

    TH.makeBaseFunctor ''Expr

    deriving instance Generic (ExprF a)
    deriving instance FromDhall a => FromDhall (ExprF a)

    example :: Text
    example = [NeatInterpolation.text|
        \(Expr : Type)
    ->  let ExprF =
              < LitF :
                  Natural
              | AddF :
                  { _1 : Expr, _2 : Expr }
              | MulF :
                  { _1 : Expr, _2 : Expr }
              >

        in      \(Fix : ExprF -> Expr)
            ->  let Lit = \(x : Natural) -> Fix (ExprF.LitF x)

                let Add =
                          \(x : Expr)
                      ->  \(y : Expr)
                      ->  Fix (ExprF.AddF { _1 = x, _2 = y })

                let Mul =
                          \(x : Expr)
                      ->  \(y : Expr)
                      ->  Fix (ExprF.MulF { _1 = x, _2 = y })

                in  Add (Mul (Lit 3) (Lit 7)) (Add (Lit 1) (Lit 2))
    |]

    convert :: Fix ExprF -> Expr
    convert = Fix.cata Foldable.embed

    main :: IO ()
    main = do
        x <- Dhall.input Dhall.auto example :: IO (Fix ExprF)

        print (convert x :: Expr)

Instance details Defined in Dhall Methods autoWith :: InputNormalizer -> Decoder (Fix f) Source #
(FromDhall a, Hashable a, Ord a, Show a) => FromDhall (HashSet a) Source # | Note that this instance will throw errors in the presence of duplicates in the list. To ignore duplicates, use `hashSetIgnoringDuplicates`.
Instance details Defined in Dhall Methods autoWith :: InputNormalizer -> Decoder (HashSet a) Source #
FromDhall a => FromDhall (Vector a) Source # |
Instance details Defined in Dhall Methods autoWith :: InputNormalizer -> Decoder (Vector a) Source #
(ToDhall a, FromDhall b) => FromDhall (a -> b) Source # |
Instance details Defined in Dhall Methods autoWith :: InputNormalizer -> Decoder (a -> b) Source #
(FromDhall a, FromDhall b) => FromDhall (a, b) Source # |
Instance details Defined in Dhall Methods autoWith :: InputNormalizer -> Decoder (a, b) Source #
(Eq k, Hashable k, FromDhall k, FromDhall v) => FromDhall (HashMap k v) Source # |
Instance details Defined in Dhall Methods autoWith :: InputNormalizer -> Decoder (HashMap k v) Source #
(Ord k, FromDhall k, FromDhall v) => FromDhall (Map k v) Source # |
Instance details Defined in Dhall Methods autoWith :: InputNormalizer -> Decoder (Map k v) Source #
(Generic a, GenericFromDhall (Rep a), ModifyOptions tag) => FromDhall (Codec tag a) Source # |
Instance details Defined in Dhall.Deriving Methods autoWith :: InputNormalizer -> Decoder (Codec tag a) Source #

type Interpret = FromDhall Source #

A compatibility alias for `FromDhall`

This will eventually be removed.

data InvalidDecoder s a Source #

Every `Decoder` must obey the contract that if an expression's type matches the the `expected` type then the `extract` function must not fail with a type error. If not, then this value is returned.

This value indicates that an invalid `Decoder` was provided to the `input` function

Constructors

InvalidDecoder |

Fields

- invalidDecoderExpected :: Expr s a
- invalidDecoderExpression :: Expr s a

#### Instances

Instances details

(Pretty s, Pretty a, Typeable s, Typeable a) => Show (InvalidDecoder s a) Source # |
Instance details Defined in Dhall Methods showsPrec :: Int -> InvalidDecoder s a -> ShowS Source # show :: InvalidDecoder s a -> String Source # showList :: [InvalidDecoder s a] -> ShowS Source #
(Pretty s, Typeable s, Pretty a, Typeable a) => Exception (InvalidDecoder s a) Source # |
Instance details Defined in Dhall Methods toException :: InvalidDecoder s a -> SomeException Source # fromException :: SomeException -> Maybe (InvalidDecoder s a) Source # displayException :: InvalidDecoder s a -> String Source #

newtype ExtractErrors s a Source #

One or more errors returned from extracting a Dhall expression to a Haskell expression

Constructors

ExtractErrors |

Fields

- getErrors :: NonEmpty (ExtractError s a)

#### Instances

Instances details

(Pretty s, Pretty a, Typeable s, Typeable a) => Show (ExtractErrors s a) Source # |
Instance details Defined in Dhall Methods showsPrec :: Int -> ExtractErrors s a -> ShowS Source # show :: ExtractErrors s a -> String Source # showList :: [ExtractErrors s a] -> ShowS Source #
Semigroup (ExtractErrors s a) Source # |
Instance details Defined in Dhall Methods (<>) :: ExtractErrors s a -> ExtractErrors s a -> ExtractErrors s a Source # sconcat :: NonEmpty (ExtractErrors s a) -> ExtractErrors s a Source # stimes :: Integral b => b -> ExtractErrors s a -> ExtractErrors s a Source #
(Pretty s, Pretty a, Typeable s, Typeable a) => Exception (ExtractErrors s a) Source # |
Instance details Defined in Dhall Methods toException :: ExtractErrors s a -> SomeException Source # fromException :: SomeException -> Maybe (ExtractErrors s a) Source # displayException :: ExtractErrors s a -> String Source #

data ExtractError s a Source #

Extraction of a value can fail for two reasons, either a type mismatch (which should not happen, as expressions are type-checked against the expected type before being passed to `extract`), or a term-level error, described with a freeform text value.

Constructors

TypeMismatch (InvalidDecoder s a) |
ExtractError Text |

#### Instances

Instances details

(Pretty s, Pretty a, Typeable s, Typeable a) => Show (ExtractError s a) Source # |
Instance details Defined in Dhall Methods showsPrec :: Int -> ExtractError s a -> ShowS Source # show :: ExtractError s a -> String Source # showList :: [ExtractError s a] -> ShowS Source #
(Pretty s, Pretty a, Typeable s, Typeable a) => Exception (ExtractError s a) Source # |
Instance details Defined in Dhall Methods toException :: ExtractError s a -> SomeException Source # fromException :: SomeException -> Maybe (ExtractError s a) Source # displayException :: ExtractError s a -> String Source #

type Extractor s a = Validation (ExtractErrors s a) Source #

Useful synonym for the `Validation` type used when marshalling Dhall expressions

type MonadicExtractor s a = Either (ExtractErrors s a) Source #

Useful synonym for the equivalent `Either` type used when marshalling Dhall code

typeError :: Expr s a -> Expr s a -> Extractor s a b Source #

Generate a type error during extraction by specifying the expected type and the actual type

extractError :: Text -> Extractor s a b Source #

Turn a `Text` message into an extraction failure

toMonadic :: Extractor s a b -> MonadicExtractor s a b Source #

Switches from an `Applicative` extraction result, able to accumulate errors, to a `Monad` extraction result, able to chain sequential operations

fromMonadic :: MonadicExtractor s a b -> Extractor s a b Source #

Switches from a `Monad` extraction result, able to chain sequential errors, to an `Applicative` extraction result, able to accumulate errors

auto :: FromDhall a => Decoder a Source #

Use the default input normalizer for interpreting a configuration file

    auto = autoWith defaultInputNormalizer

genericAuto :: (Generic a, GenericFromDhall (Rep a)) => Decoder a Source #

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

genericAutoWith :: (Generic a, GenericFromDhall (Rep a)) => InterpretOptions -> Decoder a Source #

`genericAutoWith` is a configurable version of `genericAuto`.

data InterpretOptions Source #

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

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

- singletonConstructors :: SingletonConstructors

  Specify how to handle constructors with only one field. The default is `Smart`

newtype InputNormalizer Source #

This is only used by the `FromDhall` instance for functions in order to normalize the function input before marshaling the input into a Dhall expression

Constructors

InputNormalizer |

Fields

- getInputNormalizer :: ReifiedNormalizer Void

defaultInputNormalizer :: InputNormalizer Source #

Default normalization-related settings (no custom normalization)

data SingletonConstructors Source #

This type specifies how to model a Haskell constructor with 1 field in Dhall

For example, consider the following Haskell datatype definition:

    data Example = Foo { x :: Double } | Bar Double

Depending on which option you pick, the corresponding Dhall type could be:

    < Foo : Double | Bar : Double >                   -- Bare

    < Foo : { x : Double } | Bar : { _1 : Double } >  -- Wrapped

    < Foo : { x : Double } | Bar : Double >           -- Smart

Constructors

Bare | Never wrap the field in a record
Wrapped | Always wrap the field in a record
Smart | Only fields in a record if they are named

#### Instances

Instances details

ToSingletonConstructors a => ModifyOptions (SetSingletonConstructors a :: Type) Source # |
Instance details Defined in Dhall.Deriving Methods modifyOptions :: InterpretOptions -> InterpretOptions Source #

defaultInterpretOptions :: InterpretOptions Source #

Default interpret options for generics-based instances, which you can tweak or override, like this:

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

bool :: Decoder Bool Source #

Decode a `Bool`

    >>> input bool "True"
    True

natural :: Decoder Natural Source #

Decode a `Natural`

    >>> input natural "42"
    42

integer :: Decoder Integer Source #

Decode an `Integer`

    >>> input integer "+42"
    42

scientific :: Decoder Scientific Source #

Decode a `Scientific`

    >>> input scientific "1e100"
    1.0e100

double :: Decoder Double Source #

Decode a `Double`

    >>> input double "42.0"
    42.0

lazyText :: Decoder Text Source #

Decode lazy `Text`

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

strictText :: Decoder Text Source #

Decode strict `Text`

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

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

Decode a `Maybe`

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

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

Decode a `Seq`

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

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

Decode a list

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

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

Decode a `Vector`

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

function :: Encoder a -> Decoder b -> Decoder (a -> b) Source #

Decode a Dhall function into a Haskell function

    >>> f <- input (function inject bool) "Natural/even" :: IO (Natural -> Bool)
    >>> f 0
    True
    >>> f 1
    False

functionWith :: InputNormalizer -> Encoder a -> Decoder b -> Decoder (a -> b) Source #

Decode a Dhall function into a Haskell function using the specified normalizer

    >>> f <- input (functionWith defaultInputNormalizer inject bool) "Natural/even" :: IO (Natural -> Bool)
    >>> f 0
    True
    >>> f 1
    False

setFromDistinctList :: (Ord a, Show a) => Decoder a -> Decoder (Set a) Source #

Decode a `Set` from a `List` with distinct elements

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

An error is thrown if the list contains duplicates.

    >>> input (setFromDistinctList natural) "[1, 1, 3]"
    *** Exception: Error: Failed extraction

    The expression type-checked successfully but the transformation to the target
    type failed with the following error:

    One duplicate element in the list: 1

    >>> input (setFromDistinctList natural) "[1, 1, 3, 3]"
    *** Exception: Error: Failed extraction

    The expression type-checked successfully but the transformation to the target
    type failed with the following error:

    2 duplicates were found in the list, including 1

setIgnoringDuplicates :: Ord a => Decoder a -> Decoder (Set a) Source #

Decode a `Set` from a `List`

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

Duplicate elements are ignored.

    >>> input (setIgnoringDuplicates natural) "[1, 1, 3]"
    fromList [1,3]

hashSetFromDistinctList :: (Hashable a, Ord a, Show a) => Decoder a -> Decoder (HashSet a) Source #

Decode a `HashSet` from a `List` with distinct elements

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

An error is thrown if the list contains duplicates.

    >>> input (hashSetFromDistinctList natural) "[1, 1, 3]"
    *** Exception: Error: Failed extraction

    The expression type-checked successfully but the transformation to the target
    type failed with the following error:

    One duplicate element in the list: 1

    >>> input (hashSetFromDistinctList natural) "[1, 1, 3, 3]"
    *** Exception: Error: Failed extraction

    The expression type-checked successfully but the transformation to the target
    type failed with the following error:

    2 duplicates were found in the list, including 1

hashSetIgnoringDuplicates :: (Hashable a, Ord a) => Decoder a -> Decoder (HashSet a) Source #

Decode a `HashSet` from a `List`

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

Duplicate elements are ignored.

    >>> input (hashSetIgnoringDuplicates natural) "[1, 1, 3]"
    fromList [1,3]

map :: Ord k => Decoder k -> Decoder v -> Decoder (Map k v) Source #

Decode a `Map` from a `toMap` expression or generally a `Prelude.Map.Type`

    >>> input (Dhall.map strictText bool) "toMap { a = True, b = False }"
    fromList [("a",True),("b",False)]
    >>> input (Dhall.map strictText bool) "[ { mapKey = \"foo\", mapValue = True } ]"
    fromList [("foo",True)]

If there are duplicate `mapKey`s, later `mapValue`s take precedence:

    >>> let expr = "[ { mapKey = 1, mapValue = True }, { mapKey = 1, mapValue = False } ]"
    >>> input (Dhall.map natural bool) expr
    fromList [(1,False)]

hashMap :: (Eq k, Hashable k) => Decoder k -> Decoder v -> Decoder (HashMap k v) Source #

Decode a `HashMap` from a `toMap` expression or generally a `Prelude.Map.Type`

    >>> input (Dhall.hashMap strictText bool) "toMap { a = True, b = False }"
    fromList [("a",True),("b",False)]
    >>> input (Dhall.hashMap strictText bool) "[ { mapKey = \"foo\", mapValue = True } ]"
    fromList [("foo",True)]

If there are duplicate `mapKey`s, later `mapValue`s take precedence:

    >>> let expr = "[ { mapKey = 1, mapValue = True }, { mapKey = 1, mapValue = False } ]"
    >>> input (Dhall.hashMap natural bool) expr
    fromList [(1,False)]

pairFromMapEntry :: Decoder k -> Decoder v -> Decoder (k, v) Source #

Decode a tuple from a `Prelude.Map.Entry` record

    >>> input (pairFromMapEntry strictText natural) "{ mapKey = \"foo\", mapValue = 3 }"
    ("foo",3)

unit :: Decoder () Source #

Decode `()` from an empty record.

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

void :: Decoder Void Source #

Decode `Void` from an empty union.

Since `<>` is uninhabited, ``input` `void`` will always fail.

string :: Decoder String Source #

Decode a `String`

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

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

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

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

record :: RecordDecoder a -> Decoder a Source #

Run a `RecordDecoder` to build a `Decoder`.

field :: Text -> Decoder a -> RecordDecoder a Source #

Parse a single field of a record.

union :: UnionDecoder a -> Decoder a Source #

Run a `UnionDecoder` to build a `Decoder`.

constructor :: Text -> Decoder a -> UnionDecoder a Source #

Parse a single constructor of a union

class GenericFromDhall f where Source #

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

Methods

genericAutoWithNormalizer :: InputNormalizer -> InterpretOptions -> State Int (Decoder (f a)) Source #

#### Instances

Instances details

GenericFromDhall (U1 :: k -> Type) Source # |
Instance details Defined in Dhall Methods genericAutoWithNormalizer :: forall (a :: k0). InputNormalizer -> InterpretOptions -> State Int (Decoder (U1 a)) Source #
GenericFromDhall (V1 :: k -> Type) Source # |
Instance details Defined in Dhall Methods genericAutoWithNormalizer :: forall (a :: k0). InputNormalizer -> InterpretOptions -> State Int (Decoder (V1 a)) Source #
(GenericFromDhall (f :*: g), GenericFromDhall (h :*: i)) => GenericFromDhall ((f :*: g) :*: (h :*: i) :: k -> Type) Source # |
Instance details Defined in Dhall Methods genericAutoWithNormalizer :: forall (a :: k0). InputNormalizer -> InterpretOptions -> State Int (Decoder (((f :*: g) :*: (h :*: i)) a)) Source #
(Selector s1, Selector s2, FromDhall a1, FromDhall a2) => GenericFromDhall (M1 S s1 (K1 i1 a1 :: k -> Type) :*: M1 S s2 (K1 i2 a2 :: k -> Type) :: k -> Type) Source # |
Instance details Defined in Dhall Methods genericAutoWithNormalizer :: forall (a :: k0). InputNormalizer -> InterpretOptions -> State Int (Decoder ((M1 S s1 (K1 i1 a1) :*: M1 S s2 (K1 i2 a2)) a)) Source #
(Selector s, FromDhall a, GenericFromDhall (f :*: g)) => GenericFromDhall (M1 S s (K1 i a :: k -> Type) :*: (f :*: g) :: k -> Type) Source # |
Instance details Defined in Dhall Methods genericAutoWithNormalizer :: forall (a0 :: k0). InputNormalizer -> InterpretOptions -> State Int (Decoder ((M1 S s (K1 i a) :*: (f :*: g)) a0)) Source #
(GenericFromDhall (f :*: g), Selector s, FromDhall a) => GenericFromDhall ((f :*: g) :*: M1 S s (K1 i a :: k -> Type) :: k -> Type) Source # |
Instance details Defined in Dhall Methods genericAutoWithNormalizer :: forall (a0 :: k0). InputNormalizer -> InterpretOptions -> State Int (Decoder (((f :*: g) :*: M1 S s (K1 i a)) a0)) Source #
GenericFromDhallUnion (f :+: g) => GenericFromDhall (f :+: g :: k -> Type) Source # |
Instance details Defined in Dhall Methods genericAutoWithNormalizer :: forall (a :: k0). InputNormalizer -> InterpretOptions -> State Int (Decoder ((f :+: g) a)) Source #
GenericFromDhall f => GenericFromDhall (M1 C c f :: k -> Type) Source # |
Instance details Defined in Dhall Methods genericAutoWithNormalizer :: forall (a :: k0). InputNormalizer -> InterpretOptions -> State Int (Decoder (M1 C c f a)) Source #
GenericFromDhall f => GenericFromDhall (M1 D d f :: k -> Type) Source # |
Instance details Defined in Dhall Methods genericAutoWithNormalizer :: forall (a :: k0). InputNormalizer -> InterpretOptions -> State Int (Decoder (M1 D d f a)) Source #
(Selector s, FromDhall a) => GenericFromDhall (M1 S s (K1 i a :: k -> Type) :: k -> Type) Source # |
Instance details Defined in Dhall Methods genericAutoWithNormalizer :: forall (a0 :: k0). InputNormalizer -> InterpretOptions -> State Int (Decoder (M1 S s (K1 i a) a0)) Source #

class GenericToDhall f where Source #

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

Methods

genericToDhallWithNormalizer :: InputNormalizer -> InterpretOptions -> State Int (Encoder (f a)) Source #

#### Instances

Instances details

GenericToDhall (U1 :: k -> Type) Source # |
Instance details Defined in Dhall Methods genericToDhallWithNormalizer :: forall (a :: k0). InputNormalizer -> InterpretOptions -> State Int (Encoder (U1 a)) Source #
(GenericToDhall (f :*: g), GenericToDhall (h :*: i)) => GenericToDhall ((f :*: g) :*: (h :*: i) :: k -> Type) Source # |
Instance details Defined in Dhall Methods genericToDhallWithNormalizer :: forall (a :: k0). InputNormalizer -> InterpretOptions -> State Int (Encoder (((f :*: g) :*: (h :*: i)) a)) Source #
(GenericToDhall (f :+: g), GenericToDhall (h :+: i)) => GenericToDhall ((f :+: g) :+: (h :+: i) :: k -> Type) Source # |
Instance details Defined in Dhall Methods genericToDhallWithNormalizer :: forall (a :: k0). InputNormalizer -> InterpretOptions -> State Int (Encoder (((f :+: g) :+: (h :+: i)) a)) Source #
(Constructor c, GenericToDhall f, GenericToDhall (g :+: h)) => GenericToDhall (M1 C c f :+: (g :+: h) :: k -> Type) Source # |
Instance details Defined in Dhall Methods genericToDhallWithNormalizer :: forall (a :: k0). InputNormalizer -> InterpretOptions -> State Int (Encoder ((M1 C c f :+: (g :+: h)) a)) Source #
(Constructor c, GenericToDhall (f :+: g), GenericToDhall h) => GenericToDhall ((f :+: g) :+: M1 C c h :: k -> Type) Source # |
Instance details Defined in Dhall Methods genericToDhallWithNormalizer :: forall (a :: k0). InputNormalizer -> InterpretOptions -> State Int (Encoder (((f :+: g) :+: M1 C c h) a)) Source #
(Constructor c1, Constructor c2, GenericToDhall f1, GenericToDhall f2) => GenericToDhall (M1 C c1 f1 :+: M1 C c2 f2 :: k -> Type) Source # |
Instance details Defined in Dhall Methods genericToDhallWithNormalizer :: forall (a :: k0). InputNormalizer -> InterpretOptions -> State Int (Encoder ((M1 C c1 f1 :+: M1 C c2 f2) a)) Source #
(Selector s1, Selector s2, ToDhall a1, ToDhall a2) => GenericToDhall (M1 S s1 (K1 i1 a1 :: k -> Type) :*: M1 S s2 (K1 i2 a2 :: k -> Type) :: k -> Type) Source # |
Instance details Defined in Dhall Methods genericToDhallWithNormalizer :: forall (a :: k0). InputNormalizer -> InterpretOptions -> State Int (Encoder ((M1 S s1 (K1 i1 a1) :*: M1 S s2 (K1 i2 a2)) a)) Source #
(Selector s, ToDhall a, GenericToDhall (f :*: g)) => GenericToDhall (M1 S s (K1 i a :: k -> Type) :*: (f :*: g) :: k -> Type) Source # |
Instance details Defined in Dhall Methods genericToDhallWithNormalizer :: forall (a0 :: k0). InputNormalizer -> InterpretOptions -> State Int (Encoder ((M1 S s (K1 i a) :*: (f :*: g)) a0)) Source #
(GenericToDhall (f :*: g), Selector s, ToDhall a) => GenericToDhall ((f :*: g) :*: M1 S s (K1 i a :: k -> Type) :: k -> Type) Source # |
Instance details Defined in Dhall Methods genericToDhallWithNormalizer :: forall (a0 :: k0). InputNormalizer -> InterpretOptions -> State Int (Encoder (((f :*: g) :*: M1 S s (K1 i a)) a0)) Source #
GenericToDhall f => GenericToDhall (M1 C c f :: k -> Type) Source # |
Instance details Defined in Dhall Methods genericToDhallWithNormalizer :: forall (a :: k0). InputNormalizer -> InterpretOptions -> State Int (Encoder (M1 C c f a)) Source #
GenericToDhall f => GenericToDhall (M1 D d f :: k -> Type) Source # |
Instance details Defined in Dhall Methods genericToDhallWithNormalizer :: forall (a :: k0). InputNormalizer -> InterpretOptions -> State Int (Encoder (M1 D d f a)) Source #
(Selector s, ToDhall a) => GenericToDhall (M1 S s (K1 i a :: k -> Type) :: k -> Type) Source # |
Instance details Defined in Dhall Methods genericToDhallWithNormalizer :: forall (a0 :: k0). InputNormalizer -> InterpretOptions -> State Int (Encoder (M1 S s (K1 i a) a0)) Source #

class ToDhall a where Source #

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

    instance (ToDhall a, FromDhall b) => FromDhall (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 Void`)
- Applying the Dhall function (i.e. `f :: Expr Src Void`) 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

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

The default instance can be tweaked using `genericToDhallWith` and custom `InterpretOptions`, or using DerivingVia and `Codec` from Dhall.Deriving.

Minimal complete definition

Nothing

Methods

injectWith :: InputNormalizer -> Encoder a Source #

default injectWith :: (Generic a, GenericToDhall (Rep a)) => InputNormalizer -> Encoder a Source #

#### Instances

Instances details

ToDhall Bool Source # |
Instance details Defined in Dhall Methods injectWith :: InputNormalizer -> Encoder Bool Source #
ToDhall Double Source # |
Instance details Defined in Dhall Methods injectWith :: InputNormalizer -> Encoder Double Source #
ToDhall Int Source # |
Instance details Defined in Dhall Methods injectWith :: InputNormalizer -> Encoder Int Source #
ToDhall Integer Source # |
Instance details Defined in Dhall Methods injectWith :: InputNormalizer -> Encoder Integer Source #
ToDhall Natural Source # |
Instance details Defined in Dhall Methods injectWith :: InputNormalizer -> Encoder Natural Source #

ToDhall Word Source #

    >>> embed inject (12 :: Word)
    NaturalLit 12

Instance details Defined in Dhall Methods injectWith :: InputNormalizer -> Encoder Word Source #

ToDhall Word8 Source #

    >>> embed inject (12 :: Word8)
    NaturalLit 12

Instance details Defined in Dhall Methods injectWith :: InputNormalizer -> Encoder Word8 Source #

ToDhall Word16 Source #

    >>> embed inject (12 :: Word16)
    NaturalLit 12

Instance details Defined in Dhall Methods injectWith :: InputNormalizer -> Encoder Word16 Source #

ToDhall Word32 Source #

    >>> embed inject (12 :: Word32)
    NaturalLit 12

Instance details Defined in Dhall Methods injectWith :: InputNormalizer -> Encoder Word32 Source #

ToDhall Word64 Source #

    >>> embed inject (12 :: Word64)
    NaturalLit 12

Instance details Defined in Dhall Methods injectWith :: InputNormalizer -> Encoder Word64 Source #
ToDhall () Source # |
Instance details Defined in Dhall Methods injectWith :: InputNormalizer -> Encoder () Source #
ToDhall Scientific Source # |
Instance details Defined in Dhall Methods injectWith :: InputNormalizer -> Encoder Scientific Source #
ToDhall String Source # |
Instance details Defined in Dhall Methods injectWith :: InputNormalizer -> Encoder String Source #
ToDhall Text Source # |
Instance details Defined in Dhall Methods injectWith :: InputNormalizer -> Encoder Text Source #
ToDhall Void Source # |
Instance details Defined in Dhall Methods injectWith :: InputNormalizer -> Encoder Void Source #
ToDhall Text Source # |
Instance details Defined in Dhall Methods injectWith :: InputNormalizer -> Encoder Text Source #
ToDhall a => ToDhall [a] Source # |
Instance details Defined in Dhall Methods injectWith :: InputNormalizer -> Encoder [a] Source #
ToDhall a => ToDhall (Maybe a) Source # |
Instance details Defined in Dhall Methods injectWith :: InputNormalizer -> Encoder (Maybe a) Source #
ToDhall a => ToDhall (Seq a) Source # |
Instance details Defined in Dhall Methods injectWith :: InputNormalizer -> Encoder (Seq a) Source #

ToDhall a => ToDhall (Set a) Source #

Note that the output list will be sorted

    >>> let x = Data.Set.fromList ["mom", "hi" :: Text]
    >>> prettyExpr $ embed inject x
    [ "hi", "mom" ]

Instance details Defined in Dhall Methods injectWith :: InputNormalizer -> Encoder (Set a) Source #

ToDhall a => ToDhall (HashSet a) Source #

Note that the output list may not be sorted

    >>> let x = Data.HashSet.fromList ["hi", "mom" :: Text]
    >>> prettyExpr $ embed inject x
    [ "mom", "hi" ]

Instance details Defined in Dhall Methods injectWith :: InputNormalizer -> Encoder (HashSet a) Source #
ToDhall a => ToDhall (Vector a) Source # |
Instance details Defined in Dhall Methods injectWith :: InputNormalizer -> Encoder (Vector a) Source #
(ToDhall a, ToDhall b) => ToDhall (a, b) Source # |
Instance details Defined in Dhall Methods injectWith :: InputNormalizer -> Encoder (a, b) Source #

(ToDhall k, ToDhall v) => ToDhall (HashMap k v) Source #

Embed a `HashMap` as a `Prelude.Map.Type`

    >>> prettyExpr $ embed inject (HashMap.fromList [(1 :: Natural, True)])
    [ { mapKey = 1, mapValue = True } ]

    >>> prettyExpr $ embed inject (HashMap.fromList [] :: HashMap Natural Bool)
    [] : List { mapKey : Natural, mapValue : Bool }

Instance details Defined in Dhall Methods injectWith :: InputNormalizer -> Encoder (HashMap k v) Source #

(ToDhall k, ToDhall v) => ToDhall (Map k v) Source #

Embed a `Map` as a `Prelude.Map.Type`

    >>> prettyExpr $ embed inject (Data.Map.fromList [(1 :: Natural, True)])
    [ { mapKey = 1, mapValue = True } ]

    >>> prettyExpr $ embed inject (Data.Map.fromList [] :: Data.Map.Map Natural Bool)
    [] : List { mapKey : Natural, mapValue : Bool }

Instance details Defined in Dhall Methods injectWith :: InputNormalizer -> Encoder (Map k v) Source #
(Generic a, GenericToDhall (Rep a), ModifyOptions tag) => ToDhall (Codec tag a) Source # |
Instance details Defined in Dhall.Deriving Methods injectWith :: InputNormalizer -> Encoder (Codec tag a) Source #

type Inject = ToDhall Source #

A compatibility alias for `ToDhall`

This will eventually be removed.

inject :: ToDhall a => Encoder a Source #

Use the default input normalizer for injecting a value

    inject = injectWith defaultInputNormalizer

genericToDhall :: (Generic a, GenericToDhall (Rep a)) => Encoder a Source #

Use the default options for injecting a value, whose structure is determined generically.

This can be used when you want to use `ToDhall` on types that you don't want to define orphan instances for.

genericToDhallWith :: (Generic a, GenericToDhall (Rep a)) => InterpretOptions -> Encoder a Source #

Use custom options for injecting a value, whose structure is determined generically.

This can be used when you want to use `ToDhall` on types that you don't want to define orphan instances for.

newtype RecordEncoder a Source #

Intermediate type used for building a `ToDhall` instance for a record

Constructors

RecordEncoder (Map Text (Encoder a)) |

#### Instances

Instances details

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

encodeFieldWith :: Text -> Encoder a -> RecordEncoder a Source #

Specify how to encode one field of a record by supplying an explicit `Encoder` for that field

encodeField :: ToDhall a => Text -> RecordEncoder a Source #

Specify how to encode one field of a record using the default `ToDhall` instance for that type

recordEncoder :: RecordEncoder a -> Encoder a Source #

Convert a `RecordEncoder` into the equivalent `Encoder`

newtype UnionEncoder a Source #

`UnionEncoder` allows you to build an `Encoder` for a Dhall record.

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

    >>> :{
    data Status = Queued Natural
                | Result Text
                | Errored Text
    :}

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

    < Result : Text
    | Queued : Natural
    | Errored : Text
    >.Result "Finish successfully"

Our encoder has type `Encoder` `Status`, but we can't build that out of any smaller encoders, as `Encoder`s cannot be combined. However, we can use an `UnionEncoder` to build an `Encoder` for `Status`:

    >>> :{
    injectStatus :: Encoder Status
    injectStatus = adapt >$< unionEncoder
      (   encodeConstructorWith "Queued"  inject
      >|< encodeConstructorWith "Result"  inject
      >|< encodeConstructorWith "Errored" inject
      )
      where
        adapt (Queued  n) = Left n
        adapt (Result  t) = Right (Left t)
        adapt (Errored e) = Right (Right e)
    :}

Or, since we are simply using the `ToDhall` instance to inject each branch, we could write

    >>> :{
    injectStatus :: Encoder Status
    injectStatus = adapt >$< unionEncoder
      (   encodeConstructor "Queued"
      >|< encodeConstructor "Result"
      >|< encodeConstructor "Errored"
      )
      where
        adapt (Queued  n) = Left n
        adapt (Result  t) = Right (Left t)
        adapt (Errored e) = Right (Right e)
    :}

Constructors

UnionEncoder (Product (Const (Map Text (Expr Src Void))) (Op (Text, Expr Src Void)) a) |

#### Instances

Instances details

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

encodeConstructorWith :: Text -> Encoder a -> UnionEncoder a Source #

Specify how to encode an alternative by providing an explicit `Encoder` for that alternative

encodeConstructor :: ToDhall a => Text -> UnionEncoder a Source #

Specify how to encode an alternative by using the default `ToDhall` instance for that type

unionEncoder :: UnionEncoder a -> Encoder a Source #

Convert a `UnionEncoder` into the equivalent `Encoder`

(>|<) :: UnionEncoder a -> UnionEncoder b -> UnionEncoder (Either a b) infixr 5 Source #

Combines two `UnionEncoder` values. See `UnionEncoder` for usage notes.

Ideally, this matches `chosen`; however, this allows `UnionEncoder` to not need a `Divisible` instance itself (since no instance is possible).

# Miscellaneous

rawInput Source #

Arguments

:: Alternative f |
=> Decoder a | The decoder for the Dhall value
-> Expr s Void | 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 `RecordEncoder` divisible (contravariant) functor allows you to build an `Encoder` 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 encoder has type `Encoder` `Project`, but we can't build that out of any smaller encoders, as `Encoder`s cannot be combined (they are only `Contravariant`s). However, we can use an `RecordEncoder` to build an `Encoder` for `Project`:

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

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

    >>> :{
    injectProject :: Encoder Project
    injectProject =
      recordEncoder
        ( adapt >$< encodeField "name"
                >*< encodeField "description"
                >*< encodeField "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

Instances details

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 :: forall r r'. (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 Source # inRange :: (Natural, Natural) -> Natural -> Bool Source # rangeSize :: (Natural, Natural) -> Int Source # unsafeRangeSize :: (Natural, Natural) -> Int Source #
Lift Natural |
Instance details Defined in Language.Haskell.TH.Syntax Methods lift :: Natural -> Q Exp Source #
Hashable Natural |
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> Natural -> Int Source # hash :: Natural -> Int Source #
ToJSON Natural |
Instance details Defined in Data.Aeson.Types.ToJSON Methods toJSON :: Natural -> Value Source # toEncoding :: Natural -> Encoding Source # toJSONList :: [Natural] -> Value Source # toEncodingList :: [Natural] -> Encoding Source #
ToJSONKey Natural |
Instance details Defined in Data.Aeson.Types.ToJSON Methods toJSONKey :: ToJSONKeyFunction Natural Source # toJSONKeyList :: ToJSONKeyFunction [Natural] Source #
FromJSON Natural |
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser Natural Source # parseJSONList :: Value -> Parser [Natural] Source #
FromJSONKey Natural |
Instance details Defined in Data.Aeson.Types.FromJSON Methods fromJSONKey :: FromJSONKeyFunction Natural Source # fromJSONKeyList :: FromJSONKeyFunction [Natural] Source #
PrintfArg Natural | Since: base-4.8.0.0
Instance details Defined in Text.Printf Methods formatArg :: Natural -> FieldFormatter Source # parseFormat :: Natural -> ModifierParser Source #
Bits Natural | Since: base-4.8.0

Instance details

Defined in Data.Bits

Methods

(.&.) :: Natural -> Natural -> Natural Source #

(.|.) :: Natural -> Natural -> Natural Source #

xor :: Natural -> Natural -> Natural Source #

complement :: Natural -> Natural Source #

shift :: Natural -> Int -> Natural Source #

rotate :: Natural -> Int -> Natural Source #

zeroBits :: Natural Source #

bit :: Int -> Natural Source #

setBit :: Natural -> Int -> Natural Source #

clearBit :: Natural -> Int -> Natural Source #

complementBit :: Natural -> Int -> Natural Source #

testBit :: Natural -> Int -> Bool Source #

bitSizeMaybe :: Natural -> Maybe Int Source #

bitSize :: Natural -> Int Source #

isSigned :: Natural -> Bool Source #

shiftL :: Natural -> Int -> Natural Source #

unsafeShiftL :: Natural -> Int -> Natural Source #

shiftR :: Natural -> Int -> Natural Source #

unsafeShiftR :: Natural -> Int -> Natural Source #

rotateL :: Natural -> Int -> Natural Source #

rotateR :: Natural -> Int -> Natural Source #

popCount :: Natural -> Int Source #

NFData Natural | Since: deepseq-1.4.0.0
Instance details Defined in Control.DeepSeq Methods rnf :: Natural -> () 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 #
Subtractive Natural |
Instance details Defined in Basement.Numerical.Subtractive Associated Types type Difference Natural Methods (-) :: Natural -> Natural -> Difference Natural
ToDhall Natural Source # |
Instance details Defined in Dhall Methods injectWith :: InputNormalizer -> Encoder Natural Source #
FromDhall Natural Source # |
Instance details Defined in Dhall Methods autoWith :: InputNormalizer -> Decoder 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

Instances details

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 #
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 #

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 #
ToJSON1 Seq |
Instance details Defined in Data.Aeson.Types.ToJSON Methods liftToJSON :: (a -> Value) -> ([a] -> Value) -> Seq a -> Value Source # liftToJSONList :: (a -> Value) -> ([a] -> Value) -> [Seq a] -> Value Source # liftToEncoding :: (a -> Encoding) -> ([a] -> Encoding) -> Seq a -> Encoding Source # liftToEncodingList :: (a -> Encoding) -> ([a] -> Encoding) -> [Seq a] -> Encoding Source #
FromJSON1 Seq |
Instance details Defined in Data.Aeson.Types.FromJSON Methods liftParseJSON :: (Value -> Parser a) -> (Value -> Parser [a]) -> Value -> Parser (Seq a) Source # liftParseJSONList :: (Value -> Parser a) -> (Value -> Parser [a]) -> Value -> Parser [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) 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 :: forall r r'. (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 #
ToJSON a => ToJSON (Seq a) |
Instance details Defined in Data.Aeson.Types.ToJSON Methods toJSON :: Seq a -> Value Source # toEncoding :: Seq a -> Encoding Source # toJSONList :: [Seq a] -> Value Source # toEncodingList :: [Seq a] -> Encoding Source #
FromJSON a => FromJSON (Seq a) |
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser (Seq a) Source # parseJSONList :: Value -> Parser [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 #
ToDhall a => ToDhall (Seq a) Source # |
Instance details Defined in Dhall Methods injectWith :: InputNormalizer -> Encoder (Seq a) Source #
FromDhall a => FromDhall (Seq a) Source # |
Instance details Defined in Dhall Methods autoWith :: InputNormalizer -> Decoder (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

Instances details

Hashable Text |
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> Text -> Int Source # hash :: Text -> Int Source #
ToJSON Text |
Instance details Defined in Data.Aeson.Types.ToJSON Methods toJSON :: Text -> Value Source # toEncoding :: Text -> Encoding Source # toJSONList :: [Text] -> Value Source # toEncodingList :: [Text] -> Encoding Source #
KeyValue Object | Constructs a singleton `HashMap`. For calling functions that demand an `Object` for constructing objects. To be used in conjunction with `mconcat`. Prefer to use `object` where possible.
Instance details Defined in Data.Aeson.Types.ToJSON Methods (.=) :: ToJSON v => Text -> v -> Object Source #
KeyValue Pair |
Instance details Defined in Data.Aeson.Types.ToJSON Methods (.=) :: ToJSON v => Text -> v -> Pair Source #
ToJSONKey Text |
Instance details Defined in Data.Aeson.Types.ToJSON Methods toJSONKey :: ToJSONKeyFunction Text Source # toJSONKeyList :: ToJSONKeyFunction [Text] Source #
FromJSON Text |
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser Text Source # parseJSONList :: Value -> Parser [Text] Source #
FromJSONKey Text |
Instance details Defined in Data.Aeson.Types.FromJSON Methods fromJSONKey :: FromJSONKeyFunction Text Source # fromJSONKeyList :: FromJSONKeyFunction [Text] Source #
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 Source #

type Tokens Text 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 #

tokensLength :: Proxy Text -> NonEmpty (Token Text) -> Int Source #

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

reachOffsetNoLine :: Int -> PosState Text -> 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 #
Chunk Text |
Instance details Defined in Data.Attoparsec.Internal.Types Associated Types type ChunkElem Text 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
ToDhall Text Source # |
Instance details Defined in Dhall Methods injectWith :: InputNormalizer -> Encoder Text Source #
FromDhall Text Source # |
Instance details Defined in Dhall Methods autoWith :: InputNormalizer -> Decoder Text Source #
MonadParsec Void Text Parser Source # |

Instance details

Defined in Dhall.Parser.Combinators

Methods

parseError :: ParseError Text 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 Void) Source #

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

Monad m => Stream Text m Char |
Instance details Defined in Text.Parsec.Prim Methods uncons :: Text -> m (Maybe (Char, Text)) Source #
FromPairs Value (DList Pair) |
Instance details Defined in Data.Aeson.Types.ToJSON Methods fromPairs :: DList Pair -> Value
v ~ Value => KeyValuePair v (DList Pair) |
Instance details Defined in Data.Aeson.Types.ToJSON Methods pair :: String -> v -> DList Pair
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

Instances details

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 #
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 | Since: vector-0.12.1.0
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 #

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 #
ToJSON1 Vector |
Instance details Defined in Data.Aeson.Types.ToJSON Methods liftToJSON :: (a -> Value) -> ([a] -> Value) -> Vector a -> Value Source # liftToJSONList :: (a -> Value) -> ([a] -> Value) -> [Vector a] -> Value Source # liftToEncoding :: (a -> Encoding) -> ([a] -> Encoding) -> Vector a -> Encoding Source # liftToEncodingList :: (a -> Encoding) -> ([a] -> Encoding) -> [Vector a] -> Encoding Source #
FromJSON1 Vector |
Instance details Defined in Data.Aeson.Types.FromJSON Methods liftParseJSON :: (Value -> Parser a) -> (Value -> Parser [a]) -> Value -> Parser (Vector a) Source # liftParseJSONList :: (Value -> Parser a) -> (Value -> Parser [a]) -> Value -> Parser [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 #
NFData1 Vector | Since: vector-0.12.1.0
Instance details Defined in Data.Vector Methods liftRnf :: (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) 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 :: forall r r'. (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 #
ToJSON a => ToJSON (Vector a) |
Instance details Defined in Data.Aeson.Types.ToJSON Methods toJSON :: Vector a -> Value Source # toEncoding :: Vector a -> Encoding Source # toJSONList :: [Vector a] -> Value Source # toEncodingList :: [Vector a] -> Encoding Source #
FromJSON a => FromJSON (Vector a) |
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser (Vector a) Source # parseJSONList :: Value -> Parser [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 #
ToDhall a => ToDhall (Vector a) Source # |
Instance details Defined in Dhall Methods injectWith :: InputNormalizer -> Encoder (Vector a) Source #
FromDhall a => FromDhall (Vector a) Source # |
Instance details Defined in Dhall Methods autoWith :: InputNormalizer -> Decoder (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

Instances details

Generic Bool | Since: base-4.6.0.0
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 | Since: base-4.6.0.0
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 () | Since: base-4.6.0.0
Instance details Defined in GHC.Generics Associated Types type Rep () :: Type -> Type Source # Methods from :: () -> Rep () x Source # to :: Rep () x -> () 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 Value |
Instance details Defined in Data.Aeson.Types.Internal Associated Types type Rep Value :: Type -> Type Source # Methods from :: Value -> Rep Value x Source # to :: Rep Value x -> Value Source #
Generic Void | Since: base-4.8.0.0
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 | Since: base-4.9.0.0
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 | Since: base-4.7.0.0
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 | Since: base-4.7.0.0
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 | Since: base-4.7.0.0
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 | Since: base-4.7.0.0
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 | Since: base-4.9.0.0
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 | Since: base-4.9.0.0
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 | Since: base-4.9.0.0
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 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 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 URIAuth |
Instance details Defined in Network.URI Associated Types type Rep URIAuth :: Type -> Type Source # Methods from :: URIAuth -> Rep URIAuth x Source # to :: Rep URIAuth x -> URIAuth 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 CheckColorTty |
Instance details Defined in Text.Pretty.Simple.Internal.OutputPrinter Associated Types type Rep CheckColorTty :: Type -> Type Source # Methods from :: CheckColorTty -> Rep CheckColorTty x Source # to :: Rep CheckColorTty x -> CheckColorTty Source #
Generic OutputOptions |
Instance details Defined in Text.Pretty.Simple.Internal.OutputPrinter Associated Types type Rep OutputOptions :: Type -> Type Source # Methods from :: OutputOptions -> Rep OutputOptions x Source # to :: Rep OutputOptions x -> OutputOptions Source #
Generic LineNum |
Instance details Defined in Text.Pretty.Simple.Internal.ExprToOutput Associated Types type Rep LineNum :: Type -> Type Source # Methods from :: LineNum -> Rep LineNum x Source # to :: Rep LineNum x -> LineNum Source #
Generic PrinterState |
Instance details Defined in Text.Pretty.Simple.Internal.ExprToOutput Associated Types type Rep PrinterState :: Type -> Type Source # Methods from :: PrinterState -> Rep PrinterState x Source # to :: Rep PrinterState x -> PrinterState Source #
Generic NestLevel |
Instance details Defined in Text.Pretty.Simple.Internal.Output Associated Types type Rep NestLevel :: Type -> Type Source # Methods from :: NestLevel -> Rep NestLevel x Source # to :: Rep NestLevel x -> NestLevel Source #
Generic OutputType |
Instance details Defined in Text.Pretty.Simple.Internal.Output Associated Types type Rep OutputType :: Type -> Type Source # Methods from :: OutputType -> Rep OutputType x Source # to :: Rep OutputType x -> OutputType Source #
Generic Output |
Instance details Defined in Text.Pretty.Simple.Internal.Output Associated Types type Rep Output :: Type -> Type Source # Methods from :: Output -> Rep Output x Source # to :: Rep Output x -> Output Source #
Generic Expr |
Instance details Defined in Text.Pretty.Simple.Internal.Expr Associated Types type Rep Expr :: Type -> Type Source # Methods from :: Expr -> Rep Expr x Source # to :: Rep Expr x -> Expr Source #
Generic ColorOptions |
Instance details Defined in Text.Pretty.Simple.Internal.Color Associated Types type Rep ColorOptions :: Type -> Type Source # Methods from :: ColorOptions -> Rep ColorOptions x Source # to :: Rep ColorOptions x -> ColorOptions 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 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 SHA256Digest Source # |
Instance details Defined in Dhall.Crypto Associated Types type Rep SHA256Digest :: Type -> Type Source # Methods from :: SHA256Digest -> Rep SHA256Digest x Source # to :: Rep SHA256Digest x -> SHA256Digest Source #
Generic Const Source # |
Instance details Defined in Dhall.Syntax Associated Types type Rep Const :: Type -> Type Source # Methods from :: Const -> Rep Const x Source # to :: Rep Const x -> Const Source #
Generic Var Source # |
Instance details Defined in Dhall.Syntax Associated Types type Rep Var :: Type -> Type Source # Methods from :: Var -> Rep Var x Source # to :: Rep Var x -> Var Source #
Generic Src Source # |
Instance details Defined in Dhall.Src Associated Types type Rep Src :: Type -> Type Source # Methods from :: Src -> Rep Src x Source # to :: Rep Src x -> Src Source #
Generic Import Source # |
Instance details Defined in Dhall.Syntax 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.Syntax 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.Syntax 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.Syntax 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.Syntax 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.Syntax 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.Syntax 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.Syntax 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.Syntax Associated Types type Rep Directory :: Type -> Type Source # Methods from :: Directory -> Rep Directory x Source # to :: Rep Directory x -> Directory Source #
Generic DhallDouble Source # |
Instance details Defined in Dhall.Syntax Associated Types type Rep DhallDouble :: Type -> Type Source # Methods from :: DhallDouble -> Rep DhallDouble x Source # to :: Rep DhallDouble x -> DhallDouble 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] | Since: base-4.6.0.0
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) | Since: base-4.6.0.0
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) | Since: base-4.7.0.0
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) | Since: base-4.9.0.0
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) | Since: base-4.9.0.0
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) | Since: base-4.9.0.0
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) | Since: base-4.9.0.0
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) | Since: base-4.9.0.0
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) | Since: base-4.9.0.0
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) | Since: base-4.9.0.0
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) | Since: base-4.7.0.0
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) | Since: base-4.8.0.0
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) | Since: base-4.7.0.0
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) | Since: base-4.7.0.0
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) | Since: base-4.7.0.0
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) | Since: base-4.7.0.0
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) | Since: base-4.7.0.0
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) | Since: base-4.7.0.0
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) | Since: base-4.12.0.0
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) | Since: base-4.6.0.0
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) | Since: containers-0.5.8
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) | Since: containers-0.6.1
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) | Since: containers-0.6.1
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) | Since: containers-0.6.1
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) | Since: containers-0.6.1
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) | Since: containers-0.5.8
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) | Since: containers-0.5.8
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 (Fix f) |
Instance details Defined in Data.Fix Associated Types type Rep (Fix f) :: Type -> Type Source # Methods from :: Fix f -> Rep (Fix f) x Source # to :: Rep (Fix f) x -> Fix f 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 (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 (CommaSeparated a) |
Instance details Defined in Text.Pretty.Simple.Internal.Expr Associated Types type Rep (CommaSeparated a) :: Type -> Type Source # Methods from :: CommaSeparated a -> Rep (CommaSeparated a) x Source # to :: Rep (CommaSeparated a) x -> CommaSeparated 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) | Since: base-4.6.0.0
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) | Since: base-4.9.0.0
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) | Since: base-4.7.0.0
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) | Since: base-4.6.0.0
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) | Since: base-4.9.0.0
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) | Since: base-4.7.0.0
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) | Since: base-4.6.0.0
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 (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 (State s e) |
Instance details Defined in Text.Megaparsec.State Associated Types type Rep (State s e) :: Type -> Type Source # Methods from :: State s e -> Rep (State s e) x Source # to :: Rep (State s e) x -> State s e 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 (Map k v) Source # |
Instance details Defined in Dhall.Map Associated Types type Rep (Map k v) :: Type -> Type Source # Methods from :: Map k v -> Rep (Map k v) x Source # to :: Rep (Map k v) x -> Map k v Source #
Generic (Expr s a) Source # |
Instance details Defined in Dhall.Syntax 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 (PreferAnnotation s a) Source # |
Instance details Defined in Dhall.Syntax Associated Types type Rep (PreferAnnotation s a) :: Type -> Type Source # Methods from :: PreferAnnotation s a -> Rep (PreferAnnotation s a) x Source # to :: Rep (PreferAnnotation s a) x -> PreferAnnotation s a Source #
Generic (Chunks s a) Source # |
Instance details Defined in Dhall.Syntax 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.Syntax 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) | Since: base-4.7.0.0
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) | Since: base-4.9.0.0
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) | Since: base-4.9.0.0
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) | Since: base-4.9.0.0
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) | Since: base-4.9.0.0
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) | Since: base-4.9.0.0
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) | Since: base-4.6.0.0
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) | Since: base-4.7.0.0
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) | Since: base-4.9.0.0
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) | Since: base-4.12.0.0
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) | Since: base-4.8.0.0
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 (Tagged s b) |
Instance details Defined in Data.Tagged Associated Types type Rep (Tagged s b) :: Type -> Type Source # Methods from :: Tagged s b -> Rep (Tagged s b) x Source # to :: Rep (Tagged s b) x -> Tagged s b Source #
Generic (Join p a) |
Instance details Defined in Data.Bifunctor.Join Associated Types type Rep (Join p a) :: Type -> Type Source # Methods from :: Join p a -> Rep (Join p a) x Source # to :: Rep (Join p a) x -> Join p a Source #
Generic (K1 i c p) | Since: base-4.7.0.0
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) | Since: base-4.7.0.0
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) | Since: base-4.7.0.0
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) | Since: base-4.6.0.0
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) | Since: base-4.9.0.0
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) | Since: base-4.9.0.0
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) | Since: base-4.7.0.0
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) | Since: base-4.7.0.0
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) | Since: base-4.6.0.0
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) | Since: base-4.9.0.0
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 (Clown f a b) |
Instance details Defined in Data.Bifunctor.Clown Associated Types type Rep (Clown f a b) :: Type -> Type Source # Methods from :: Clown f a b -> Rep (Clown f a b) x Source # to :: Rep (Clown f a b) x -> Clown f a b Source #
Generic (Joker g a b) |
Instance details Defined in Data.Bifunctor.Joker Associated Types type Rep (Joker g a b) :: Type -> Type Source # Methods from :: Joker g a b -> Rep (Joker g a b) x Source # to :: Rep (Joker g a b) x -> Joker g a b Source #
Generic (Flip p a b) |
Instance details Defined in Data.Bifunctor.Flip Associated Types type Rep (Flip p a b) :: Type -> Type Source # Methods from :: Flip p a b -> Rep (Flip p a b) x Source # to :: Rep (Flip p a b) x -> Flip p a b Source #
Generic (WrappedBifunctor p a b) |
Instance details Defined in Data.Bifunctor.Wrapped Associated Types type Rep (WrappedBifunctor p a b) :: Type -> Type Source # Methods from :: WrappedBifunctor p a b -> Rep (WrappedBifunctor p a b) x Source # to :: Rep (WrappedBifunctor p a b) x -> WrappedBifunctor p a b Source #
Generic (a, b, c, d, e, f) | Since: base-4.6.0.0
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 (Product f g a b) |
Instance details Defined in Data.Bifunctor.Product Associated Types type Rep (Product f g a b) :: Type -> Type Source # Methods from :: Product f g a b -> Rep (Product f g a b) x Source # to :: Rep (Product f g a b) x -> Product f g a b Source #
Generic (Sum p q a b) |
Instance details Defined in Data.Bifunctor.Sum Associated Types type Rep (Sum p q a b) :: Type -> Type Source # Methods from :: Sum p q a b -> Rep (Sum p q a b) x Source # to :: Rep (Sum p q a b) x -> Sum p q a b Source #
Generic (a, b, c, d, e, f, g) | Since: base-4.6.0.0
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 #
Generic (Tannen f p a b) |
Instance details Defined in Data.Bifunctor.Tannen Associated Types type Rep (Tannen f p a b) :: Type -> Type Source # Methods from :: Tannen f p a b -> Rep (Tannen f p a b) x Source # to :: Rep (Tannen f p a b) x -> Tannen f p a b Source #
Generic (Biff p f g a b) |
Instance details Defined in Data.Bifunctor.Biff Associated Types type Rep (Biff p f g a b) :: Type -> Type Source # Methods from :: Biff p f g a b -> Rep (Biff p f g a b) x Source # to :: Rep (Biff p f g a b) x -> Biff p f g a b Source #