Web.Hyperbole

Create fully interactive HTML applications with type-safe serverside Haskell. Inspired by HTMX, Elm, and Phoenix LiveView

Introduction

Single Page Applications (SPAs) require the programmer to write two programs: a Javascript client and a Server, which both must conform to a common API

Hyperbole allows us instead to write a single Haskell program which runs exclusively on the server. All user interactions are sent to the server for processing, and a sub-section of the page is updated with the resulting HTML.

There are frameworks that support this in different ways, including HTMX, Phoenix LiveView, and others. Hyperbole has the following advantages

1. 100% Haskell
2. Type safe views, actions, routes, and forms
3. Elegant interface with little boilerplate
4. VirtualDOM updates over sockets, fallback to HTTP
5. Easy to use

Like HTMX, Hyperbole extends the capability of UI elements, but it uses Haskell's type-system to prevent common errors and provide default functionality. Specifically, a page has multiple update targets called HyperViews. These are automatically targeted by any UI element that triggers an action inside them. The compiler makes sure that actions and targets match

Like Phoenix LiveView, it upgrades the page to a fast WebSocket connection and uses VirtualDOM for live updates

Like Elm, it relies on an update function to handle actions, but greatly simplifies the Elm Architecture by handling state with extensible effects. forms are easy to use with minimal boilerplate

Depends heavily on the following frameworks

• Effectful
• Web View

Hello World

Hyperbole applications run via Warp and WAI

They are divided into top-level Pages. We use load to handle the initial page load

main = do
  run 3000 $ do
    liveApp (basicDocument "Example") (page messagePage)

messagePage = do
  load $ do
    pure $ do
      el bold "Message Page"
      messageView "Hello World"

messageView m = do
  el_ "Message:"
  el_ (text m)

Interactivity

Embed HyperViews to add type-safe interactivity to subsections of a Page.

To do this, first we connect a view id type to the actions it supports

data Message = Message
  deriving (Generic, Param)

data MessageAction = Louder Text
  deriving (Generic, Param)

instance HyperView Message where
  type Action Message = MessageAction

Next we add a handler for our view type. It performs side effects, and returns a new view of the same type

message :: Message -> MessageAction -> Eff es (View Message ())
message _ (Louder m) = do
  -- side effects
  let new = m <> "!"
  pure $ messageView new

We update our parent page view to make the messageView interactive using hyper, and add our handler to the Page

messagePage = do
  handle message
  load $ do
    pure $ do
      el bold "Message Page"
      hyper Message $ messageView "Hello World"

Finally, let's add a button to our view. When clicked, Hyperbole will run the message handler, and update our view, leaving the page header untouched

messageView :: Text -> View Message ()
messageView m = do
  el_ m
  button (Louder m) id "Change Message"

Independent Updates

Multiple views update independently, as long as they have different values for their View Id. Add an Int identifier to Message

data Message = Message Int
  deriving (Generic, Param)

We can embed multiple HyperViews on the same page with different ids. Each button will update its view independently

messagePage = do
  handle message
  load $ do
    pure $ do
      el bold "Message Page"
      hyper (Message 1) $ messageView "Hello"
      hyper (Message 2) $ messageView "World"

Examples

The example directory contains an app with pages demonstrating various features

• Main
• Simple
• Counter
• CSS Transitions
• Forms
• Sessions
• Redirects
• Lazy Loading and Polling
• Errors
• Contacts (Advanced)

Run an Application

liveApp :: (ByteString -> ByteString) -> Eff '[Hyperbole, Server, IOE] Response -> Application

Turn one or more Pages into a Wai Application. Respond using both HTTP and WebSockets

main = do
  run 3000 $ do
  liveApp (basicDocument "Example") $ do
     page mainPage

run :: Port -> Application -> IO ()

Run an Application on the given port. This calls runSettings with defaultSettings.

page :: Hyperbole :> es => Page es Response -> Eff es Response

Run a Page in Hyperbole

basicDocument :: Text -> ByteString -> ByteString

wrap HTML fragments in a simple document with a custom title and include required embeds

liveApp (basicDocument "App Title") (routeRequest router)

You may want to specify a custom document function instead:

myDocument :: ByteString -> ByteString
myDocument content =
  [i|<html>
    <head>
      <title>#{title}</title>
      <script type="text/javascript">#{scriptEmbed}</script>
      <style type type="text/css">#{cssResetEmbed}</style>
    </head>
    <body>#{content}</body>
  </html>|]

Type-Safe Routes

routeRequest :: (Hyperbole :> es, Route route) => (route -> Eff es Response) -> Eff es Response

Route URL patterns to different pages

import Page.Messages qualified as Messages
import Page.Users qualified as Users

data AppRoute
  = Main
  | Messages
  | Users UserId
  deriving (Eq, Generic, Route)

router :: (Hyperbole :> es) => AppRoute -> Eff es Response
router Messages = page Messages.page
router (Users uid) = page $ Users.page uid
router Main = do
  view $ do
    el_ "click a link below to visit a page"
    route Messages id "Messages"

main = do
  run 3000 $ do
    liveApp (basicDocument "Example") (routeRequest router)

class Route a

Derive this class to use a sum type as a route. Constructors and Selectors map intuitively to url patterns

data AppRoute
 = HomePage
 | Users
 | User Int
 deriving (Generic, Route)

/         -> HomePage
/users/   -> Users
/user/100 -> User 100

Instances

Route Text

Defined in Web.Hyperbole.Route

Methods

defRoute :: Text

routePath :: Text -> [Segment]

matchRoute :: [Segment] -> Maybe Text

Route String

Defined in Web.Hyperbole.Route

Methods

defRoute :: String

routePath :: String -> [Segment]

matchRoute :: [Segment] -> Maybe String

Route Integer

Defined in Web.Hyperbole.Route

Methods

defRoute :: Integer

routePath :: Integer -> [Segment]

matchRoute :: [Segment] -> Maybe Integer

Route Int

Defined in Web.Hyperbole.Route

Methods

defRoute :: Int

routePath :: Int -> [Segment]

matchRoute :: [Segment] -> Maybe Int

Route a => Route (Maybe a)

Defined in Web.Hyperbole.Route

Methods

defRoute :: Maybe a

routePath :: Maybe a -> [Segment]

matchRoute :: [Segment] -> Maybe (Maybe a)

routeUrl :: Route a => a -> Url

Convert a Route to a Url

>>> routeUrl (User 100)
/user/100

route :: Route a => a -> Mod -> View c () -> View c ()

A hyperlink to another route

>>> route (User 100) id "View User"
<a href="/user/100">View User</a>

Pages

Page

data Page es a

Hyperbole applications are divided into Pages. Each Page must load the whole page , and handle each type of HyperView

myPage :: (Hyperbole :> es) => Page es Response
myPage = do
  handle messages
  load pageView

pageView = do
  el_ "My Page"
  hyper (Message 1) $ messageView "Starting Message"

Instances

Applicative (Page es)

Defined in Web.Hyperbole.Effect

Methods

pure :: a -> Page es a

(<*>) :: Page es (a -> b) -> Page es a -> Page es b

liftA2 :: (a -> b -> c) -> Page es a -> Page es b -> Page es c

(*>) :: Page es a -> Page es b -> Page es b

(<*) :: Page es a -> Page es b -> Page es a

Functor (Page es)

Defined in Web.Hyperbole.Effect

Methods

fmap :: (a -> b) -> Page es a -> Page es b

(<$) :: a -> Page es b -> Page es a

Monad (Page es)

Defined in Web.Hyperbole.Effect

Methods

(>>=) :: Page es a -> (a -> Page es b) -> Page es b

(>>) :: Page es a -> Page es b -> Page es b

return :: a -> Page es a

load :: Hyperbole :> es => Eff es (View () ()) -> Page es Response

The load handler is run when the page is first loaded. Run any side effects needed, then return a view of the full page

myPage :: (Hyperbole :> es) => UserId -> Page es Response
myPage userId = do
  load $ do
    user <- loadUserFromDatabase userId
    pure $ userPageView user

handle :: forall id es. (Hyperbole :> es, HyperView id) => (id -> Action id -> Eff es (View id ())) -> Page es ()

A handler is run when an action for that HyperView is triggered. Run any side effects needed, then return a view of the corresponding type

myPage :: (Hyperbole :> es) => Page es Response
myPage = do
  handle messages
  load pageView

messages :: (Hyperbole :> es, MessageDatabase) => Message -> MessageAction -> Eff es (View Message ())
messages (Message mid) ClearMessage = do
  deleteMessageSideEffect mid
  pure $ messageView ""

messages (Message mid) (Louder m) = do
  let new = m <> "!"
  saveMessageSideEffect mid new
  pure $ messageView new

HyperView

class (Param id, Param (Action id)) => HyperView id

HyperViews are interactive subsections of a Page

Create an instance with a unique view id type and a sum type describing the actions the HyperView supports. The View Id can contain context (a database id, for example)

data Message = Message Int
  deriving (Generic, Param)

data MessageAction
  = Louder Text
  | ClearMessage
  deriving (Generic, Param)

instance HyperView Message where
  type Action Message = MessageAction

Associated Types

type Action id :: Type

Instances

(HyperView id, Param id) => HyperView (FormFields id)

Defined in Web.Hyperbole.Forms

Associated Types

type Action (FormFields id)

hyper :: forall id ctx. HyperView id => id -> View id () -> View ctx ()

Embed HyperViews into the page, or nest them into other views

myPage :: (Hyperbole :> es) => Page es Response
myPage = do
  handle messages
  load $ do
    pure $ do
      el_ "My Page"
      hyper (Message 1) $ messageView "Hello World"
      hyper (Message 2) $ do
        messageView "Another Message"
        hyper OtherView otherView

Views can only trigger actions that match their HyperView

messageView :: Text -> View Message ()
messageView m = do
  el_ (text m)
  button (Louder m) Louder

otherView :: View OtherView ()
otherView = do
  -- Type Error!
  button (Louder "Hi") id Louder

Interactive Elements

Buttons

button :: HyperView id => Action id -> Mod -> View id () -> View id ()

<button> HTML tag which sends the action when pressed

button SomeAction (border 1) "Click Me"

Dropdowns

dropdown :: HyperView id => (opt -> Action id) -> (opt -> Bool) -> Mod -> View (Option opt id (Action id)) () -> View id ()

Type-safe dropdown. Sends (opt -> Action id) when selected. The selection predicate (opt -> Bool) controls which option is selected. See Example.Contacts

data ContactsAction
  = Reload (Maybe Filter)
  | Delete Int
  deriving (Generic, Param)

allContactsView :: Maybe Filter -> View Contacts ()
allContactsView fil = do
  row (gap 10) $ do
    el (pad 10) "Filter: "
    dropdown Reload (== fil) id $ do
      option Nothing ""
      option (Just Active) "Active!"
      option (Just Inactive) Inactive
  ...

option :: (HyperView id, Eq opt) => opt -> View (Option opt id (Action id)) () -> View (Option opt id (Action id)) ()

An option for a dropdown. First argument is passed to (opt -> Action id) in the dropdown, and to the selected predicate

data Option opt id action

The view context for an option

Events

onRequest :: View id () -> View id () -> View id ()

Give visual feedback when an action is in-flight.

myView = do
  onRequest loadingIndicator $ do
    el_ "Loaded"
  where
    loadingIndicator = el_ "Loading..."

onLoad :: HyperView id => Action id -> DelayMs -> View id () -> View id ()

Send the action after N milliseconds. Can be used to implement lazy loading or polling

pollMessageView :: Text -> View Message ()
pollMessageView m = do
  onLoad LoadMessage 1000 $ do
    el bold "Current Message. Reloading in 1s"
    el_ (text m)

type DelayMs = Int

Type-Safe Forms

Painless forms with type-checked field names, and support for validation. See Example.Forms

class FormField a

Form Fields are identified by a type

data User = User Text deriving (Generic, FormField)
data Age = Age Int deriving (Generic, FormField)

Form View

form :: forall id. HyperView id => Action id -> Validation -> Mod -> View (FormFields id) () -> View id ()

Type-safe <form>. Calls (Action id) on submit

userForm :: Validation -> View FormView ()
userForm v = do
  form Signup v id $ do
    el Style.h1 "Sign Up"

    field @User id Style.invalid $ do
      label "Username"
      input Username (placeholder "username")
      el_ invalidText

    field @Age id Style.invalid $ do
      label "Age"
      input Number (placeholder "age" . value "0")
      el_ invalidText

    submit (border 1) "Submit"

field :: forall a id. FormField a => Mod -> Mod -> View (Input id a) () -> View (FormFields id) ()

Display a FormField

data Age = Age Int deriving (Generic, FormField)

myForm = do
  form SignUp mempty id $ do
    field @Age id id $ do
     label Age
     input Number (value "0")

label :: Text -> View (Input id a) ()

label for a field

input :: InputType -> Mod -> View (Input id a) ()

input for a field

submit :: Mod -> View (FormFields id) () -> View (FormFields id) ()

Button that submits the form. Use button to specify actions other than submit

placeholder :: Text -> Mod

data InputType

Choose one for inputs to give the browser autocomplete hints

Constructors

NewPassword

CurrentPassword

Username

Email

Number

TextInput

Name

OneTimeCode

Organization

StreetAddress

Country

CountryName

PostalCode

Search

Instances

Show InputType

Defined in Web.Hyperbole.Forms

Methods

showsPrec :: Int -> InputType -> ShowS

show :: InputType -> String

showList :: [InputType] -> ShowS

Handlers

formField :: forall a es. (FormField a, Hyperbole :> es) => Eff es a

Parse a FormField from the request

formAction :: (Hyperbole :> es, UserDB :> es) => FormView -> FormAction -> Eff es (View FormView ())
formAction _ SignUp = do
  a <- formField @Age
  u <- formField @User
  saveUserToDB u a
  pure $ el_ "Saved!"

Validation

newtype Validation

Validation results for a form

validateUser :: User -> Age -> Validation
validateUser (User u) (Age a) =
  validation
    [ validate @Age (a < 20) "User must be at least 20 years old"
    , validate @User (T.elem ' ' u) "Username must not contain spaces"
    , validate @User (T.length u < 4) "Username must be at least 4 chars"
    ]

formAction :: (Hyperbole :> es, UserDB :> es) => FormView -> FormAction -> Eff es (View FormView ())
formAction _ SignUp = do
  a <- formField @Age
  u <- formField @User

  case validateUser u a of
    Validation [] -> successView
    errs -> userForm v

@

Constructors

Validation [(Text, Text)]

Instances

Monoid Validation

Defined in Web.Hyperbole.Forms

Methods

mempty :: Validation

mappend :: Validation -> Validation -> Validation

mconcat :: [Validation] -> Validation

Semigroup Validation

Defined in Web.Hyperbole.Forms

Methods

(<>) :: Validation -> Validation -> Validation

sconcat :: NonEmpty Validation -> Validation

stimes :: Integral b => b -> Validation -> Validation

validate :: forall a. FormField a => Bool -> Text -> Maybe (Text, Text)

specify a check for a Validation

validation :: [Maybe (Text, Text)] -> Validation

Create a Validation from list of validators

invalidText :: forall a id. FormField a => View (Input id a) ()

Display any validation error for the FormField from the Validation passed to form

field @User id Style.invalid $ do
  label "Username"
  input Username (placeholder "username")
  el_ invalidText

Hyperbole Effect

data Hyperbole :: Effect

In any load or handle, you can use this Effect to get extra request information or control the response manually.

For most Pages, you won't need to use this effect directly. Use custom Routes for request info, and return Views to respond

Instances

type DispatchOf Hyperbole

Defined in Web.Hyperbole.Effect

type DispatchOf Hyperbole = 'Dynamic

Request Info

reqParam :: (Hyperbole :> es, FromHttpApiData a) => Text -> Eff es a

Require a given parameter from the Query arguments

myPage :: Page es Response
myPage = do
  load $ do
    token <- reqParam "token"
    sideEffectUsingToken token
    pure myPageView

reqParams :: Hyperbole :> es => Eff es Query

Return the entire Query

myPage :: Page es Response
myPage = do
  load $ do
    q <- reqParams
    case lookupParam "token" q of
      Nothing -> pure $ errorView "Missing Token in Query String"
      Just t -> do
        sideEffectUsingToken token
        pure myPageView

request :: Hyperbole :> es => Eff es Request

Return all information about the Request

lookupParam :: ByteString -> Query -> Maybe Text

Lookup the query param in the Query

formData :: Hyperbole :> es => Eff es Form

Return the request body as a Web.FormUrlEncoded.Form

Prefer using Type-Safe Forms when possible

Response

notFound :: Hyperbole :> es => Eff es a

Respond immediately with 404 Not Found

userLoad :: (Hyperbole :> es, Users :> es) => UserId -> Eff es User
userLoad uid = do
  mu <- send (LoadUser uid)
  maybe notFound pure mu

myPage :: (Hyperbole :> es, Users :> es) => Eff es View
myPage = do
  load $ do
    u <- userLoad 100
    -- skipped if user = Nothing
    pure $ userView u

redirect :: Hyperbole :> es => Url -> Eff es a

Redirect immediately to the Url

respondEarly :: (Hyperbole :> es, HyperView id) => id -> View id () -> Eff es ()

Respond with the given view, and stop execution

Sessions

session :: (Hyperbole :> es, FromHttpApiData a) => Text -> Eff es (Maybe a)

Lookup a session variable by keyword

load $ do
  tok <- session "token"
  ...

setSession :: (Hyperbole :> es, ToHttpApiData a) => Text -> a -> Eff es ()

Set a session variable by keyword

load $ do
  t <- reqParam "token"
  setSession "token" t
  ...

clearSession :: Hyperbole :> es => Text -> Eff es ()

Clear the user's session

Advanced

target :: HyperView id => id -> View id () -> View a ()

Trigger actions for another view. They will update the view specified

otherView :: View OtherView ()
otherView = do
  el_ "This is not a message view"
  button OtherAction id "Do Something"

  target (Message 2) $ do
    el_ "Now we can trigger a MessageAction which will update our Message HyperView, not this one"
    button ClearMessage id "Clear Message #2"

view :: Hyperbole :> es => View () () -> Eff es Response

Manually set the response to the given view. Normally you return a View from load or handle instead of using this

class Param a where

Types that can be serialized. HyperView requires this for both its view id and action

data Message = Message Int
  deriving (Generic, Param)

Minimal complete definition

Nothing

Methods

toParam :: a -> Text

default toParam :: (Generic a, GParam (Rep a)) => a -> Text

parseParam :: Text -> Maybe a

default parseParam :: (Generic a, GParam (Rep a)) => Text -> Maybe a

Instances

Param Text

Defined in Web.Hyperbole.HyperView

Methods

toParam :: Text -> Text

parseParam :: Text -> Maybe Text

Param Integer

Defined in Web.Hyperbole.HyperView

Methods

toParam :: Integer -> Text

parseParam :: Text -> Maybe Integer

Param ()

Defined in Web.Hyperbole.HyperView

Methods

toParam :: () -> Text

parseParam :: Text -> Maybe ()

Param Float

Defined in Web.Hyperbole.HyperView

Methods

toParam :: Float -> Text

parseParam :: Text -> Maybe Float

Param Int

Defined in Web.Hyperbole.HyperView

Methods

toParam :: Int -> Text

parseParam :: Text -> Maybe Int

Param id => Param (FormFields id)

Defined in Web.Hyperbole.Forms

Methods

toParam :: FormFields id -> Text

parseParam :: Text -> Maybe (FormFields id)

Param a => Param (Maybe a)

Defined in Web.Hyperbole.HyperView

Methods

toParam :: Maybe a -> Text

parseParam :: Text -> Maybe (Maybe a)

data Response

Valid responses for a Hyperbole effect. Use notFound, etc instead. Reminds you to use load in your Page

myPage :: (Hyperbole :> es) => Page es Response
myPage = do
  -- compiler error: () does not equal Response
  pure ()

Exports

Web.View

Hyperbole is tightly integrated with Web.View for HTML generation

module Web.Hyperbole.View

Embeds

Embedded CSS and Javascript to include in your document function. See basicDocument

module Web.Hyperbole.Embed

Effectful

Hyperbole is tighly integrated with Effectful for extensible effects. It is used to implement the Hyperbole and Server effects.

• See Effectful.Dispatch.Dynamic for an example of how to create a custom effect
• See Example.Counter for an example of how to compose an existing effect

class (e :: Effect) :> (es :: [Effect])

A constraint that requires that a particular effect e is a member of the type-level list es. This is used to parameterize an Eff computation over an arbitrary list of effects, so long as e is somewhere in the list.

For example, a computation that only needs access to a mutable value of type Integer would have the following type:

State Integer :> es => Eff es ()

Instances

(TypeError (('Text "There is no handler for '" ':<>: 'ShowType e) ':<>: 'Text "' in the context") :: Constraint) => e :> ('[] :: [Effect])

Defined in Effectful.Internal.Effect

Methods

reifyIndex :: Int

e :> (e ': es)

Defined in Effectful.Internal.Effect

Methods

reifyIndex :: Int

e :> es => e :> (x ': es)

Defined in Effectful.Internal.Effect

Methods

reifyIndex :: Int

data Eff (es :: [Effect]) a

The Eff monad provides the implementation of a computation that performs an arbitrary set of effects. In Eff es a, es is a type-level list that contains all the effects that the computation may perform. For example, a computation that produces an Integer by consuming a String from the global environment and acting upon a single mutable value of type Bool would have the following type:

(Reader String :> es, State Bool :> es) => Eff es Integer

Abstracting over the list of effects with (:>):

• Allows the computation to be used in functions that may perform other effects.
• Allows the effects to be handled in any order.

Instances

IOE :> es => MonadBaseControl IO (Eff es)

Instance included for compatibility with existing code.

Usage of withEffToIO is preferrable as it allows specifying the UnliftStrategy on a case-by-case basis and has better error reporting.

Note: the unlifting strategy for liftBaseWith is taken from the IOE context (see unliftStrategy).

Defined in Effectful.Internal.Monad

Associated Types

type StM (Eff es) a

Methods

liftBaseWith :: (RunInBase (Eff es) IO -> IO a) -> Eff es a

restoreM :: StM (Eff es) a -> Eff es a

IOE :> es => MonadBase IO (Eff es)

Instance included for compatibility with existing code.

Usage of liftIO is preferrable as it's a standard.

Defined in Effectful.Internal.Monad

Methods

liftBase :: IO α -> Eff es α

Fail :> es => MonadFail (Eff es)

Defined in Effectful.Internal.Monad

Methods

fail :: String -> Eff es a

MonadFix (Eff es)

Defined in Effectful.Internal.Monad

Methods

mfix :: (a -> Eff es a) -> Eff es a

IOE :> es => MonadIO (Eff es)

Defined in Effectful.Internal.Monad

Methods

liftIO :: IO a -> Eff es a

NonDet :> es => Alternative (Eff es)

Since: effectful-core-2.2.0.0

Defined in Effectful.Internal.Monad

Methods

empty :: Eff es a

(<|>) :: Eff es a -> Eff es a -> Eff es a

some :: Eff es a -> Eff es [a]

many :: Eff es a -> Eff es [a]

Applicative (Eff es)

Defined in Effectful.Internal.Monad

Methods

pure :: a -> Eff es a

(<*>) :: Eff es (a -> b) -> Eff es a -> Eff es b

liftA2 :: (a -> b -> c) -> Eff es a -> Eff es b -> Eff es c

(*>) :: Eff es a -> Eff es b -> Eff es b

(<*) :: Eff es a -> Eff es b -> Eff es a

Functor (Eff es)

Defined in Effectful.Internal.Monad

Methods

fmap :: (a -> b) -> Eff es a -> Eff es b

(<$) :: a -> Eff es b -> Eff es a

Monad (Eff es)

Defined in Effectful.Internal.Monad

Methods

(>>=) :: Eff es a -> (a -> Eff es b) -> Eff es b

(>>) :: Eff es a -> Eff es b -> Eff es b

return :: a -> Eff es a

NonDet :> es => MonadPlus (Eff es)

Since: effectful-core-2.2.0.0

Defined in Effectful.Internal.Monad

Methods

mzero :: Eff es a

mplus :: Eff es a -> Eff es a -> Eff es a

MonadCatch (Eff es)

Defined in Effectful.Internal.Monad

Methods

catch :: (HasCallStack, Exception e) => Eff es a -> (e -> Eff es a) -> Eff es a

MonadMask (Eff es)

Defined in Effectful.Internal.Monad

Methods

mask :: HasCallStack => ((forall a. Eff es a -> Eff es a) -> Eff es b) -> Eff es b

uninterruptibleMask :: HasCallStack => ((forall a. Eff es a -> Eff es a) -> Eff es b) -> Eff es b

generalBracket :: HasCallStack => Eff es a -> (a -> ExitCase b -> Eff es c) -> (a -> Eff es b) -> Eff es (b, c)

MonadThrow (Eff es)

Defined in Effectful.Internal.Monad

Methods

throwM :: (HasCallStack, Exception e) => e -> Eff es a

Prim :> es => PrimMonad (Eff es)

Defined in Effectful.Internal.Monad

Associated Types

type PrimState (Eff es)

Methods

primitive :: (State# (PrimState (Eff es)) -> (# State# (PrimState (Eff es)), a #)) -> Eff es a

IOE :> es => MonadUnliftIO (Eff es)

Instance included for compatibility with existing code.

Usage of withEffToIO is preferrable as it allows specifying the UnliftStrategy on a case-by-case basis and has better error reporting.

Note: the unlifting strategy for withRunInIO is taken from the IOE context (see unliftStrategy).

Defined in Effectful.Internal.Monad

Methods

withRunInIO :: ((forall a. Eff es a -> IO a) -> IO b) -> Eff es b

Monoid a => Monoid (Eff es a)

Defined in Effectful.Internal.Monad

Methods

mempty :: Eff es a

mappend :: Eff es a -> Eff es a -> Eff es a

mconcat :: [Eff es a] -> Eff es a

Semigroup a => Semigroup (Eff es a)

Defined in Effectful.Internal.Monad

Methods

(<>) :: Eff es a -> Eff es a -> Eff es a

sconcat :: NonEmpty (Eff es a) -> Eff es a

stimes :: Integral b => b -> Eff es a -> Eff es a

type PrimState (Eff es)

Defined in Effectful.Internal.Monad

type PrimState (Eff es) = PrimStateEff

type StM (Eff es) a

Defined in Effectful.Internal.Monad

type StM (Eff es) a = a

Other

type Application = Request -> (Response -> IO ResponseReceived) -> IO ResponseReceived

The WAI application.

Note that, since WAI 3.0, this type is structured in continuation passing style to allow for proper safe resource handling. This was handled in the past via other means (e.g., ResourceT). As a demonstration:

app :: Application
app req respond = bracket_
    (putStrLn "Allocating scarce resource")
    (putStrLn "Cleaning up")
    (respond $ responseLBS status200 [] "Hello World")

class Generic a

Representable types of kind *. This class is derivable in GHC with the DeriveGeneric flag on.

A Generic instance must satisfy the following laws:

from . to ≡ id
to . from ≡ id

Minimal complete definition

from, to

Instances

Generic All

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

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

Defined in Data.Version

Associated Types

type Rep Version :: Type -> Type

Methods

from :: Version -> Rep Version x

to :: Rep Version x -> Version

Generic Void

Defined in GHC.Generics

Associated Types

type Rep Void :: Type -> Type

Methods

from :: Void -> Rep Void x

to :: Rep Void x -> Void

Generic Fingerprint

Defined in GHC.Generics

Associated Types

type Rep Fingerprint :: Type -> Type

Methods

from :: Fingerprint -> Rep Fingerprint x

to :: Rep Fingerprint x -> Fingerprint

Generic Associativity

Defined in GHC.Generics

Associated Types

type Rep Associativity :: Type -> Type

Methods

from :: Associativity -> Rep Associativity x

to :: Rep Associativity x -> Associativity

Generic DecidedStrictness

Defined in GHC.Generics

Associated Types

type Rep DecidedStrictness :: Type -> Type

Methods

from :: DecidedStrictness -> Rep DecidedStrictness x

to :: Rep DecidedStrictness x -> DecidedStrictness

Generic Fixity

Defined in GHC.Generics

Associated Types

type Rep Fixity :: Type -> Type

Methods

from :: Fixity -> Rep Fixity x

to :: Rep Fixity x -> Fixity

Generic SourceStrictness

Defined in GHC.Generics

Associated Types

type Rep SourceStrictness :: Type -> Type

Methods

from :: SourceStrictness -> Rep SourceStrictness x

to :: Rep SourceStrictness x -> SourceStrictness

Generic SourceUnpackedness

Defined in GHC.Generics

Associated Types

type Rep SourceUnpackedness :: Type -> Type

Methods

from :: SourceUnpackedness -> Rep SourceUnpackedness x

to :: Rep SourceUnpackedness x -> SourceUnpackedness

Generic ExitCode

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Defined in GHC.Generics

Associated Types

type Rep SrcLoc :: Type -> Type

Methods

from :: SrcLoc -> Rep SrcLoc x

to :: Rep SrcLoc x -> SrcLoc

Generic GCDetails

Defined in GHC.Stats

Associated Types

type Rep GCDetails :: Type -> Type

Methods

from :: GCDetails -> Rep GCDetails x

to :: Rep GCDetails x -> GCDetails

Generic RTSStats

Defined in GHC.Stats

Associated Types

type Rep RTSStats :: Type -> Type

Methods

from :: RTSStats -> Rep RTSStats x

to :: Rep RTSStats x -> RTSStats

Generic GeneralCategory

Defined in GHC.Generics

Associated Types

type Rep GeneralCategory :: Type -> Type

Methods

from :: GeneralCategory -> Rep GeneralCategory x

to :: Rep GeneralCategory x -> GeneralCategory

Generic Limit

Defined in Effectful.Internal.Unlift

Associated Types

type Rep Limit :: Type -> Type

Methods

from :: Limit -> Rep Limit x

to :: Rep Limit x -> Limit

Generic Persistence

Defined in Effectful.Internal.Unlift

Associated Types

type Rep Persistence :: Type -> Type

Methods

from :: Persistence -> Rep Persistence x

to :: Rep Persistence x -> Persistence

Generic UnliftStrategy

Defined in Effectful.Internal.Unlift

Associated Types

type Rep UnliftStrategy :: Type -> Type

Methods

from :: UnliftStrategy -> Rep UnliftStrategy x

to :: Rep UnliftStrategy x -> UnliftStrategy

Generic ForeignSrcLang

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

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

Defined in GHC.Generics

Associated Types

type Rep Ordering :: Type -> Type

Methods

from :: Ordering -> Rep Ordering x

to :: Rep Ordering x -> Ordering

Generic SrcLoc

Defined in Language.Haskell.Exts.SrcLoc

Associated Types

type Rep SrcLoc :: Type -> Type

Methods

from :: SrcLoc -> Rep SrcLoc x

to :: Rep SrcLoc x -> SrcLoc

Generic SrcSpan

Defined in Language.Haskell.Exts.SrcLoc

Associated Types

type Rep SrcSpan :: Type -> Type

Methods

from :: SrcSpan -> Rep SrcSpan x

to :: Rep SrcSpan x -> SrcSpan

Generic SrcSpanInfo

Defined in Language.Haskell.Exts.SrcLoc

Associated Types

type Rep SrcSpanInfo :: Type -> Type

Methods

from :: SrcSpanInfo -> Rep SrcSpanInfo x

to :: Rep SrcSpanInfo x -> SrcSpanInfo

Generic Boxed

Defined in Language.Haskell.Exts.Syntax

Associated Types

type Rep Boxed :: Type -> Type

Methods

from :: Boxed -> Rep Boxed x

to :: Rep Boxed x -> Boxed

Generic Tool

Defined in Language.Haskell.Exts.Syntax

Associated Types

type Rep Tool :: Type -> Type

Methods

from :: Tool -> Rep Tool x

to :: Rep Tool x -> Tool

Generic Form

Defined in Web.Internal.FormUrlEncoded

Associated Types

type Rep Form :: Type -> Type

Methods

from :: Form -> Rep Form x

to :: Rep Form x -> Form

Generic ByteRange

Defined in Network.HTTP.Types.Header

Associated Types

type Rep ByteRange :: Type -> Type

Methods

from :: ByteRange -> Rep ByteRange x

to :: Rep ByteRange x -> ByteRange

Generic StdMethod

Defined in Network.HTTP.Types.Method

Associated Types

type Rep StdMethod :: Type -> Type

Methods

from :: StdMethod -> Rep StdMethod x

to :: Rep StdMethod x -> StdMethod

Generic Status

Defined in Network.HTTP.Types.Status

Associated Types

type Rep Status :: Type -> Type

Methods

from :: Status -> Rep Status x

to :: Rep Status x -> Status

Generic HttpVersion

Defined in Network.HTTP.Types.Version

Associated Types

type Rep HttpVersion :: Type -> Type

Methods

from :: HttpVersion -> Rep HttpVersion x

to :: Rep HttpVersion x -> HttpVersion

Generic IP

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

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

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

Defined in Data.IP.Range

Associated Types

type Rep IPRange :: Type -> Type

Methods

from :: IPRange -> Rep IPRange x

to :: Rep IPRange x -> IPRange

Generic OsChar

Defined in System.OsString.Internal.Types

Associated Types

type Rep OsChar :: Type -> Type

Methods

from :: OsChar -> Rep OsChar x

to :: Rep OsChar x -> OsChar

Generic OsString

Defined in System.OsString.Internal.Types

Associated Types

type Rep OsString :: Type -> Type

Methods

from :: OsString -> Rep OsString x

to :: Rep OsString x -> OsString

Generic PosixChar

Defined in System.OsString.Internal.Types

Associated Types

type Rep PosixChar :: Type -> Type

Methods

from :: PosixChar -> Rep PosixChar x

to :: Rep PosixChar x -> PosixChar

Generic PosixString

Defined in System.OsString.Internal.Types

Associated Types

type Rep PosixString :: Type -> Type

Methods

from :: PosixString -> Rep PosixString x

to :: Rep PosixString x -> PosixString

Generic WindowsChar

Defined in System.OsString.Internal.Types

Associated Types

type Rep WindowsChar :: Type -> Type

Methods

from :: WindowsChar -> Rep WindowsChar x

to :: Rep WindowsChar x -> WindowsChar

Generic WindowsString

Defined in System.OsString.Internal.Types

Associated Types

type Rep WindowsString :: Type -> Type

Methods

from :: WindowsString -> Rep WindowsString x

to :: Rep WindowsString x -> WindowsString

Generic Mode

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

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

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

Defined in Text.PrettyPrint.HughesPJ

Associated Types

type Rep Doc :: Type -> Type

Methods

from :: Doc -> Rep Doc x

to :: Rep Doc x -> Doc

Generic AnnLookup

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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 ConstructorInfo

Defined in Language.Haskell.TH.Datatype

Associated Types

type Rep ConstructorInfo :: Type -> Type

Methods

from :: ConstructorInfo -> Rep ConstructorInfo x

to :: Rep ConstructorInfo x -> ConstructorInfo

Generic ConstructorVariant

Defined in Language.Haskell.TH.Datatype

Associated Types

type Rep ConstructorVariant :: Type -> Type

Methods

from :: ConstructorVariant -> Rep ConstructorVariant x

to :: Rep ConstructorVariant x -> ConstructorVariant

Generic DatatypeInfo

Defined in Language.Haskell.TH.Datatype

Associated Types

type Rep DatatypeInfo :: Type -> Type

Methods

from :: DatatypeInfo -> Rep DatatypeInfo x

to :: Rep DatatypeInfo x -> DatatypeInfo

Generic DatatypeVariant

Defined in Language.Haskell.TH.Datatype

Associated Types

type Rep DatatypeVariant :: Type -> Type

Methods

from :: DatatypeVariant -> Rep DatatypeVariant x

to :: Rep DatatypeVariant x -> DatatypeVariant

Generic FieldStrictness

Defined in Language.Haskell.TH.Datatype

Associated Types

type Rep FieldStrictness :: Type -> Type

Methods

from :: FieldStrictness -> Rep FieldStrictness x

to :: Rep FieldStrictness x -> FieldStrictness

Generic Strictness

Defined in Language.Haskell.TH.Datatype

Associated Types

type Rep Strictness :: Type -> Type

Methods

from :: Strictness -> Rep Strictness x

to :: Rep Strictness x -> Strictness

Generic Unpackedness

Defined in Language.Haskell.TH.Datatype

Associated Types

type Rep Unpackedness :: Type -> Type

Methods

from :: Unpackedness -> Rep Unpackedness x

to :: Rep Unpackedness x -> Unpackedness

Generic UnixTime

Defined in Data.UnixTime.Types

Associated Types

type Rep UnixTime :: Type -> Type

Methods

from :: UnixTime -> Rep UnixTime x

to :: Rep UnixTime x -> UnixTime

Generic ConcException

Defined in UnliftIO.Internals.Async

Associated Types

type Rep ConcException :: Type -> Type

Methods

from :: ConcException -> Rep ConcException x

to :: Rep ConcException x -> ConcException

Generic FlatAttributes

Defined in Web.View.Types

Associated Types

type Rep FlatAttributes :: Type -> Type

Methods

from :: FlatAttributes -> Rep FlatAttributes x

to :: Rep FlatAttributes x -> FlatAttributes

Generic CompressParams

Defined in Codec.Compression.Zlib.Internal

Associated Types

type Rep CompressParams :: Type -> Type

Methods

from :: CompressParams -> Rep CompressParams x

to :: Rep CompressParams x -> CompressParams

Generic DecompressError

Defined in Codec.Compression.Zlib.Internal

Associated Types

type Rep DecompressError :: Type -> Type

Methods

from :: DecompressError -> Rep DecompressError x

to :: Rep DecompressError x -> DecompressError

Generic DecompressParams

Defined in Codec.Compression.Zlib.Internal

Associated Types

type Rep DecompressParams :: Type -> Type

Methods

from :: DecompressParams -> Rep DecompressParams x

to :: Rep DecompressParams x -> DecompressParams

Generic CompressionLevel

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

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

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

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

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

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

Defined in GHC.Generics

Associated Types

type Rep () :: Type -> Type

Methods

from :: () -> Rep () x

to :: Rep () x -> ()

Generic Bool

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)

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)

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)

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)

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)

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)

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)

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)

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)

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)

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)

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)

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)

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)

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)

Defined in Data.Semigroup.Internal

Associated Types

type Rep (Sum a) :: Type -> Type

Methods

from :: Sum a -> Rep (Sum a) x

to :: Rep (Sum a) x -> Sum a

Generic (NonEmpty a)

Defined in GHC.Generics

Associated Types

type Rep (NonEmpty a) :: Type -> Type

Methods

from :: NonEmpty a -> Rep (NonEmpty a) x

to :: Rep (NonEmpty a) x -> NonEmpty a

Generic (Par1 p)

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)

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)

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)

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)

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)

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)

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)

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

Defined in Language.Haskell.Exts.SrcLoc

Associated Types

type Rep (Loc a) :: Type -> Type

Methods

from :: Loc a -> Rep (Loc a) x

to :: Rep (Loc a) x -> Loc a

Generic (Activation l)

Defined in Language.Haskell.Exts.Syntax

Associated Types

type Rep (Activation l) :: Type -> Type

Methods

from :: Activation l -> Rep (Activation l) x

to :: Rep (Activation l) x -> Activation l

Generic (Alt l)

Defined in Language.Haskell.Exts.Syntax

Associated Types

type Rep (Alt l) :: Type -> Type

Methods

from :: Alt l -> Rep (Alt l) x

to :: Rep (Alt l) x -> Alt l

Generic (Annotation l)

Defined in Language.Haskell.Exts.Syntax

Associated Types

type Rep (Annotation l) :: Type -> Type

Methods

from :: Annotation l -> Rep (Annotation l) x

to :: Rep (Annotation l) x -> Annotation l

Generic (Assoc l)

Defined in Language.Haskell.Exts.Syntax

Associated Types

type Rep (Assoc l) :: Type -> Type

Methods

from :: Assoc l -> Rep (Assoc l) x

to :: Rep (Assoc l) x -> Assoc l

Generic (Asst l)

Defined in Language.Haskell.Exts.Syntax

Associated Types

type Rep (Asst l) :: Type -> Type

Methods

from :: Asst l -> Rep (Asst l) x

to :: Rep (Asst l) x -> Asst l

Generic (BangType l)

Defined in Language.Haskell.Exts.Syntax

Associated Types

type Rep (BangType l) :: Type -> Type

Methods

from :: BangType l -> Rep (BangType l) x

to :: Rep (BangType l) x -> BangType l

Generic (Binds l)

Defined in Language.Haskell.Exts.Syntax

Associated Types

type Rep (Binds l) :: Type -> Type

Methods

from :: Binds l -> Rep (Binds l) x

to :: Rep (Binds l) x -> Binds l

Generic (BooleanFormula l)

Defined in Language.Haskell.Exts.Syntax

Associated Types

type Rep (BooleanFormula l) :: Type -> Type

Methods

from :: BooleanFormula l -> Rep (BooleanFormula l) x

to :: Rep (BooleanFormula l) x -> BooleanFormula l

Generic (Bracket l)

Defined in Language.Haskell.Exts.Syntax

Associated Types

type Rep (Bracket l) :: Type -> Type

Methods

from :: Bracket l -> Rep (Bracket l) x

to :: Rep (Bracket l) x -> Bracket l

Generic (CName l)

Defined in Language.Haskell.Exts.Syntax

Associated Types

type Rep (CName l) :: Type -> Type

Methods

from :: CName l -> Rep (CName l) x

to :: Rep (CName l) x -> CName l

Generic (CallConv l)

Defined in Language.Haskell.Exts.Syntax

Associated Types

type Rep (CallConv l) :: Type -> Type

Methods

from :: CallConv l -> Rep (CallConv l) x

to :: Rep (CallConv l) x -> CallConv l

Generic (ClassDecl l)

Defined in Language.Haskell.Exts.Syntax

Associated Types

type Rep (ClassDecl l) :: Type -> Type

Methods

from :: ClassDecl l -> Rep (ClassDecl l) x

to :: Rep (ClassDecl l) x -> ClassDecl l

Generic (ConDecl l)

Defined in Language.Haskell.Exts.Syntax

Associated Types

type Rep (ConDecl l) :: Type -> Type

Methods

from :: ConDecl l -> Rep (ConDecl l) x

to :: Rep (ConDecl l) x -> ConDecl l

Generic (Context l)

Defined in Language.Haskell.Exts.Syntax

Associated Types

type Rep (Context l) :: Type -> Type

Methods

from :: Context l -> Rep (Context l) x

to :: Rep (Context l) x -> Context l

Generic (DataOrNew l)

Defined in Language.Haskell.Exts.Syntax

Associated Types

type Rep (DataOrNew l) :: Type -> Type

Methods

from :: DataOrNew l -> Rep (DataOrNew l) x

to :: Rep (DataOrNew l) x -> DataOrNew l

Generic (Decl l)

Defined in Language.Haskell.Exts.Syntax

Associated Types

type Rep (Decl l) :: Type -> Type

Methods

from :: Decl l -> Rep (Decl l) x

to :: Rep (Decl l) x -> Decl l

Generic (DeclHead l)

Defined in Language.Haskell.Exts.Syntax

Associated Types

type Rep (DeclHead l) :: Type -> Type

Methods

from :: DeclHead l -> Rep (DeclHead l) x

to :: Rep (DeclHead l) x -> DeclHead l

Generic (DerivStrategy l)

Defined in Language.Haskell.Exts.Syntax

Associated Types

type Rep (DerivStrategy l) :: Type -> Type

Methods

from :: DerivStrategy l -> Rep (DerivStrategy l) x

to :: Rep (DerivStrategy l) x -> DerivStrategy l

Generic (Deriving l)

Defined in Language.Haskell.Exts.Syntax

Associated Types

type Rep (Deriving l) :: Type -> Type

Methods

from :: Deriving l -> Rep (Deriving l) x

to :: Rep (Deriving l) x -> Deriving l

Generic (EWildcard l)

Defined in Language.Haskell.Exts.Syntax

Associated Types

type Rep (EWildcard l) :: Type -> Type

Methods

from :: EWildcard l -> Rep (EWildcard l) x

to :: Rep (EWildcard l) x -> EWildcard l

Generic (Exp l)

Defined in Language.Haskell.Exts.Syntax

Associated Types

type Rep (Exp l) :: Type -> Type

Methods

from :: Exp l -> Rep (Exp l) x

to :: Rep (Exp l) x -> Exp l

Generic (ExportSpec l)

Defined in Language.Haskell.Exts.Syntax

Associated Types

type Rep (ExportSpec l) :: Type -> Type

Methods

from :: ExportSpec l -> Rep (ExportSpec l) x

to :: Rep (ExportSpec l) x -> ExportSpec l

Generic (ExportSpecList l)

Defined in Language.Haskell.Exts.Syntax

Associated Types

type Rep (ExportSpecList l) :: Type -> Type

Methods

from :: ExportSpecList l -> Rep (ExportSpecList l) x

to :: Rep (ExportSpecList l) x -> ExportSpecList l

Generic (FieldDecl l)

Defined in Language.Haskell.Exts.Syntax

Associated Types

type Rep (FieldDecl l) :: Type -> Type

Methods

from :: FieldDecl l -> Rep (FieldDecl l) x

to :: Rep (FieldDecl l) x -> FieldDecl l

Generic (FieldUpdate l)

Defined in Language.Haskell.Exts.Syntax

Associated Types

type Rep (FieldUpdate l) :: Type -> Type

Methods

from :: FieldUpdate l -> Rep (FieldUpdate l) x

to :: Rep (FieldUpdate l) x -> FieldUpdate l

Generic (FunDep l)

Defined in Language.Haskell.Exts.Syntax

Associated Types

type Rep (FunDep l) :: Type -> Type

Methods

from :: FunDep l -> Rep (FunDep l) x

to :: Rep (FunDep l) x -> FunDep l

Generic (GadtDecl l)

Defined in Language.Haskell.Exts.Syntax

Associated Types

type Rep (GadtDecl l) :: Type -> Type

Methods

from :: GadtDecl l -> Rep (GadtDecl l) x

to :: Rep (GadtDecl l) x -> GadtDecl l

Generic (GuardedRhs l)

Defined in Language.Haskell.Exts.Syntax

Associated Types

type Rep (GuardedRhs l) :: Type -> Type

Methods

from :: GuardedRhs l -> Rep (GuardedRhs l) x

to :: Rep (GuardedRhs l) x -> GuardedRhs l

Generic (IPBind l)

Defined in Language.Haskell.Exts.Syntax

Associated Types

type Rep (IPBind l) :: Type -> Type

Methods

from :: IPBind l -> Rep (IPBind l) x

to :: Rep (IPBind l) x -> IPBind l

Generic (IPName l)

Defined in Language.Haskell.Exts.Syntax

Associated Types

type Rep (IPName l) :: Type -> Type

Methods

from :: IPName l -> Rep (IPName l) x

to :: Rep (IPName l) x -> IPName l

Generic (ImportDecl l)

Defined in Language.Haskell.Exts.Syntax

Associated Types

type Rep (ImportDecl l) :: Type -> Type

Methods

from :: ImportDecl l -> Rep (ImportDecl l) x

to :: Rep (ImportDecl l) x -> ImportDecl l

Generic (ImportSpec l)

Defined in Language.Haskell.Exts.Syntax

Associated Types

type Rep (ImportSpec l) :: Type -> Type

Methods

from :: ImportSpec l -> Rep (ImportSpec l) x

to :: Rep (ImportSpec l) x -> ImportSpec l

Generic (ImportSpecList l)

Defined in Language.Haskell.Exts.Syntax

Associated Types

type Rep (ImportSpecList l) :: Type -> Type

Methods

from :: ImportSpecList l -> Rep (ImportSpecList l) x

to :: Rep (ImportSpecList l) x -> ImportSpecList l

Generic (InjectivityInfo l)

Defined in Language.Haskell.Exts.Syntax

Associated Types

type Rep (InjectivityInfo l) :: Type -> Type

Methods

from :: InjectivityInfo l -> Rep (InjectivityInfo l) x

to :: Rep (InjectivityInfo l) x -> InjectivityInfo l

Generic (InstDecl l)

Defined in Language.Haskell.Exts.Syntax

Associated Types

type Rep (InstDecl l) :: Type -> Type

Methods

from :: InstDecl l -> Rep (InstDecl l) x

to :: Rep (InstDecl l) x -> InstDecl l

Generic (InstHead l)

Defined in Language.Haskell.Exts.Syntax

Associated Types

type Rep (InstHead l) :: Type -> Type

Methods

from :: InstHead l -> Rep (InstHead l) x

to :: Rep (InstHead l) x -> InstHead l

Generic (InstRule l)

Defined in Language.Haskell.Exts.Syntax

Associated Types

type Rep (InstRule l) :: Type -> Type

Methods

from :: InstRule l -> Rep (InstRule l) x

to :: Rep (InstRule l) x -> InstRule l

Generic (Literal l)

Defined in Language.Haskell.Exts.Syntax

Associated Types

type Rep (Literal l) :: Type -> Type

Methods

from :: Literal l -> Rep (Literal l) x

to :: Rep (Literal l) x -> Literal l

Generic (Match l)

Defined in Language.Haskell.Exts.Syntax

Associated Types

type Rep (Match l) :: Type -> Type

Methods

from :: Match l -> Rep (Match l) x

to :: Rep (Match l) x -> Match l

Generic (MaybePromotedName l)

Defined in Language.Haskell.Exts.Syntax

Associated Types

type Rep (MaybePromotedName l) :: Type -> Type

Methods

from :: MaybePromotedName l -> Rep (MaybePromotedName l) x

to :: Rep (MaybePromotedName l) x -> MaybePromotedName l

Generic (Module l)

Defined in Language.Haskell.Exts.Syntax

Associated Types

type Rep (Module l) :: Type -> Type

Methods

from :: Module l -> Rep (Module l) x

to :: Rep (Module l) x -> Module l

Generic (ModuleHead l)

Defined in Language.Haskell.Exts.Syntax

Associated Types

type Rep (ModuleHead l) :: Type -> Type

Methods

from :: ModuleHead l -> Rep (ModuleHead l) x

to :: Rep (ModuleHead l) x -> ModuleHead l

Generic (ModuleName l)

Defined in Language.Haskell.Exts.Syntax

Associated Types

type Rep (ModuleName l) :: Type -> Type

Methods

from :: ModuleName l -> Rep (ModuleName l) x

to :: Rep (ModuleName l) x -> ModuleName l

Generic (ModulePragma l)

Defined in Language.Haskell.Exts.Syntax

Associated Types

type Rep (ModulePragma l) :: Type -> Type

Methods

from :: ModulePragma l -> Rep (ModulePragma l) x

to :: Rep (ModulePragma l) x -> ModulePragma l

Generic (Name l)

Defined in Language.Haskell.Exts.Syntax

Associated Types

type Rep (Name l) :: Type -> Type

Methods

from :: Name l -> Rep (Name l) x

to :: Rep (Name l) x -> Name l

Generic (Namespace l)

Defined in Language.Haskell.Exts.Syntax

Associated Types

type Rep (Namespace l) :: Type -> Type

Methods

from :: Namespace l -> Rep (Namespace l) x

to :: Rep (Namespace l) x -> Namespace l

Generic (Op l)

Defined in Language.Haskell.Exts.Syntax

Associated Types

type Rep (Op l) :: Type -> Type

Methods

from :: Op l -> Rep (Op l) x

to :: Rep (Op l) x -> Op l

Generic (Overlap l)

Defined in Language.Haskell.Exts.Syntax

Associated Types

type Rep (Overlap l) :: Type -> Type

Methods

from :: Overlap l -> Rep (Overlap l) x

to :: Rep (Overlap l) x -> Overlap l

Generic (PXAttr l)

Defined in Language.Haskell.Exts.Syntax

Associated Types

type Rep (PXAttr l) :: Type -> Type

Methods

from :: PXAttr l -> Rep (PXAttr l) x

to :: Rep (PXAttr l) x -> PXAttr l

Generic (Pat l)

Defined in Language.Haskell.Exts.Syntax

Associated Types

type Rep (Pat l) :: Type -> Type

Methods

from :: Pat l -> Rep (Pat l) x

to :: Rep (Pat l) x -> Pat l

Generic (PatField l)

Defined in Language.Haskell.Exts.Syntax

Associated Types

type Rep (PatField l) :: Type -> Type

Methods

from :: PatField l -> Rep (PatField l) x

to :: Rep (PatField l) x -> PatField l

Generic (PatternSynDirection l)

Defined in Language.Haskell.Exts.Syntax

Associated Types

type Rep (PatternSynDirection l) :: Type -> Type

Methods

from :: PatternSynDirection l -> Rep (PatternSynDirection l) x

to :: Rep (PatternSynDirection l) x -> PatternSynDirection l

Generic (Promoted l)

Defined in Language.Haskell.Exts.Syntax

Associated Types

type Rep (Promoted l) :: Type -> Type

Methods

from :: Promoted l -> Rep (Promoted l) x

to :: Rep (Promoted l) x -> Promoted l

Generic (QName l)

Defined in Language.Haskell.Exts.Syntax

Associated Types

type Rep (QName l) :: Type -> Type

Methods

from :: QName l -> Rep (QName l) x

to :: Rep (QName l) x -> QName l

Generic (QOp l)

Defined in Language.Haskell.Exts.Syntax

Associated Types

type Rep (QOp l) :: Type -> Type

Methods

from :: QOp l -> Rep (QOp l) x

to :: Rep (QOp l) x -> QOp l

Generic (QualConDecl l)

Defined in Language.Haskell.Exts.Syntax

Associated Types

type Rep (QualConDecl l) :: Type -> Type

Methods

from :: QualConDecl l -> Rep (QualConDecl l) x

to :: Rep (QualConDecl l) x -> QualConDecl l

Generic (QualStmt l)

Defined in Language.Haskell.Exts.Syntax

Associated Types

type Rep (QualStmt l) :: Type -> Type

Methods

from :: QualStmt l -> Rep (QualStmt l) x

to :: Rep (QualStmt l) x -> QualStmt l

Generic (RPat l)

Defined in Language.Haskell.Exts.Syntax

Associated Types

type Rep (RPat l) :: Type -> Type

Methods

from :: RPat l -> Rep (RPat l) x

to :: Rep (RPat l) x -> RPat l

Generic (RPatOp l)

Defined in Language.Haskell.Exts.Syntax

Associated Types

type Rep (RPatOp l) :: Type -> Type

Methods

from :: RPatOp l -> Rep (RPatOp l) x

to :: Rep (RPatOp l) x -> RPatOp l

Generic (ResultSig l)

Defined in Language.Haskell.Exts.Syntax

Associated Types

type Rep (ResultSig l) :: Type -> Type

Methods

from :: ResultSig l -> Rep (ResultSig l) x

to :: Rep (ResultSig l) x -> ResultSig l

Generic (Rhs l)

Defined in Language.Haskell.Exts.Syntax

Associated Types

type Rep (Rhs l) :: Type -> Type

Methods

from :: Rhs l -> Rep (Rhs l) x

to :: Rep (Rhs l) x -> Rhs l

Generic (Role l)

Defined in Language.Haskell.Exts.Syntax

Associated Types

type Rep (Role l) :: Type -> Type

Methods

from :: Role l -> Rep (Role l) x

to :: Rep (Role l) x -> Role l

Generic (Rule l)

Defined in Language.Haskell.Exts.Syntax

Associated Types

type Rep (Rule l) :: Type -> Type

Methods

from :: Rule l -> Rep (Rule l) x

to :: Rep (Rule l) x -> Rule l

Generic (RuleVar l)

Defined in Language.Haskell.Exts.Syntax

Associated Types

type Rep (RuleVar l) :: Type -> Type

Methods

from :: RuleVar l -> Rep (RuleVar l) x

to :: Rep (RuleVar l) x -> RuleVar l

Generic (Safety l)

Defined in Language.Haskell.Exts.Syntax

Associated Types

type Rep (Safety l) :: Type -> Type

Methods

from :: Safety l -> Rep (Safety l) x

to :: Rep (Safety l) x -> Safety l

Generic (Sign l)

Defined in Language.Haskell.Exts.Syntax

Associated Types

type Rep (Sign l) :: Type -> Type

Methods

from :: Sign l -> Rep (Sign l) x

to :: Rep (Sign l) x -> Sign l

Generic (SpecialCon l)

Defined in Language.Haskell.Exts.Syntax

Associated Types

type Rep (SpecialCon l) :: Type -> Type

Methods

from :: SpecialCon l -> Rep (SpecialCon l) x

to :: Rep (SpecialCon l) x -> SpecialCon l

Generic (Splice l)

Defined in Language.Haskell.Exts.Syntax

Associated Types

type Rep (Splice l) :: Type -> Type

Methods

from :: Splice l -> Rep (Splice l) x

to :: Rep (Splice l) x -> Splice l

Generic (Stmt l)

Defined in Language.Haskell.Exts.Syntax

Associated Types

type Rep (Stmt l) :: Type -> Type

Methods

from :: Stmt l -> Rep (Stmt l) x

to :: Rep (Stmt l) x -> Stmt l

Generic (TyVarBind l)

Defined in Language.Haskell.Exts.Syntax

Associated Types

type Rep (TyVarBind l) :: Type -> Type

Methods

from :: TyVarBind l -> Rep (TyVarBind l) x

to :: Rep (TyVarBind l) x -> TyVarBind l

Generic (Type l)

Defined in Language.Haskell.Exts.Syntax

Associated Types

type Rep (Type l) :: Type -> Type

Methods

from :: Type l -> Rep (Type l) x

to :: Rep (Type l) x -> Type l

Generic (TypeEqn l)

Defined in Language.Haskell.Exts.Syntax

Associated Types

type Rep (TypeEqn l) :: Type -> Type

Methods

from :: TypeEqn l -> Rep (TypeEqn l) x

to :: Rep (TypeEqn l) x -> TypeEqn l

Generic (Unpackedness l)

Defined in Language.Haskell.Exts.Syntax

Associated Types

type Rep (Unpackedness l) :: Type -> Type

Methods

from :: Unpackedness l -> Rep (Unpackedness l) x

to :: Rep (Unpackedness l) x -> Unpackedness l

Generic (WarningText l)

Defined in Language.Haskell.Exts.Syntax

Associated Types

type Rep (WarningText l) :: Type -> Type

Methods

from :: WarningText l -> Rep (WarningText l) x

to :: Rep (WarningText l) x -> WarningText l

Generic (XAttr l)

Defined in Language.Haskell.Exts.Syntax

Associated Types

type Rep (XAttr l) :: Type -> Type

Methods

from :: XAttr l -> Rep (XAttr l) x

to :: Rep (XAttr l) x -> XAttr l

Generic (XName l)

Defined in Language.Haskell.Exts.Syntax

Associated Types

type Rep (XName l) :: Type -> Type

Methods

from :: XName l -> Rep (XName l) x

to :: Rep (XName l) x -> XName l

Generic (AddrRange a)

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

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

Defined in Language.Haskell.TH.Syntax

Associated Types

type Rep (TyVarBndr flag) :: Type -> Type

Methods

from :: TyVarBndr flag -> Rep (TyVarBndr flag) x

to :: Rep (TyVarBndr flag) x -> TyVarBndr flag

Generic (Maybe a)

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)

Defined in GHC.Generics

Associated Types

type Rep (a) :: Type -> Type

Methods

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

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

Generic [a]

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)

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)

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)

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)

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)

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)

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 (MaybeT m a)

Defined in Control.Monad.Trans.Maybe

Associated Types

type Rep (MaybeT m a) :: Type -> Type

Methods

from :: MaybeT m a -> Rep (MaybeT m a) x

to :: Rep (MaybeT m a) x -> MaybeT m a

Generic (a, b)

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)

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)

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)

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)

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)

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)

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)

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)

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)

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)

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)

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)

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 (Tagged s b)

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 (AccumT w m a)

Defined in Control.Monad.Trans.Accum

Associated Types

type Rep (AccumT w m a) :: Type -> Type

Methods

from :: AccumT w m a -> Rep (AccumT w m a) x

to :: Rep (AccumT w m a) x -> AccumT w m a

Generic (ExceptT e m a)

Defined in Control.Monad.Trans.Except

Associated Types

type Rep (ExceptT e m a) :: Type -> Type

Methods

from :: ExceptT e m a -> Rep (ExceptT e m a) x

to :: Rep (ExceptT e m a) x -> ExceptT e m a

Generic (IdentityT f a)

Defined in Control.Monad.Trans.Identity

Associated Types

type Rep (IdentityT f a) :: Type -> Type

Methods

from :: IdentityT f a -> Rep (IdentityT f a) x

to :: Rep (IdentityT f a) x -> IdentityT f a

Generic (ReaderT r m a)

Defined in Control.Monad.Trans.Reader

Associated Types

type Rep (ReaderT r m a) :: Type -> Type

Methods

from :: ReaderT r m a -> Rep (ReaderT r m a) x

to :: Rep (ReaderT r m a) x -> ReaderT r m a

Generic (SelectT r m a)

Defined in Control.Monad.Trans.Select

Associated Types

type Rep (SelectT r m a) :: Type -> Type

Methods

from :: SelectT r m a -> Rep (SelectT r m a) x

to :: Rep (SelectT r m a) x -> SelectT r m a

Generic (StateT s m a)

Defined in Control.Monad.Trans.State.Lazy

Associated Types

type Rep (StateT s m a) :: Type -> Type

Methods

from :: StateT s m a -> Rep (StateT s m a) x

to :: Rep (StateT s m a) x -> StateT s m a

Generic (StateT s m a)

Defined in Control.Monad.Trans.State.Strict

Associated Types

type Rep (StateT s m a) :: Type -> Type

Methods

from :: StateT s m a -> Rep (StateT s m a) x

to :: Rep (StateT s m a) x -> StateT s m a

Generic (WriterT w m a)

Defined in Control.Monad.Trans.Writer.CPS

Associated Types

type Rep (WriterT w m a) :: Type -> Type

Methods

from :: WriterT w m a -> Rep (WriterT w m a) x

to :: Rep (WriterT w m a) x -> WriterT w m a

Generic (WriterT w m a)

Defined in Control.Monad.Trans.Writer.Lazy

Associated Types

type Rep (WriterT w m a) :: Type -> Type

Methods

from :: WriterT w m a -> Rep (WriterT w m a) x

to :: Rep (WriterT w m a) x -> WriterT w m a

Generic (WriterT w m a)

Defined in Control.Monad.Trans.Writer.Strict

Associated Types

type Rep (WriterT w m a) :: Type -> Type

Methods

from :: WriterT w m a -> Rep (WriterT w m a) x

to :: Rep (WriterT w m a) x -> WriterT w m a

Generic (Constant a b)

Defined in Data.Functor.Constant

Associated Types

type Rep (Constant a b) :: Type -> Type

Methods

from :: Constant a b -> Rep (Constant a b) x

to :: Rep (Constant a b) x -> Constant a b

Generic (a, b, c)

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)

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)

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)

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)

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)

Defined in GHC.Generics

Associated Types

type Rep (K1 i c p) :: Type -> Type

Methods

from :: K1 i c p -> Rep (K1 i c p) x

to :: Rep (K1 i c p) x -> K1 i c p

Generic (ContT r m a)

Defined in Control.Monad.Trans.Cont

Associated Types

type Rep (ContT r m a) :: Type -> Type

Methods

from :: ContT r m a -> Rep (ContT r m a) x

to :: Rep (ContT r m a) x -> ContT r m a

Generic (a, b, c, d)

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)

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)

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)

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 (RWST r w s m a)

Defined in Control.Monad.Trans.RWS.CPS

Associated Types

type Rep (RWST r w s m a) :: Type -> Type

Methods

from :: RWST r w s m a -> Rep (RWST r w s m a) x

to :: Rep (RWST r w s m a) x -> RWST r w s m a

Generic (RWST r w s m a)

Defined in Control.Monad.Trans.RWS.Lazy

Associated Types

type Rep (RWST r w s m a) :: Type -> Type

Methods

from :: RWST r w s m a -> Rep (RWST r w s m a) x

to :: Rep (RWST r w s m a) x -> RWST r w s m a

Generic (RWST r w s m a)

Defined in Control.Monad.Trans.RWS.Strict

Associated Types

type Rep (RWST r w s m a) :: Type -> Type

Methods

from :: RWST r w s m a -> Rep (RWST r w s m a) x

to :: Rep (RWST r w s m a) x -> RWST r w s m a

Generic (a, b, c, d, e)

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 (a, b, c, d, e, f)

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 (a, b, c, d, e, f, g)

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)

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 (a, b, c, d, e, f, g, h, i)

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)

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)

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)

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)

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)

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)

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)