dhall-1.42.0: 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 #

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 # |
Instance details Defined in Dhall.Marshal.Decode Methods fmap :: (a -> b) -> Decoder a -> Decoder b # (<$) :: a -> Decoder b -> Decoder a #

class FromDhall a where #

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 #

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

#### Instances

Instances details

FromDhall Void # |
Instance details Defined in Dhall.Marshal.Decode Methods autoWith :: InputNormalizer -> Decoder Void #
FromDhall Int16 # |
Instance details Defined in Dhall.Marshal.Decode Methods autoWith :: InputNormalizer -> Decoder Int16 #
FromDhall Int32 # |
Instance details Defined in Dhall.Marshal.Decode Methods autoWith :: InputNormalizer -> Decoder Int32 #
FromDhall Int64 # |
Instance details Defined in Dhall.Marshal.Decode Methods autoWith :: InputNormalizer -> Decoder Int64 #
FromDhall Int8 # |
Instance details Defined in Dhall.Marshal.Decode Methods autoWith :: InputNormalizer -> Decoder Int8 #
FromDhall Word16 # |
Instance details Defined in Dhall.Marshal.Decode Methods autoWith :: InputNormalizer -> Decoder Word16 #
FromDhall Word32 # |
Instance details Defined in Dhall.Marshal.Decode Methods autoWith :: InputNormalizer -> Decoder Word32 #
FromDhall Word64 # |
Instance details Defined in Dhall.Marshal.Decode Methods autoWith :: InputNormalizer -> Decoder Word64 #
FromDhall Word8 # |
Instance details Defined in Dhall.Marshal.Decode Methods autoWith :: InputNormalizer -> Decoder Word8 #
FromDhall CGid # |
Instance details Defined in Dhall.DirectoryTree.Types Methods autoWith :: InputNormalizer -> Decoder CGid #
FromDhall CUid # |
Instance details Defined in Dhall.DirectoryTree.Types Methods autoWith :: InputNormalizer -> Decoder CUid #
FromDhall ByteString # |
Instance details Defined in Dhall.Marshal.Decode Methods autoWith :: InputNormalizer -> Decoder ByteString #
FromDhall ByteString # |
Instance details Defined in Dhall.Marshal.Decode Methods autoWith :: InputNormalizer -> Decoder ByteString #
FromDhall ShortByteString # |
Instance details Defined in Dhall.Marshal.Decode Methods autoWith :: InputNormalizer -> Decoder ShortByteString #
FromDhall FilesystemEntry # |
Instance details Defined in Dhall.DirectoryTree.Types Methods autoWith :: InputNormalizer -> Decoder FilesystemEntry #
FromDhall Group # |
Instance details Defined in Dhall.DirectoryTree.Types Methods autoWith :: InputNormalizer -> Decoder Group #
FromDhall User # |
Instance details Defined in Dhall.DirectoryTree.Types Methods autoWith :: InputNormalizer -> Decoder User #
FromDhall Scientific # |
Instance details Defined in Dhall.Marshal.Decode Methods autoWith :: InputNormalizer -> Decoder Scientific #
FromDhall Text # |
Instance details Defined in Dhall.Marshal.Decode Methods autoWith :: InputNormalizer -> Decoder Text #
FromDhall Text # |
Instance details Defined in Dhall.Marshal.Decode Methods autoWith :: InputNormalizer -> Decoder Text #
FromDhall ShortText # |
Instance details Defined in Dhall.Marshal.Decode Methods autoWith :: InputNormalizer -> Decoder ShortText #
FromDhall Day # |
Instance details Defined in Dhall.Marshal.Decode Methods autoWith :: InputNormalizer -> Decoder Day #
FromDhall DayOfWeek # |
Instance details Defined in Dhall.Marshal.Decode Methods autoWith :: InputNormalizer -> Decoder DayOfWeek #
FromDhall UTCTime # |
Instance details Defined in Dhall.Marshal.Decode Methods autoWith :: InputNormalizer -> Decoder UTCTime #
FromDhall LocalTime # |
Instance details Defined in Dhall.Marshal.Decode Methods autoWith :: InputNormalizer -> Decoder LocalTime #
FromDhall TimeOfDay # |
Instance details Defined in Dhall.Marshal.Decode Methods autoWith :: InputNormalizer -> Decoder TimeOfDay #
FromDhall TimeZone # |
Instance details Defined in Dhall.Marshal.Decode Methods autoWith :: InputNormalizer -> Decoder TimeZone #
FromDhall ZonedTime # |
Instance details Defined in Dhall.Marshal.Decode Methods autoWith :: InputNormalizer -> Decoder ZonedTime #
FromDhall Integer # |
Instance details Defined in Dhall.Marshal.Decode Methods autoWith :: InputNormalizer -> Decoder Integer #
FromDhall Natural # |
Instance details Defined in Dhall.Marshal.Decode Methods autoWith :: InputNormalizer -> Decoder Natural #
FromDhall () # |
Instance details Defined in Dhall.Marshal.Decode Methods autoWith :: InputNormalizer -> Decoder () #
FromDhall Bool # |
Instance details Defined in Dhall.Marshal.Decode Methods autoWith :: InputNormalizer -> Decoder Bool #
FromDhall Double # |
Instance details Defined in Dhall.Marshal.Decode Methods autoWith :: InputNormalizer -> Decoder Double #
FromDhall Int # |
Instance details Defined in Dhall.Marshal.Decode Methods autoWith :: InputNormalizer -> Decoder Int #
FromDhall Word # |
Instance details Defined in Dhall.Marshal.Decode Methods autoWith :: InputNormalizer -> Decoder Word #
ToDhall x => FromDhall (Equivalence x) # |
Instance details Defined in Dhall.Marshal.Decode Methods autoWith :: InputNormalizer -> Decoder (Equivalence x) #
ToDhall x => FromDhall (Predicate x) # |
Instance details Defined in Dhall.Marshal.Decode Methods autoWith :: InputNormalizer -> Decoder (Predicate x) #
FromDhall a => FromDhall (Identity a) # |
Instance details Defined in Dhall.Marshal.Decode Methods autoWith :: InputNormalizer -> Decoder (Identity a) #
FromDhall a => FromDhall (Seq a) # |
Instance details Defined in Dhall.Marshal.Decode Methods autoWith :: InputNormalizer -> Decoder (Seq a) #
(FromDhall a, Ord a, Show a) => FromDhall (Set a) # | 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) #
(Functor f, FromDhall (f (Result f))) => FromDhall (Fix f) # | 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) #
FromDhall (Access Identity) # |
Instance details Defined in Dhall.DirectoryTree.Types Methods autoWith :: InputNormalizer -> Decoder (Access Identity) #
FromDhall (Access Maybe) # |
Instance details Defined in Dhall.DirectoryTree.Types Methods autoWith :: InputNormalizer -> Decoder (Access Maybe) #
FromDhall a => FromDhall (Entry a) # |
Instance details Defined in Dhall.DirectoryTree.Types Methods autoWith :: InputNormalizer -> Decoder (Entry a) #
FromDhall (Mode Identity) # |
Instance details Defined in Dhall.DirectoryTree.Types Methods autoWith :: InputNormalizer -> Decoder (Mode Identity) #
FromDhall (Mode Maybe) # |
Instance details Defined in Dhall.DirectoryTree.Types Methods autoWith :: InputNormalizer -> Decoder (Mode Maybe) #
FromDhall (f (Result f)) => FromDhall (Result f) # |
Instance details Defined in Dhall.Marshal.Decode Methods autoWith :: InputNormalizer -> Decoder (Result f) #
(FromDhall a, Hashable a, Ord a, Show a) => FromDhall (HashSet a) # | 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) #
FromDhall a => FromDhall (Vector a) # |
Instance details Defined in Dhall.Marshal.Decode Methods autoWith :: InputNormalizer -> Decoder (Vector a) #
FromDhall a => FromDhall (Maybe a) # |
Instance details Defined in Dhall.Marshal.Decode Methods autoWith :: InputNormalizer -> Decoder (Maybe a) #
FromDhall [Char] # |
Instance details Defined in Dhall.Marshal.Decode Methods autoWith :: InputNormalizer -> Decoder [Char] #
FromDhall a => FromDhall [a] # |
Instance details Defined in Dhall.Marshal.Decode Methods autoWith :: InputNormalizer -> Decoder [a] #
(FromDhall b, ToDhall x) => FromDhall (Op b x) # |
Instance details Defined in Dhall.Marshal.Decode Methods autoWith :: InputNormalizer -> Decoder (Op b x) #
(Ord k, FromDhall k, FromDhall v) => FromDhall (Map k v) # |
Instance details Defined in Dhall.Marshal.Decode Methods autoWith :: InputNormalizer -> Decoder (Map k v) #
(Eq k, Hashable k, FromDhall k, FromDhall v) => FromDhall (HashMap k v) # |
Instance details Defined in Dhall.Marshal.Decode Methods autoWith :: InputNormalizer -> Decoder (HashMap k v) #
(FromDhall a, FromDhall b) => FromDhall (a, b) # |
Instance details Defined in Dhall.Marshal.Decode Methods autoWith :: InputNormalizer -> Decoder (a, b) #
(ToDhall a, FromDhall b) => FromDhall (a -> b) # |
Instance details Defined in Dhall.Marshal.Decode Methods autoWith :: InputNormalizer -> Decoder (a -> b) #
(Generic a, GenericFromDhall a (Rep a), ModifyOptions tag) => FromDhall (Codec tag a) # |
Instance details Defined in Dhall.Deriving Methods autoWith :: InputNormalizer -> Decoder (Codec tag a) #

type Interpret = FromDhall #

Deprecated: Use FromDhall instead

A compatibility alias for `FromDhall`.

auto :: FromDhall a => Decoder a #

Use the default input normalizer for interpreting an input.

    auto = autoWith defaultInputNormalizer

# Building decoders

## Simple decoders

bool :: Decoder Bool #

Decode a `Bool`.

    >>> input bool "True"
    True

unit :: Decoder () #

Decode `()` from an empty record.

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

void :: Decoder Void #

Decode `Void` from an empty union.

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

## Numbers

natural :: Decoder Natural #

Decode a `Natural`.

    >>> input natural "42"
    42

word :: Decoder Word #

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

    >>> input word "42"
    42

word8 :: Decoder Word8 #

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

    >>> input word8 "42"
    42

word16 :: Decoder Word16 #

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

    >>> input word16 "42"
    42

word32 :: Decoder Word32 #

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

    >>> input word32 "42"
    42

word64 :: Decoder Word64 #

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

    >>> input word64 "42"
    42

integer :: Decoder Integer #

Decode an `Integer`.

    >>> input integer "+42"
    42

int :: Decoder Int #

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

    >>> input int "-42"
    -42

int8 :: Decoder Int8 #

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

    >>> input int8 "-42"
    -42

int16 :: Decoder Int16 #

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

    >>> input int16 "-42"
    -42

int32 :: Decoder Int32 #

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

    >>> input int32 "-42"
    -42

int64 :: Decoder Int64 #

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

    >>> input int64 "-42"
    -42

scientific :: Decoder Scientific #

Decode a `Scientific`.

    >>> input scientific "1e100"
    1.0e100

double :: Decoder Double #

Decode a `Double`.

    >>> input double "42.0"
    42.0

## Bytes

lazyBytes :: Decoder ByteString #

Decode a lazy `ByteString`.

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

strictBytes :: Decoder ByteString #

Decode a strict `ByteString`

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

shortBytes :: Decoder ShortByteString #

Decode a `ShortByteString`

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

## Textual

string :: Decoder String #

Decode a `String`

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

lazyText :: Decoder Text #

Decode lazy `Text`.

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

strictText :: Decoder Text #

Decode strict `Text`.

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

shortText :: Decoder ShortText #

Decode `ShortText`.

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

## Time

timeOfDay :: Decoder TimeOfDay #

Decode `TimeOfDay`

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

day :: Decoder Day #

Decode `Day`

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

timeZone :: Decoder TimeZone #

Decode `TimeZone`

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

localTime :: Decoder LocalTime #

Decode `LocalTime`

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

zonedTime :: Decoder ZonedTime #

Decode `ZonedTime`

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

utcTime :: Decoder UTCTime #

Decode `UTCTime`

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

dayOfWeek :: Decoder DayOfWeek #

Decode `DayOfWeek`

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

## Containers

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

Decode a `Maybe`.

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

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

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

Decode a `Seq`.

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

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

Decode a list.

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

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

Decode a `Vector`.

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

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

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

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

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

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

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

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

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

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

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 #

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 # |
Instance details Defined in Dhall.Marshal.Decode Methods pure :: a -> RecordDecoder a # (<*>) :: RecordDecoder (a -> b) -> RecordDecoder a -> RecordDecoder b # liftA2 :: (a -> b -> c) -> RecordDecoder a -> RecordDecoder b -> RecordDecoder c # (*>) :: RecordDecoder a -> RecordDecoder b -> RecordDecoder b # (<*) :: RecordDecoder a -> RecordDecoder b -> RecordDecoder a #
Functor RecordDecoder # |
Instance details Defined in Dhall.Marshal.Decode Methods fmap :: (a -> b) -> RecordDecoder a -> RecordDecoder b # (<$) :: a -> RecordDecoder b -> RecordDecoder a #

record :: RecordDecoder a -> Decoder a #

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

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

Parse a single field of a record.

## Unions

newtype UnionDecoder a #

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

union :: UnionDecoder a -> Decoder a #

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

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

Parse a single constructor of a union.

# Generic decoding

class GenericFromDhall t f where #

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

#### Instances

Instances details

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

class GenericFromDhallUnion t f where #

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

#### Instances

Instances details

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

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

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

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

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

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

# Decoding errors

newtype DhallErrors e #

A newtype suitable for collecting one or more errors.

Constructors

DhallErrors |
Fields getErrors :: NonEmpty e

#### Instances

Instances details

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

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

Render a given prefix and some errors to a string.

data InvalidDecoder s a #

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

## Extraction errors

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

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

data ExtractError s a #

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

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

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

typeError :: Expector (Expr s a) -> Expr s a -> Extractor s a b #

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 #

Turn a `Text` message into an extraction failure.

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

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

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

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 #

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 #

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

data ExpectedTypeError #

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

Constructors

RecursiveTypeError |

#### Instances

Instances details

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

type Expector = Validation ExpectedTypeErrors #

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

# Miscellaneous

newtype InputNormalizer #

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 #

Default normalization-related settings (no custom normalization)

data InterpretOptions #

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 #

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) # |
Instance details Defined in Dhall.Deriving Methods modifyOptions :: InterpretOptions -> InterpretOptions #

defaultInterpretOptions :: InterpretOptions #

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 #

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) # |
Instance details Defined in Dhall.Marshal.Decode Methods autoWith :: InputNormalizer -> Decoder (Result f) #
ToDhall (f (Result f)) => ToDhall (Result f) # |
Instance details Defined in Dhall.Marshal.Encode Methods injectWith :: InputNormalizer -> Encoder (Result f) #

# Re-exports

data Natural #

#### Instances

Instances details

FromJSON Natural |
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser Natural # parseJSONList :: Value -> Parser [Natural] # omittedField :: Maybe Natural #
FromJSONKey Natural |
Instance details Defined in Data.Aeson.Types.FromJSON Methods fromJSONKey :: FromJSONKeyFunction Natural # fromJSONKeyList :: FromJSONKeyFunction [Natural] #
ToJSON Natural |
Instance details Defined in Data.Aeson.Types.ToJSON Methods toJSON :: Natural -> Value # toEncoding :: Natural -> Encoding # toJSONList :: [Natural] -> Value # toEncodingList :: [Natural] -> Encoding # omitField :: Natural -> Bool #
ToJSONKey Natural |
Instance details Defined in Data.Aeson.Types.ToJSON Methods toJSONKey :: ToJSONKeyFunction Natural # toJSONKeyList :: ToJSONKeyFunction [Natural] #
Data Natural |
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 # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Natural # toConstr :: Natural -> Constr # dataTypeOf :: Natural -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Natural) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Natural) # gmapT :: (forall b. Data b => b -> b) -> Natural -> Natural # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Natural -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Natural -> r # gmapQ :: (forall d. Data d => d -> u) -> Natural -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Natural -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Natural -> m Natural # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Natural -> m Natural # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Natural -> m Natural #
Bits Natural |
Instance details Defined in GHC.Bits Methods (.&.) :: Natural -> Natural -> Natural (.|.) :: Natural -> Natural -> Natural xor :: Natural -> Natural -> Natural complement :: Natural -> Natural shift :: Natural -> Int -> Natural rotate :: Natural -> Int -> Natural zeroBits :: Natural bit :: Int -> Natural setBit :: Natural -> Int -> Natural clearBit :: Natural -> Int -> Natural complementBit :: Natural -> Int -> Natural testBit :: Natural -> Int -> Bool bitSizeMaybe :: Natural -> Maybe Int bitSize :: Natural -> Int isSigned :: Natural -> Bool shiftL :: Natural -> Int -> Natural unsafeShiftL :: Natural -> Int -> Natural shiftR :: Natural -> Int -> Natural unsafeShiftR :: Natural -> Int -> Natural rotateL :: Natural -> Int -> Natural rotateR :: Natural -> Int -> Natural popCount :: Natural -> Int
Enum Natural |
Instance details Defined in GHC.Enum Methods succ :: Natural -> Natural # pred :: Natural -> Natural # toEnum :: Int -> Natural # fromEnum :: Natural -> Int # enumFrom :: Natural -> [Natural] # enumFromThen :: Natural -> Natural -> [Natural] # enumFromTo :: Natural -> Natural -> [Natural] # enumFromThenTo :: Natural -> Natural -> Natural -> [Natural] #
Num Natural |
Instance details Defined in GHC.Num Methods (+) :: Natural -> Natural -> Natural (-) :: Natural -> Natural -> Natural (*) :: Natural -> Natural -> Natural negate :: Natural -> Natural abs :: Natural -> Natural signum :: Natural -> Natural fromInteger :: Integer -> Natural
Read Natural |
Instance details Defined in GHC.Read Methods readsPrec :: Int -> ReadS Natural # readList :: ReadS [Natural] # readPrec :: ReadPrec Natural # readListPrec :: ReadPrec [Natural] #
Integral Natural |
Instance details Defined in GHC.Real Methods quot :: Natural -> Natural -> Natural rem :: Natural -> Natural -> Natural div :: Natural -> Natural -> Natural mod :: Natural -> Natural -> Natural quotRem :: Natural -> Natural -> (Natural, Natural) divMod :: Natural -> Natural -> (Natural, Natural) toInteger :: Natural -> Integer
Real Natural |
Instance details Defined in GHC.Real Methods toRational :: Natural -> Rational
Show Natural |
Instance details Defined in GHC.Show Methods showsPrec :: Int -> Natural -> ShowS # show :: Natural -> String # showList :: [Natural] -> ShowS #
PrintfArg Natural |
Instance details Defined in Text.Printf Methods formatArg :: Natural -> FieldFormatter parseFormat :: Natural -> ModifierParser
Subtractive Natural |
Instance details Defined in Basement.Numerical.Subtractive Associated Types type Difference Natural # Methods (-) :: Natural -> Natural -> Difference Natural #
NFData Natural |
Instance details Defined in Control.DeepSeq Methods rnf :: Natural -> ()
FromDhall Natural # |
Instance details Defined in Dhall.Marshal.Decode Methods autoWith :: InputNormalizer -> Decoder Natural #
ToDhall Natural # |
Instance details Defined in Dhall.Marshal.Encode Methods injectWith :: InputNormalizer -> Encoder Natural #
Eq Natural |
Instance details Defined in GHC.Num.Natural Methods (==) :: Natural -> Natural -> Bool # (/=) :: Natural -> Natural -> Bool #
Ord Natural |
Instance details Defined in GHC.Num.Natural Methods compare :: Natural -> Natural -> Ordering # (<) :: Natural -> Natural -> Bool # (<=) :: Natural -> Natural -> Bool # (>) :: Natural -> Natural -> Bool # (>=) :: Natural -> Natural -> Bool # max :: Natural -> Natural -> Natural # min :: Natural -> Natural -> Natural #
Hashable Natural |
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> Natural -> Int # hash :: Natural -> Int #
Pretty Natural |
Instance details Defined in Prettyprinter.Internal Methods pretty :: Natural -> Doc ann # prettyList :: [Natural] -> Doc ann #
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 # decode :: Decoder s Natural # encodeList :: [Natural] -> Encoding # decodeList :: Decoder s [Natural] #
KnownNat n => HasResolution (n :: Nat) |
Instance details Defined in Data.Fixed Methods resolution :: p n -> Integer
TestCoercion SNat |
Instance details Defined in GHC.TypeNats Methods testCoercion :: forall (a :: k) (b :: k). SNat a -> SNat b -> Maybe (Coercion a b)
TestEquality SNat |
Instance details Defined in GHC.TypeNats Methods testEquality :: forall (a :: k) (b :: k). SNat a -> SNat b -> Maybe (a :~: b)
Lift Natural |
Instance details Defined in Language.Haskell.TH.Syntax Methods lift :: Quote m => Natural -> m Exp # liftTyped :: forall (m :: Type -> Type). Quote m => Natural -> Code m Natural #
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 #

#### Instances

Instances details

FromJSON1 Seq |
Instance details Defined in Data.Aeson.Types.FromJSON Methods liftParseJSON :: Maybe a -> (Value -> Parser a) -> (Value -> Parser [a]) -> Value -> Parser (Seq a) # liftParseJSONList :: Maybe a -> (Value -> Parser a) -> (Value -> Parser [a]) -> Value -> Parser [Seq a] # liftOmittedField :: Maybe a -> Maybe (Seq a) #
ToJSON1 Seq |
Instance details Defined in Data.Aeson.Types.ToJSON Methods liftToJSON :: (a -> Bool) -> (a -> Value) -> ([a] -> Value) -> Seq a -> Value # liftToJSONList :: (a -> Bool) -> (a -> Value) -> ([a] -> Value) -> [Seq a] -> Value # liftToEncoding :: (a -> Bool) -> (a -> Encoding) -> ([a] -> Encoding) -> Seq a -> Encoding # liftToEncodingList :: (a -> Bool) -> (a -> Encoding) -> ([a] -> Encoding) -> [Seq a] -> Encoding # liftOmitField :: (a -> Bool) -> Seq a -> Bool #
MonadFix Seq |
Instance details Defined in Data.Sequence.Internal Methods mfix :: (a -> Seq a) -> Seq a
MonadZip Seq |
Instance details Defined in Data.Sequence.Internal Methods mzip :: Seq a -> Seq b -> Seq (a, b) mzipWith :: (a -> b -> c) -> Seq a -> Seq b -> Seq c munzip :: Seq (a, b) -> (Seq a, Seq b)
Foldable Seq |
Instance details Defined in Data.Sequence.Internal Methods fold :: Monoid m => Seq m -> m foldMap :: Monoid m => (a -> m) -> Seq a -> m foldMap' :: Monoid m => (a -> m) -> Seq a -> m foldr :: (a -> b -> b) -> b -> Seq a -> b foldr' :: (a -> b -> b) -> b -> Seq a -> b foldl :: (b -> a -> b) -> b -> Seq a -> b foldl' :: (b -> a -> b) -> b -> Seq a -> b foldr1 :: (a -> a -> a) -> Seq a -> a foldl1 :: (a -> a -> a) -> Seq a -> a toList :: Seq a -> [a] null :: Seq a -> Bool length :: Seq a -> Int elem :: Eq a => a -> Seq a -> Bool maximum :: Ord a => Seq a -> a minimum :: Ord a => Seq a -> a sum :: Num a => Seq a -> a product :: Num a => Seq a -> a
Eq1 Seq |
Instance details Defined in Data.Sequence.Internal Methods liftEq :: (a -> b -> Bool) -> Seq a -> Seq b -> Bool
Ord1 Seq |
Instance details Defined in Data.Sequence.Internal Methods liftCompare :: (a -> b -> Ordering) -> Seq a -> Seq b -> Ordering
Read1 Seq |
Instance details Defined in Data.Sequence.Internal Methods liftReadsPrec :: (Int -> ReadS a) -> ReadS [a] -> Int -> ReadS (Seq a) liftReadList :: (Int -> ReadS a) -> ReadS [a] -> ReadS [Seq a] liftReadPrec :: ReadPrec a -> ReadPrec [a] -> ReadPrec (Seq a) liftReadListPrec :: ReadPrec a -> ReadPrec [a] -> ReadPrec [Seq a]
Show1 Seq |
Instance details Defined in Data.Sequence.Internal Methods liftShowsPrec :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> Int -> Seq a -> ShowS liftShowList :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> [Seq a] -> ShowS
Traversable Seq |
Instance details Defined in Data.Sequence.Internal Methods traverse :: Applicative f => (a -> f b) -> Seq a -> f (Seq b) sequenceA :: Applicative f => Seq (f a) -> f (Seq a) mapM :: Monad m => (a -> m b) -> Seq a -> m (Seq b) # sequence :: Monad m => Seq (m a) -> m (Seq a) #
Alternative Seq |
Instance details Defined in Data.Sequence.Internal Methods empty :: Seq a # (<|>) :: Seq a -> Seq a -> Seq a # some :: Seq a -> Seq [a] # many :: Seq a -> Seq [a] #
Applicative Seq |
Instance details Defined in Data.Sequence.Internal Methods pure :: a -> Seq a # (<*>) :: Seq (a -> b) -> Seq a -> Seq b # liftA2 :: (a -> b -> c) -> Seq a -> Seq b -> Seq c # (*>) :: Seq a -> Seq b -> Seq b # (<*) :: Seq a -> Seq b -> Seq a #
Functor Seq |
Instance details Defined in Data.Sequence.Internal Methods fmap :: (a -> b) -> Seq a -> Seq b # (<$) :: a -> Seq b -> Seq a #
Monad Seq |
Instance details Defined in Data.Sequence.Internal Methods (>>=) :: Seq a -> (a -> Seq b) -> Seq b # (>>) :: Seq a -> Seq b -> Seq b # return :: a -> Seq a #
MonadPlus Seq |
Instance details Defined in Data.Sequence.Internal Methods mzero :: Seq a # mplus :: Seq a -> Seq a -> Seq a #
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 #
FoldableWithIndex Int Seq |
Instance details Defined in WithIndex Methods ifoldMap :: Monoid m => (Int -> a -> m) -> Seq a -> m # ifoldMap' :: Monoid m => (Int -> a -> m) -> Seq a -> m # ifoldr :: (Int -> a -> b -> b) -> b -> Seq a -> b # ifoldl :: (Int -> b -> a -> b) -> b -> Seq a -> b # ifoldr' :: (Int -> a -> b -> b) -> b -> Seq a -> b # ifoldl' :: (Int -> b -> a -> b) -> b -> Seq a -> b #
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 #
TraversableWithIndex Int Seq |
Instance details Defined in WithIndex Methods itraverse :: Applicative f => (Int -> a -> f b) -> Seq a -> f (Seq b) #
Lift a => Lift (Seq a :: Type) |
Instance details Defined in Data.Sequence.Internal Methods lift :: Quote m => Seq a -> m Exp # liftTyped :: forall (m :: Type -> Type). Quote m => Seq a -> Code m (Seq a) #
FromJSON a => FromJSON (Seq a) |
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser (Seq a) # parseJSONList :: Value -> Parser [Seq a] # omittedField :: Maybe (Seq a) #
ToJSON a => ToJSON (Seq a) |
Instance details Defined in Data.Aeson.Types.ToJSON Methods toJSON :: Seq a -> Value # toEncoding :: Seq a -> Encoding # toJSONList :: [Seq a] -> Value # toEncodingList :: [Seq a] -> Encoding # omitField :: Seq a -> Bool #
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) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Seq a) # toConstr :: Seq a -> Constr # dataTypeOf :: Seq a -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Seq a)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Seq a)) # gmapT :: (forall b. Data b => b -> b) -> Seq a -> Seq a # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Seq a -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Seq a -> r # gmapQ :: (forall d. Data d => d -> u) -> Seq a -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Seq a -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Seq a -> m (Seq a) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Seq a -> m (Seq a) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Seq a -> m (Seq a) #
a ~ Char => IsString (Seq a) |
Instance details Defined in Data.Sequence.Internal Methods fromString :: String -> Seq a #
Monoid (Seq a) |
Instance details Defined in Data.Sequence.Internal Methods mempty :: Seq a # mappend :: Seq a -> Seq a -> Seq a # mconcat :: [Seq a] -> Seq a #
Semigroup (Seq a) |
Instance details Defined in Data.Sequence.Internal Methods (<>) :: Seq a -> Seq a -> Seq a # sconcat :: NonEmpty (Seq a) -> Seq a # stimes :: Integral b => b -> Seq a -> Seq a #
IsList (Seq a) |
Instance details Defined in Data.Sequence.Internal Associated Types type Item (Seq a) # Methods fromList :: [Item (Seq a)] -> Seq a # fromListN :: Int -> [Item (Seq a)] -> Seq a # toList :: Seq a -> [Item (Seq a)] #
Read a => Read (Seq a) |
Instance details Defined in Data.Sequence.Internal Methods readsPrec :: Int -> ReadS (Seq a) # readList :: ReadS [Seq a] # readPrec :: ReadPrec (Seq a) # readListPrec :: ReadPrec [Seq a] #
Show a => Show (Seq a) |
Instance details Defined in Data.Sequence.Internal Methods showsPrec :: Int -> Seq a -> ShowS # show :: Seq a -> String # showList :: [Seq a] -> ShowS #
NFData a => NFData (Seq a) |
Instance details Defined in Data.Sequence.Internal Methods rnf :: Seq a -> ()
FromDhall a => FromDhall (Seq a) # |
Instance details Defined in Dhall.Marshal.Decode Methods autoWith :: InputNormalizer -> Decoder (Seq a) #
ToDhall a => ToDhall (Seq a) # |
Instance details Defined in Dhall.Marshal.Encode Methods injectWith :: InputNormalizer -> Encoder (Seq a) #
Eq a => Eq (Seq a) |
Instance details Defined in Data.Sequence.Internal Methods (==) :: Seq a -> Seq a -> Bool # (/=) :: Seq a -> Seq a -> Bool #
Ord a => Ord (Seq a) |
Instance details Defined in Data.Sequence.Internal Methods compare :: Seq a -> Seq a -> Ordering # (<) :: Seq a -> Seq a -> Bool # (<=) :: Seq a -> Seq a -> Bool # (>) :: Seq a -> Seq a -> Bool # (>=) :: Seq a -> Seq a -> Bool # max :: Seq a -> Seq a -> Seq a # min :: Seq a -> Seq a -> Seq a #
Hashable v => Hashable (Seq v) | Since: hashable-1.3.4.0
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> Seq v -> Int # hash :: Seq v -> Int #
Ord a => Stream (Seq a) | Since: megaparsec-9.0.0
Instance details Defined in Text.Megaparsec.Stream Associated Types type Token (Seq a) # type Tokens (Seq a) # Methods tokenToChunk :: Proxy (Seq a) -> Token (Seq a) -> Tokens (Seq a) # tokensToChunk :: Proxy (Seq a) -> [Token (Seq a)] -> Tokens (Seq a) # chunkToTokens :: Proxy (Seq a) -> Tokens (Seq a) -> [Token (Seq a)] # chunkLength :: Proxy (Seq a) -> Tokens (Seq a) -> Int # chunkEmpty :: Proxy (Seq a) -> Tokens (Seq a) -> Bool # take1_ :: Seq a -> Maybe (Token (Seq a), Seq a) # takeN_ :: Int -> Seq a -> Maybe (Tokens (Seq a), Seq a) # takeWhile_ :: (Token (Seq a) -> Bool) -> Seq a -> (Tokens (Seq a), Seq a) #
Serialise a => Serialise (Seq a) | Since: serialise-0.2.0.0
Instance details Defined in Codec.Serialise.Class Methods encode :: Seq a -> Encoding # decode :: Decoder s (Seq a) # encodeList :: [Seq a] -> Encoding # decodeList :: Decoder s [Seq a] #
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 #

#### Instances

Instances details

FromJSON Text |
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser Text # parseJSONList :: Value -> Parser [Text] # omittedField :: Maybe Text #
FromJSONKey Text |
Instance details Defined in Data.Aeson.Types.FromJSON Methods fromJSONKey :: FromJSONKeyFunction Text # fromJSONKeyList :: FromJSONKeyFunction [Text] #
ToJSON Text |
Instance details Defined in Data.Aeson.Types.ToJSON Methods toJSON :: Text -> Value # toEncoding :: Text -> Encoding # toJSONList :: [Text] -> Value # toEncodingList :: [Text] -> Encoding # omitField :: Text -> Bool #
ToJSONKey Text |
Instance details Defined in Data.Aeson.Types.ToJSON Methods toJSONKey :: ToJSONKeyFunction Text # toJSONKeyList :: ToJSONKeyFunction [Text] #
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 # foldCaseList :: [Text] -> [Text]
FromDhall Text # |
Instance details Defined in Dhall.Marshal.Decode Methods autoWith :: InputNormalizer -> Decoder Text #
ToDhall Text # |
Instance details Defined in Dhall.Marshal.Encode Methods injectWith :: InputNormalizer -> Encoder Text #
Hashable Text |
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> Text -> Int # hash :: Text -> Int #
Stream Text |
Instance details Defined in Text.Megaparsec.Stream Associated Types type Token Text # type Tokens Text # Methods tokenToChunk :: Proxy Text -> Token Text -> Tokens Text # tokensToChunk :: Proxy Text -> [Token Text] -> Tokens Text # chunkToTokens :: Proxy Text -> Tokens Text -> [Token Text] # chunkLength :: Proxy Text -> Tokens Text -> Int # chunkEmpty :: Proxy Text -> Tokens Text -> Bool # take1_ :: Text -> Maybe (Token Text, Text) # takeN_ :: Int -> Text -> Maybe (Tokens Text, Text) # takeWhile_ :: (Token Text -> Bool) -> Text -> (Tokens Text, Text) #
TraversableStream Text |
Instance details Defined in Text.Megaparsec.Stream Methods reachOffset :: Int -> PosState Text -> (Maybe String, PosState Text) # reachOffsetNoLine :: Int -> PosState Text -> PosState Text #
VisualStream Text |
Instance details Defined in Text.Megaparsec.Stream Methods showTokens :: Proxy Text -> NonEmpty (Token Text) -> String # tokensLength :: Proxy Text -> NonEmpty (Token Text) -> Int #
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 # prettyList :: [Text] -> Doc ann #
Serialise Text | Since: serialise-0.2.0.0
Instance details Defined in Codec.Serialise.Class Methods encode :: Text -> Encoding # decode :: Decoder s Text # encodeList :: [Text] -> Encoding # decodeList :: Decoder s [Text] #
MonadParsec Void Text Parser # |
Instance details Defined in Dhall.Parser.Combinators Methods parseError :: ParseError Text Void -> Parser a # label :: String -> Parser a -> Parser a # hidden :: Parser a -> Parser a # try :: Parser a -> Parser a # lookAhead :: Parser a -> Parser a # notFollowedBy :: Parser a -> Parser () # withRecovery :: (ParseError Text Void -> Parser a) -> Parser a -> Parser a # observing :: Parser a -> Parser (Either (ParseError Text Void) a) # eof :: Parser () # token :: (Token Text -> Maybe a) -> Set (ErrorItem (Token Text)) -> Parser a # tokens :: (Tokens Text -> Tokens Text -> Bool) -> Tokens Text -> Parser (Tokens Text) # takeWhileP :: Maybe String -> (Token Text -> Bool) -> Parser (Tokens Text) # takeWhile1P :: Maybe String -> (Token Text -> Bool) -> Parser (Tokens Text) # takeP :: Maybe String -> Int -> Parser (Tokens Text) # getParserState :: Parser (State Text Void) # updateParserState :: (State Text Void -> State Text Void) -> Parser () # mkParsec :: (State Text Void -> Reply Void Text a) -> Parser a #
Stream (NoShareInput Text) |
Instance details Defined in Text.Megaparsec.Stream Associated Types type Token (NoShareInput Text) # type Tokens (NoShareInput Text) # Methods tokenToChunk :: Proxy (NoShareInput Text) -> Token (NoShareInput Text) -> Tokens (NoShareInput Text) # tokensToChunk :: Proxy (NoShareInput Text) -> [Token (NoShareInput Text)] -> Tokens (NoShareInput Text) # chunkToTokens :: Proxy (NoShareInput Text) -> Tokens (NoShareInput Text) -> [Token (NoShareInput Text)] # chunkLength :: Proxy (NoShareInput Text) -> Tokens (NoShareInput Text) -> Int # chunkEmpty :: Proxy (NoShareInput Text) -> Tokens (NoShareInput Text) -> Bool # take1_ :: NoShareInput Text -> Maybe (Token (NoShareInput Text), NoShareInput Text) # takeN_ :: Int -> NoShareInput Text -> Maybe (Tokens (NoShareInput Text), NoShareInput Text) # takeWhile_ :: (Token (NoShareInput Text) -> Bool) -> NoShareInput Text -> (Tokens (NoShareInput Text), NoShareInput Text) #
Stream (ShareInput Text) |
Instance details Defined in Text.Megaparsec.Stream Associated Types type Token (ShareInput Text) # type Tokens (ShareInput Text) # Methods tokenToChunk :: Proxy (ShareInput Text) -> Token (ShareInput Text) -> Tokens (ShareInput Text) # tokensToChunk :: Proxy (ShareInput Text) -> [Token (ShareInput Text)] -> Tokens (ShareInput Text) # chunkToTokens :: Proxy (ShareInput Text) -> Tokens (ShareInput Text) -> [Token (ShareInput Text)] # chunkLength :: Proxy (ShareInput Text) -> Tokens (ShareInput Text) -> Int # chunkEmpty :: Proxy (ShareInput Text) -> Tokens (ShareInput Text) -> Bool # take1_ :: ShareInput Text -> Maybe (Token (ShareInput Text), ShareInput Text) # takeN_ :: Int -> ShareInput Text -> Maybe (Tokens (ShareInput Text), ShareInput Text) # takeWhile_ :: (Token (ShareInput Text) -> Bool) -> ShareInput Text -> (Tokens (ShareInput Text), ShareInput Text) #
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 #

Boxed vectors, supporting efficient slicing.

#### Instances

Instances details

FromJSON1 Vector |
Instance details Defined in Data.Aeson.Types.FromJSON Methods liftParseJSON :: Maybe a -> (Value -> Parser a) -> (Value -> Parser [a]) -> Value -> Parser (Vector a) # liftParseJSONList :: Maybe a -> (Value -> Parser a) -> (Value -> Parser [a]) -> Value -> Parser [Vector a] # liftOmittedField :: Maybe a -> Maybe (Vector a) #
ToJSON1 Vector |
Instance details Defined in Data.Aeson.Types.ToJSON Methods liftToJSON :: (a -> Bool) -> (a -> Value) -> ([a] -> Value) -> Vector a -> Value # liftToJSONList :: (a -> Bool) -> (a -> Value) -> ([a] -> Value) -> [Vector a] -> Value # liftToEncoding :: (a -> Bool) -> (a -> Encoding) -> ([a] -> Encoding) -> Vector a -> Encoding # liftToEncodingList :: (a -> Bool) -> (a -> Encoding) -> ([a] -> Encoding) -> [Vector a] -> Encoding # liftOmitField :: (a -> Bool) -> Vector a -> Bool #
MonadFail Vector | Since: vector-0.12.1.0
Instance details Defined in Data.Vector Methods fail :: String -> Vector a #
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
MonadZip Vector |
Instance details Defined in Data.Vector Methods mzip :: Vector a -> Vector b -> Vector (a, b) mzipWith :: (a -> b -> c) -> Vector a -> Vector b -> Vector c munzip :: Vector (a, b) -> (Vector a, Vector b)
Foldable Vector |
Instance details Defined in Data.Vector Methods fold :: Monoid m => Vector m -> m foldMap :: Monoid m => (a -> m) -> Vector a -> m foldMap' :: Monoid m => (a -> m) -> Vector a -> m foldr :: (a -> b -> b) -> b -> Vector a -> b foldr' :: (a -> b -> b) -> b -> Vector a -> b foldl :: (b -> a -> b) -> b -> Vector a -> b foldl' :: (b -> a -> b) -> b -> Vector a -> b foldr1 :: (a -> a -> a) -> Vector a -> a foldl1 :: (a -> a -> a) -> Vector a -> a toList :: Vector a -> [a] null :: Vector a -> Bool length :: Vector a -> Int elem :: Eq a => a -> Vector a -> Bool maximum :: Ord a => Vector a -> a minimum :: Ord a => Vector a -> a sum :: Num a => Vector a -> a product :: Num a => Vector a -> a
Eq1 Vector |
Instance details Defined in Data.Vector Methods liftEq :: (a -> b -> Bool) -> Vector a -> Vector b -> Bool
Ord1 Vector |
Instance details Defined in Data.Vector Methods liftCompare :: (a -> b -> Ordering) -> Vector a -> Vector b -> Ordering
Read1 Vector |
Instance details Defined in Data.Vector Methods liftReadsPrec :: (Int -> ReadS a) -> ReadS [a] -> Int -> ReadS (Vector a) liftReadList :: (Int -> ReadS a) -> ReadS [a] -> ReadS [Vector a] liftReadPrec :: ReadPrec a -> ReadPrec [a] -> ReadPrec (Vector a) liftReadListPrec :: ReadPrec a -> ReadPrec [a] -> ReadPrec [Vector a]
Show1 Vector |
Instance details Defined in Data.Vector Methods liftShowsPrec :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> Int -> Vector a -> ShowS liftShowList :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> [Vector a] -> ShowS
Traversable Vector |
Instance details Defined in Data.Vector Methods traverse :: Applicative f => (a -> f b) -> Vector a -> f (Vector b) sequenceA :: Applicative f => Vector (f a) -> f (Vector a) mapM :: Monad m => (a -> m b) -> Vector a -> m (Vector b) # sequence :: Monad m => Vector (m a) -> m (Vector a) #
Alternative Vector |
Instance details Defined in Data.Vector Methods empty :: Vector a # (<|>) :: Vector a -> Vector a -> Vector a # some :: Vector a -> Vector [a] # many :: Vector a -> Vector [a] #
Applicative Vector |
Instance details Defined in Data.Vector Methods pure :: a -> Vector a # (<*>) :: Vector (a -> b) -> Vector a -> Vector b # liftA2 :: (a -> b -> c) -> Vector a -> Vector b -> Vector c # (*>) :: Vector a -> Vector b -> Vector b # (<*) :: Vector a -> Vector b -> Vector a #
Functor Vector |
Instance details Defined in Data.Vector Methods fmap :: (a -> b) -> Vector a -> Vector b # (<$) :: a -> Vector b -> Vector a #
Monad Vector |
Instance details Defined in Data.Vector Methods (>>=) :: Vector a -> (a -> Vector b) -> Vector b # (>>) :: Vector a -> Vector b -> Vector b # return :: a -> Vector a #
MonadPlus Vector |
Instance details Defined in Data.Vector Methods mzero :: Vector a # mplus :: Vector a -> Vector a -> Vector a #
NFData1 Vector | Since: vector-0.12.1.0
Instance details Defined in Data.Vector Methods liftRnf :: (a -> ()) -> Vector a -> ()
Vector Vector a |
Instance details Defined in Data.Vector Methods basicUnsafeFreeze :: Mutable Vector s a -> ST s (Vector a) # basicUnsafeThaw :: Vector a -> ST s (Mutable Vector s a) # basicLength :: Vector a -> Int # basicUnsafeSlice :: Int -> Int -> Vector a -> Vector a # basicUnsafeIndexM :: Vector a -> Int -> Box a # basicUnsafeCopy :: Mutable Vector s a -> Vector a -> ST s () # elemseq :: Vector a -> a -> b -> b #
FromJSON a => FromJSON (Vector a) |
Instance details Defined in Data.Aeson.Types.FromJSON Methods parseJSON :: Value -> Parser (Vector a) # parseJSONList :: Value -> Parser [Vector a] # omittedField :: Maybe (Vector a) #
ToJSON a => ToJSON (Vector a) |
Instance details Defined in Data.Aeson.Types.ToJSON Methods toJSON :: Vector a -> Value # toEncoding :: Vector a -> Encoding # toJSONList :: [Vector a] -> Value # toEncodingList :: [Vector a] -> Encoding # omitField :: Vector a -> Bool #
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) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Vector a) # toConstr :: Vector a -> Constr # dataTypeOf :: Vector a -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Vector a)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Vector a)) # gmapT :: (forall b. Data b => b -> b) -> Vector a -> Vector a # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Vector a -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Vector a -> r # gmapQ :: (forall d. Data d => d -> u) -> Vector a -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Vector a -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Vector a -> m (Vector a) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Vector a -> m (Vector a) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Vector a -> m (Vector a) #
Monoid (Vector a) |
Instance details Defined in Data.Vector Methods mempty :: Vector a # mappend :: Vector a -> Vector a -> Vector a # mconcat :: [Vector a] -> Vector a #
Semigroup (Vector a) |
Instance details Defined in Data.Vector Methods (<>) :: Vector a -> Vector a -> Vector a # sconcat :: NonEmpty (Vector a) -> Vector a # stimes :: Integral b => b -> Vector a -> Vector a #
IsList (Vector a) |
Instance details Defined in Data.Vector Associated Types type Item (Vector a) # Methods fromList :: [Item (Vector a)] -> Vector a # fromListN :: Int -> [Item (Vector a)] -> Vector a # toList :: Vector a -> [Item (Vector a)] #
Read a => Read (Vector a) |
Instance details Defined in Data.Vector Methods readsPrec :: Int -> ReadS (Vector a) # readList :: ReadS [Vector a] # readPrec :: ReadPrec (Vector a) # readListPrec :: ReadPrec [Vector a] #
Show a => Show (Vector a) |
Instance details Defined in Data.Vector Methods showsPrec :: Int -> Vector a -> ShowS # show :: Vector a -> String # showList :: [Vector a] -> ShowS #
NFData a => NFData (Vector a) |
Instance details Defined in Data.Vector Methods rnf :: Vector a -> ()
FromDhall a => FromDhall (Vector a) # |
Instance details Defined in Dhall.Marshal.Decode Methods autoWith :: InputNormalizer -> Decoder (Vector a) #
ToDhall a => ToDhall (Vector a) # |
Instance details Defined in Dhall.Marshal.Encode Methods injectWith :: InputNormalizer -> Encoder (Vector a) #
Eq a => Eq (Vector a) |
Instance details Defined in Data.Vector Methods (==) :: Vector a -> Vector a -> Bool # (/=) :: Vector a -> Vector a -> Bool #
Ord a => Ord (Vector a) |
Instance details Defined in Data.Vector Methods compare :: Vector a -> Vector a -> Ordering # (<) :: Vector a -> Vector a -> Bool # (<=) :: Vector a -> Vector a -> Bool # (>) :: Vector a -> Vector a -> Bool # (>=) :: Vector a -> Vector a -> Bool # max :: Vector a -> Vector a -> Vector a # min :: Vector a -> Vector a -> Vector a #
Serialise a => Serialise (Vector a) | Since: serialise-0.2.0.0
Instance details Defined in Codec.Serialise.Class Methods encode :: Vector a -> Encoding # decode :: Decoder s (Vector a) # encodeList :: [Vector a] -> Encoding # decodeList :: Decoder s [Vector a] #
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 #

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 # Methods from :: Value -> Rep Value x # to :: Rep Value x -> Value #
Generic All |
Instance details Defined in Data.Semigroup.Internal Associated Types type Rep All :: Type -> Type # Methods from :: All -> Rep All x # to :: Rep All x -> All #
Generic Any |
Instance details Defined in Data.Semigroup.Internal Associated Types type Rep Any :: Type -> Type # Methods from :: Any -> Rep Any x # to :: Rep Any x -> Any #
Generic Version |
Instance details Defined in Data.Version Associated Types type Rep Version :: Type -> Type # Methods from :: Version -> Rep Version x # to :: Rep Version x -> Version #
Generic Void |
Instance details Defined in GHC.Generics Associated Types type Rep Void :: Type -> Type # Methods from :: Void -> Rep Void x # to :: Rep Void x -> Void #
Generic Fingerprint |
Instance details Defined in GHC.Generics Associated Types type Rep Fingerprint :: Type -> Type # Methods from :: Fingerprint -> Rep Fingerprint x # to :: Rep Fingerprint x -> Fingerprint #
Generic Associativity |
Instance details Defined in GHC.Generics Associated Types type Rep Associativity :: Type -> Type # Methods from :: Associativity -> Rep Associativity x # to :: Rep Associativity x -> Associativity #
Generic DecidedStrictness |
Instance details Defined in GHC.Generics Associated Types type Rep DecidedStrictness :: Type -> Type # Methods from :: DecidedStrictness -> Rep DecidedStrictness x # to :: Rep DecidedStrictness x -> DecidedStrictness #
Generic Fixity |
Instance details Defined in GHC.Generics Associated Types type Rep Fixity :: Type -> Type # Methods from :: Fixity -> Rep Fixity x # to :: Rep Fixity x -> Fixity #
Generic SourceStrictness |
Instance details Defined in GHC.Generics Associated Types type Rep SourceStrictness :: Type -> Type # Methods from :: SourceStrictness -> Rep SourceStrictness x # to :: Rep SourceStrictness x -> SourceStrictness #
Generic SourceUnpackedness |
Instance details Defined in GHC.Generics Associated Types type Rep SourceUnpackedness :: Type -> Type # Methods from :: SourceUnpackedness -> Rep SourceUnpackedness x # to :: Rep SourceUnpackedness x -> SourceUnpackedness #
Generic ExitCode |
Instance details Defined in GHC.IO.Exception Associated Types type Rep ExitCode :: Type -> Type # Methods from :: ExitCode -> Rep ExitCode x # to :: Rep ExitCode x -> ExitCode #
Generic CCFlags |
Instance details Defined in GHC.RTS.Flags Associated Types type Rep CCFlags :: Type -> Type # Methods from :: CCFlags -> Rep CCFlags x # to :: Rep CCFlags x -> CCFlags #
Generic ConcFlags |
Instance details Defined in GHC.RTS.Flags Associated Types type Rep ConcFlags :: Type -> Type # Methods from :: ConcFlags -> Rep ConcFlags x # to :: Rep ConcFlags x -> ConcFlags #
Generic DebugFlags |
Instance details Defined in GHC.RTS.Flags Associated Types type Rep DebugFlags :: Type -> Type # Methods from :: DebugFlags -> Rep DebugFlags x # to :: Rep DebugFlags x -> DebugFlags #
Generic DoCostCentres |
Instance details Defined in GHC.RTS.Flags Associated Types type Rep DoCostCentres :: Type -> Type # Methods from :: DoCostCentres -> Rep DoCostCentres x # to :: Rep DoCostCentres x -> DoCostCentres #
Generic DoHeapProfile |
Instance details Defined in GHC.RTS.Flags Associated Types type Rep DoHeapProfile :: Type -> Type # Methods from :: DoHeapProfile -> Rep DoHeapProfile x # to :: Rep DoHeapProfile x -> DoHeapProfile #
Generic DoTrace |
Instance details Defined in GHC.RTS.Flags Associated Types type Rep DoTrace :: Type -> Type # Methods from :: DoTrace -> Rep DoTrace x # to :: Rep DoTrace x -> DoTrace #
Generic GCFlags |
Instance details Defined in GHC.RTS.Flags Associated Types type Rep GCFlags :: Type -> Type # Methods from :: GCFlags -> Rep GCFlags x # to :: Rep GCFlags x -> GCFlags #
Generic GiveGCStats |
Instance details Defined in GHC.RTS.Flags Associated Types type Rep GiveGCStats :: Type -> Type # Methods from :: GiveGCStats -> Rep GiveGCStats x # to :: Rep GiveGCStats x -> GiveGCStats #
Generic MiscFlags |
Instance details Defined in GHC.RTS.Flags Associated Types type Rep MiscFlags :: Type -> Type # Methods from :: MiscFlags -> Rep MiscFlags x # to :: Rep MiscFlags x -> MiscFlags #
Generic ParFlags |
Instance details Defined in GHC.RTS.Flags Associated Types type Rep ParFlags :: Type -> Type # Methods from :: ParFlags -> Rep ParFlags x # to :: Rep ParFlags x -> ParFlags #
Generic ProfFlags |
Instance details Defined in GHC.RTS.Flags Associated Types type Rep ProfFlags :: Type -> Type # Methods from :: ProfFlags -> Rep ProfFlags x # to :: Rep ProfFlags x -> ProfFlags #
Generic RTSFlags |
Instance details Defined in GHC.RTS.Flags Associated Types type Rep RTSFlags :: Type -> Type # Methods from :: RTSFlags -> Rep RTSFlags x # to :: Rep RTSFlags x -> RTSFlags #
Generic TickyFlags |
Instance details Defined in GHC.RTS.Flags Associated Types type Rep TickyFlags :: Type -> Type # Methods from :: TickyFlags -> Rep TickyFlags x # to :: Rep TickyFlags x -> TickyFlags #
Generic TraceFlags |
Instance details Defined in GHC.RTS.Flags Associated Types type Rep TraceFlags :: Type -> Type # Methods from :: TraceFlags -> Rep TraceFlags x # to :: Rep TraceFlags x -> TraceFlags #
Generic SrcLoc |
Instance details Defined in GHC.Generics Associated Types type Rep SrcLoc :: Type -> Type # Methods from :: SrcLoc -> Rep SrcLoc x # to :: Rep SrcLoc x -> SrcLoc #
Generic GCDetails |
Instance details Defined in GHC.Stats Associated Types type Rep GCDetails :: Type -> Type # Methods from :: GCDetails -> Rep GCDetails x # to :: Rep GCDetails x -> GCDetails #
Generic RTSStats |
Instance details Defined in GHC.Stats Associated Types type Rep RTSStats :: Type -> Type # Methods from :: RTSStats -> Rep RTSStats x # to :: Rep RTSStats x -> RTSStats #
Generic GeneralCategory |
Instance details Defined in GHC.Generics Associated Types type Rep GeneralCategory :: Type -> Type # Methods from :: GeneralCategory -> Rep GeneralCategory x # to :: Rep GeneralCategory x -> GeneralCategory #
Generic SHA256Digest # |
Instance details Defined in Dhall.Crypto Associated Types type Rep SHA256Digest :: Type -> Type # Methods from :: SHA256Digest -> Rep SHA256Digest x # to :: Rep SHA256Digest x -> SHA256Digest #
Generic FilesystemEntry # |
Instance details Defined in Dhall.DirectoryTree.Types Associated Types type Rep FilesystemEntry :: Type -> Type # Methods from :: FilesystemEntry -> Rep FilesystemEntry x # to :: Rep FilesystemEntry x -> FilesystemEntry #
Generic Group # |
Instance details Defined in Dhall.DirectoryTree.Types Associated Types type Rep Group :: Type -> Type # Methods from :: Group -> Rep Group x # to :: Rep Group x -> Group #
Generic User # |
Instance details Defined in Dhall.DirectoryTree.Types Associated Types type Rep User :: Type -> Type # Methods from :: User -> Rep User x # to :: Rep User x -> User #
Generic CharacterSet # |
Instance details Defined in Dhall.Pretty.Internal Associated Types type Rep CharacterSet :: Type -> Type # Methods from :: CharacterSet -> Rep CharacterSet x # to :: Rep CharacterSet x -> CharacterSet #
Generic Src # |
Instance details Defined in Dhall.Src Associated Types type Rep Src :: Type -> Type # Methods from :: Src -> Rep Src x # to :: Rep Src x -> Src #
Generic Const # |
Instance details Defined in Dhall.Syntax.Const Associated Types type Rep Const :: Type -> Type # Methods from :: Const -> Rep Const x # to :: Rep Const x -> Const #
Generic Directory # |
Instance details Defined in Dhall.Syntax.Import Associated Types type Rep Directory :: Type -> Type # Methods from :: Directory -> Rep Directory x # to :: Rep Directory x -> Directory #
Generic File # |
Instance details Defined in Dhall.Syntax.Import Associated Types type Rep File :: Type -> Type # Methods from :: File -> Rep File x # to :: Rep File x -> File #
Generic FilePrefix # |
Instance details Defined in Dhall.Syntax.Import Associated Types type Rep FilePrefix :: Type -> Type # Methods from :: FilePrefix -> Rep FilePrefix x # to :: Rep FilePrefix x -> FilePrefix #
Generic Import # |
Instance details Defined in Dhall.Syntax.Import Associated Types type Rep Import :: Type -> Type # Methods from :: Import -> Rep Import x # to :: Rep Import x -> Import #
Generic ImportHashed # |
Instance details Defined in Dhall.Syntax.Import Associated Types type Rep ImportHashed :: Type -> Type # Methods from :: ImportHashed -> Rep ImportHashed x # to :: Rep ImportHashed x -> ImportHashed #
Generic ImportMode # |
Instance details Defined in Dhall.Syntax.Import Associated Types type Rep ImportMode :: Type -> Type # Methods from :: ImportMode -> Rep ImportMode x # to :: Rep ImportMode x -> ImportMode #
Generic ImportType # |
Instance details Defined in Dhall.Syntax.Import Associated Types type Rep ImportType :: Type -> Type # Methods from :: ImportType -> Rep ImportType x # to :: Rep ImportType x -> ImportType #
Generic Scheme # |
Instance details Defined in Dhall.Syntax.Import Associated Types type Rep Scheme :: Type -> Type # Methods from :: Scheme -> Rep Scheme x # to :: Rep Scheme x -> Scheme #
Generic URL # |
Instance details Defined in Dhall.Syntax.Import Associated Types type Rep URL :: Type -> Type # Methods from :: URL -> Rep URL x # to :: Rep URL x -> URL #
Generic DhallDouble # |
Instance details Defined in Dhall.Syntax.Types Associated Types type Rep DhallDouble :: Type -> Type # Methods from :: DhallDouble -> Rep DhallDouble x # to :: Rep DhallDouble x -> DhallDouble #
Generic PreferAnnotation # |
Instance details Defined in Dhall.Syntax.Types Associated Types type Rep PreferAnnotation :: Type -> Type # Methods from :: PreferAnnotation -> Rep PreferAnnotation x # to :: Rep PreferAnnotation x -> PreferAnnotation #
Generic WithComponent # |
Instance details Defined in Dhall.Syntax.Types Associated Types type Rep WithComponent :: Type -> Type # Methods from :: WithComponent -> Rep WithComponent x # to :: Rep WithComponent x -> WithComponent #
Generic Var # |
Instance details Defined in Dhall.Syntax.Var Associated Types type Rep Var :: Type -> Type # Methods from :: Var -> Rep Var x # to :: Rep Var x -> Var #
Generic OsChar |
Instance details Defined in System.OsString.Internal.Types Associated Types type Rep OsChar :: Type -> Type # Methods from :: OsChar -> Rep OsChar x # to :: Rep OsChar x -> OsChar #
Generic OsString |
Instance details Defined in System.OsString.Internal.Types Associated Types type Rep OsString :: Type -> Type # Methods from :: OsString -> Rep OsString x # to :: Rep OsString x -> OsString #
Generic PosixChar |
Instance details Defined in System.OsString.Internal.Types Associated Types type Rep PosixChar :: Type -> Type # Methods from :: PosixChar -> Rep PosixChar x # to :: Rep PosixChar x -> PosixChar #
Generic PosixString |
Instance details Defined in System.OsString.Internal.Types Associated Types type Rep PosixString :: Type -> Type # Methods from :: PosixString -> Rep PosixString x # to :: Rep PosixString x -> PosixString #
Generic WindowsChar |
Instance details Defined in System.OsString.Internal.Types Associated Types type Rep WindowsChar :: Type -> Type # Methods from :: WindowsChar -> Rep WindowsChar x # to :: Rep WindowsChar x -> WindowsChar #
Generic WindowsString |
Instance details Defined in System.OsString.Internal.Types Associated Types type Rep WindowsString :: Type -> Type # Methods from :: WindowsString -> Rep WindowsString x # to :: Rep WindowsString x -> WindowsString #
Generic ForeignSrcLang |
Instance details Defined in GHC.ForeignSrcLang.Type Associated Types type Rep ForeignSrcLang :: Type -> Type # Methods from :: ForeignSrcLang -> Rep ForeignSrcLang x # to :: Rep ForeignSrcLang x -> ForeignSrcLang #
Generic Extension |
Instance details Defined in GHC.LanguageExtensions.Type Associated Types type Rep Extension :: Type -> Type # Methods from :: Extension -> Rep Extension x # to :: Rep Extension x -> Extension #
Generic Ordering |
Instance details Defined in GHC.Generics Associated Types type Rep Ordering :: Type -> Type # Methods from :: Ordering -> Rep Ordering x # to :: Rep Ordering x -> Ordering #
Generic Half |
Instance details Defined in Numeric.Half.Internal Associated Types type Rep Half :: Type -> Type # Methods from :: Half -> Rep Half x # to :: Rep Half x -> Half #
Generic IP |
Instance details Defined in Data.IP.Addr Associated Types type Rep IP :: Type -> Type # Methods from :: IP -> Rep IP x # to :: Rep IP x -> IP #
Generic IPv4 |
Instance details Defined in Data.IP.Addr Associated Types type Rep IPv4 :: Type -> Type # Methods from :: IPv4 -> Rep IPv4 x # to :: Rep IPv4 x -> IPv4 #
Generic IPv6 |
Instance details Defined in Data.IP.Addr Associated Types type Rep IPv6 :: Type -> Type # Methods from :: IPv6 -> Rep IPv6 x # to :: Rep IPv6 x -> IPv6 #
Generic IPRange |
Instance details Defined in Data.IP.Range Associated Types type Rep IPRange :: Type -> Type # Methods from :: IPRange -> Rep IPRange x # to :: Rep IPRange x -> IPRange #
Generic InvalidPosException |
Instance details Defined in Text.Megaparsec.Pos Associated Types type Rep InvalidPosException :: Type -> Type # Methods from :: InvalidPosException -> Rep InvalidPosException x # to :: Rep InvalidPosException x -> InvalidPosException #
Generic Pos |
Instance details Defined in Text.Megaparsec.Pos Associated Types type Rep Pos :: Type -> Type # Methods from :: Pos -> Rep Pos x # to :: Rep Pos x -> Pos #
Generic SourcePos |
Instance details Defined in Text.Megaparsec.Pos Associated Types type Rep SourcePos :: Type -> Type # Methods from :: SourcePos -> Rep SourcePos x # to :: Rep SourcePos x -> SourcePos #
Generic URI |
Instance details Defined in Network.URI Associated Types type Rep URI :: Type -> Type # Methods from :: URI -> Rep URI x # to :: Rep URI x -> URI #
Generic URIAuth |
Instance details Defined in Network.URI Associated Types type Rep URIAuth :: Type -> Type # Methods from :: URIAuth -> Rep URIAuth x # to :: Rep URIAuth x -> URIAuth #
Generic Mode |
Instance details Defined in Text.PrettyPrint.Annotated.HughesPJ Associated Types type Rep Mode :: Type -> Type # Methods from :: Mode -> Rep Mode x # to :: Rep Mode x -> Mode #
Generic Style |
Instance details Defined in Text.PrettyPrint.Annotated.HughesPJ Associated Types type Rep Style :: Type -> Type # Methods from :: Style -> Rep Style x # to :: Rep Style x -> Style #
Generic TextDetails |
Instance details Defined in Text.PrettyPrint.Annotated.HughesPJ Associated Types type Rep TextDetails :: Type -> Type # Methods from :: TextDetails -> Rep TextDetails x # to :: Rep TextDetails x -> TextDetails #
Generic Doc |
Instance details Defined in Text.PrettyPrint.HughesPJ Associated Types type Rep Doc :: Type -> Type # Methods from :: Doc -> Rep Doc x # to :: Rep Doc x -> Doc #
Generic ColorOptions |
Instance details Defined in Text.Pretty.Simple.Internal.Color Associated Types type Rep ColorOptions :: Type -> Type # Methods from :: ColorOptions -> Rep ColorOptions x # to :: Rep ColorOptions x -> ColorOptions #
Generic Style |
Instance details Defined in Text.Pretty.Simple.Internal.Color Associated Types type Rep Style :: Type -> Type # Methods from :: Style -> Rep Style x # to :: Rep Style x -> Style #
Generic Expr |
Instance details Defined in Text.Pretty.Simple.Internal.Expr Associated Types type Rep Expr :: Type -> Type # Methods from :: Expr -> Rep Expr x # to :: Rep Expr x -> Expr #
Generic CheckColorTty |
Instance details Defined in Text.Pretty.Simple.Internal.Printer Associated Types type Rep CheckColorTty :: Type -> Type # Methods from :: CheckColorTty -> Rep CheckColorTty x # to :: Rep CheckColorTty x -> CheckColorTty #
Generic OutputOptions |
Instance details Defined in Text.Pretty.Simple.Internal.Printer Associated Types type Rep OutputOptions :: Type -> Type # Methods from :: OutputOptions -> Rep OutputOptions x # to :: Rep OutputOptions x -> OutputOptions #
Generic StringOutputStyle |
Instance details Defined in Text.Pretty.Simple.Internal.Printer Associated Types type Rep StringOutputStyle :: Type -> Type # Methods from :: StringOutputStyle -> Rep StringOutputStyle x # to :: Rep StringOutputStyle x -> StringOutputStyle #
Generic AnnLookup |
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep AnnLookup :: Type -> Type # Methods from :: AnnLookup -> Rep AnnLookup x # to :: Rep AnnLookup x -> AnnLookup #
Generic AnnTarget |
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep AnnTarget :: Type -> Type # Methods from :: AnnTarget -> Rep AnnTarget x # to :: Rep AnnTarget x -> AnnTarget #
Generic Bang |
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep Bang :: Type -> Type # Methods from :: Bang -> Rep Bang x # to :: Rep Bang x -> Bang #
Generic Body |
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep Body :: Type -> Type # Methods from :: Body -> Rep Body x # to :: Rep Body x -> Body #
Generic Bytes |
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep Bytes :: Type -> Type # Methods from :: Bytes -> Rep Bytes x # to :: Rep Bytes x -> Bytes #
Generic Callconv |
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep Callconv :: Type -> Type # Methods from :: Callconv -> Rep Callconv x # to :: Rep Callconv x -> Callconv #
Generic Clause |
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep Clause :: Type -> Type # Methods from :: Clause -> Rep Clause x # to :: Rep Clause x -> Clause #
Generic Con |
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep Con :: Type -> Type # Methods from :: Con -> Rep Con x # to :: Rep Con x -> Con #
Generic Dec |
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep Dec :: Type -> Type # Methods from :: Dec -> Rep Dec x # to :: Rep Dec x -> Dec #
Generic DecidedStrictness |
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep DecidedStrictness :: Type -> Type # Methods from :: DecidedStrictness -> Rep DecidedStrictness x # to :: Rep DecidedStrictness x -> DecidedStrictness #
Generic DerivClause |
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep DerivClause :: Type -> Type # Methods from :: DerivClause -> Rep DerivClause x # to :: Rep DerivClause x -> DerivClause #
Generic DerivStrategy |
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep DerivStrategy :: Type -> Type # Methods from :: DerivStrategy -> Rep DerivStrategy x # to :: Rep DerivStrategy x -> DerivStrategy #
Generic DocLoc |
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep DocLoc :: Type -> Type # Methods from :: DocLoc -> Rep DocLoc x # to :: Rep DocLoc x -> DocLoc #
Generic Exp |
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep Exp :: Type -> Type # Methods from :: Exp -> Rep Exp x # to :: Rep Exp x -> Exp #
Generic FamilyResultSig |
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep FamilyResultSig :: Type -> Type # Methods from :: FamilyResultSig -> Rep FamilyResultSig x # to :: Rep FamilyResultSig x -> FamilyResultSig #
Generic Fixity |
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep Fixity :: Type -> Type # Methods from :: Fixity -> Rep Fixity x # to :: Rep Fixity x -> Fixity #
Generic FixityDirection |
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep FixityDirection :: Type -> Type # Methods from :: FixityDirection -> Rep FixityDirection x # to :: Rep FixityDirection x -> FixityDirection #
Generic Foreign |
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep Foreign :: Type -> Type # Methods from :: Foreign -> Rep Foreign x # to :: Rep Foreign x -> Foreign #
Generic FunDep |
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep FunDep :: Type -> Type # Methods from :: FunDep -> Rep FunDep x # to :: Rep FunDep x -> FunDep #
Generic Guard |
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep Guard :: Type -> Type # Methods from :: Guard -> Rep Guard x # to :: Rep Guard x -> Guard #
Generic Info |
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep Info :: Type -> Type # Methods from :: Info -> Rep Info x # to :: Rep Info x -> Info #
Generic InjectivityAnn |
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep InjectivityAnn :: Type -> Type # Methods from :: InjectivityAnn -> Rep InjectivityAnn x # to :: Rep InjectivityAnn x -> InjectivityAnn #
Generic Inline |
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep Inline :: Type -> Type # Methods from :: Inline -> Rep Inline x # to :: Rep Inline x -> Inline #
Generic Lit |
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep Lit :: Type -> Type # Methods from :: Lit -> Rep Lit x # to :: Rep Lit x -> Lit #
Generic Loc |
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep Loc :: Type -> Type # Methods from :: Loc -> Rep Loc x # to :: Rep Loc x -> Loc #
Generic Match |
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep Match :: Type -> Type # Methods from :: Match -> Rep Match x # to :: Rep Match x -> Match #
Generic ModName |
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep ModName :: Type -> Type # Methods from :: ModName -> Rep ModName x # to :: Rep ModName x -> ModName #
Generic Module |
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep Module :: Type -> Type # Methods from :: Module -> Rep Module x # to :: Rep Module x -> Module #
Generic ModuleInfo |
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep ModuleInfo :: Type -> Type # Methods from :: ModuleInfo -> Rep ModuleInfo x # to :: Rep ModuleInfo x -> ModuleInfo #
Generic Name |
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep Name :: Type -> Type # Methods from :: Name -> Rep Name x # to :: Rep Name x -> Name #
Generic NameFlavour |
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep NameFlavour :: Type -> Type # Methods from :: NameFlavour -> Rep NameFlavour x # to :: Rep NameFlavour x -> NameFlavour #
Generic NameSpace |
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep NameSpace :: Type -> Type # Methods from :: NameSpace -> Rep NameSpace x # to :: Rep NameSpace x -> NameSpace #
Generic OccName |
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep OccName :: Type -> Type # Methods from :: OccName -> Rep OccName x # to :: Rep OccName x -> OccName #
Generic Overlap |
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep Overlap :: Type -> Type # Methods from :: Overlap -> Rep Overlap x # to :: Rep Overlap x -> Overlap #
Generic Pat |
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep Pat :: Type -> Type # Methods from :: Pat -> Rep Pat x # to :: Rep Pat x -> Pat #
Generic PatSynArgs |
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep PatSynArgs :: Type -> Type # Methods from :: PatSynArgs -> Rep PatSynArgs x # to :: Rep PatSynArgs x -> PatSynArgs #
Generic PatSynDir |
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep PatSynDir :: Type -> Type # Methods from :: PatSynDir -> Rep PatSynDir x # to :: Rep PatSynDir x -> PatSynDir #
Generic Phases |
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep Phases :: Type -> Type # Methods from :: Phases -> Rep Phases x # to :: Rep Phases x -> Phases #
Generic PkgName |
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep PkgName :: Type -> Type # Methods from :: PkgName -> Rep PkgName x # to :: Rep PkgName x -> PkgName #
Generic Pragma |
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep Pragma :: Type -> Type # Methods from :: Pragma -> Rep Pragma x # to :: Rep Pragma x -> Pragma #
Generic Range |
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep Range :: Type -> Type # Methods from :: Range -> Rep Range x # to :: Rep Range x -> Range #
Generic Role |
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep Role :: Type -> Type # Methods from :: Role -> Rep Role x # to :: Rep Role x -> Role #
Generic RuleBndr |
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep RuleBndr :: Type -> Type # Methods from :: RuleBndr -> Rep RuleBndr x # to :: Rep RuleBndr x -> RuleBndr #
Generic RuleMatch |
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep RuleMatch :: Type -> Type # Methods from :: RuleMatch -> Rep RuleMatch x # to :: Rep RuleMatch x -> RuleMatch #
Generic Safety |
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep Safety :: Type -> Type # Methods from :: Safety -> Rep Safety x # to :: Rep Safety x -> Safety #
Generic SourceStrictness |
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep SourceStrictness :: Type -> Type # Methods from :: SourceStrictness -> Rep SourceStrictness x # to :: Rep SourceStrictness x -> SourceStrictness #
Generic SourceUnpackedness |
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep SourceUnpackedness :: Type -> Type # Methods from :: SourceUnpackedness -> Rep SourceUnpackedness x # to :: Rep SourceUnpackedness x -> SourceUnpackedness #
Generic Specificity |
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep Specificity :: Type -> Type # Methods from :: Specificity -> Rep Specificity x # to :: Rep Specificity x -> Specificity #
Generic Stmt |
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep Stmt :: Type -> Type # Methods from :: Stmt -> Rep Stmt x # to :: Rep Stmt x -> Stmt #
Generic TyLit |
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep TyLit :: Type -> Type # Methods from :: TyLit -> Rep TyLit x # to :: Rep TyLit x -> TyLit #
Generic TySynEqn |
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep TySynEqn :: Type -> Type # Methods from :: TySynEqn -> Rep TySynEqn x # to :: Rep TySynEqn x -> TySynEqn #
Generic Type |
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep Type :: Type -> Type # Methods from :: Type -> Rep Type x # to :: Rep Type x -> Type #
Generic TypeFamilyHead |
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep TypeFamilyHead :: Type -> Type # Methods from :: TypeFamilyHead -> Rep TypeFamilyHead x # to :: Rep TypeFamilyHead x -> TypeFamilyHead #
Generic CompressionLevel |
Instance details Defined in Codec.Compression.Zlib.Stream Associated Types type Rep CompressionLevel :: Type -> Type # Methods from :: CompressionLevel -> Rep CompressionLevel x # to :: Rep CompressionLevel x -> CompressionLevel #
Generic CompressionStrategy |
Instance details Defined in Codec.Compression.Zlib.Stream Associated Types type Rep CompressionStrategy :: Type -> Type # Methods from :: CompressionStrategy -> Rep CompressionStrategy x # to :: Rep CompressionStrategy x -> CompressionStrategy #
Generic Format |
Instance details Defined in Codec.Compression.Zlib.Stream Associated Types type Rep Format :: Type -> Type # Methods from :: Format -> Rep Format x # to :: Rep Format x -> Format #
Generic MemoryLevel |
Instance details Defined in Codec.Compression.Zlib.Stream Associated Types type Rep MemoryLevel :: Type -> Type # Methods from :: MemoryLevel -> Rep MemoryLevel x # to :: Rep MemoryLevel x -> MemoryLevel #
Generic Method |
Instance details Defined in Codec.Compression.Zlib.Stream Associated Types type Rep Method :: Type -> Type # Methods from :: Method -> Rep Method x # to :: Rep Method x -> Method #
Generic WindowBits |
Instance details Defined in Codec.Compression.Zlib.Stream Associated Types type Rep WindowBits :: Type -> Type # Methods from :: WindowBits -> Rep WindowBits x # to :: Rep WindowBits x -> WindowBits #
Generic () |
Instance details Defined in GHC.Generics Associated Types type Rep () :: Type -> Type # Methods from :: () -> Rep () x # to :: Rep () x -> () #
Generic Bool |
Instance details Defined in GHC.Generics Associated Types type Rep Bool :: Type -> Type # Methods from :: Bool -> Rep Bool x # to :: Rep Bool x -> Bool #
Generic (ZipList a) |
Instance details Defined in Control.Applicative Associated Types type Rep (ZipList a) :: Type -> Type # Methods from :: ZipList a -> Rep (ZipList a) x # to :: Rep (ZipList a) x -> ZipList a #
Generic (Complex a) |
Instance details Defined in Data.Complex Associated Types type Rep (Complex a) :: Type -> Type # Methods from :: Complex a -> Rep (Complex a) x # to :: Rep (Complex a) x -> Complex a #
Generic (Identity a) |
Instance details Defined in Data.Functor.Identity Associated Types type Rep (Identity a) :: Type -> Type # Methods from :: Identity a -> Rep (Identity a) x # to :: Rep (Identity a) x -> Identity a #
Generic (First a) |
Instance details Defined in Data.Monoid Associated Types type Rep (First a) :: Type -> Type # Methods from :: First a -> Rep (First a) x # to :: Rep (First a) x -> First a #
Generic (Last a) |
Instance details Defined in Data.Monoid Associated Types type Rep (Last a) :: Type -> Type # Methods from :: Last a -> Rep (Last a) x # to :: Rep (Last a) x -> Last a #
Generic (Down a) |
Instance details Defined in GHC.Generics Associated Types type Rep (Down a) :: Type -> Type # Methods from :: Down a -> Rep (Down a) x # to :: Rep (Down a) x -> Down a #
Generic (First a) |
Instance details Defined in Data.Semigroup Associated Types type Rep (First a) :: Type -> Type # Methods from :: First a -> Rep (First a) x # to :: Rep (First a) x -> First a #
Generic (Last a) |
Instance details Defined in Data.Semigroup Associated Types type Rep (Last a) :: Type -> Type # Methods from :: Last a -> Rep (Last a) x # to :: Rep (Last a) x -> Last a #
Generic (Max a) |
Instance details Defined in Data.Semigroup Associated Types type Rep (Max a) :: Type -> Type # Methods from :: Max a -> Rep (Max a) x # to :: Rep (Max a) x -> Max a #
Generic (Min a) |
Instance details Defined in Data.Semigroup Associated Types type Rep (Min a) :: Type -> Type # Methods from :: Min a -> Rep (Min a) x # to :: Rep (Min a) x -> Min a #
Generic (WrappedMonoid m) |
Instance details Defined in Data.Semigroup Associated Types type Rep (WrappedMonoid m) :: Type -> Type # Methods from :: WrappedMonoid m -> Rep (WrappedMonoid m) x # to :: Rep (WrappedMonoid m) x -> WrappedMonoid m #
Generic (Dual a) |
Instance details Defined in Data.Semigroup.Internal Associated Types type Rep (Dual a) :: Type -> Type # Methods from :: Dual a -> Rep (Dual a) x # to :: Rep (Dual a) x -> Dual a #
Generic (Endo a) |
Instance details Defined in Data.Semigroup.Internal Associated Types type Rep (Endo a) :: Type -> Type # Methods from :: Endo a -> Rep (Endo a) x # to :: Rep (Endo a) x -> Endo a #
Generic (Product a) |
Instance details Defined in Data.Semigroup.Internal Associated Types type Rep (Product a) :: Type -> Type # Methods from :: Product a -> Rep (Product a) x # to :: Rep (Product a) x -> Product a #
Generic (Sum a) |
Instance details Defined in Data.Semigroup.Internal Associated Types type Rep (Sum a) :: Type -> Type # Methods from :: Sum a -> Rep (Sum a) x # to :: Rep (Sum a) x -> Sum a #
Generic (NonEmpty a) |
Instance details Defined in GHC.Generics Associated Types type Rep (NonEmpty a) :: Type -> Type # Methods from :: NonEmpty a -> Rep (NonEmpty a) x # to :: Rep (NonEmpty a) x -> NonEmpty a #
Generic (Par1 p) |
Instance details Defined in GHC.Generics Associated Types type Rep (Par1 p) :: Type -> Type # Methods from :: Par1 p -> Rep (Par1 p) x # to :: Rep (Par1 p) x -> Par1 p #
Generic (Digit a) |
Instance details Defined in Data.Sequence.Internal Associated Types type Rep (Digit a) :: Type -> Type # Methods from :: Digit a -> Rep (Digit a) x # to :: Rep (Digit a) x -> Digit a #
Generic (Elem a) |
Instance details Defined in Data.Sequence.Internal Associated Types type Rep (Elem a) :: Type -> Type # Methods from :: Elem a -> Rep (Elem a) x # to :: Rep (Elem a) x -> Elem a #
Generic (FingerTree a) |
Instance details Defined in Data.Sequence.Internal Associated Types type Rep (FingerTree a) :: Type -> Type # Methods from :: FingerTree a -> Rep (FingerTree a) x # to :: Rep (FingerTree a) x -> FingerTree a #
Generic (Node a) |
Instance details Defined in Data.Sequence.Internal Associated Types type Rep (Node a) :: Type -> Type # Methods from :: Node a -> Rep (Node a) x # to :: Rep (Node a) x -> Node a #
Generic (ViewL a) |
Instance details Defined in Data.Sequence.Internal Associated Types type Rep (ViewL a) :: Type -> Type # Methods from :: ViewL a -> Rep (ViewL a) x # to :: Rep (ViewL a) x -> ViewL a #
Generic (ViewR a) |
Instance details Defined in Data.Sequence.Internal Associated Types type Rep (ViewR a) :: Type -> Type # Methods from :: ViewR a -> Rep (ViewR a) x # to :: Rep (ViewR a) x -> ViewR a #
Generic (Tree a) |
Instance details Defined in Data.Tree Associated Types type Rep (Tree a) :: Type -> Type # Methods from :: Tree a -> Rep (Tree a) x # to :: Rep (Tree a) x -> Tree a #
Generic (Fix f) |
Instance details Defined in Data.Fix Associated Types type Rep (Fix f) :: Type -> Type # Methods from :: Fix f -> Rep (Fix f) x # to :: Rep (Fix f) x -> Fix f #
Generic (Access f) # |
Instance details Defined in Dhall.DirectoryTree.Types Associated Types type Rep (Access f) :: Type -> Type # Methods from :: Access f -> Rep (Access f) x # to :: Rep (Access f) x -> Access f #
Generic (Entry a) # |
Instance details Defined in Dhall.DirectoryTree.Types Associated Types type Rep (Entry a) :: Type -> Type # Methods from :: Entry a -> Rep (Entry a) x # to :: Rep (Entry a) x -> Entry a #
Generic (Mode f) # |
Instance details Defined in Dhall.DirectoryTree.Types Associated Types type Rep (Mode f) :: Type -> Type # Methods from :: Mode f -> Rep (Mode f) x # to :: Rep (Mode f) x -> Mode f #
Generic (Set a) # |
Instance details Defined in Dhall.Set Associated Types type Rep (Set a) :: Type -> Type # Methods from :: Set a -> Rep (Set a) x # to :: Rep (Set a) x -> Set a #
Generic (FieldSelection s) # |
Instance details Defined in Dhall.Syntax.Types Associated Types type Rep (FieldSelection s) :: Type -> Type # Methods from :: FieldSelection s -> Rep (FieldSelection s) x # to :: Rep (FieldSelection s) x -> FieldSelection s #
Generic (HistoriedResponse body) |
Instance details Defined in Network.HTTP.Client Associated Types type Rep (HistoriedResponse body) :: Type -> Type # Methods from :: HistoriedResponse body -> Rep (HistoriedResponse body) x # to :: Rep (HistoriedResponse body) x -> HistoriedResponse body #
Generic (AddrRange a) |
Instance details Defined in Data.IP.Range Associated Types type Rep (AddrRange a) :: Type -> Type # Methods from :: AddrRange a -> Rep (AddrRange a) x # to :: Rep (AddrRange a) x -> AddrRange a #
Generic (ErrorFancy e) |
Instance details Defined in Text.Megaparsec.Error Associated Types type Rep (ErrorFancy e) :: Type -> Type # Methods from :: ErrorFancy e -> Rep (ErrorFancy e) x # to :: Rep (ErrorFancy e) x -> ErrorFancy e #
Generic (ErrorItem t) |
Instance details Defined in Text.Megaparsec.Error Associated Types type Rep (ErrorItem t) :: Type -> Type # Methods from :: ErrorItem t -> Rep (ErrorItem t) x # to :: Rep (ErrorItem t) x -> ErrorItem t #
Generic (PosState s) |
Instance details Defined in Text.Megaparsec.State Associated Types type Rep (PosState s) :: Type -> Type # Methods from :: PosState s -> Rep (PosState s) x # to :: Rep (PosState s) x -> PosState s #
Generic (Doc a) |
Instance details Defined in Text.PrettyPrint.Annotated.HughesPJ Associated Types type Rep (Doc a) :: Type -> Type # Methods from :: Doc a -> Rep (Doc a) x # to :: Rep (Doc a) x -> Doc a #
Generic (CommaSeparated a) |
Instance details Defined in Text.Pretty.Simple.Internal.Expr Associated Types type Rep (CommaSeparated a) :: Type -> Type # Methods from :: CommaSeparated a -> Rep (CommaSeparated a) x # to :: Rep (CommaSeparated a) x -> CommaSeparated a #
Generic (Doc ann) |
Instance details Defined in Prettyprinter.Internal Associated Types type Rep (Doc ann) :: Type -> Type # Methods from :: Doc ann -> Rep (Doc ann) x # to :: Rep (Doc ann) x -> Doc ann #
Generic (SimpleDocStream ann) |
Instance details Defined in Prettyprinter.Internal Associated Types type Rep (SimpleDocStream ann) :: Type -> Type # Methods from :: SimpleDocStream ann -> Rep (SimpleDocStream ann) x # to :: Rep (SimpleDocStream ann) x -> SimpleDocStream ann #
Generic (Maybe a) |
Instance details Defined in Data.Strict.Maybe Associated Types type Rep (Maybe a) :: Type -> Type # Methods from :: Maybe a -> Rep (Maybe a) x # to :: Rep (Maybe a) x -> Maybe a #
Generic (TyVarBndr flag) |
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep (TyVarBndr flag) :: Type -> Type # Methods from :: TyVarBndr flag -> Rep (TyVarBndr flag) x # to :: Rep (TyVarBndr flag) x -> TyVarBndr flag #
Generic (Maybe a) |
Instance details Defined in GHC.Generics Associated Types type Rep (Maybe a) :: Type -> Type # Methods from :: Maybe a -> Rep (Maybe a) x # to :: Rep (Maybe a) x -> Maybe a #
Generic (a) |
Instance details Defined in GHC.Generics Associated Types type Rep (a) :: Type -> Type # Methods from :: (a) -> Rep (a) x # to :: Rep (a) x -> (a) #
Generic [a] |
Instance details Defined in GHC.Generics Associated Types type Rep [a] :: Type -> Type # Methods from :: [a] -> Rep [a] x # to :: Rep [a] x -> [a] #
Generic (WrappedMonad m a) |
Instance details Defined in Control.Applicative Associated Types type Rep (WrappedMonad m a) :: Type -> Type # Methods from :: WrappedMonad m a -> Rep (WrappedMonad m a) x # to :: Rep (WrappedMonad m a) x -> WrappedMonad m a #
Generic (Either a b) |
Instance details Defined in GHC.Generics Associated Types type Rep (Either a b) :: Type -> Type # Methods from :: Either a b -> Rep (Either a b) x # to :: Rep (Either a b) x -> Either a b #
Generic (Proxy t) |
Instance details Defined in GHC.Generics Associated Types type Rep (Proxy t) :: Type -> Type # Methods from :: Proxy t -> Rep (Proxy t) x # to :: Rep (Proxy t) x -> Proxy t #
Generic (Arg a b) |
Instance details Defined in Data.Semigroup Associated Types type Rep (Arg a b) :: Type -> Type # Methods from :: Arg a b -> Rep (Arg a b) x # to :: Rep (Arg a b) x -> Arg a b #
Generic (U1 p) |
Instance details Defined in GHC.Generics Associated Types type Rep (U1 p) :: Type -> Type # Methods from :: U1 p -> Rep (U1 p) x # to :: Rep (U1 p) x -> U1 p #
Generic (V1 p) |
Instance details Defined in GHC.Generics Associated Types type Rep (V1 p) :: Type -> Type # Methods from :: V1 p -> Rep (V1 p) x # to :: Rep (V1 p) x -> V1 p #
Generic (Map k v) # |
Instance details Defined in Dhall.Map Associated Types type Rep (Map k v) :: Type -> Type # Methods from :: Map k v -> Rep (Map k v) x # to :: Rep (Map k v) x -> Map k v #
Generic (Binding s a) # |
Instance details Defined in Dhall.Syntax.Binding Associated Types type Rep (Binding s a) :: Type -> Type # Methods from :: Binding s a -> Rep (Binding s a) x # to :: Rep (Binding s a) x -> Binding s a #
Generic (Chunks s a) # |
Instance details Defined in Dhall.Syntax.Chunks Associated Types type Rep (Chunks s a) :: Type -> Type # Methods from :: Chunks s a -> Rep (Chunks s a) x # to :: Rep (Chunks s a) x -> Chunks s a #
Generic (Expr s a) # |
Instance details Defined in Dhall.Syntax.Expr Associated Types type Rep (Expr s a) :: Type -> Type # Methods from :: Expr s a -> Rep (Expr s a) x # to :: Rep (Expr s a) x -> Expr s a #
Generic (FunctionBinding s a) # |
Instance details Defined in Dhall.Syntax.FunctionBinding Associated Types type Rep (FunctionBinding s a) :: Type -> Type # Methods from :: FunctionBinding s a -> Rep (FunctionBinding s a) x # to :: Rep (FunctionBinding s a) x -> FunctionBinding s a #
Generic (RecordField s a) # |
Instance details Defined in Dhall.Syntax.RecordField Associated Types type Rep (RecordField s a) :: Type -> Type # Methods from :: RecordField s a -> Rep (RecordField s a) x # to :: Rep (RecordField s a) x -> RecordField s a #
Generic (ParseError s e) |
Instance details Defined in Text.Megaparsec.Error Associated Types type Rep (ParseError s e) :: Type -> Type # Methods from :: ParseError s e -> Rep (ParseError s e) x # to :: Rep (ParseError s e) x -> ParseError s e #
Generic (ParseErrorBundle s e) |
Instance details Defined in Text.Megaparsec.Error Associated Types type Rep (ParseErrorBundle s e) :: Type -> Type # Methods from :: ParseErrorBundle s e -> Rep (ParseErrorBundle s e) x # to :: Rep (ParseErrorBundle s e) x -> ParseErrorBundle s e #
Generic (State s e) |
Instance details Defined in Text.Megaparsec.State Associated Types type Rep (State s e) :: Type -> Type # Methods from :: State s e -> Rep (State s e) x # to :: Rep (State s e) x -> State s e #
Generic (Either a b) |
Instance details Defined in Data.Strict.Either Associated Types type Rep (Either a b) :: Type -> Type # Methods from :: Either a b -> Rep (Either a b) x # to :: Rep (Either a b) x -> Either a b #
Generic (These a b) |
Instance details Defined in Data.Strict.These Associated Types type Rep (These a b) :: Type -> Type # Methods from :: These a b -> Rep (These a b) x # to :: Rep (These a b) x -> These a b #
Generic (Pair a b) |
Instance details Defined in Data.Strict.Tuple Associated Types type Rep (Pair a b) :: Type -> Type # Methods from :: Pair a b -> Rep (Pair a b) x # to :: Rep (Pair a b) x -> Pair a b #
Generic (These a b) |
Instance details Defined in Data.These Associated Types type Rep (These a b) :: Type -> Type # Methods from :: These a b -> Rep (These a b) x # to :: Rep (These a b) x -> These a b #
Generic (Lift f a) |
Instance details Defined in Control.Applicative.Lift Associated Types type Rep (Lift f a) :: Type -> Type # Methods from :: Lift f a -> Rep (Lift f a) x # to :: Rep (Lift f a) x -> Lift f a #
Generic (MaybeT m a) |
Instance details Defined in Control.Monad.Trans.Maybe Associated Types type Rep (MaybeT m a) :: Type -> Type # Methods from :: MaybeT m a -> Rep (MaybeT m a) x # to :: Rep (MaybeT m a) x -> MaybeT m a #
Generic (a, b) |
Instance details Defined in GHC.Generics Associated Types type Rep (a, b) :: Type -> Type # Methods from :: (a, b) -> Rep (a, b) x # to :: Rep (a, b) x -> (a, b) #
Generic (WrappedArrow a b c) |
Instance details Defined in Control.Applicative Associated Types type Rep (WrappedArrow a b c) :: Type -> Type # Methods from :: WrappedArrow a b c -> Rep (WrappedArrow a b c) x # to :: Rep (WrappedArrow a b c) x -> WrappedArrow a b c #
Generic (Kleisli m a b) |
Instance details Defined in Control.Arrow Associated Types type Rep (Kleisli m a b) :: Type -> Type # Methods from :: Kleisli m a b -> Rep (Kleisli m a b) x # to :: Rep (Kleisli m a b) x -> Kleisli m a b #
Generic (Const a b) |
Instance details Defined in Data.Functor.Const Associated Types type Rep (Const a b) :: Type -> Type # Methods from :: Const a b -> Rep (Const a b) x # to :: Rep (Const a b) x -> Const a b #
Generic (Ap f a) |
Instance details Defined in Data.Monoid Associated Types type Rep (Ap f a) :: Type -> Type # Methods from :: Ap f a -> Rep (Ap f a) x # to :: Rep (Ap f a) x -> Ap f a #
Generic (Alt f a) |
Instance details Defined in Data.Semigroup.Internal Associated Types type Rep (Alt f a) :: Type -> Type # Methods from :: Alt f a -> Rep (Alt f a) x # to :: Rep (Alt f a) x -> Alt f a #
Generic (Rec1 f p) |
Instance details Defined in GHC.Generics Associated Types type Rep (Rec1 f p) :: Type -> Type # Methods from :: Rec1 f p -> Rep (Rec1 f p) x # to :: Rep (Rec1 f p) x -> Rec1 f p #
Generic (URec (Ptr ()) p) |
Instance details Defined in GHC.Generics Associated Types type Rep (URec (Ptr ()) p) :: Type -> Type # Methods from :: URec (Ptr ()) p -> Rep (URec (Ptr ()) p) x # to :: Rep (URec (Ptr ()) p) x -> URec (Ptr ()) p #
Generic (URec Char p) |
Instance details Defined in GHC.Generics Associated Types type Rep (URec Char p) :: Type -> Type # Methods from :: URec Char p -> Rep (URec Char p) x # to :: Rep (URec Char p) x -> URec Char p #
Generic (URec Double p) |
Instance details Defined in GHC.Generics Associated Types type Rep (URec Double p) :: Type -> Type # Methods from :: URec Double p -> Rep (URec Double p) x # to :: Rep (URec Double p) x -> URec Double p #
Generic (URec Float p) |
Instance details Defined in GHC.Generics Associated Types type Rep (URec Float p) :: Type -> Type # Methods from :: URec Float p -> Rep (URec Float p) x # to :: Rep (URec Float p) x -> URec Float p #
Generic (URec Int p) |
Instance details Defined in GHC.Generics Associated Types type Rep (URec Int p) :: Type -> Type # Methods from :: URec Int p -> Rep (URec Int p) x # to :: Rep (URec Int p) x -> URec Int p #
Generic (URec Word p) |
Instance details Defined in GHC.Generics Associated Types type Rep (URec Word p) :: Type -> Type # Methods from :: URec Word p -> Rep (URec Word p) x # to :: Rep (URec Word p) x -> URec Word p #
Generic (Join p a) |
Instance details Defined in Data.Bifunctor.Join Associated Types type Rep (Join p a) :: Type -> Type # Methods from :: Join p a -> Rep (Join p a) x # to :: Rep (Join p a) x -> Join p a #
Generic (Tagged s b) |
Instance details Defined in Data.Tagged Associated Types type Rep (Tagged s b) :: Type -> Type # Methods from :: Tagged s b -> Rep (Tagged s b) x # to :: Rep (Tagged s b) x -> Tagged s b #
Generic (These1 f g a) |
Instance details Defined in Data.Functor.These Associated Types type Rep (These1 f g a) :: Type -> Type # Methods from :: These1 f g a -> Rep (These1 f g a) x # to :: Rep (These1 f g a) x -> These1 f g a #
Generic (Backwards f a) |
Instance details Defined in Control.Applicative.Backwards Associated Types type Rep (Backwards f a) :: Type -> Type # Methods from :: Backwards f a -> Rep (Backwards f a) x # to :: Rep (Backwards f a) x -> Backwards f a #
Generic (AccumT w m a) |
Instance details Defined in Control.Monad.Trans.Accum Associated Types type Rep (AccumT w m a) :: Type -> Type # Methods from :: AccumT w m a -> Rep (AccumT w m a) x # to :: Rep (AccumT w m a) x -> AccumT w m a #
Generic (ExceptT e m a) |
Instance details Defined in Control.Monad.Trans.Except Associated Types type Rep (ExceptT e m a) :: Type -> Type # Methods from :: ExceptT e m a -> Rep (ExceptT e m a) x # to :: Rep (ExceptT e m a) x -> ExceptT e m a #
Generic (IdentityT f a) |
Instance details Defined in Control.Monad.Trans.Identity Associated Types type Rep (IdentityT f a) :: Type -> Type # Methods from :: IdentityT f a -> Rep (IdentityT f a) x # to :: Rep (IdentityT f a) x -> IdentityT f a #
Generic (ReaderT r m a) |
Instance details Defined in Control.Monad.Trans.Reader Associated Types type Rep (ReaderT r m a) :: Type -> Type # Methods from :: ReaderT r m a -> Rep (ReaderT r m a) x # to :: Rep (ReaderT r m a) x -> ReaderT r m a #
Generic (SelectT r m a) |
Instance details Defined in Control.Monad.Trans.Select Associated Types type Rep (SelectT r m a) :: Type -> Type # Methods from :: SelectT r m a -> Rep (SelectT r m a) x # to :: Rep (SelectT r m a) x -> SelectT r m a #
Generic (StateT s m a) |
Instance details Defined in Control.Monad.Trans.State.Lazy Associated Types type Rep (StateT s m a) :: Type -> Type # Methods from :: StateT s m a -> Rep (StateT s m a) x # to :: Rep (StateT s m a) x -> StateT s m a #
Generic (StateT s m a) |
Instance details Defined in Control.Monad.Trans.State.Strict Associated Types type Rep (StateT s m a) :: Type -> Type # Methods from :: StateT s m a -> Rep (StateT s m a) x # to :: Rep (StateT s m a) x -> StateT s m a #
Generic (WriterT w m a) |
Instance details Defined in Control.Monad.Trans.Writer.CPS Associated Types type Rep (WriterT w m a) :: Type -> Type # Methods from :: WriterT w m a -> Rep (WriterT w m a) x # to :: Rep (WriterT w m a) x -> WriterT w m a #
Generic (WriterT w m a) |
Instance details Defined in Control.Monad.Trans.Writer.Lazy Associated Types type Rep (WriterT w m a) :: Type -> Type # Methods from :: WriterT w m a -> Rep (WriterT w m a) x # to :: Rep (WriterT w m a) x -> WriterT w m a #
Generic (WriterT w m a) |
Instance details Defined in Control.Monad.Trans.Writer.Strict Associated Types type Rep (WriterT w m a) :: Type -> Type # Methods from :: WriterT w m a -> Rep (WriterT w m a) x # to :: Rep (WriterT w m a) x -> WriterT w m a #
Generic (Constant a b) |
Instance details Defined in Data.Functor.Constant Associated Types type Rep (Constant a b) :: Type -> Type # Methods from :: Constant a b -> Rep (Constant a b) x # to :: Rep (Constant a b) x -> Constant a b #
Generic (Reverse f a) |
Instance details Defined in Data.Functor.Reverse Associated Types type Rep (Reverse f a) :: Type -> Type # Methods from :: Reverse f a -> Rep (Reverse f a) x # to :: Rep (Reverse f a) x -> Reverse f a #
Generic (a, b, c) |
Instance details Defined in GHC.Generics Associated Types type Rep (a, b, c) :: Type -> Type # Methods from :: (a, b, c) -> Rep (a, b, c) x # to :: Rep (a, b, c) x -> (a, b, c) #
Generic (Product f g a) |
Instance details Defined in Data.Functor.Product Associated Types type Rep (Product f g a) :: Type -> Type # Methods from :: Product f g a -> Rep (Product f g a) x # to :: Rep (Product f g a) x -> Product f g a #
Generic (Sum f g a) |
Instance details Defined in Data.Functor.Sum Associated Types type Rep (Sum f g a) :: Type -> Type # Methods from :: Sum f g a -> Rep (Sum f g a) x # to :: Rep (Sum f g a) x -> Sum f g a #
Generic ((f :*: g) p) |
Instance details Defined in GHC.Generics Associated Types type Rep ((f :*: g) p) :: Type -> Type # Methods from :: (f :*: g) p -> Rep ((f :*: g) p) x # to :: Rep ((f :*: g) p) x -> (f :*: g) p #
Generic ((f :+: g) p) |
Instance details Defined in GHC.Generics Associated Types type Rep ((f :+: g) p) :: Type -> Type # Methods from :: (f :+: g) p -> Rep ((f :+: g) p) x # to :: Rep ((f :+: g) p) x -> (f :+: g) p #
Generic (K1 i c p) |
Instance details Defined in GHC.Generics Associated Types type Rep (K1 i c p) :: Type -> Type # Methods from :: K1 i c p -> Rep (K1 i c p) x # to :: Rep (K1 i c p) x -> K1 i c p #
Generic (ContT r m a) |
Instance details Defined in Control.Monad.Trans.Cont Associated Types type Rep (ContT r m a) :: Type -> Type # Methods from :: ContT r m a -> Rep (ContT r m a) x # to :: Rep (ContT r m a) x -> ContT r m a #
Generic (a, b, c, d) |
Instance details Defined in GHC.Generics Associated Types type Rep (a, b, c, d) :: Type -> Type # Methods from :: (a, b, c, d) -> Rep (a, b, c, d) x # to :: Rep (a, b, c, d) x -> (a, b, c, d) #
Generic (Compose f g a) |
Instance details Defined in Data.Functor.Compose Associated Types type Rep (Compose f g a) :: Type -> Type # Methods from :: Compose f g a -> Rep (Compose f g a) x # to :: Rep (Compose f g a) x -> Compose f g a #
Generic ((f :.: g) p) |
Instance details Defined in GHC.Generics Associated Types type Rep ((f :.: g) p) :: Type -> Type # Methods from :: (f :.: g) p -> Rep ((f :.: g) p) x # to :: Rep ((f :.: g) p) x -> (f :.: g) p #
Generic (M1 i c f p) |
Instance details Defined in GHC.Generics Associated Types type Rep (M1 i c f p) :: Type -> Type # Methods from :: M1 i c f p -> Rep (M1 i c f p) x # to :: Rep (M1 i c f p) x -> M1 i c f p #
Generic (Clown f a b) |
Instance details Defined in Data.Bifunctor.Clown Associated Types type Rep (Clown f a b) :: Type -> Type # Methods from :: Clown f a b -> Rep (Clown f a b) x # to :: Rep (Clown f a b) x -> Clown f a b #
Generic (Flip p a b) |
Instance details Defined in Data.Bifunctor.Flip Associated Types type Rep (Flip p a b) :: Type -> Type # Methods from :: Flip p a b -> Rep (Flip p a b) x # to :: Rep (Flip p a b) x -> Flip p a b #
Generic (Joker g a b) |
Instance details Defined in Data.Bifunctor.Joker Associated Types type Rep (Joker g a b) :: Type -> Type # Methods from :: Joker g a b -> Rep (Joker g a b) x # to :: Rep (Joker g a b) x -> Joker g a b #
Generic (WrappedBifunctor p a b) |
Instance details Defined in Data.Bifunctor.Wrapped Associated Types type Rep (WrappedBifunctor p a b) :: Type -> Type # Methods from :: WrappedBifunctor p a b -> Rep (WrappedBifunctor p a b) x # to :: Rep (WrappedBifunctor p a b) x -> WrappedBifunctor p a b #
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 # Methods from :: RWST r w s m a -> Rep (RWST r w s m a) x # to :: Rep (RWST r w s m a) x -> RWST r w s m a #
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 # Methods from :: RWST r w s m a -> Rep (RWST r w s m a) x # to :: Rep (RWST r w s m a) x -> RWST r w s m a #
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 # Methods from :: RWST r w s m a -> Rep (RWST r w s m a) x # to :: Rep (RWST r w s m a) x -> RWST r w s m a #
Generic (a, b, c, d, e) |
Instance details Defined in GHC.Generics Associated Types type Rep (a, b, c, d, e) :: Type -> Type # Methods from :: (a, b, c, d, e) -> Rep (a, b, c, d, e) x # to :: Rep (a, b, c, d, e) x -> (a, b, c, d, e) #
Generic (Product f g a b) |
Instance details Defined in Data.Bifunctor.Product Associated Types type Rep (Product f g a b) :: Type -> Type # Methods from :: Product f g a b -> Rep (Product f g a b) x # to :: Rep (Product f g a b) x -> Product f g a b #
Generic (Sum p q a b) |
Instance details Defined in Data.Bifunctor.Sum Associated Types type Rep (Sum p q a b) :: Type -> Type # Methods from :: Sum p q a b -> Rep (Sum p q a b) x # to :: Rep (Sum p q a b) x -> Sum p q a b #
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 # Methods from :: (a, b, c, d, e, f) -> Rep (a, b, c, d, e, f) x # to :: Rep (a, b, c, d, e, f) x -> (a, b, c, d, e, f) #
Generic (Tannen f p a b) |
Instance details Defined in Data.Bifunctor.Tannen Associated Types type Rep (Tannen f p a b) :: Type -> Type # Methods from :: Tannen f p a b -> Rep (Tannen f p a b) x # to :: Rep (Tannen f p a b) x -> Tannen f p a b #
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 # Methods from :: (a, b, c, d, e, f, g) -> Rep (a, b, c, d, e, f, g) x # to :: Rep (a, b, c, d, e, f, g) x -> (a, b, c, d, e, f, g) #
Generic (a, b, c, d, e, f, g, h) |
Instance details Defined in GHC.Generics Associated Types type Rep (a, b, c, d, e, f, g, h) :: Type -> Type # Methods from :: (a, b, c, d, e, f, g, h) -> Rep (a, b, c, d, e, f, g, h) x # to :: Rep (a, b, c, d, e, f, g, h) x -> (a, b, c, d, e, f, g, h) #
Generic (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 # Methods from :: Biff p f g a b -> Rep (Biff p f g a b) x # to :: Rep (Biff p f g a b) x -> Biff p f g a b #
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 # Methods from :: (a, b, c, d, e, f, g, h, i) -> Rep (a, b, c, d, e, f, g, h, i) x # to :: Rep (a, b, c, d, e, f, g, h, i) x -> (a, b, c, d, e, f, g, h, i) #
Generic (a, b, c, d, e, f, g, h, i, j) |
Instance details Defined in GHC.Generics Associated Types type Rep (a, b, c, d, e, f, g, h, i, j) :: Type -> Type # Methods from :: (a, b, c, d, e, f, g, h, i, j) -> Rep (a, b, c, d, e, f, g, h, i, j) x # to :: Rep (a, b, c, d, e, f, g, h, i, j) x -> (a, b, c, d, e, f, g, h, i, j) #
Generic (a, b, c, d, e, f, g, h, i, j, k) |
Instance details Defined in GHC.Generics Associated Types type Rep (a, b, c, d, e, f, g, h, i, j, k) :: Type -> Type # Methods from :: (a, b, c, d, e, f, g, h, i, j, k) -> Rep (a, b, c, d, e, f, g, h, i, j, k) x # to :: Rep (a, b, c, d, e, f, g, h, i, j, k) x -> (a, b, c, d, e, f, g, h, i, j, k) #
Generic (a, b, c, d, e, f, g, h, i, j, k, l) |
Instance details Defined in GHC.Generics Associated Types type Rep (a, b, c, d, e, f, g, h, i, j, k, l) :: Type -> Type # Methods from :: (a, b, c, d, e, f, g, h, i, j, k, l) -> Rep (a, b, c, d, e, f, g, h, i, j, k, l) x # to :: Rep (a, b, c, d, e, f, g, h, i, j, k, l) x -> (a, b, c, d, e, f, g, h, i, j, k, l) #
Generic (a, b, c, d, e, f, g, h, i, j, k, l, m) |
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 # Methods from :: (a, b, c, d, e, f, g, h, i, j, k, l, m) -> Rep (a, b, c, d, e, f, g, h, i, j, k, l, m) x # to :: Rep (a, b, c, d, e, f, g, h, i, j, k, l, m) x -> (a, b, c, d, e, f, g, h, i, j, k, l, m) #
Generic (a, b, c, d, e, f, g, h, i, j, k, l, m, n) |
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 # Methods from :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> Rep (a, b, c, d, e, f, g, h, i, j, k, l, m, n) x # to :: Rep (a, b, c, d, e, f, g, h, i, j, k, l, m, n) x -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n) #
Generic (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) |
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 # Methods from :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> Rep (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) x # to :: Rep (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) x -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) #