dhall-1.41.2: A configuration language guaranteed to terminate
Safe HaskellSafe-Inferred
LanguageHaskell2010

Dhall.Marshal.Decode

Description

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

Synopsis

General

data Decoder a Source #

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

You can produce Decoders either explicitly:

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

... or implicitly using auto:

example :: Decoder (Vector Text)
example = auto

You can consume Decoders using the input function:

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

Constructors

Decoder 

Fields

Instances

Instances details
Functor Decoder Source # 
Instance details

Defined in Dhall.Marshal.Decode

Methods

fmap :: (a -> b) -> Decoder a -> Decoder b

(<$) :: a -> Decoder b -> Decoder a

class FromDhall a where Source #

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

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

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

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

Minimal complete definition

Nothing

Instances

Instances details
FromDhall Void Source # 
Instance details

Defined in Dhall.Marshal.Decode

FromDhall Int16 Source # 
Instance details

Defined in Dhall.Marshal.Decode

FromDhall Int32 Source # 
Instance details

Defined in Dhall.Marshal.Decode

FromDhall Int64 Source # 
Instance details

Defined in Dhall.Marshal.Decode

FromDhall Int8 Source # 
Instance details

Defined in Dhall.Marshal.Decode

FromDhall Word16 Source # 
Instance details

Defined in Dhall.Marshal.Decode

FromDhall Word32 Source # 
Instance details

Defined in Dhall.Marshal.Decode

FromDhall Word64 Source # 
Instance details

Defined in Dhall.Marshal.Decode

FromDhall Word8 Source # 
Instance details

Defined in Dhall.Marshal.Decode

FromDhall Scientific Source # 
Instance details

Defined in Dhall.Marshal.Decode

Methods

autoWith :: InputNormalizer -> Decoder Scientific Source #

FromDhall Text Source # 
Instance details

Defined in Dhall.Marshal.Decode

FromDhall Text Source # 
Instance details

Defined in Dhall.Marshal.Decode

FromDhall ShortText Source # 
Instance details

Defined in Dhall.Marshal.Decode

Methods

autoWith :: InputNormalizer -> Decoder ShortText Source #

FromDhall Day Source # 
Instance details

Defined in Dhall.Marshal.Decode

FromDhall DayOfWeek Source # 
Instance details

Defined in Dhall.Marshal.Decode

Methods

autoWith :: InputNormalizer -> Decoder DayOfWeek Source #

FromDhall UTCTime Source # 
Instance details

Defined in Dhall.Marshal.Decode

Methods

autoWith :: InputNormalizer -> Decoder UTCTime Source #

FromDhall LocalTime Source # 
Instance details

Defined in Dhall.Marshal.Decode

Methods

autoWith :: InputNormalizer -> Decoder LocalTime Source #

FromDhall TimeOfDay Source # 
Instance details

Defined in Dhall.Marshal.Decode

Methods

autoWith :: InputNormalizer -> Decoder TimeOfDay Source #

FromDhall TimeZone Source # 
Instance details

Defined in Dhall.Marshal.Decode

Methods

autoWith :: InputNormalizer -> Decoder TimeZone Source #

FromDhall ZonedTime Source # 
Instance details

Defined in Dhall.Marshal.Decode

Methods

autoWith :: InputNormalizer -> Decoder ZonedTime Source #

FromDhall Integer Source # 
Instance details

Defined in Dhall.Marshal.Decode

Methods

autoWith :: InputNormalizer -> Decoder Integer Source #

FromDhall Natural Source # 
Instance details

Defined in Dhall.Marshal.Decode

FromDhall () Source # 
Instance details

Defined in Dhall.Marshal.Decode

FromDhall Bool Source # 
Instance details

Defined in Dhall.Marshal.Decode

FromDhall Double Source # 
Instance details

Defined in Dhall.Marshal.Decode

FromDhall Int Source # 
Instance details

Defined in Dhall.Marshal.Decode

FromDhall Word Source # 
Instance details

Defined in Dhall.Marshal.Decode

ToDhall x => FromDhall (Equivalence x) Source # 
Instance details

Defined in Dhall.Marshal.Decode

Methods

autoWith :: InputNormalizer -> Decoder (Equivalence x) Source #

ToDhall x => FromDhall (Predicate x) Source # 
Instance details

Defined in Dhall.Marshal.Decode

Methods

autoWith :: InputNormalizer -> Decoder (Predicate x) Source #

FromDhall a => FromDhall (Seq a) Source # 
Instance details

Defined in Dhall.Marshal.Decode

(FromDhall a, Ord a, Show a) => FromDhall (Set a) Source #

Note that this instance will throw errors in the presence of duplicates in the list. To ignore duplicates, use setIgnoringDuplicates.

Instance details

Defined in Dhall.Marshal.Decode

Methods

autoWith :: InputNormalizer -> Decoder (Set a) Source #

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

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

Here is an example use of this instance:

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

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

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

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

TH.makeBaseFunctor ''Expr

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

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

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

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

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

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

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

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

    print (convert x :: Expr)
Instance details

Defined in Dhall.Marshal.Decode

Methods

autoWith :: InputNormalizer -> Decoder (Fix f) Source #

FromDhall (f (Result f)) => FromDhall (Result f) Source # 
Instance details

Defined in Dhall.Marshal.Decode

(FromDhall a, Hashable a, Ord a, Show a) => FromDhall (HashSet a) Source #

Note that this instance will throw errors in the presence of duplicates in the list. To ignore duplicates, use hashSetIgnoringDuplicates.

Instance details

Defined in Dhall.Marshal.Decode

Methods

autoWith :: InputNormalizer -> Decoder (HashSet a) Source #

FromDhall a => FromDhall (Vector a) Source # 
Instance details

Defined in Dhall.Marshal.Decode

FromDhall a => FromDhall (Maybe a) Source # 
Instance details

Defined in Dhall.Marshal.Decode

Methods

autoWith :: InputNormalizer -> Decoder (Maybe a) Source #

FromDhall [Char] Source # 
Instance details

Defined in Dhall.Marshal.Decode

FromDhall a => FromDhall [a] Source # 
Instance details

Defined in Dhall.Marshal.Decode

(FromDhall b, ToDhall x) => FromDhall (Op b x) Source # 
Instance details

Defined in Dhall.Marshal.Decode

Methods

autoWith :: InputNormalizer -> Decoder (Op b x) Source #

(Ord k, FromDhall k, FromDhall v) => FromDhall (Map k v) Source # 
Instance details

Defined in Dhall.Marshal.Decode

Methods

autoWith :: InputNormalizer -> Decoder (Map k v) Source #

(Eq k, Hashable k, FromDhall k, FromDhall v) => FromDhall (HashMap k v) Source # 
Instance details

Defined in Dhall.Marshal.Decode

Methods

autoWith :: InputNormalizer -> Decoder (HashMap k v) Source #

(ToDhall a, FromDhall b) => FromDhall (a -> b) Source # 
Instance details

Defined in Dhall.Marshal.Decode

Methods

autoWith :: InputNormalizer -> Decoder (a -> b) Source #

(FromDhall a, FromDhall b) => FromDhall (a, b) Source # 
Instance details

Defined in Dhall.Marshal.Decode

(Generic a, GenericFromDhall a (Rep a), ModifyOptions tag) => FromDhall (Codec tag a) Source # 
Instance details

Defined in Dhall.Deriving

type Interpret = FromDhall Source #

Deprecated: Use FromDhall instead

A compatibility alias for FromDhall.

auto :: FromDhall a => Decoder a Source #

Use the default input normalizer for interpreting an input.

auto = autoWith defaultInputNormalizer

Building decoders

Simple decoders

bool :: Decoder Bool Source #

Decode a Bool.

>>> input bool "True"
True

unit :: Decoder () Source #

Decode () from an empty record.

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

void :: Decoder Void Source #

Decode Void from an empty union.

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

Numbers

natural :: Decoder Natural Source #

Decode a Natural.

>>> input natural "42"
42

word :: Decoder Word Source #

Decode a Word from a Dhall Natural.

>>> input word "42"
42

word8 :: Decoder Word8 Source #

Decode a Word8 from a Dhall Natural.

>>> input word8 "42"
42

word16 :: Decoder Word16 Source #

Decode a Word16 from a Dhall Natural.

>>> input word16 "42"
42

word32 :: Decoder Word32 Source #

Decode a Word32 from a Dhall Natural.

>>> input word32 "42"
42

word64 :: Decoder Word64 Source #

Decode a Word64 from a Dhall Natural.

>>> input word64 "42"
42

integer :: Decoder Integer Source #

Decode an Integer.

>>> input integer "+42"
42

int :: Decoder Int Source #

Decode an Int from a Dhall Integer.

>>> input int "-42"
-42

int8 :: Decoder Int8 Source #

Decode an Int8 from a Dhall Integer.

>>> input int8 "-42"
-42

int16 :: Decoder Int16 Source #

Decode an Int16 from a Dhall Integer.

>>> input int16 "-42"
-42

int32 :: Decoder Int32 Source #

Decode an Int32 from a Dhall Integer.

>>> input int32 "-42"
-42

int64 :: Decoder Int64 Source #

Decode an Int64 from a Dhall Integer.

>>> input int64 "-42"
-42

scientific :: Decoder Scientific Source #

Decode a Scientific.

>>> input scientific "1e100"
1.0e100

double :: Decoder Double Source #

Decode a Double.

>>> input double "42.0"
42.0

Textual

string :: Decoder String Source #

Decode a String

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

lazyText :: Decoder Text Source #

Decode lazy Text.

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

strictText :: Decoder Text Source #

Decode strict Text.

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

shortText :: Decoder ShortText Source #

Decode ShortText.

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

Time

timeOfDay :: Decoder TimeOfDay Source #

Decode TimeOfDay

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

day :: Decoder Day Source #

Decode Day

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

timeZone :: Decoder TimeZone Source #

Decode TimeZone

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

localTime :: Decoder LocalTime Source #

Decode LocalTime

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

zonedTime :: Decoder ZonedTime Source #

Decode ZonedTime

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

utcTime :: Decoder UTCTime Source #

Decode UTCTime

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

dayOfWeek :: Decoder DayOfWeek Source #

Decode DayOfWeek

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

Containers

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

Decode a Maybe.

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

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

Given a pair of Decoders, decode a tuple-record into their pairing.

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

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

Decode a Seq.

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

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

Decode a list.

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

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

Decode a Vector.

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

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

Decode a Set from a List with distinct elements.

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

An error is thrown if the list contains duplicates.

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

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

One duplicate element in the list: 1
>>> input (setFromDistinctList natural) "[1, 1, 3, 3]"
*** Exception: Error: Failed extraction

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

2 duplicates were found in the list, including 1

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

Decode a Set from a List.

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

Duplicate elements are ignored.

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

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

Decode a HashSet from a List with distinct elements.

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

An error is thrown if the list contains duplicates.

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

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

One duplicate element in the list: 1
>>> input (hashSetFromDistinctList natural) "[1, 1, 3, 3]"
*** Exception: Error: Failed extraction

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

2 duplicates were found in the list, including 1

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

Decode a HashSet from a List.

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

Duplicate elements are ignored.

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

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

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

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

If there are duplicate mapKeys, later mapValues take precedence:

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

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

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

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

If there are duplicate mapKeys, later mapValues take precedence:

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

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

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

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

Functions

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

Decode a Dhall function into a Haskell function.

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

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

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

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

Records

newtype RecordDecoder a Source #

The RecordDecoder applicative functor allows you to build a Decoder from a Dhall record.

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

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

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

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

Our decoder has type Decoder Project, but we can't build that out of any smaller decoders, as Decoders cannot be combined (they are only Functors). However, we can use a RecordDecoder to build a Decoder for Project:

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

Constructors

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

Instances

Instances details
Applicative RecordDecoder Source # 
Instance details

Defined in Dhall.Marshal.Decode

Functor RecordDecoder Source # 
Instance details

Defined in Dhall.Marshal.Decode

Methods

fmap :: (a -> b) -> RecordDecoder a -> RecordDecoder b

(<$) :: a -> RecordDecoder b -> RecordDecoder a

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

Parse a single field of a record.

Unions

newtype UnionDecoder a Source #

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

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

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

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

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

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

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

Constructors

UnionDecoder (Compose (Map Text) Decoder a) 

Instances

Instances details
Functor UnionDecoder Source # 
Instance details

Defined in Dhall.Marshal.Decode

Methods

fmap :: (a -> b) -> UnionDecoder a -> UnionDecoder b

(<$) :: a -> UnionDecoder b -> UnionDecoder a

Monoid (UnionDecoder a) Source # 
Instance details

Defined in Dhall.Marshal.Decode

Semigroup (UnionDecoder a) Source # 
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

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

Parse a single constructor of a union.

Generic decoding

class GenericFromDhall t f where Source #

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

Methods

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

Instances

Instances details
GenericFromDhall (t :: k1) (U1 :: k2 -> Type) Source # 
Instance details

Defined in Dhall.Marshal.Decode

Methods

genericAutoWithNormalizer :: forall (a :: k10). Proxy t -> InputNormalizer -> InterpretOptions -> State Int (Decoder (U1 a)) Source #

GenericFromDhall (t :: k1) (V1 :: k2 -> Type) Source # 
Instance details

Defined in Dhall.Marshal.Decode

Methods

genericAutoWithNormalizer :: forall (a :: k10). Proxy t -> InputNormalizer -> InterpretOptions -> State Int (Decoder (V1 a)) Source #

GenericFromDhall (a1 :: Type) (M1 S s1 (K1 i1 a1 :: k -> Type) :*: M1 S s2 (K1 i2 a2 :: k -> Type) :: k -> Type) Source # 
Instance details

Defined in Dhall.Marshal.Decode

Methods

genericAutoWithNormalizer :: forall (a :: k1). Proxy a1 -> InputNormalizer -> InterpretOptions -> State Int (Decoder ((M1 S s1 (K1 i1 a1) :*: M1 S s2 (K1 i2 a2)) a)) Source #

GenericFromDhall (a2 :: Type) (M1 S s1 (K1 i1 a1 :: k -> Type) :*: M1 S s2 (K1 i2 a2 :: k -> Type) :: k -> Type) Source # 
Instance details

Defined in Dhall.Marshal.Decode

Methods

genericAutoWithNormalizer :: forall (a :: k1). Proxy a2 -> InputNormalizer -> InterpretOptions -> State Int (Decoder ((M1 S s1 (K1 i1 a1) :*: M1 S s2 (K1 i2 a2)) a)) Source #

(GenericFromDhall t (f :*: g), GenericFromDhall t (h :*: i)) => GenericFromDhall (t :: k1) ((f :*: g) :*: (h :*: i) :: k2 -> Type) Source # 
Instance details

Defined in Dhall.Marshal.Decode

Methods

genericAutoWithNormalizer :: forall (a :: k10). Proxy t -> InputNormalizer -> InterpretOptions -> State Int (Decoder (((f :*: g) :*: (h :*: i)) a)) Source #

(GenericFromDhall t (f :*: g), Selector s, FromDhall a) => GenericFromDhall (t :: k1) ((f :*: g) :*: M1 S s (K1 i a :: k2 -> Type) :: k2 -> Type) Source # 
Instance details

Defined in Dhall.Marshal.Decode

Methods

genericAutoWithNormalizer :: forall (a0 :: k10). Proxy t -> InputNormalizer -> InterpretOptions -> State Int (Decoder (((f :*: g) :*: M1 S s (K1 i a)) a0)) Source #

(Selector s, FromDhall a, GenericFromDhall t (f :*: g)) => GenericFromDhall (t :: k1) (M1 S s (K1 i a :: k2 -> Type) :*: (f :*: g) :: k2 -> Type) Source # 
Instance details

Defined in Dhall.Marshal.Decode

Methods

genericAutoWithNormalizer :: forall (a0 :: k10). Proxy t -> InputNormalizer -> InterpretOptions -> State Int (Decoder ((M1 S s (K1 i a) :*: (f :*: g)) a0)) Source #

(Selector s1, Selector s2, FromDhall a1, FromDhall a2) => GenericFromDhall (t :: k1) (M1 S s1 (K1 i1 a1 :: k2 -> Type) :*: M1 S s2 (K1 i2 a2 :: k2 -> Type) :: k2 -> Type) Source # 
Instance details

Defined in Dhall.Marshal.Decode

Methods

genericAutoWithNormalizer :: forall (a :: k10). Proxy t -> InputNormalizer -> InterpretOptions -> State Int (Decoder ((M1 S s1 (K1 i1 a1) :*: M1 S s2 (K1 i2 a2)) a)) Source #

GenericFromDhallUnion t (f :+: g) => GenericFromDhall (t :: k1) (f :+: g :: k2 -> Type) Source # 
Instance details

Defined in Dhall.Marshal.Decode

Methods

genericAutoWithNormalizer :: forall (a :: k10). Proxy t -> InputNormalizer -> InterpretOptions -> State Int (Decoder ((f :+: g) a)) Source #

GenericFromDhall (a :: Type) (M1 S s (K1 i a :: k -> Type) :: k -> Type) Source # 
Instance details

Defined in Dhall.Marshal.Decode

Methods

genericAutoWithNormalizer :: forall (a0 :: k1). Proxy a -> InputNormalizer -> InterpretOptions -> State Int (Decoder (M1 S s (K1 i a) a0)) Source #

GenericFromDhall t f => GenericFromDhall (t :: k1) (M1 C c f :: k2 -> Type) Source # 
Instance details

Defined in Dhall.Marshal.Decode

Methods

genericAutoWithNormalizer :: forall (a :: k10). Proxy t -> InputNormalizer -> InterpretOptions -> State Int (Decoder (M1 C c f a)) Source #

GenericFromDhall t f => GenericFromDhall (t :: k1) (M1 D d f :: k2 -> Type) Source # 
Instance details

Defined in Dhall.Marshal.Decode

Methods

genericAutoWithNormalizer :: forall (a :: k10). Proxy t -> InputNormalizer -> InterpretOptions -> State Int (Decoder (M1 D d f a)) Source #

(Selector s, FromDhall a) => GenericFromDhall (t :: k1) (M1 S s (K1 i a :: k2 -> Type) :: k2 -> Type) Source # 
Instance details

Defined in Dhall.Marshal.Decode

Methods

genericAutoWithNormalizer :: forall (a0 :: k10). Proxy t -> InputNormalizer -> InterpretOptions -> State Int (Decoder (M1 S s (K1 i a) a0)) Source #

class GenericFromDhallUnion t f where Source #

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

Instances

Instances details
(GenericFromDhallUnion t f1, GenericFromDhallUnion t f2) => GenericFromDhallUnion (t :: k1) (f1 :+: f2 :: k2 -> Type) Source # 
Instance details

Defined in Dhall.Marshal.Decode

Methods

genericUnionAutoWithNormalizer :: forall (a :: k10). Proxy t -> InputNormalizer -> InterpretOptions -> UnionDecoder ((f1 :+: f2) a) Source #

(Constructor c1, GenericFromDhall t f1) => GenericFromDhallUnion (t :: k1) (M1 C c1 f1 :: k2 -> Type) Source # 
Instance details

Defined in Dhall.Marshal.Decode

Methods

genericUnionAutoWithNormalizer :: forall (a :: k10). Proxy t -> InputNormalizer -> InterpretOptions -> UnionDecoder (M1 C c1 f1 a) Source #

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

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

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

genericAutoWith is a configurable version of genericAuto.

Decoding errors

newtype DhallErrors e Source #

A newtype suitable for collecting one or more errors.

Constructors

DhallErrors 

Fields

Instances

Instances details
Functor DhallErrors Source # 
Instance details

Defined in Dhall.Marshal.Decode

Methods

fmap :: (a -> b) -> DhallErrors a -> DhallErrors b

(<$) :: a -> DhallErrors b -> DhallErrors a

Show ExpectedTypeErrors Source # 
Instance details

Defined in Dhall.Marshal.Decode

Methods

showsPrec :: Int -> ExpectedTypeErrors -> ShowS

show :: ExpectedTypeErrors -> String

showList :: [ExpectedTypeErrors] -> ShowS

Semigroup (DhallErrors e) Source # 
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) Source # 
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) Source # 
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) Source # 
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 Source #

Render a given prefix and some errors to a string.

data InvalidDecoder s a Source #

Every Decoder must obey the contract that if an expression's type matches the expected type then the extract function must not fail with a type error. However, decoding may still fail for other reasons (such as the decoder for Sets 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.

Instances

Instances details
(Pretty s, Typeable s, Pretty a, Typeable a) => Exception (InvalidDecoder s a) Source # 
Instance details

Defined in Dhall.Marshal.Decode

Methods

toException :: InvalidDecoder s a -> SomeException

fromException :: SomeException -> Maybe (InvalidDecoder s a)

displayException :: InvalidDecoder s a -> String

(Pretty s, Pretty a, Typeable s, Typeable a) => Show (InvalidDecoder s a) Source # 
Instance details

Defined in Dhall.Marshal.Decode

Methods

showsPrec :: Int -> InvalidDecoder s a -> ShowS

show :: InvalidDecoder s a -> String

showList :: [InvalidDecoder s a] -> ShowS

Extraction errors

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

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

data ExtractError s a Source #

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

Instances

Instances details
(Pretty s, Pretty a, Typeable s, Typeable a) => Exception (ExtractError s a) Source # 
Instance details

Defined in Dhall.Marshal.Decode

Methods

toException :: ExtractError s a -> SomeException

fromException :: SomeException -> Maybe (ExtractError s a)

displayException :: ExtractError s a -> String

(Pretty s, Pretty a, Typeable s, Typeable a) => Show (ExtractError s a) Source # 
Instance details

Defined in Dhall.Marshal.Decode

Methods

showsPrec :: Int -> ExtractError s a -> ShowS

show :: ExtractError s a -> String

showList :: [ExtractError s a] -> ShowS

(Pretty s, Pretty a, Typeable s, Typeable a) => Show (ExtractErrors s a) Source # 
Instance details

Defined in Dhall.Marshal.Decode

Methods

showsPrec :: Int -> ExtractErrors s a -> ShowS

show :: ExtractErrors s a -> String

showList :: [ExtractErrors s a] -> ShowS

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

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

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

Generate a type error during extraction by specifying the expected type and the actual type. The expected type is not yet determined.

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

Turn a Text message into an extraction failure.

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

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

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

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

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

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

Typing errors

type ExpectedTypeErrors = DhallErrors ExpectedTypeError Source #

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

data ExpectedTypeError Source #

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

Constructors

RecursiveTypeError 

Instances

Instances details
Exception ExpectedTypeError Source # 
Instance details

Defined in Dhall.Marshal.Decode

Methods

toException :: ExpectedTypeError -> SomeException

fromException :: SomeException -> Maybe ExpectedTypeError

displayException :: ExpectedTypeError -> String

Show ExpectedTypeError Source # 
Instance details

Defined in Dhall.Marshal.Decode

Methods

showsPrec :: Int -> ExpectedTypeError -> ShowS

show :: ExpectedTypeError -> String

showList :: [ExpectedTypeError] -> ShowS

Show ExpectedTypeErrors Source # 
Instance details

Defined in Dhall.Marshal.Decode

Methods

showsPrec :: Int -> ExpectedTypeErrors -> ShowS

show :: ExpectedTypeErrors -> String

showList :: [ExpectedTypeErrors] -> ShowS

Eq ExpectedTypeError Source # 
Instance details

Defined in Dhall.Marshal.Decode

type Expector = Validation ExpectedTypeErrors Source #

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

Miscellaneous

newtype InputNormalizer Source #

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

defaultInputNormalizer :: InputNormalizer Source #

Default normalization-related settings (no custom normalization)

data InterpretOptions Source #

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

Constructors

InterpretOptions 

Fields

data SingletonConstructors Source #

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

For example, consider the following Haskell datatype definition:

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

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

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

Constructors

Bare

Never wrap the field in a record

Wrapped

Always wrap the field in a record

Smart

Only fields in a record if they are named

Instances

Instances details
ToSingletonConstructors a => ModifyOptions (SetSingletonConstructors a :: Type) Source # 
Instance details

Defined in Dhall.Deriving

defaultInterpretOptions :: InterpretOptions Source #

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

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

data Result f Source #

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

Instances

Instances details
FromDhall (f (Result f)) => FromDhall (Result f) Source # 
Instance details

Defined in Dhall.Marshal.Decode

ToDhall (f (Result f)) => ToDhall (Result f) Source # 
Instance details

Defined in Dhall.Marshal.Encode

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]

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

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

Ix Natural 
Instance details

Defined in GHC.Ix

Num Natural 
Instance details

Defined in GHC.Num

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

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 Source # 
Instance details

Defined in Dhall.Marshal.Decode

ToDhall Natural Source # 
Instance details

Defined in Dhall.Marshal.Encode

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

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 :: (Value -> Parser a) -> (Value -> Parser [a]) -> Value -> Parser (Seq a)

liftParseJSONList :: (Value -> Parser a) -> (Value -> Parser [a]) -> Value -> Parser [Seq a]

ToJSON1 Seq 
Instance details

Defined in Data.Aeson.Types.ToJSON

Methods

liftToJSON :: (a -> Value) -> ([a] -> Value) -> Seq a -> Value

liftToJSONList :: (a -> Value) -> ([a] -> Value) -> [Seq a] -> Value

liftToEncoding :: (a -> Encoding) -> ([a] -> Encoding) -> Seq a -> Encoding

liftToEncodingList :: (a -> Encoding) -> ([a] -> Encoding) -> [Seq a] -> Encoding

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

FromJSON a => FromJSON (Seq a) 
Instance details

Defined in Data.Aeson.Types.FromJSON

Methods

parseJSON :: Value -> Parser (Seq a)

parseJSONList :: Value -> Parser [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

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) Source # 
Instance details

Defined in Dhall.Marshal.Decode

ToDhall a => ToDhall (Seq a) Source # 
Instance details

Defined in Dhall.Marshal.Encode

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) 
Instance details

Defined in Data.Hashable.Class

Methods

hashWithSalt :: Int -> Seq v -> Int

hash :: Seq v -> Int

Ord a => Stream (Seq a) 
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) 
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]

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

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 Source # 
Instance details

Defined in Dhall.Marshal.Decode

ToDhall Text Source # 
Instance details

Defined in Dhall.Marshal.Encode

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 
Instance details

Defined in Prettyprinter.Internal

Methods

pretty :: Text -> Doc ann

prettyList :: [Text] -> Doc ann

Serialise Text 
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 ()

Monad m => Stream Text m Char 
Instance details

Defined in Text.Parsec.Prim

Methods

uncons :: Text -> m (Maybe (Char, 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 = Char
type Tokens Text 
Instance details

Defined in Text.Megaparsec.Stream

type Tokens Text = Text

data Vector a #

Instances

Instances details
FromJSON1 Vector 
Instance details

Defined in Data.Aeson.Types.FromJSON

Methods

liftParseJSON :: (Value -> Parser a) -> (Value -> Parser [a]) -> Value -> Parser (Vector a)

liftParseJSONList :: (Value -> Parser a) -> (Value -> Parser [a]) -> Value -> Parser [Vector a]

ToJSON1 Vector 
Instance details

Defined in Data.Aeson.Types.ToJSON

Methods

liftToJSON :: (a -> Value) -> ([a] -> Value) -> Vector a -> Value

liftToJSONList :: (a -> Value) -> ([a] -> Value) -> [Vector a] -> Value

liftToEncoding :: (a -> Encoding) -> ([a] -> Encoding) -> Vector a -> Encoding

liftToEncodingList :: (a -> Encoding) -> ([a] -> Encoding) -> [Vector a] -> Encoding

MonadFail Vector 
Instance details

Defined in Data.Vector

Methods

fail :: String -> Vector a

MonadFix Vector 
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 
Instance details

Defined in Data.Vector

Methods

liftRnf :: (a -> ()) -> Vector a -> ()

Vector Vector a 
Instance details

Defined in Data.Vector

Methods

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

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

basicLength :: Vector a -> Int

basicUnsafeSlice :: Int -> Int -> Vector a -> Vector a

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

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

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]

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

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) Source # 
Instance details

Defined in Dhall.Marshal.Decode

ToDhall a => ToDhall (Vector a) Source # 
Instance details

Defined in Dhall.Marshal.Encode

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) 
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 Data.Void

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 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 Source # 
Instance details

Defined in Dhall.Crypto

Associated Types

type Rep SHA256Digest :: Type -> Type

Generic CharacterSet Source # 
Instance details

Defined in Dhall.Pretty.Internal

Associated Types

type Rep CharacterSet :: Type -> Type

Generic Src Source # 
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 Source # 
Instance details

Defined in Dhall.Syntax

Associated Types

type Rep Const :: Type -> Type

Methods

from :: Const -> Rep Const x

to :: Rep Const x -> Const

Generic DhallDouble Source # 
Instance details

Defined in Dhall.Syntax

Associated Types

type Rep DhallDouble :: Type -> Type

Methods

from :: DhallDouble -> Rep DhallDouble x

to :: Rep DhallDouble x -> DhallDouble

Generic Directory Source # 
Instance details

Defined in Dhall.Syntax

Associated Types

type Rep Directory :: Type -> Type

Methods

from :: Directory -> Rep Directory x

to :: Rep Directory x -> Directory

Generic File Source # 
Instance details

Defined in Dhall.Syntax

Associated Types

type Rep File :: Type -> Type

Methods

from :: File -> Rep File x

to :: Rep File x -> File

Generic FilePrefix Source # 
Instance details

Defined in Dhall.Syntax

Associated Types

type Rep FilePrefix :: Type -> Type

Methods

from :: FilePrefix -> Rep FilePrefix x

to :: Rep FilePrefix x -> FilePrefix

Generic Import Source # 
Instance details

Defined in Dhall.Syntax

Associated Types

type Rep Import :: Type -> Type

Methods

from :: Import -> Rep Import x

to :: Rep Import x -> Import

Generic ImportHashed Source # 
Instance details

Defined in Dhall.Syntax

Associated Types

type Rep ImportHashed :: Type -> Type

Generic ImportMode Source # 
Instance details

Defined in Dhall.Syntax

Associated Types

type Rep ImportMode :: Type -> Type

Methods

from :: ImportMode -> Rep ImportMode x

to :: Rep ImportMode x -> ImportMode

Generic ImportType Source # 
Instance details

Defined in Dhall.Syntax

Associated Types

type Rep ImportType :: Type -> Type

Methods

from :: ImportType -> Rep ImportType x

to :: Rep ImportType x -> ImportType

Generic Scheme Source # 
Instance details

Defined in Dhall.Syntax

Associated Types

type Rep Scheme :: Type -> Type

Methods

from :: Scheme -> Rep Scheme x

to :: Rep Scheme x -> Scheme

Generic URL Source # 
Instance details

Defined in Dhall.Syntax

Associated Types

type Rep URL :: Type -> Type

Methods

from :: URL -> Rep URL x

to :: Rep URL x -> URL

Generic Var Source # 
Instance details

Defined in Dhall.Syntax

Associated Types

type Rep Var :: Type -> Type

Methods

from :: Var -> Rep Var x

to :: Rep Var x -> Var

Generic WithComponent Source # 
Instance details

Defined in Dhall.Syntax

Associated Types

type Rep WithComponent :: Type -> Type

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 (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 (Set a) Source # 
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) Source # 
Instance details

Defined in Dhall.Syntax

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 (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 (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) Source # 
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) Source # 
Instance details

Defined in Dhall.Syntax

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) Source # 
Instance details

Defined in Dhall.Syntax

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) Source # 
Instance details

Defined in Dhall.Syntax

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) Source # 
Instance details

Defined in Dhall.Syntax

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 (PreferAnnotation s a) Source # 
Instance details

Defined in Dhall.Syntax

Associated Types

type Rep (PreferAnnotation s a) :: Type -> Type

Methods

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

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

Generic (RecordField s a) Source # 
Instance details

Defined in Dhall.Syntax

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