dhall-1.42.1: A configuration language guaranteed to terminate

Safe Haskell | Safe-Inferred
Language | Haskell2010

Dhall.Marshal.Decode

Contents

- General
- Building decoders
  - Simple decoders
  - Numbers
  - Bytes
  - Textual
  - Time
  - Containers
  - Functions
  - Records
  - Unions
- Generic decoding
- Decoding errors
  - Extraction errors
  - Typing errors
- 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

- data Decoder a = Decoder {
  - extract :: Expr Src Void -> Extractor Src Void a
  - expected :: Expector (Expr Src Void)
  }
- class FromDhall a where
  - autoWith :: InputNormalizer -> Decoder a
- type Interpret = FromDhall
- auto :: FromDhall a => Decoder a
- bool :: Decoder Bool
- unit :: Decoder ()
- void :: Decoder Void
- natural :: Decoder Natural
- word :: Decoder Word
- word8 :: Decoder Word8
- word16 :: Decoder Word16
- word32 :: Decoder Word32
- word64 :: Decoder Word64
- integer :: Decoder Integer
- int :: Decoder Int
- int8 :: Decoder Int8
- int16 :: Decoder Int16
- int32 :: Decoder Int32
- int64 :: Decoder Int64
- scientific :: Decoder Scientific
- double :: Decoder Double
- lazyBytes :: Decoder ByteString
- strictBytes :: Decoder ByteString
- shortBytes :: Decoder ShortByteString
- string :: Decoder String
- lazyText :: Decoder Text
- strictText :: Decoder Text
- shortText :: Decoder ShortText
- timeOfDay :: Decoder TimeOfDay
- day :: Decoder Day
- timeZone :: Decoder TimeZone
- localTime :: Decoder LocalTime
- zonedTime :: Decoder ZonedTime
- utcTime :: Decoder UTCTime
- dayOfWeek :: Decoder DayOfWeek
- maybe :: Decoder a -> Decoder (Maybe a)
- pair :: Decoder a -> Decoder b -> Decoder (a, b)
- sequence :: Decoder a -> Decoder (Seq a)
- list :: Decoder a -> Decoder [a]
- vector :: Decoder a -> Decoder (Vector a)
- 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)
- function :: Encoder a -> Decoder b -> Decoder (a -> b)
- functionWith :: InputNormalizer -> Encoder a -> Decoder b -> Decoder (a -> b)
- newtype RecordDecoder a = RecordDecoder (Product (Const (Map Text (Expector (Expr Src Void)))) (Compose ((->) (Expr Src Void)) (Extractor Src Void)) a)
- record :: RecordDecoder a -> Decoder a
- field :: Text -> Decoder a -> RecordDecoder a
- newtype UnionDecoder a = UnionDecoder (Compose (Map Text) Decoder a)
- union :: UnionDecoder a -> Decoder a
- constructor :: Text -> Decoder a -> UnionDecoder a
- class GenericFromDhall t f where
  - genericAutoWithNormalizer :: Proxy t -> InputNormalizer -> InterpretOptions -> State Int (Decoder (f a))
- class GenericFromDhallUnion t f where
  - genericUnionAutoWithNormalizer :: Proxy t -> InputNormalizer -> InterpretOptions -> UnionDecoder (f a)
- genericAuto :: (Generic a, GenericFromDhall a (Rep a)) => Decoder a
- genericAutoWith :: (Generic a, GenericFromDhall a (Rep a)) => InterpretOptions -> Decoder a
- genericAutoWithInputNormalizer :: (Generic a, GenericFromDhall a (Rep a)) => InterpretOptions -> InputNormalizer -> Decoder a
- newtype DhallErrors e = DhallErrors {
  - getErrors :: NonEmpty e
  }
- showDhallErrors :: Show e => String -> DhallErrors e -> String
- data InvalidDecoder s a = InvalidDecoder {
  - invalidDecoderExpected :: Expr s a
  - invalidDecoderExpression :: Expr s a
  }
- type ExtractErrors s a = DhallErrors (ExtractError s a)
- data ExtractError s a
  - = TypeMismatch (InvalidDecoder s a)
  - | ExpectedTypeError ExpectedTypeError
  - | ExtractError Text
- type Extractor s a = Validation (ExtractErrors s a)
- typeError :: Expector (Expr s a) -> Expr s a -> Extractor s a b
- extractError :: Text -> Extractor s a b
- type MonadicExtractor s a = Either (ExtractErrors s a)
- toMonadic :: Extractor s a b -> MonadicExtractor s a b
- fromMonadic :: MonadicExtractor s a b -> Extractor s a b
- type ExpectedTypeErrors = DhallErrors ExpectedTypeError
- data ExpectedTypeError = RecursiveTypeError
- type Expector = Validation ExpectedTypeErrors
- newtype InputNormalizer = InputNormalizer {
  - getInputNormalizer :: ReifiedNormalizer Void
  }
- defaultInputNormalizer :: InputNormalizer
- data InterpretOptions = InterpretOptions {
  - fieldModifier :: Text -> Text
  - constructorModifier :: Text -> Text
  - singletonConstructors :: SingletonConstructors
  }
- data SingletonConstructors
  - = Bare
  - | Wrapped
  - | Smart
- defaultInterpretOptions :: InterpretOptions
- data Result f
- data Natural
- data Seq a
- data Text
- data Vector a
- class Generic a

# General

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 :: Expector (Expr Src Void)

  Dhall type of the Haskell value

#### Instances

Instances details

Functor Decoder Source # |
Instance details Defined in Dhall.Marshal.Decode Methods fmap :: (a -> b) -> Decoder a -> Decoder b Source # (<$) :: a -> Decoder b -> Decoder 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`/`genericAutoWithInputNormalizer` 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 a (Rep a)) => InputNormalizer -> Decoder a Source #

#### Instances

Instances details

FromDhall Void Source # |
Instance details Defined in Dhall.Marshal.Decode Methods autoWith :: InputNormalizer -> Decoder Void Source #
FromDhall Int16 Source # |
Instance details Defined in Dhall.Marshal.Decode Methods autoWith :: InputNormalizer -> Decoder Int16 Source #
FromDhall Int32 Source # |
Instance details Defined in Dhall.Marshal.Decode Methods autoWith :: InputNormalizer -> Decoder Int32 Source #
FromDhall Int64 Source # |
Instance details Defined in Dhall.Marshal.Decode Methods autoWith :: InputNormalizer -> Decoder Int64 Source #
FromDhall Int8 Source # |
Instance details Defined in Dhall.Marshal.Decode Methods autoWith :: InputNormalizer -> Decoder Int8 Source #
FromDhall Word16 Source # |
Instance details Defined in Dhall.Marshal.Decode Methods autoWith :: InputNormalizer -> Decoder Word16 Source #
FromDhall Word32 Source # |
Instance details Defined in Dhall.Marshal.Decode Methods autoWith :: InputNormalizer -> Decoder Word32 Source #
FromDhall Word64 Source # |
Instance details Defined in Dhall.Marshal.Decode Methods autoWith :: InputNormalizer -> Decoder Word64 Source #
FromDhall Word8 Source # |
Instance details Defined in Dhall.Marshal.Decode Methods autoWith :: InputNormalizer -> Decoder Word8 Source #
FromDhall CGid Source # |
Instance details Defined in Dhall.DirectoryTree.Types Methods autoWith :: InputNormalizer -> Decoder CGid Source #
FromDhall CUid Source # |
Instance details Defined in Dhall.DirectoryTree.Types Methods autoWith :: InputNormalizer -> Decoder CUid Source #
FromDhall ByteString Source # |
Instance details Defined in Dhall.Marshal.Decode Methods autoWith :: InputNormalizer -> Decoder ByteString Source #
FromDhall ByteString Source # |
Instance details Defined in Dhall.Marshal.Decode Methods autoWith :: InputNormalizer -> Decoder ByteString Source #
FromDhall ShortByteString Source # |
Instance details Defined in Dhall.Marshal.Decode Methods autoWith :: InputNormalizer -> Decoder ShortByteString Source #
FromDhall FilesystemEntry Source # |
Instance details Defined in Dhall.DirectoryTree.Types Methods autoWith :: InputNormalizer -> Decoder FilesystemEntry Source #
FromDhall Group Source # |
Instance details Defined in Dhall.DirectoryTree.Types Methods autoWith :: InputNormalizer -> Decoder Group Source #
FromDhall User Source # |
Instance details Defined in Dhall.DirectoryTree.Types Methods autoWith :: InputNormalizer -> Decoder User Source #
FromDhall Scientific Source # |
Instance details Defined in Dhall.Marshal.Decode Methods autoWith :: InputNormalizer -> Decoder Scientific Source #
FromDhall Text Source # |
Instance details Defined in Dhall.Marshal.Decode Methods autoWith :: InputNormalizer -> Decoder Text Source #
FromDhall Text Source # |
Instance details Defined in Dhall.Marshal.Decode Methods autoWith :: InputNormalizer -> Decoder Text Source #
FromDhall ShortText Source # |
Instance details Defined in Dhall.Marshal.Decode Methods autoWith :: InputNormalizer -> Decoder ShortText Source #
FromDhall Day Source # |
Instance details Defined in Dhall.Marshal.Decode Methods autoWith :: InputNormalizer -> Decoder Day Source #
FromDhall DayOfWeek Source # |
Instance details Defined in Dhall.Marshal.Decode Methods autoWith :: InputNormalizer -> Decoder DayOfWeek Source #
FromDhall UTCTime Source # |
Instance details Defined in Dhall.Marshal.Decode Methods autoWith :: InputNormalizer -> Decoder UTCTime Source #
FromDhall LocalTime Source # |
Instance details Defined in Dhall.Marshal.Decode Methods autoWith :: InputNormalizer -> Decoder LocalTime Source #
FromDhall TimeOfDay Source # |
Instance details Defined in Dhall.Marshal.Decode Methods autoWith :: InputNormalizer -> Decoder TimeOfDay Source #
FromDhall TimeZone Source # |
Instance details Defined in Dhall.Marshal.Decode Methods autoWith :: InputNormalizer -> Decoder TimeZone Source #
FromDhall ZonedTime Source # |
Instance details Defined in Dhall.Marshal.Decode Methods autoWith :: InputNormalizer -> Decoder ZonedTime Source #
FromDhall Integer Source # |
Instance details Defined in Dhall.Marshal.Decode Methods autoWith :: InputNormalizer -> Decoder Integer Source #
FromDhall Natural Source # |
Instance details Defined in Dhall.Marshal.Decode Methods autoWith :: InputNormalizer -> Decoder Natural Source #
FromDhall () Source # |
Instance details Defined in Dhall.Marshal.Decode Methods autoWith :: InputNormalizer -> Decoder () Source #
FromDhall Bool Source # |
Instance details Defined in Dhall.Marshal.Decode Methods autoWith :: InputNormalizer -> Decoder Bool Source #
FromDhall Double Source # |
Instance details Defined in Dhall.Marshal.Decode Methods autoWith :: InputNormalizer -> Decoder Double Source #
FromDhall Int Source # |
Instance details Defined in Dhall.Marshal.Decode Methods autoWith :: InputNormalizer -> Decoder Int Source #
FromDhall Word Source # |
Instance details Defined in Dhall.Marshal.Decode Methods autoWith :: InputNormalizer -> Decoder Word Source #
ToDhall x => FromDhall (Equivalence x) Source # |
Instance details Defined in Dhall.Marshal.Decode Methods autoWith :: InputNormalizer -> Decoder (Equivalence x) Source #
ToDhall x => FromDhall (Predicate x) Source # |
Instance details Defined in Dhall.Marshal.Decode Methods autoWith :: InputNormalizer -> Decoder (Predicate x) Source #
FromDhall a => FromDhall (Identity a) Source # |
Instance details Defined in Dhall.Marshal.Decode Methods autoWith :: InputNormalizer -> Decoder (Identity a) Source #
FromDhall a => FromDhall (Seq a) Source # |
Instance details Defined in Dhall.Marshal.Decode 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.Marshal.Decode 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.foldFix Foldable.embed

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

        print (convert x :: Expr)

Instance details Defined in Dhall.Marshal.Decode Methods autoWith :: InputNormalizer -> Decoder (Fix f) Source #
FromDhall (Access Identity) Source # |
Instance details Defined in Dhall.DirectoryTree.Types Methods autoWith :: InputNormalizer -> Decoder (Access Identity) Source #
FromDhall (Access Maybe) Source # |
Instance details Defined in Dhall.DirectoryTree.Types Methods autoWith :: InputNormalizer -> Decoder (Access Maybe) Source #
FromDhall a => FromDhall (Entry a) Source # |
Instance details Defined in Dhall.DirectoryTree.Types Methods autoWith :: InputNormalizer -> Decoder (Entry a) Source #
FromDhall (Mode Identity) Source # |
Instance details Defined in Dhall.DirectoryTree.Types Methods autoWith :: InputNormalizer -> Decoder (Mode Identity) Source #
FromDhall (Mode Maybe) Source # |
Instance details Defined in Dhall.DirectoryTree.Types Methods autoWith :: InputNormalizer -> Decoder (Mode Maybe) Source #
FromDhall (f (Result f)) => FromDhall (Result f) Source # |
Instance details Defined in Dhall.Marshal.Decode Methods autoWith :: InputNormalizer -> Decoder (Result 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.Marshal.Decode Methods autoWith :: InputNormalizer -> Decoder (HashSet a) Source #
FromDhall a => FromDhall (Vector a) Source # |
Instance details Defined in Dhall.Marshal.Decode Methods autoWith :: InputNormalizer -> Decoder (Vector a) Source #
FromDhall a => FromDhall (Maybe a) Source # |
Instance details Defined in Dhall.Marshal.Decode Methods autoWith :: InputNormalizer -> Decoder (Maybe a) Source #
FromDhall [Char] Source # |
Instance details Defined in Dhall.Marshal.Decode Methods autoWith :: InputNormalizer -> Decoder [Char] Source #
FromDhall a => FromDhall [a] Source # |
Instance details Defined in Dhall.Marshal.Decode Methods autoWith :: InputNormalizer -> Decoder [a] Source #
(FromDhall b, ToDhall x) => FromDhall (Op b x) Source # |
Instance details Defined in Dhall.Marshal.Decode Methods autoWith :: InputNormalizer -> Decoder (Op b x) Source #
(Ord k, FromDhall k, FromDhall v) => FromDhall (Map k v) Source # |
Instance details Defined in Dhall.Marshal.Decode Methods autoWith :: InputNormalizer -> Decoder (Map k v) Source #
(Eq k, Hashable k, FromDhall k, FromDhall v) => FromDhall (HashMap k v) Source # |
Instance details Defined in Dhall.Marshal.Decode Methods autoWith :: InputNormalizer -> Decoder (HashMap k v) Source #
(FromDhall a, FromDhall b) => FromDhall (a, b) Source # |
Instance details Defined in Dhall.Marshal.Decode Methods autoWith :: InputNormalizer -> Decoder (a, b) Source #
(ToDhall a, FromDhall b) => FromDhall (a -> b) Source # |
Instance details Defined in Dhall.Marshal.Decode Methods autoWith :: InputNormalizer -> Decoder (a -> b) Source #
(Generic a, GenericFromDhall a (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 #

Deprecated: Use FromDhall instead

A compatibility alias for `FromDhall`.

auto :: FromDhall a => Decoder a Source #

Use the default input normalizer for interpreting an input.

    auto = autoWith defaultInputNormalizer

# Building decoders

## Simple decoders

bool :: Decoder Bool Source #

Decode a `Bool`.

    >>> input bool "True"
    True

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.

## Numbers

natural :: Decoder Natural Source #

Decode a `Natural`.

    >>> input natural "42"
    42

word :: Decoder Word Source #

Decode a `Word` from a Dhall `Natural`.

    >>> input word "42"
    42

word8 :: Decoder Word8 Source #

Decode a `Word8` from a Dhall `Natural`.

    >>> input word8 "42"
    42

word16 :: Decoder Word16 Source #

Decode a `Word16` from a Dhall `Natural`.

    >>> input word16 "42"
    42

word32 :: Decoder Word32 Source #

Decode a `Word32` from a Dhall `Natural`.

    >>> input word32 "42"
    42

word64 :: Decoder Word64 Source #

Decode a `Word64` from a Dhall `Natural`.

    >>> input word64 "42"
    42

integer :: Decoder Integer Source #

Decode an `Integer`.

    >>> input integer "+42"
    42

int :: Decoder Int Source #

Decode an `Int` from a Dhall `Integer`.

    >>> input int "-42"
    -42

int8 :: Decoder Int8 Source #

Decode an `Int8` from a Dhall `Integer`.

    >>> input int8 "-42"
    -42

int16 :: Decoder Int16 Source #

Decode an `Int16` from a Dhall `Integer`.

    >>> input int16 "-42"
    -42

int32 :: Decoder Int32 Source #

Decode an `Int32` from a Dhall `Integer`.

    >>> input int32 "-42"
    -42

int64 :: Decoder Int64 Source #

Decode an `Int64` from a Dhall `Integer`.

    >>> input int64 "-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

## Bytes

lazyBytes :: Decoder ByteString Source #

Decode a lazy `ByteString`.

    >>> input lazyBytes "0x\"00FF\""
    "\NUL\255"

strictBytes :: Decoder ByteString Source #

Decode a strict `ByteString`

    >>> input strictBytes "0x\"00FF\""
    "\NUL\255"

shortBytes :: Decoder ShortByteString Source #

Decode a `ShortByteString`

    >>> input shortBytes "0x\"00FF\""
    "\NUL\255"

## Textual

string :: Decoder String Source #

Decode a `String`

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

lazyText :: Decoder Text Source #

Decode lazy `Text`.

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

strictText :: Decoder Text Source #

Decode strict `Text`.

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

shortText :: Decoder ShortText Source #

Decode `ShortText`.

    >>> input shortText "\"Test\""
    "Test"

## Time

timeOfDay :: Decoder TimeOfDay Source #

Decode `TimeOfDay`

    >>> input timeOfDay "00:00:00"
    00:00:00

day :: Decoder Day Source #

Decode `Day`

    >>> input day "2000-01-01"
    2000-01-01

timeZone :: Decoder TimeZone Source #

Decode `TimeZone`

    >>> input timeZone "+00:00"
    +0000

localTime :: Decoder LocalTime Source #

Decode `LocalTime`

    >>> input localTime "2020-01-01T12:34:56"
    2020-01-01 12:34:56

zonedTime :: Decoder ZonedTime Source #

Decode `ZonedTime`

    >>> input zonedTime "2020-01-01T12:34:56+02:00"
    2020-01-01 12:34:56 +0200

utcTime :: Decoder UTCTime Source #

Decode `UTCTime`

    >>> input utcTime "2020-01-01T12:34:56+02:00"
    2020-01-01 10:34:56 UTC

dayOfWeek :: Decoder DayOfWeek Source #

Decode `DayOfWeek`

    >>> input dayOfWeek "< Sunday | Monday | Tuesday | Wednesday | Thursday | Friday | Saturday >.Monday"
    Monday

## Containers

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

Decode a `Maybe`.

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

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)

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]

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`.

    >>> fmap (List.sort . HashMap.toList) (input (Dhall.hashMap strictText bool) "toMap { a = True, b = False }")
    [("a",True),("b",False)]
    >>> fmap (List.sort . HashMap.toList) (input (Dhall.hashMap strictText bool) "[ { mapKey = \"foo\", mapValue = True } ]")
    [("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)

## Functions

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

## Records

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 (Expector (Expr Src Void)))) (Compose ((->) (Expr Src Void)) (Extractor Src Void)) a) |

#### Instances

Instances details

Applicative RecordDecoder Source # |

Instance details

Defined in Dhall.Marshal.Decode

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 #

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

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.

## Unions

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

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.

# Generic decoding

class GenericFromDhall t f where Source #

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

Methods

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

#### Instances

Instances details

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

class GenericFromDhallUnion t f where Source #

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

Methods

genericUnionAutoWithNormalizer :: Proxy t -> InputNormalizer -> InterpretOptions -> UnionDecoder (f a) Source #

#### Instances

Instances details

(GenericFromDhallUnion t f1, GenericFromDhallUnion t f2) => GenericFromDhallUnion (t :: k1) (f1 :+: f2 :: k2 -> Type) Source # |
Instance details Defined in Dhall.Marshal.Decode Methods genericUnionAutoWithNormalizer :: forall (a :: k10). Proxy t -> InputNormalizer -> InterpretOptions -> UnionDecoder ((f1 :+: f2) a) Source #
(Constructor c1, GenericFromDhall t f1) => GenericFromDhallUnion (t :: k1) (M1 C c1 f1 :: k2 -> Type) Source # |
Instance details Defined in Dhall.Marshal.Decode Methods genericUnionAutoWithNormalizer :: forall (a :: k10). Proxy t -> InputNormalizer -> InterpretOptions -> UnionDecoder (M1 C c1 f1 a) Source #

genericAuto :: (Generic a, GenericFromDhall a (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 a (Rep a)) => InterpretOptions -> Decoder a Source #

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

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

`genericAutoWithInputNormalizer` is like `genericAutoWith`, but instead of using the `defaultInputNormalizer` it expects an custom `InputNormalizer`.

# Decoding errors

newtype DhallErrors e Source #

A newtype suitable for collecting one or more errors.

Constructors

DhallErrors |

Fields

- getErrors :: NonEmpty e

#### Instances

Instances details

Functor DhallErrors Source # |
Instance details Defined in Dhall.Marshal.Decode Methods fmap :: (a -> b) -> DhallErrors a -> DhallErrors b Source # (<$) :: a -> DhallErrors b -> DhallErrors a Source #
Show ExpectedTypeErrors Source # |
Instance details Defined in Dhall.Marshal.Decode Methods showsPrec :: Int -> ExpectedTypeErrors -> ShowS Source # show :: ExpectedTypeErrors -> String Source # showList :: [ExpectedTypeErrors] -> ShowS Source #
Semigroup (DhallErrors e) Source # |
Instance details Defined in Dhall.Marshal.Decode Methods (<>) :: DhallErrors e -> DhallErrors e -> DhallErrors e Source # sconcat :: NonEmpty (DhallErrors e) -> DhallErrors e Source # stimes :: Integral b => b -> DhallErrors e -> DhallErrors e Source #
(Show (DhallErrors e), Typeable e) => Exception (DhallErrors e) Source # |
Instance details Defined in Dhall.Marshal.Decode Methods toException :: DhallErrors e -> SomeException Source # fromException :: SomeException -> Maybe (DhallErrors e) Source # displayException :: DhallErrors e -> String Source #
Eq e => Eq (DhallErrors e) Source # |
Instance details Defined in Dhall.Marshal.Decode Methods (==) :: DhallErrors e -> DhallErrors e -> Bool Source # (/=) :: DhallErrors e -> DhallErrors e -> Bool Source #
(Pretty s, Pretty a, Typeable s, Typeable a) => Show (ExtractErrors s a) Source # |
Instance details Defined in Dhall.Marshal.Decode Methods showsPrec :: Int -> ExtractErrors s a -> ShowS Source # show :: ExtractErrors s a -> String Source # showList :: [ExtractErrors s a] -> ShowS Source #

showDhallErrors :: Show e => String -> DhallErrors e -> String Source #

Render a given prefix and some errors to a string.

data InvalidDecoder s a Source #

Every `Decoder` must obey the contract that if an expression's type matches the `expected` type then the `extract` function must not fail with a type error. However, decoding may still fail for other reasons (such as the decoder for `Set`s rejecting a Dhall `List` with duplicate elements).

This error type is used to indicate an internal error in the implementation of a `Decoder` where the expected type matched the Dhall expression, but the expression supplied to the extraction function did not match the expected type. If this happens that means that the `Decoder` itself needs to be fixed.

Constructors

InvalidDecoder |

Fields

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

#### Instances

Instances details

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

## Extraction errors

type ExtractErrors s a = DhallErrors (ExtractError s a) Source #

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

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) |
ExpectedTypeError ExpectedTypeError |
ExtractError Text |

#### Instances

Instances details

(Pretty s, Pretty a, Typeable s, Typeable a) => Exception (ExtractError s a) Source # |
Instance details Defined in Dhall.Marshal.Decode Methods toException :: ExtractError s a -> SomeException Source # fromException :: SomeException -> Maybe (ExtractError s a) Source # displayException :: ExtractError s a -> String Source #
(Pretty s, Pretty a, Typeable s, Typeable a) => Show (ExtractError s a) Source # |
Instance details Defined in Dhall.Marshal.Decode 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) => Show (ExtractErrors s a) Source # |
Instance details Defined in Dhall.Marshal.Decode Methods showsPrec :: Int -> ExtractErrors s a -> ShowS Source # show :: ExtractErrors s a -> String Source # showList :: [ExtractErrors s a] -> ShowS Source #
(Eq s, Eq a) => Eq (ExtractError s a) Source # |
Instance details Defined in Dhall.Marshal.Decode Methods (==) :: ExtractError s a -> ExtractError s a -> Bool Source # (/=) :: ExtractError s a -> ExtractError s a -> Bool Source #

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

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

typeError :: Expector (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. The expected type is not yet determined.

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

Turn a `Text` message into an extraction failure.

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

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

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.

## Typing errors

type ExpectedTypeErrors = DhallErrors ExpectedTypeError Source #

One or more errors returned when determining the Dhall type of a Haskell expression.

data ExpectedTypeError Source #

Error type used when determining the Dhall type of a Haskell expression.

Constructors

RecursiveTypeError |

#### Instances

Instances details

Exception ExpectedTypeError Source # |
Instance details Defined in Dhall.Marshal.Decode Methods toException :: ExpectedTypeError -> SomeException Source # fromException :: SomeException -> Maybe ExpectedTypeError Source # displayException :: ExpectedTypeError -> String Source #
Show ExpectedTypeError Source # |
Instance details Defined in Dhall.Marshal.Decode Methods showsPrec :: Int -> ExpectedTypeError -> ShowS Source # show :: ExpectedTypeError -> String Source # showList :: [ExpectedTypeError] -> ShowS Source #
Show ExpectedTypeErrors Source # |
Instance details Defined in Dhall.Marshal.Decode Methods showsPrec :: Int -> ExpectedTypeErrors -> ShowS Source # show :: ExpectedTypeErrors -> String Source # showList :: [ExpectedTypeErrors] -> ShowS Source #
Eq ExpectedTypeError Source # |
Instance details Defined in Dhall.Marshal.Decode Methods (==) :: ExpectedTypeError -> ExpectedTypeError -> Bool Source # (/=) :: ExpectedTypeError -> ExpectedTypeError -> Bool Source #

type Expector = Validation ExpectedTypeErrors Source #

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

# Miscellaneous

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

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 (== '_') })

data Result f Source #

This type is exactly the same as `Fix` except with a different `FromDhall` instance. This intermediate type simplifies the implementation of the inner loop for the `FromDhall` instance for `Fix`.

#### Instances

Instances details

FromDhall (f (Result f)) => FromDhall (Result f) Source # |
Instance details Defined in Dhall.Marshal.Decode Methods autoWith :: InputNormalizer -> Decoder (Result f) Source #
ToDhall (f (Result f)) => ToDhall (Result f) Source # |
Instance details Defined in Dhall.Marshal.Encode Methods injectWith :: InputNormalizer -> Encoder (Result f) Source #

# Re-exports

data Natural Source #

Natural number

Invariant: numbers <= 0xffffffffffffffff use the `NS` constructor

#### Instances

Instances details

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

Bits Natural | Since: base-4.8.0

Instance details

Defined in GHC.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 #

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 #

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 #
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 #
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 #
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 #
PrintfArg Natural | Since: base-4.8.0.0
Instance details Defined in Text.Printf Methods formatArg :: Natural -> FieldFormatter Source # parseFormat :: Natural -> ModifierParser Source #
Subtractive Natural |
Instance details Defined in Basement.Numerical.Subtractive Associated Types type Difference Natural Methods (-) :: Natural -> Natural -> Difference Natural
NFData Natural | Since: deepseq-1.4.0.0
Instance details Defined in Control.DeepSeq Methods rnf :: Natural -> () Source #
FromDhall Natural Source # |
Instance details Defined in Dhall.Marshal.Decode Methods autoWith :: InputNormalizer -> Decoder Natural Source #
ToDhall Natural Source # |
Instance details Defined in Dhall.Marshal.Encode Methods injectWith :: InputNormalizer -> Encoder Natural Source #
Eq Natural |
Instance details Defined in GHC.Num.Natural Methods (==) :: Natural -> Natural -> Bool Source # (/=) :: Natural -> Natural -> Bool Source #
Ord Natural |
Instance details Defined in GHC.Num.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 #
Hashable Natural |
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> Natural -> Int Source # hash :: Natural -> Int Source #
Pretty Natural |
Instance details Defined in Prettyprinter.Internal Methods pretty :: Natural -> Doc ann Source # prettyList :: [Natural] -> Doc ann Source #
UniformRange Natural |
Instance details Defined in System.Random.Internal Methods uniformRM :: StatefulGen g m => (Natural, Natural) -> g -> m Natural
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 #
KnownNat n => HasResolution (n :: Nat) | For example, `Fixed 1000` will give you a `Fixed` with a resolution of 1000.
Instance details Defined in Data.Fixed Methods resolution :: p n -> Integer Source #
TestCoercion SNat | Since: base-4.18.0.0
Instance details Defined in GHC.TypeNats Methods testCoercion :: forall (a :: k) (b :: k). SNat a -> SNat b -> Maybe (Coercion a b) Source #
TestEquality SNat | Since: base-4.18.0.0
Instance details Defined in GHC.TypeNats Methods testEquality :: forall (a :: k) (b :: k). SNat a -> SNat b -> Maybe (a :~: b) Source #
Lift Natural |
Instance details Defined in Language.Haskell.TH.Syntax Methods lift :: Quote m => Natural -> m Exp Source # liftTyped :: forall (m :: Type -> Type). Quote m => Natural -> Code m Natural Source #
type Difference Natural |
Instance details Defined in Basement.Numerical.Subtractive type Difference Natural = Maybe Natural
type Compare (a :: Natural) (b :: Natural) |
Instance details Defined in Data.Type.Ord type Compare (a :: Natural) (b :: Natural) = CmpNat a b

data Seq a Source #

General-purpose finite sequences.

#### Instances

Instances details

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 #
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 #
MonadFix Seq | Since: containers-0.5.11
Instance details Defined in Data.Sequence.Internal Methods mfix :: (a -> Seq a) -> Seq a 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 #
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 #

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 #
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 #
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 #
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 #
Functor Seq |
Instance details Defined in Data.Sequence.Internal Methods fmap :: (a -> b) -> Seq a -> Seq b Source # (<$) :: a -> Seq b -> Seq a Source #
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 #
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)
Hashable1 Seq | Since: hashable-1.3.4.0
Instance details Defined in Data.Hashable.Class Methods liftHashWithSalt :: (Int -> a -> Int) -> Int -> Seq a -> Int Source #
FoldableWithIndex Int Seq |

Instance details

Defined in WithIndex

Methods

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

ifoldMap' :: Monoid m => (Int -> a -> m) -> Seq a -> m Source #

ifoldr :: (Int -> a -> b -> b) -> b -> Seq a -> b Source #

ifoldl :: (Int -> b -> a -> b) -> b -> Seq a -> b Source #

ifoldr' :: (Int -> a -> b -> b) -> b -> Seq a -> b Source #

ifoldl' :: (Int -> b -> a -> b) -> b -> Seq a -> b Source #

FunctorWithIndex Int Seq | The position in the `Seq` is available as the index.
Instance details Defined in WithIndex Methods imap :: (Int -> a -> b) -> Seq a -> Seq b Source #
TraversableWithIndex Int Seq |
Instance details Defined in WithIndex Methods itraverse :: Applicative f => (Int -> a -> f b) -> Seq a -> f (Seq b) Source #
Lift a => Lift (Seq a :: Type) | Since: containers-0.6.6
Instance details Defined in Data.Sequence.Internal Methods lift :: Quote m => Seq a -> m Exp Source # liftTyped :: forall (m :: Type -> Type). Quote m => Seq a -> Code m (Seq a) 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 #
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 #
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 #

a ~ Char => IsString (Seq a) | Since: containers-0.5.7
Instance details Defined in Data.Sequence.Internal Methods fromString :: String -> 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 #
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 #
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 #
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 #
NFData a => NFData (Seq a) |
Instance details Defined in Data.Sequence.Internal Methods rnf :: Seq a -> () Source #
FromDhall a => FromDhall (Seq a) Source # |
Instance details Defined in Dhall.Marshal.Decode Methods autoWith :: InputNormalizer -> Decoder (Seq a) Source #
ToDhall a => ToDhall (Seq a) Source # |
Instance details Defined in Dhall.Marshal.Encode Methods injectWith :: InputNormalizer -> Encoder (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 #
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 #
Hashable v => Hashable (Seq v) | Since: hashable-1.3.4.0
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> Seq v -> Int Source # hash :: Seq v -> Int Source #
Ord a => Stream (Seq a) | Since: megaparsec-9.0.0

Instance details

Defined in Text.Megaparsec.Stream

Associated Types

type Token (Seq a) Source #

type Tokens (Seq a) Source #

Methods

tokenToChunk :: Proxy (Seq a) -> Token (Seq a) -> Tokens (Seq a) Source #

tokensToChunk :: Proxy (Seq a) -> [Token (Seq a)] -> Tokens (Seq a) Source #

chunkToTokens :: Proxy (Seq a) -> Tokens (Seq a) -> [Token (Seq a)] Source #

chunkLength :: Proxy (Seq a) -> Tokens (Seq a) -> Int Source #

chunkEmpty :: Proxy (Seq a) -> Tokens (Seq a) -> Bool Source #

take1_ :: Seq a -> Maybe (Token (Seq a), Seq a) Source #

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

takeWhile_ :: (Token (Seq a) -> Bool) -> Seq a -> (Tokens (Seq a), 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 #
type Item (Seq a) |
Instance details Defined in Data.Sequence.Internal type Item (Seq a) = a
type Token (Seq a) |
Instance details Defined in Text.Megaparsec.Stream type Token (Seq a) = a
type Tokens (Seq a) |
Instance details Defined in Text.Megaparsec.Stream type Tokens (Seq a) = Seq a

data Text Source #

A space efficient, packed, unboxed Unicode text type.

#### Instances

Instances details

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 #
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 #
ToJSONKey Text |
Instance details Defined in Data.Aeson.Types.ToJSON Methods toJSONKey :: ToJSONKeyFunction Text Source # toJSONKeyList :: ToJSONKeyFunction [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
FoldCase Text |
Instance details Defined in Data.CaseInsensitive.Internal Methods foldCase :: Text -> Text Source # foldCaseList :: [Text] -> [Text]
FromDhall Text Source # |
Instance details Defined in Dhall.Marshal.Decode Methods autoWith :: InputNormalizer -> Decoder Text Source #
ToDhall Text Source # |
Instance details Defined in Dhall.Marshal.Encode Methods injectWith :: InputNormalizer -> Encoder Text Source #
Hashable Text |
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> Text -> Int Source # hash :: Text -> Int Source #
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 #

TraversableStream Text |
Instance details Defined in Text.Megaparsec.Stream Methods reachOffset :: Int -> PosState Text -> (Maybe String, PosState Text) Source # reachOffsetNoLine :: Int -> PosState Text -> PosState Text Source #
VisualStream Text |
Instance details Defined in Text.Megaparsec.Stream Methods showTokens :: Proxy Text -> NonEmpty (Token Text) -> String Source # tokensLength :: Proxy Text -> NonEmpty (Token Text) -> Int 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 Prettyprinter.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 #
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 #

mkParsec :: (State Text Void -> Reply Void Text a) -> Parser a Source #

Stream (NoShareInput Text) |

Instance details

Defined in Text.Megaparsec.Stream

Associated Types

type Token (NoShareInput Text) Source #

type Tokens (NoShareInput Text) Source #

Methods

tokenToChunk :: Proxy (NoShareInput Text) -> Token (NoShareInput Text) -> Tokens (NoShareInput Text) Source #

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

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

chunkLength :: Proxy (NoShareInput Text) -> Tokens (NoShareInput Text) -> Int Source #

chunkEmpty :: Proxy (NoShareInput Text) -> Tokens (NoShareInput Text) -> Bool Source #

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

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

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

Stream (ShareInput Text) |

Instance details

Defined in Text.Megaparsec.Stream

Associated Types

type Token (ShareInput Text) Source #

type Tokens (ShareInput Text) Source #

Methods

tokenToChunk :: Proxy (ShareInput Text) -> Token (ShareInput Text) -> Tokens (ShareInput Text) Source #

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

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

chunkLength :: Proxy (ShareInput Text) -> Tokens (ShareInput Text) -> Int Source #

chunkEmpty :: Proxy (ShareInput Text) -> Tokens (ShareInput Text) -> Bool Source #

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

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

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

type ChunkElem Text |
Instance details Defined in Data.Attoparsec.Internal.Types type ChunkElem Text = Char
type State Text |
Instance details Defined in Data.Attoparsec.Internal.Types type State Text = Buffer
type Item Text |
Instance details Defined in Data.Text type Item Text = Char
type Token Text |
Instance details Defined in Text.Megaparsec.Stream type Token Text = Token (ShareInput Text)
type Tokens Text |
Instance details Defined in Text.Megaparsec.Stream type Tokens Text = Tokens (ShareInput Text)
type Token (NoShareInput Text) |
Instance details Defined in Text.Megaparsec.Stream type Token (NoShareInput Text) = Char
type Token (ShareInput Text) |
Instance details Defined in Text.Megaparsec.Stream type Token (ShareInput Text) = Char
type Tokens (NoShareInput Text) |
Instance details Defined in Text.Megaparsec.Stream type Tokens (NoShareInput Text) = Text
type Tokens (ShareInput Text) |
Instance details Defined in Text.Megaparsec.Stream type Tokens (ShareInput Text) = Text

data Vector a Source #

Boxed vectors, supporting efficient slicing.

#### Instances

Instances details

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 #
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 #
MonadFail Vector | Since: vector-0.12.1.0
Instance details Defined in Data.Vector Methods fail :: String -> Vector a Source #
MonadFix Vector | This instance has the same semantics as the one for lists. Since: vector-0.12.2.0
Instance details Defined in Data.Vector Methods mfix :: (a -> Vector a) -> Vector a 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 #
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 #

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 #
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 #
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 #
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 #
Functor Vector |
Instance details Defined in Data.Vector Methods fmap :: (a -> b) -> Vector a -> Vector b Source # (<$) :: a -> Vector b -> Vector a Source #
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 #
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 :: Mutable Vector s a -> ST s (Vector a) Source #

basicUnsafeThaw :: Vector a -> ST s (Mutable Vector s a) Source #

basicLength :: Vector a -> Int Source #

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

basicUnsafeIndexM :: Vector a -> Int -> Box a Source #

basicUnsafeCopy :: Mutable Vector s a -> Vector a -> ST s () Source #

elemseq :: Vector a -> a -> b -> b 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 #
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 #
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 #

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 #
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 #
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 #
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 #
NFData a => NFData (Vector a) |
Instance details Defined in Data.Vector Methods rnf :: Vector a -> () Source #
FromDhall a => FromDhall (Vector a) Source # |
Instance details Defined in Dhall.Marshal.Decode Methods autoWith :: InputNormalizer -> Decoder (Vector a) Source #
ToDhall a => ToDhall (Vector a) Source # |
Instance details Defined in Dhall.Marshal.Encode Methods injectWith :: InputNormalizer -> Encoder (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 #
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 #
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 #
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 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 All |
Instance details Defined in Data.Semigroup.Internal Associated Types type Rep All :: Type -> Type Source # Methods from :: All -> Rep All x Source # to :: Rep All x -> All Source #
Generic Any |
Instance details Defined in Data.Semigroup.Internal Associated Types type Rep Any :: Type -> Type Source # Methods from :: Any -> Rep Any x Source # to :: Rep Any x -> Any Source #
Generic Version |
Instance details Defined in Data.Version Associated Types type Rep Version :: Type -> Type Source # Methods from :: Version -> Rep Version x Source # to :: Rep Version x -> Version Source #
Generic Void |
Instance details Defined in GHC.Generics Associated Types type Rep Void :: Type -> Type Source # Methods from :: Void -> Rep Void x Source # to :: Rep Void x -> Void Source #
Generic Fingerprint |
Instance details Defined in GHC.Generics Associated Types type Rep Fingerprint :: Type -> Type Source # Methods from :: Fingerprint -> Rep Fingerprint x Source # to :: Rep Fingerprint x -> Fingerprint Source #
Generic Associativity |
Instance details Defined in GHC.Generics Associated Types type Rep Associativity :: Type -> Type Source # Methods from :: Associativity -> Rep Associativity x Source # to :: Rep Associativity x -> Associativity Source #
Generic DecidedStrictness |
Instance details Defined in GHC.Generics Associated Types type Rep DecidedStrictness :: Type -> Type Source # Methods from :: DecidedStrictness -> Rep DecidedStrictness x Source # to :: Rep DecidedStrictness x -> DecidedStrictness Source #
Generic Fixity |
Instance details Defined in GHC.Generics Associated Types type Rep Fixity :: Type -> Type Source # Methods from :: Fixity -> Rep Fixity x Source # to :: Rep Fixity x -> Fixity Source #
Generic SourceStrictness |
Instance details Defined in GHC.Generics Associated Types type Rep SourceStrictness :: Type -> Type Source # Methods from :: SourceStrictness -> Rep SourceStrictness x Source # to :: Rep SourceStrictness x -> SourceStrictness Source #
Generic SourceUnpackedness |
Instance details Defined in GHC.Generics Associated Types type Rep SourceUnpackedness :: Type -> Type Source # Methods from :: SourceUnpackedness -> Rep SourceUnpackedness x Source # to :: Rep SourceUnpackedness x -> SourceUnpackedness Source #
Generic 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 CCFlags |
Instance details Defined in GHC.RTS.Flags Associated Types type Rep CCFlags :: Type -> Type Source # Methods from :: CCFlags -> Rep CCFlags x Source # to :: Rep CCFlags x -> CCFlags Source #
Generic ConcFlags |
Instance details Defined in GHC.RTS.Flags Associated Types type Rep ConcFlags :: Type -> Type Source # Methods from :: ConcFlags -> Rep ConcFlags x Source # to :: Rep ConcFlags x -> ConcFlags Source #
Generic DebugFlags |
Instance details Defined in GHC.RTS.Flags Associated Types type Rep DebugFlags :: Type -> Type Source # Methods from :: DebugFlags -> Rep DebugFlags x Source # to :: Rep DebugFlags x -> DebugFlags Source #
Generic DoCostCentres |
Instance details Defined in GHC.RTS.Flags Associated Types type Rep DoCostCentres :: Type -> Type Source # Methods from :: DoCostCentres -> Rep DoCostCentres x Source # to :: Rep DoCostCentres x -> DoCostCentres Source #
Generic DoHeapProfile |
Instance details Defined in GHC.RTS.Flags Associated Types type Rep DoHeapProfile :: Type -> Type Source # Methods from :: DoHeapProfile -> Rep DoHeapProfile x Source # to :: Rep DoHeapProfile x -> DoHeapProfile Source #
Generic DoTrace |
Instance details Defined in GHC.RTS.Flags Associated Types type Rep DoTrace :: Type -> Type Source # Methods from :: DoTrace -> Rep DoTrace x Source # to :: Rep DoTrace x -> DoTrace Source #
Generic GCFlags |
Instance details Defined in GHC.RTS.Flags Associated Types type Rep GCFlags :: Type -> Type Source # Methods from :: GCFlags -> Rep GCFlags x Source # to :: Rep GCFlags x -> GCFlags Source #
Generic GiveGCStats |
Instance details Defined in GHC.RTS.Flags Associated Types type Rep GiveGCStats :: Type -> Type Source # Methods from :: GiveGCStats -> Rep GiveGCStats x Source # to :: Rep GiveGCStats x -> GiveGCStats Source #
Generic MiscFlags |
Instance details Defined in GHC.RTS.Flags Associated Types type Rep MiscFlags :: Type -> Type Source # Methods from :: MiscFlags -> Rep MiscFlags x Source # to :: Rep MiscFlags x -> MiscFlags Source #
Generic ParFlags |
Instance details Defined in GHC.RTS.Flags Associated Types type Rep ParFlags :: Type -> Type Source # Methods from :: ParFlags -> Rep ParFlags x Source # to :: Rep ParFlags x -> ParFlags Source #
Generic ProfFlags |
Instance details Defined in GHC.RTS.Flags Associated Types type Rep ProfFlags :: Type -> Type Source # Methods from :: ProfFlags -> Rep ProfFlags x Source # to :: Rep ProfFlags x -> ProfFlags Source #
Generic RTSFlags |
Instance details Defined in GHC.RTS.Flags Associated Types type Rep RTSFlags :: Type -> Type Source # Methods from :: RTSFlags -> Rep RTSFlags x Source # to :: Rep RTSFlags x -> RTSFlags Source #
Generic TickyFlags |
Instance details Defined in GHC.RTS.Flags Associated Types type Rep TickyFlags :: Type -> Type Source # Methods from :: TickyFlags -> Rep TickyFlags x Source # to :: Rep TickyFlags x -> TickyFlags Source #
Generic TraceFlags |
Instance details Defined in GHC.RTS.Flags Associated Types type Rep TraceFlags :: Type -> Type Source # Methods from :: TraceFlags -> Rep TraceFlags x Source # to :: Rep TraceFlags x -> TraceFlags Source #
Generic SrcLoc |
Instance details Defined in GHC.Generics Associated Types type Rep SrcLoc :: Type -> Type Source # Methods from :: SrcLoc -> Rep SrcLoc x Source # to :: Rep SrcLoc x -> SrcLoc Source #
Generic GCDetails |
Instance details Defined in GHC.Stats Associated Types type Rep GCDetails :: Type -> Type Source # Methods from :: GCDetails -> Rep GCDetails x Source # to :: Rep GCDetails x -> GCDetails Source #
Generic RTSStats |
Instance details Defined in GHC.Stats Associated Types type Rep RTSStats :: Type -> Type Source # Methods from :: RTSStats -> Rep RTSStats x Source # to :: Rep RTSStats x -> RTSStats Source #
Generic GeneralCategory |
Instance details Defined in GHC.Generics Associated Types type Rep GeneralCategory :: Type -> Type Source # Methods from :: GeneralCategory -> Rep GeneralCategory x Source # to :: Rep GeneralCategory x -> GeneralCategory 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 FilesystemEntry Source # |
Instance details Defined in Dhall.DirectoryTree.Types Associated Types type Rep FilesystemEntry :: Type -> Type Source # Methods from :: FilesystemEntry -> Rep FilesystemEntry x Source # to :: Rep FilesystemEntry x -> FilesystemEntry Source #
Generic Group Source # |
Instance details Defined in Dhall.DirectoryTree.Types Associated Types type Rep Group :: Type -> Type Source # Methods from :: Group -> Rep Group x Source # to :: Rep Group x -> Group Source #
Generic User Source # |
Instance details Defined in Dhall.DirectoryTree.Types Associated Types type Rep User :: Type -> Type Source # Methods from :: User -> Rep User x Source # to :: Rep User x -> User Source #
Generic CharacterSet Source # |
Instance details Defined in Dhall.Pretty.Internal Associated Types type Rep CharacterSet :: Type -> Type Source # Methods from :: CharacterSet -> Rep CharacterSet x Source # to :: Rep CharacterSet x -> CharacterSet 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 Const Source # |
Instance details Defined in Dhall.Syntax.Const Associated Types type Rep Const :: Type -> Type Source # Methods from :: Const -> Rep Const x Source # to :: Rep Const x -> Const Source #
Generic Directory Source # |
Instance details Defined in Dhall.Syntax.Import Associated Types type Rep Directory :: Type -> Type Source # Methods from :: Directory -> Rep Directory x Source # to :: Rep Directory x -> Directory Source #
Generic File Source # |
Instance details Defined in Dhall.Syntax.Import Associated Types type Rep File :: Type -> Type Source # Methods from :: File -> Rep File x Source # to :: Rep File x -> File Source #
Generic FilePrefix Source # |
Instance details Defined in Dhall.Syntax.Import Associated Types type Rep FilePrefix :: Type -> Type Source # Methods from :: FilePrefix -> Rep FilePrefix x Source # to :: Rep FilePrefix x -> FilePrefix Source #
Generic Import Source # |
Instance details Defined in Dhall.Syntax.Import 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.Import 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.Import 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.Import Associated Types type Rep ImportType :: Type -> Type Source # Methods from :: ImportType -> Rep ImportType x Source # to :: Rep ImportType x -> ImportType Source #
Generic Scheme Source # |
Instance details Defined in Dhall.Syntax.Import Associated Types type Rep Scheme :: Type -> Type Source # Methods from :: Scheme -> Rep Scheme x Source # to :: Rep Scheme x -> Scheme Source #
Generic URL Source # |
Instance details Defined in Dhall.Syntax.Import Associated Types type Rep URL :: Type -> Type Source # Methods from :: URL -> Rep URL x Source # to :: Rep URL x -> URL Source #
Generic DhallDouble Source # |
Instance details Defined in Dhall.Syntax.Types Associated Types type Rep DhallDouble :: Type -> Type Source # Methods from :: DhallDouble -> Rep DhallDouble x Source # to :: Rep DhallDouble x -> DhallDouble Source #
Generic PreferAnnotation Source # |
Instance details Defined in Dhall.Syntax.Types Associated Types type Rep PreferAnnotation :: Type -> Type Source # Methods from :: PreferAnnotation -> Rep PreferAnnotation x Source # to :: Rep PreferAnnotation x -> PreferAnnotation Source #
Generic WithComponent Source # |
Instance details Defined in Dhall.Syntax.Types Associated Types type Rep WithComponent :: Type -> Type Source # Methods from :: WithComponent -> Rep WithComponent x Source # to :: Rep WithComponent x -> WithComponent Source #
Generic Var Source # |
Instance details Defined in Dhall.Syntax.Var Associated Types type Rep Var :: Type -> Type Source # Methods from :: Var -> Rep Var x Source # to :: Rep Var x -> Var Source #
Generic OsChar |
Instance details Defined in System.OsString.Internal.Types.Hidden Associated Types type Rep OsChar :: Type -> Type Source # Methods from :: OsChar -> Rep OsChar x Source # to :: Rep OsChar x -> OsChar Source #
Generic OsString |
Instance details Defined in System.OsString.Internal.Types.Hidden Associated Types type Rep OsString :: Type -> Type Source # Methods from :: OsString -> Rep OsString x Source # to :: Rep OsString x -> OsString Source #
Generic PosixChar |
Instance details Defined in System.OsString.Internal.Types.Hidden Associated Types type Rep PosixChar :: Type -> Type Source # Methods from :: PosixChar -> Rep PosixChar x Source # to :: Rep PosixChar x -> PosixChar Source #
Generic PosixString |
Instance details Defined in System.OsString.Internal.Types.Hidden Associated Types type Rep PosixString :: Type -> Type Source # Methods from :: PosixString -> Rep PosixString x Source # to :: Rep PosixString x -> PosixString Source #
Generic WindowsChar |
Instance details Defined in System.OsString.Internal.Types.Hidden Associated Types type Rep WindowsChar :: Type -> Type Source # Methods from :: WindowsChar -> Rep WindowsChar x Source # to :: Rep WindowsChar x -> WindowsChar Source #
Generic WindowsString |
Instance details Defined in System.OsString.Internal.Types.Hidden Associated Types type Rep WindowsString :: Type -> Type Source # Methods from :: WindowsString -> Rep WindowsString x Source # to :: Rep WindowsString x -> WindowsString 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 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 Ordering |
Instance details Defined in GHC.Generics Associated Types type Rep Ordering :: Type -> Type Source # Methods from :: Ordering -> Rep Ordering x Source # to :: Rep Ordering x -> Ordering Source #
Generic Half |
Instance details Defined in Numeric.Half.Internal Associated Types type Rep Half :: Type -> Type Source # Methods from :: Half -> Rep Half x Source # to :: Rep Half x -> Half Source #
Generic ByteRange |
Instance details Defined in Network.HTTP.Types.Header Associated Types type Rep ByteRange :: Type -> Type Source # Methods from :: ByteRange -> Rep ByteRange x Source # to :: Rep ByteRange x -> ByteRange Source #
Generic StdMethod |
Instance details Defined in Network.HTTP.Types.Method Associated Types type Rep StdMethod :: Type -> Type Source # Methods from :: StdMethod -> Rep StdMethod x Source # to :: Rep StdMethod x -> StdMethod Source #
Generic Status |
Instance details Defined in Network.HTTP.Types.Status Associated Types type Rep Status :: Type -> Type Source # Methods from :: Status -> Rep Status x Source # to :: Rep Status x -> Status Source #
Generic HttpVersion |
Instance details Defined in Network.HTTP.Types.Version Associated Types type Rep HttpVersion :: Type -> Type Source # Methods from :: HttpVersion -> Rep HttpVersion x Source # to :: Rep HttpVersion x -> HttpVersion Source #
Generic IP |
Instance details Defined in Data.IP.Addr Associated Types type Rep IP :: Type -> Type Source # Methods from :: IP -> Rep IP x Source # to :: Rep IP x -> IP Source #
Generic IPv4 |
Instance details Defined in Data.IP.Addr Associated Types type Rep IPv4 :: Type -> Type Source # Methods from :: IPv4 -> Rep IPv4 x Source # to :: Rep IPv4 x -> IPv4 Source #
Generic IPv6 |
Instance details Defined in Data.IP.Addr Associated Types type Rep IPv6 :: Type -> Type Source # Methods from :: IPv6 -> Rep IPv6 x Source # to :: Rep IPv6 x -> IPv6 Source #
Generic IPRange |
Instance details Defined in Data.IP.Range Associated Types type Rep IPRange :: Type -> Type Source # Methods from :: IPRange -> Rep IPRange x Source # to :: Rep IPRange x -> IPRange 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 Pos |
Instance details Defined in Text.Megaparsec.Pos Associated Types type Rep Pos :: Type -> Type Source # Methods from :: Pos -> Rep Pos x Source # to :: Rep Pos x -> Pos 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 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 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 OsChar |
Instance details Defined in System.OsString.Internal.Types Associated Types type Rep OsChar :: Type -> Type Source # Methods from :: OsChar -> Rep OsChar x Source # to :: Rep OsChar x -> OsChar Source #
Generic OsString |
Instance details Defined in System.OsString.Internal.Types Associated Types type Rep OsString :: Type -> Type Source # Methods from :: OsString -> Rep OsString x Source # to :: Rep OsString x -> OsString Source #
Generic PosixChar |
Instance details Defined in System.OsString.Internal.Types Associated Types type Rep PosixChar :: Type -> Type Source # Methods from :: PosixChar -> Rep PosixChar x Source # to :: Rep PosixChar x -> PosixChar Source #
Generic PosixString |
Instance details Defined in System.OsString.Internal.Types Associated Types type Rep PosixString :: Type -> Type Source # Methods from :: PosixString -> Rep PosixString x Source # to :: Rep PosixString x -> PosixString Source #
Generic WindowsChar |
Instance details Defined in System.OsString.Internal.Types Associated Types type Rep WindowsChar :: Type -> Type Source # Methods from :: WindowsChar -> Rep WindowsChar x Source # to :: Rep WindowsChar x -> WindowsChar Source #
Generic WindowsString |
Instance details Defined in System.OsString.Internal.Types Associated Types type Rep WindowsString :: Type -> Type Source # Methods from :: WindowsString -> Rep WindowsString x Source # to :: Rep WindowsString x -> WindowsString 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 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 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 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 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 Style |
Instance details Defined in Text.Pretty.Simple.Internal.Color Associated Types type Rep Style :: Type -> Type Source # Methods from :: Style -> Rep Style x Source # to :: Rep Style x -> Style 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 CheckColorTty |
Instance details Defined in Text.Pretty.Simple.Internal.Printer 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.Printer Associated Types type Rep OutputOptions :: Type -> Type Source # Methods from :: OutputOptions -> Rep OutputOptions x Source # to :: Rep OutputOptions x -> OutputOptions Source #
Generic StringOutputStyle |
Instance details Defined in Text.Pretty.Simple.Internal.Printer Associated Types type Rep StringOutputStyle :: Type -> Type Source # Methods from :: StringOutputStyle -> Rep StringOutputStyle x Source # to :: Rep StringOutputStyle x -> StringOutputStyle 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 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 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 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 Bytes |
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep Bytes :: Type -> Type Source # Methods from :: Bytes -> Rep Bytes x Source # to :: Rep Bytes x -> Bytes 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 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 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 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 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 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 DocLoc |
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep DocLoc :: Type -> Type Source # Methods from :: DocLoc -> Rep DocLoc x Source # to :: Rep DocLoc x -> DocLoc 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 Specificity |
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep Specificity :: Type -> Type Source # Methods from :: Specificity -> Rep Specificity x Source # to :: Rep Specificity x -> Specificity 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 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 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 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 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 UnixTime |
Instance details Defined in Data.UnixTime.Types Associated Types type Rep UnixTime :: Type -> Type Source # Methods from :: UnixTime -> Rep UnixTime x Source # to :: Rep UnixTime x -> UnixTime 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 () |
Instance details Defined in GHC.Generics Associated Types type Rep () :: Type -> Type Source # Methods from :: () -> Rep () x Source # to :: Rep () x -> () Source #
Generic Bool |
Instance details Defined in GHC.Generics Associated Types type Rep Bool :: Type -> Type Source # Methods from :: Bool -> Rep Bool x Source # to :: Rep Bool x -> Bool Source #
Generic (ZipList a) |
Instance details Defined in Control.Applicative Associated Types type Rep (ZipList a) :: Type -> Type Source # Methods from :: ZipList a -> Rep (ZipList a) x Source # to :: Rep (ZipList a) x -> ZipList a Source #
Generic (Complex a) |
Instance details Defined in Data.Complex Associated Types type Rep (Complex a) :: Type -> Type Source # Methods from :: Complex a -> Rep (Complex a) x Source # to :: Rep (Complex a) x -> Complex a Source #
Generic (Identity a) |
Instance details Defined in Data.Functor.Identity Associated Types type Rep (Identity a) :: Type -> Type Source # Methods from :: Identity a -> Rep (Identity a) x Source # to :: Rep (Identity a) x -> Identity a Source #
Generic (First a) |
Instance details Defined in Data.Monoid Associated Types type Rep (First a) :: Type -> Type Source # Methods from :: First a -> Rep (First a) x Source # to :: Rep (First a) x -> First a Source #
Generic (Last a) |
Instance details Defined in Data.Monoid Associated Types type Rep (Last a) :: Type -> Type Source # Methods from :: Last a -> Rep (Last a) x Source # to :: Rep (Last a) x -> Last a Source #
Generic (Down a) |
Instance details Defined in GHC.Generics Associated Types type Rep (Down a) :: Type -> Type Source # Methods from :: Down a -> Rep (Down a) x Source # to :: Rep (Down a) x -> Down a Source #
Generic (First a) |
Instance details Defined in Data.Semigroup Associated Types type Rep (First a) :: Type -> Type Source # Methods from :: First a -> Rep (First a) x Source # to :: Rep (First a) x -> First a Source #
Generic (Last a) |
Instance details Defined in Data.Semigroup Associated Types type Rep (Last a) :: Type -> Type Source # Methods from :: Last a -> Rep (Last a) x Source # to :: Rep (Last a) x -> Last a Source #
Generic (Max a) |
Instance details Defined in Data.Semigroup Associated Types type Rep (Max a) :: Type -> Type Source # Methods from :: Max a -> Rep (Max a) x Source # to :: Rep (Max a) x -> Max a Source #
Generic (Min a) |
Instance details Defined in Data.Semigroup Associated Types type Rep (Min a) :: Type -> Type Source # Methods from :: Min a -> Rep (Min a) x Source # to :: Rep (Min a) x -> Min a Source #
Generic (WrappedMonoid m) |
Instance details Defined in Data.Semigroup Associated Types type Rep (WrappedMonoid m) :: Type -> Type Source # Methods from :: WrappedMonoid m -> Rep (WrappedMonoid m) x Source # to :: Rep (WrappedMonoid m) x -> WrappedMonoid m Source #
Generic (Dual a) |
Instance details Defined in Data.Semigroup.Internal Associated Types type Rep (Dual a) :: Type -> Type Source # Methods from :: Dual a -> Rep (Dual a) x Source # to :: Rep (Dual a) x -> Dual a Source #
Generic (Endo a) |
Instance details Defined in Data.Semigroup.Internal Associated Types type Rep (Endo a) :: Type -> Type Source # Methods from :: Endo a -> Rep (Endo a) x Source # to :: Rep (Endo a) x -> Endo a Source #
Generic (Product a) |
Instance details Defined in Data.Semigroup.Internal Associated Types type Rep (Product a) :: Type -> Type Source # Methods from :: Product a -> Rep (Product a) x Source # to :: Rep (Product a) x -> Product a Source #
Generic (Sum a) |
Instance details Defined in Data.Semigroup.Internal Associated Types type Rep (Sum a) :: Type -> Type Source # Methods from :: Sum a -> Rep (Sum a) x Source # to :: Rep (Sum a) x -> Sum a Source #
Generic (NonEmpty a) |
Instance details Defined in GHC.Generics Associated Types type Rep (NonEmpty a) :: Type -> Type Source # Methods from :: NonEmpty a -> Rep (NonEmpty a) x Source # to :: Rep (NonEmpty a) x -> NonEmpty a Source #
Generic (Par1 p) |
Instance details Defined in GHC.Generics Associated Types type Rep (Par1 p) :: Type -> Type Source # Methods from :: Par1 p -> Rep (Par1 p) x Source # to :: Rep (Par1 p) x -> Par1 p Source #
Generic (Digit a) |
Instance details Defined in Data.Sequence.Internal Associated Types type Rep (Digit a) :: Type -> Type Source # Methods from :: Digit a -> Rep (Digit a) x Source # to :: Rep (Digit a) x -> Digit a Source #
Generic (Elem a) |
Instance details Defined in Data.Sequence.Internal Associated Types type Rep (Elem a) :: Type -> Type Source # Methods from :: Elem a -> Rep (Elem a) x Source # to :: Rep (Elem a) x -> Elem a Source #
Generic (FingerTree a) |
Instance details Defined in Data.Sequence.Internal Associated Types type Rep (FingerTree a) :: Type -> Type Source # Methods from :: FingerTree a -> Rep (FingerTree a) x Source # to :: Rep (FingerTree a) x -> FingerTree a Source #
Generic (Node a) |
Instance details Defined in Data.Sequence.Internal Associated Types type Rep (Node a) :: Type -> Type Source # Methods from :: Node a -> Rep (Node a) x Source # to :: Rep (Node a) x -> Node a Source #
Generic (ViewL a) |
Instance details Defined in Data.Sequence.Internal Associated Types type Rep (ViewL a) :: Type -> Type Source # Methods from :: ViewL a -> Rep (ViewL a) x Source # to :: Rep (ViewL a) x -> ViewL a Source #
Generic (ViewR a) |
Instance details Defined in Data.Sequence.Internal Associated Types type Rep (ViewR a) :: Type -> Type Source # Methods from :: ViewR a -> Rep (ViewR a) x Source # to :: Rep (ViewR a) x -> ViewR a Source #
Generic (Tree a) |
Instance details Defined in Data.Tree Associated Types type Rep (Tree a) :: Type -> Type Source # Methods from :: Tree a -> Rep (Tree a) x Source # to :: Rep (Tree a) x -> Tree a Source #
Generic (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 (Access f) Source # |
Instance details Defined in Dhall.DirectoryTree.Types Associated Types type Rep (Access f) :: Type -> Type Source # Methods from :: Access f -> Rep (Access f) x Source # to :: Rep (Access f) x -> Access f Source #
Generic (Entry a) Source # |
Instance details Defined in Dhall.DirectoryTree.Types Associated Types type Rep (Entry a) :: Type -> Type Source # Methods from :: Entry a -> Rep (Entry a) x Source # to :: Rep (Entry a) x -> Entry a Source #
Generic (Mode f) Source # |
Instance details Defined in Dhall.DirectoryTree.Types Associated Types type Rep (Mode f) :: Type -> Type Source # Methods from :: Mode f -> Rep (Mode f) x Source # to :: Rep (Mode f) x -> Mode f 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 (FieldSelection s) Source # |
Instance details Defined in Dhall.Syntax.Types Associated Types type Rep (FieldSelection s) :: Type -> Type Source # Methods from :: FieldSelection s -> Rep (FieldSelection s) x Source # to :: Rep (FieldSelection s) x -> FieldSelection s 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 (AddrRange a) |
Instance details Defined in Data.IP.Range Associated Types type Rep (AddrRange a) :: Type -> Type Source # Methods from :: AddrRange a -> Rep (AddrRange a) x Source # to :: Rep (AddrRange a) x -> AddrRange a 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 (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 (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 Prettyprinter.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 Prettyprinter.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 (Maybe a) |
Instance details Defined in Data.Strict.Maybe 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 (TyVarBndr flag) |
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep (TyVarBndr flag) :: Type -> Type Source # Methods from :: TyVarBndr flag -> Rep (TyVarBndr flag) x Source # to :: Rep (TyVarBndr flag) x -> TyVarBndr flag Source #
Generic (Maybe a) |
Instance details Defined in GHC.Generics Associated Types type Rep (Maybe a) :: Type -> Type Source # Methods from :: Maybe a -> Rep (Maybe a) x Source # to :: Rep (Maybe a) x -> Maybe a Source #
Generic (a) |
Instance details Defined in GHC.Generics Associated Types type Rep (a) :: Type -> Type Source # Methods from :: (a) -> Rep (a) x Source # to :: Rep (a) x -> (a) Source #
Generic [a] |
Instance details Defined in GHC.Generics Associated Types type Rep [a] :: Type -> Type Source # Methods from :: [a] -> Rep [a] x Source # to :: Rep [a] x -> [a] Source #
Generic (WrappedMonad m a) |
Instance details Defined in Control.Applicative Associated Types type Rep (WrappedMonad m a) :: Type -> Type Source # Methods from :: WrappedMonad m a -> Rep (WrappedMonad m a) x Source # to :: Rep (WrappedMonad m a) x -> WrappedMonad m a Source #
Generic (Either a b) |
Instance details Defined in GHC.Generics Associated Types type Rep (Either a b) :: Type -> Type Source # Methods from :: Either a b -> Rep (Either a b) x Source # to :: Rep (Either a b) x -> Either a b Source #
Generic (Proxy t) |
Instance details Defined in GHC.Generics Associated Types type Rep (Proxy t) :: Type -> Type Source # Methods from :: Proxy t -> Rep (Proxy t) x Source # to :: Rep (Proxy t) x -> Proxy t Source #
Generic (Arg a b) |
Instance details Defined in Data.Semigroup Associated Types type Rep (Arg a b) :: Type -> Type Source # Methods from :: Arg a b -> Rep (Arg a b) x Source # to :: Rep (Arg a b) x -> Arg a b Source #
Generic (U1 p) |
Instance details Defined in GHC.Generics Associated Types type Rep (U1 p) :: Type -> Type Source # Methods from :: U1 p -> Rep (U1 p) x Source # to :: Rep (U1 p) x -> U1 p Source #
Generic (V1 p) |
Instance details Defined in GHC.Generics Associated Types type Rep (V1 p) :: Type -> Type Source # Methods from :: V1 p -> Rep (V1 p) x Source # to :: Rep (V1 p) x -> V1 p Source #
Generic (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 (Binding s a) Source # |
Instance details Defined in Dhall.Syntax.Binding 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 (Chunks s a) Source # |
Instance details Defined in Dhall.Syntax.Chunks 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 (Expr s a) Source # |
Instance details Defined in Dhall.Syntax.Expr 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 (FunctionBinding s a) Source # |
Instance details Defined in Dhall.Syntax.FunctionBinding Associated Types type Rep (FunctionBinding s a) :: Type -> Type Source # Methods from :: FunctionBinding s a -> Rep (FunctionBinding s a) x Source # to :: Rep (FunctionBinding s a) x -> FunctionBinding s a Source #
Generic (RecordField s a) Source # |
Instance details Defined in Dhall.Syntax.RecordField Associated Types type Rep (RecordField s a) :: Type -> Type Source # Methods from :: RecordField s a -> Rep (RecordField s a) x Source # to :: Rep (RecordField s a) x -> RecordField s a Source #
Generic (ParseError s e) |
Instance details Defined in Text.Megaparsec.Error Associated Types type Rep (ParseError s e) :: Type -> Type Source # Methods from :: ParseError s e -> Rep (ParseError s e) x Source # to :: Rep (ParseError s e) x -> ParseError s e Source #
Generic (ParseErrorBundle s e) |
Instance details Defined in Text.Megaparsec.Error Associated Types type Rep (ParseErrorBundle s e) :: Type -> Type Source # Methods from :: ParseErrorBundle s e -> Rep (ParseErrorBundle s e) x Source # to :: Rep (ParseErrorBundle s e) x -> ParseErrorBundle s e Source #
Generic (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 (Either a b) |
Instance details Defined in Data.Strict.Either 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 (These a b) |
Instance details Defined in Data.Strict.These Associated Types type Rep (These a b) :: Type -> Type Source # Methods from :: These a b -> Rep (These a b) x Source # to :: Rep (These a b) x -> These a b Source #
Generic (Pair a b) |
Instance details Defined in Data.Strict.Tuple Associated Types type Rep (Pair a b) :: Type -> Type Source # Methods from :: Pair a b -> Rep (Pair a b) x Source # to :: Rep (Pair a b) x -> Pair a b Source #
Generic (These a b) |
Instance details Defined in Data.These Associated Types type Rep (These a b) :: Type -> Type Source # Methods from :: These a b -> Rep (These a b) x Source # to :: Rep (These a b) x -> These a b Source #
Generic (Lift f a) |
Instance details Defined in Control.Applicative.Lift Associated Types type Rep (Lift f a) :: Type -> Type Source # Methods from :: Lift f a -> Rep (Lift f a) x Source # to :: Rep (Lift f a) x -> Lift f a Source #
Generic (MaybeT m a) |
Instance details Defined in Control.Monad.Trans.Maybe Associated Types type Rep (MaybeT m a) :: Type -> Type Source # Methods from :: MaybeT m a -> Rep (MaybeT m a) x Source # to :: Rep (MaybeT m a) x -> MaybeT m a Source #
Generic (a, b) |
Instance details Defined in GHC.Generics Associated Types type Rep (a, b) :: Type -> Type Source # Methods from :: (a, b) -> Rep (a, b) x Source # to :: Rep (a, b) x -> (a, b) Source #
Generic (WrappedArrow a b c) |
Instance details Defined in Control.Applicative Associated Types type Rep (WrappedArrow a b c) :: Type -> Type Source # Methods from :: WrappedArrow a b c -> Rep (WrappedArrow a b c) x Source # to :: Rep (WrappedArrow a b c) x -> WrappedArrow a b c Source #
Generic (Kleisli m a b) |
Instance details Defined in Control.Arrow Associated Types type Rep (Kleisli m a b) :: Type -> Type Source # Methods from :: Kleisli m a b -> Rep (Kleisli m a b) x Source # to :: Rep (Kleisli m a b) x -> Kleisli m a b Source #
Generic (Const a b) |
Instance details Defined in Data.Functor.Const Associated Types type Rep (Const a b) :: Type -> Type Source # Methods from :: Const a b -> Rep (Const a b) x Source # to :: Rep (Const a b) x -> Const a b Source #
Generic (Ap f a) |
Instance details Defined in Data.Monoid Associated Types type Rep (Ap f a) :: Type -> Type Source # Methods from :: Ap f a -> Rep (Ap f a) x Source # to :: Rep (Ap f a) x -> Ap f a Source #
Generic (Alt f a) |
Instance details Defined in Data.Semigroup.Internal Associated Types type Rep (Alt f a) :: Type -> Type Source # Methods from :: Alt f a -> Rep (Alt f a) x Source # to :: Rep (Alt f a) x -> Alt f a Source #
Generic (Rec1 f p) |
Instance details Defined in GHC.Generics Associated Types type Rep (Rec1 f p) :: Type -> Type Source # Methods from :: Rec1 f p -> Rep (Rec1 f p) x Source # to :: Rep (Rec1 f p) x -> Rec1 f p Source #
Generic (URec (Ptr ()) p) |
Instance details Defined in GHC.Generics Associated Types type Rep (URec (Ptr ()) p) :: Type -> Type Source # Methods from :: URec (Ptr ()) p -> Rep (URec (Ptr ()) p) x Source # to :: Rep (URec (Ptr ()) p) x -> URec (Ptr ()) p Source #
Generic (URec Char p) |
Instance details Defined in GHC.Generics Associated Types type Rep (URec Char p) :: Type -> Type Source # Methods from :: URec Char p -> Rep (URec Char p) x Source # to :: Rep (URec Char p) x -> URec Char p Source #
Generic (URec Double p) |
Instance details Defined in GHC.Generics Associated Types type Rep (URec Double p) :: Type -> Type Source # Methods from :: URec Double p -> Rep (URec Double p) x Source # to :: Rep (URec Double p) x -> URec Double p Source #
Generic (URec Float p) |
Instance details Defined in GHC.Generics Associated Types type Rep (URec Float p) :: Type -> Type Source # Methods from :: URec Float p -> Rep (URec Float p) x Source # to :: Rep (URec Float p) x -> URec Float p Source #
Generic (URec Int p) |
Instance details Defined in GHC.Generics Associated Types type Rep (URec Int p) :: Type -> Type Source # Methods from :: URec Int p -> Rep (URec Int p) x Source # to :: Rep (URec Int p) x -> URec Int p Source #
Generic (URec Word p) |
Instance details Defined in GHC.Generics Associated Types type Rep (URec Word p) :: Type -> Type Source # Methods from :: URec Word p -> Rep (URec Word p) x Source # to :: Rep (URec Word p) x -> URec Word p Source #
Generic (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 (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 (These1 f g a) |
Instance details Defined in Data.Functor.These Associated Types type Rep (These1 f g a) :: Type -> Type Source # Methods from :: These1 f g a -> Rep (These1 f g a) x Source # to :: Rep (These1 f g a) x -> These1 f g a Source #
Generic (Backwards f a) |
Instance details Defined in Control.Applicative.Backwards Associated Types type Rep (Backwards f a) :: Type -> Type Source # Methods from :: Backwards f a -> Rep (Backwards f a) x Source # to :: Rep (Backwards f a) x -> Backwards f a Source #
Generic (AccumT w m a) |
Instance details Defined in Control.Monad.Trans.Accum Associated Types type Rep (AccumT w m a) :: Type -> Type Source # Methods from :: AccumT w m a -> Rep (AccumT w m a) x Source # to :: Rep (AccumT w m a) x -> AccumT w m a Source #
Generic (ExceptT e m a) |
Instance details Defined in Control.Monad.Trans.Except Associated Types type Rep (ExceptT e m a) :: Type -> Type Source # Methods from :: ExceptT e m a -> Rep (ExceptT e m a) x Source # to :: Rep (ExceptT e m a) x -> ExceptT e m a Source #
Generic (IdentityT f a) |
Instance details Defined in Control.Monad.Trans.Identity Associated Types type Rep (IdentityT f a) :: Type -> Type Source # Methods from :: IdentityT f a -> Rep (IdentityT f a) x Source # to :: Rep (IdentityT f a) x -> IdentityT f a Source #
Generic (ReaderT r m a) |
Instance details Defined in Control.Monad.Trans.Reader Associated Types type Rep (ReaderT r m a) :: Type -> Type Source # Methods from :: ReaderT r m a -> Rep (ReaderT r m a) x Source # to :: Rep (ReaderT r m a) x -> ReaderT r m a Source #
Generic (SelectT r m a) |
Instance details Defined in Control.Monad.Trans.Select Associated Types type Rep (SelectT r m a) :: Type -> Type Source # Methods from :: SelectT r m a -> Rep (SelectT r m a) x Source # to :: Rep (SelectT r m a) x -> SelectT r m a Source #
Generic (StateT s m a) |
Instance details Defined in Control.Monad.Trans.State.Lazy Associated Types type Rep (StateT s m a) :: Type -> Type Source # Methods from :: StateT s m a -> Rep (StateT s m a) x Source # to :: Rep (StateT s m a) x -> StateT s m a Source #
Generic (StateT s m a) |
Instance details Defined in Control.Monad.Trans.State.Strict Associated Types type Rep (StateT s m a) :: Type -> Type Source # Methods from :: StateT s m a -> Rep (StateT s m a) x Source # to :: Rep (StateT s m a) x -> StateT s m a Source #
Generic (WriterT w m a) |
Instance details Defined in Control.Monad.Trans.Writer.CPS Associated Types type Rep (WriterT w m a) :: Type -> Type Source # Methods from :: WriterT w m a -> Rep (WriterT w m a) x Source # to :: Rep (WriterT w m a) x -> WriterT w m a Source #
Generic (WriterT w m a) |
Instance details Defined in Control.Monad.Trans.Writer.Lazy Associated Types type Rep (WriterT w m a) :: Type -> Type Source # Methods from :: WriterT w m a -> Rep (WriterT w m a) x Source # to :: Rep (WriterT w m a) x -> WriterT w m a Source #
Generic (WriterT w m a) |
Instance details Defined in Control.Monad.Trans.Writer.Strict Associated Types type Rep (WriterT w m a) :: Type -> Type Source # Methods from :: WriterT w m a -> Rep (WriterT w m a) x Source # to :: Rep (WriterT w m a) x -> WriterT w m a Source #
Generic (Constant a b) |
Instance details Defined in Data.Functor.Constant Associated Types type Rep (Constant a b) :: Type -> Type Source # Methods from :: Constant a b -> Rep (Constant a b) x Source # to :: Rep (Constant a b) x -> Constant a b Source #
Generic (Reverse f a) |
Instance details Defined in Data.Functor.Reverse Associated Types type Rep (Reverse f a) :: Type -> Type Source # Methods from :: Reverse f a -> Rep (Reverse f a) x Source # to :: Rep (Reverse f a) x -> Reverse f a Source #
Generic (a, b, c) |
Instance details Defined in GHC.Generics Associated Types type Rep (a, b, c) :: Type -> Type Source # Methods from :: (a, b, c) -> Rep (a, b, c) x Source # to :: Rep (a, b, c) x -> (a, b, c) Source #
Generic (Product f g a) |
Instance details Defined in Data.Functor.Product Associated Types type Rep (Product f g a) :: Type -> Type Source # Methods from :: Product f g a -> Rep (Product f g a) x Source # to :: Rep (Product f g a) x -> Product f g a Source #
Generic (Sum f g a) |
Instance details Defined in Data.Functor.Sum Associated Types type Rep (Sum f g a) :: Type -> Type Source # Methods from :: Sum f g a -> Rep (Sum f g a) x Source # to :: Rep (Sum f g a) x -> Sum f g a Source #
Generic ((f :*: g) p) |
Instance details Defined in GHC.Generics Associated Types type Rep ((f :*: g) p) :: Type -> Type Source # Methods from :: (f :*: g) p -> Rep ((f :*: g) p) x Source # to :: Rep ((f :*: g) p) x -> (f :*: g) p Source #
Generic ((f :+: g) p) |
Instance details Defined in GHC.Generics Associated Types type Rep ((f :+: g) p) :: Type -> Type Source # Methods from :: (f :+: g) p -> Rep ((f :+: g) p) x Source # to :: Rep ((f :+: g) p) x -> (f :+: g) p Source #
Generic (K1 i c p) |
Instance details Defined in GHC.Generics Associated Types type Rep (K1 i c p) :: Type -> Type Source # Methods from :: K1 i c p -> Rep (K1 i c p) x Source # to :: Rep (K1 i c p) x -> K1 i c p Source #
Generic (ContT r m a) |
Instance details Defined in Control.Monad.Trans.Cont Associated Types type Rep (ContT r m a) :: Type -> Type Source # Methods from :: ContT r m a -> Rep (ContT r m a) x Source # to :: Rep (ContT r m a) x -> ContT r m a Source #
Generic (a, b, c, d) |
Instance details Defined in GHC.Generics Associated Types type Rep (a, b, c, d) :: Type -> Type Source # Methods from :: (a, b, c, d) -> Rep (a, b, c, d) x Source # to :: Rep (a, b, c, d) x -> (a, b, c, d) Source #
Generic (Compose f g a) |
Instance details Defined in Data.Functor.Compose Associated Types type Rep (Compose f g a) :: Type -> Type Source # Methods from :: Compose f g a -> Rep (Compose f g a) x Source # to :: Rep (Compose f g a) x -> Compose f g a Source #
Generic ((f :.: g) p) |
Instance details Defined in GHC.Generics Associated Types type Rep ((f :.: g) p) :: Type -> Type Source # Methods from :: (f :.: g) p -> Rep ((f :.: g) p) x Source # to :: Rep ((f :.: g) p) x -> (f :.: g) p Source #
Generic (M1 i c f p) |
Instance details Defined in GHC.Generics Associated Types type Rep (M1 i c f p) :: Type -> Type Source # Methods from :: M1 i c f p -> Rep (M1 i c f p) x Source # to :: Rep (M1 i c f p) x -> M1 i c f p Source #
Generic (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 (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 (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 (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 (RWST r w s m a) |
Instance details Defined in Control.Monad.Trans.RWS.CPS Associated Types type Rep (RWST r w s m a) :: Type -> Type Source # Methods from :: RWST r w s m a -> Rep (RWST r w s m a) x Source # to :: Rep (RWST r w s m a) x -> RWST r w s m a Source #
Generic (RWST r w s m a) |
Instance details Defined in Control.Monad.Trans.RWS.Lazy Associated Types type Rep (RWST r w s m a) :: Type -> Type Source # Methods from :: RWST r w s m a -> Rep (RWST r w s m a) x Source # to :: Rep (RWST r w s m a) x -> RWST r w s m a Source #
Generic (RWST r w s m a) |
Instance details Defined in Control.Monad.Trans.RWS.Strict Associated Types type Rep (RWST r w s m a) :: Type -> Type Source # Methods from :: RWST r w s m a -> Rep (RWST r w s m a) x Source # to :: Rep (RWST r w s m a) x -> RWST r w s m a Source #
Generic (a, b, c, d, e) |
Instance details Defined in GHC.Generics Associated Types type Rep (a, b, c, d, e) :: Type -> Type Source # Methods from :: (a, b, c, d, e) -> Rep (a, b, c, d, e) x Source # to :: Rep (a, b, c, d, e) x -> (a, b, c, d, e) Source #
Generic (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) |
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 (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 (a, b, c, d, e, f, g) |
Instance details Defined in GHC.Generics Associated Types type Rep (a, b, c, d, e, f, g) :: Type -> Type Source # Methods from :: (a, b, c, d, e, f, g) -> Rep (a, b, c, d, e, f, g) x Source # to :: Rep (a, b, c, d, e, f, g) x -> (a, b, c, d, e, f, g) Source #
Generic (a, b, c, d, e, f, g, h) |
Instance details Defined in GHC.Generics Associated Types type Rep (a, b, c, d, e, f, g, h) :: Type -> Type Source # Methods from :: (a, b, c, d, e, f, g, h) -> Rep (a, b, c, d, e, f, g, h) x Source # to :: Rep (a, b, c, d, e, f, g, h) x -> (a, b, c, d, e, f, g, h) 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 #
Generic (a, b, c, d, e, f, g, h, i) |
Instance details Defined in GHC.Generics Associated Types type Rep (a, b, c, d, e, f, g, h, i) :: Type -> Type Source # Methods from :: (a, b, c, d, e, f, g, h, i) -> Rep (a, b, c, d, e, f, g, h, i) x Source # to :: Rep (a, b, c, d, e, f, g, h, i) x -> (a, b, c, d, e, f, g, h, i) Source #
Generic (a, b, c, d, e, f, g, h, i, j) |
Instance details Defined in GHC.Generics Associated Types type Rep (a, b, c, d, e, f, g, h, i, j) :: Type -> Type Source # Methods from :: (a, b, c, d, e, f, g, h, i, j) -> Rep (a, b, c, d, e, f, g, h, i, j) x Source # to :: Rep (a, b, c, d, e, f, g, h, i, j) x -> (a, b, c, d, e, f, g, h, i, j) Source #
Generic (a, b, c, d, e, f, g, h, i, j, k) |
Instance details Defined in GHC.Generics Associated Types type Rep (a, b, c, d, e, f, g, h, i, j, k) :: Type -> Type Source # Methods from :: (a, b, c, d, e, f, g, h, i, j, k) -> Rep (a, b, c, d, e, f, g, h, i, j, k) x Source # to :: Rep (a, b, c, d, e, f, g, h, i, j, k) x -> (a, b, c, d, e, f, g, h, i, j, k) Source #
Generic (a, b, c, d, e, f, g, h, i, j, k, l) |
Instance details Defined in GHC.Generics Associated Types type Rep (a, b, c, d, e, f, g, h, i, j, k, l) :: Type -> Type Source # Methods from :: (a, b, c, d, e, f, g, h, i, j, k, l) -> Rep (a, b, c, d, e, f, g, h, i, j, k, l) x Source # to :: Rep (a, b, c, d, e, f, g, h, i, j, k, l) x -> (a, b, c, d, e, f, g, h, i, j, k, l) Source #
Generic (a, b, c, d, e, f, g, h, i, j, k, l, m) |
Instance details Defined in GHC.Generics Associated Types type Rep (a, b, c, d, e, f, g, h, i, j, k, l, m) :: Type -> Type Source # Methods from :: (a, b, c, d, e, f, g, h, i, j, k, l, m) -> Rep (a, b, c, d, e, f, g, h, i, j, k, l, m) x Source # to :: Rep (a, b, c, d, e, f, g, h, i, j, k, l, m) x -> (a, b, c, d, e, f, g, h, i, j, k, l, m) Source #
Generic (a, b, c, d, e, f, g, h, i, j, k, l, m, n) |
Instance details Defined in GHC.Generics Associated Types type Rep (a, b, c, d, e, f, g, h, i, j, k, l, m, n) :: Type -> Type Source # Methods from :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> Rep (a, b, c, d, e, f, g, h, i, j, k, l, m, n) x Source # to :: Rep (a, b, c, d, e, f, g, h, i, j, k, l, m, n) x -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n) Source #
Generic (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) |
Instance details Defined in GHC.Generics Associated Types type Rep (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) :: Type -> Type Source # Methods from :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> Rep (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) x Source # to :: Rep (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) x -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) Source #