Copyright	(c) 2024 Sean Hess
License	BSD3
Maintainer	Sean Hess <seanhess@gmail.com>
Stability	experimental
Portability	portable
Safe Haskell	Safe-Inferred
Language	GHC2021

Web.Hyperbole

Contents

Introduction
Run an Application
- Type-Safe Routes
Pages
- Page
- HyperView
Interactive Elements
Type-Safe Forms
Hyperbole Effect
Advanced
Exports

Description

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

Synopsis

liveApp :: (ByteString -> ByteString) -> Eff '[Hyperbole, Server, IOE] Response -> Application
run :: Port -> Application -> IO ()
page :: Hyperbole :> es => Page es Response -> Eff es Response
basicDocument :: Text -> ByteString -> ByteString
routeRequest :: (Hyperbole :> es, Route route) => (route -> Eff es Response) -> Eff es Response
class Route a
routeUrl :: Route a => a -> Url
route :: Route a => a -> Mod -> View c () -> View c ()
data Page es a
load :: Hyperbole :> es => Eff es (View () ()) -> Page es Response
handle :: forall id es. (Hyperbole :> es, HyperView id) => (id -> Action id -> Eff es (View id ())) -> Page es ()
class (Param id, Param (Action id)) => HyperView id where
- type Action id :: Type
hyper :: forall id ctx. HyperView id => id -> View id () -> View ctx ()
button :: HyperView id => Action id -> Mod -> View id () -> View id ()
dropdown :: HyperView id => (opt -> Action id) -> (opt -> Bool) -> Mod -> View (Option opt id (Action id)) () -> View id ()
option :: (HyperView id, Eq opt) => opt -> View (Option opt id (Action id)) () -> View (Option opt id (Action id)) ()
data Option opt id action
onRequest :: View id () -> View id () -> View id ()
onLoad :: HyperView id => Action id -> DelayMs -> View id () -> View id ()
type DelayMs = Int
class FormField a
form :: forall id. HyperView id => Action id -> Validation -> Mod -> View (FormFields id) () -> View id ()
field :: forall a id. FormField a => Mod -> Mod -> View (Input id a) () -> View (FormFields id) ()
label :: Text -> View (Input id a) ()
input :: InputType -> Mod -> View (Input id a) ()
submit :: Mod -> View (FormFields id) () -> View (FormFields id) ()
placeholder :: Text -> Mod
data InputType
- = NewPassword
- | CurrentPassword
- | Username
- | Email
- | Number
- | TextInput
- | Name
- | OneTimeCode
- | Organization
- | StreetAddress
- | Country
- | CountryName
- | PostalCode
- | Search
formField :: forall a es. (FormField a, Hyperbole :> es) => Eff es a
newtype Validation = Validation [(Text, Text)]
validate :: forall a. FormField a => Bool -> Text -> Maybe (Text, Text)
validation :: [Maybe (Text, Text)] -> Validation
invalidText :: forall a id. FormField a => View (Input id a) ()
data Hyperbole :: Effect
reqParam :: (Hyperbole :> es, FromHttpApiData a) => Text -> Eff es a
reqParams :: Hyperbole :> es => Eff es Query
request :: Hyperbole :> es => Eff es Request
lookupParam :: ByteString -> Query -> Maybe Text
formData :: Hyperbole :> es => Eff es Form
notFound :: Hyperbole :> es => Eff es a
redirect :: Hyperbole :> es => Url -> Eff es a
respondEarly :: (Hyperbole :> es, HyperView id) => id -> View id () -> Eff es ()
session :: (Hyperbole :> es, FromHttpApiData a) => Text -> Eff es (Maybe a)
setSession :: (Hyperbole :> es, ToHttpApiData a) => Text -> a -> Eff es ()
clearSession :: Hyperbole :> es => Text -> Eff es ()
target :: HyperView id => id -> View id () -> View a ()
view :: Hyperbole :> es => View () () -> Eff es Response
class Param a where
- toParam :: a -> Text
- parseParam :: Text -> Maybe a
data Response
module Web.Hyperbole.View
module Web.Hyperbole.Embed
class (e :: Effect) :> (es :: [Effect])
data Eff (es :: [Effect]) a
type Application = Request -> (Response -> IO ResponseReceived) -> IO ResponseReceived
class Generic a

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

100% Haskell
Type safe views, actions, routes, and forms
Elegant interface with little boilerplate
VirtualDOM updates over sockets, fallback to HTTP
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. You can only trigger existing actions that match that HyperView

Like Phoenix LiveView, it upgrades the page to a 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

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

Run an Application

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

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

Run a Page in Hyperbole

basicDocument :: Text -> ByteString -> ByteString Source #

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

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

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

Instances details

Route Text Source #
Instance details Defined in Web.Hyperbole.Route Methods defRoute :: Text Source # routePath :: Text -> [Segment] Source # matchRoute :: [Segment] -> Maybe Text Source #
Route String Source #
Instance details Defined in Web.Hyperbole.Route Methods defRoute :: String Source # routePath :: String -> [Segment] Source # matchRoute :: [Segment] -> Maybe String Source #
Route Integer Source #
Instance details Defined in Web.Hyperbole.Route Methods defRoute :: Integer Source # routePath :: Integer -> [Segment] Source # matchRoute :: [Segment] -> Maybe Integer Source #
Route Int Source #
Instance details Defined in Web.Hyperbole.Route Methods defRoute :: Int Source # routePath :: Int -> [Segment] Source # matchRoute :: [Segment] -> Maybe Int Source #
Route a => Route (Maybe a) Source #
Instance details Defined in Web.Hyperbole.Route Methods defRoute :: Maybe a Source # routePath :: Maybe a -> [Segment] Source # matchRoute :: [Segment] -> Maybe (Maybe a) Source #

routeUrl :: Route a => a -> Url Source #

Convert a Route to a Url

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

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

A hyperlink to another route

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

Pages

Page

data Page es a Source #

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

Instances details

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

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

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

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

Instances

Instances details

(HyperView id, Param id) => HyperView (FormFields id) Source #
Instance details Defined in Web.Hyperbole.Forms Associated Types type Action (FormFields id) Source #

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

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

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

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

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

The view context for an option

Events

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

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

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

Type-Safe Forms

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

class FormField a Source #

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

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

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

label for a field

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

input for a field

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

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

placeholder :: Text -> Mod Source #

data InputType Source #

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

Instances details

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

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

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

Instances details

Monoid Validation Source #
Instance details Defined in Web.Hyperbole.Forms Methods mempty :: Validation # mappend :: Validation -> Validation -> Validation # mconcat :: [Validation] -> Validation #
Semigroup Validation Source #
Instance details 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) Source #

specify a check for a Validation

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

Create a Validation from list of validators

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

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

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

Instances details

type DispatchOf Hyperbole Source #
Instance details Defined in Web.Hyperbole.Effect type DispatchOf Hyperbole = 'Dynamic

Request Info

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

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

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

Return all information about the Request

lookupParam :: ByteString -> Query -> Maybe Text Source #

Lookup the query param in the Query

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

Return the request body as a Web.FormUrlEncoded.Form

Prefer using Type-Safe Forms when possible

Response

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

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

Redirect immediately to the Url

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

Respond with the given view, and stop execution

Sessions

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

Lookup a session variable by keyword

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

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

Set a session variable by keyword

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

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

Clear the user's session

Advanced

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

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

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

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

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

parseParam :: Text -> Maybe a Source #

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

Instances

Instances details

Param Text Source #
Instance details Defined in Web.Hyperbole.HyperView Methods toParam :: Text -> Text Source # parseParam :: Text -> Maybe Text Source #
Param Integer Source #
Instance details Defined in Web.Hyperbole.HyperView Methods toParam :: Integer -> Text Source # parseParam :: Text -> Maybe Integer Source #
Param () Source #
Instance details Defined in Web.Hyperbole.HyperView Methods toParam :: () -> Text Source # parseParam :: Text -> Maybe () Source #
Param Float Source #
Instance details Defined in Web.Hyperbole.HyperView Methods toParam :: Float -> Text Source # parseParam :: Text -> Maybe Float Source #
Param Int Source #
Instance details Defined in Web.Hyperbole.HyperView Methods toParam :: Int -> Text Source # parseParam :: Text -> Maybe Int Source #
Param id => Param (FormFields id) Source #
Instance details Defined in Web.Hyperbole.Forms Methods toParam :: FormFields id -> Text Source # parseParam :: Text -> Maybe (FormFields id) Source #
Param a => Param (Maybe a) Source #
Instance details Defined in Web.Hyperbole.HyperView Methods toParam :: Maybe a -> Text Source # parseParam :: Text -> Maybe (Maybe a) Source #

data Response Source #

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

Instances details

(TypeError (('Text "There is no handler for '" ':<>: 'ShowType e) ':<>: 'Text "' in the context") :: Constraint) => e :> ('[] :: [Effect])
Instance details Defined in Effectful.Internal.Effect Methods reifyIndex :: Int #
e :> (e ': es)
Instance details Defined in Effectful.Internal.Effect Methods reifyIndex :: Int #
e :> es => e :> (x ': es)
Instance details 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

Instances details

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`).
Instance details 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.
Instance details Defined in Effectful.Internal.Monad Methods liftBase :: IO α -> Eff es α #
Fail :> es => MonadFail (Eff es)
Instance details Defined in Effectful.Internal.Monad Methods fail :: String -> Eff es a #
MonadFix (Eff es)
Instance details Defined in Effectful.Internal.Monad Methods mfix :: (a -> Eff es a) -> Eff es a #
IOE :> es => MonadIO (Eff es)
Instance details Defined in Effectful.Internal.Monad Methods liftIO :: IO a -> Eff es a #
NonDet :> es => Alternative (Eff es)	Since: effectful-core-2.2.0.0
Instance details 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)
Instance details 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)
Instance details 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)
Instance details 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
Instance details Defined in Effectful.Internal.Monad Methods mzero :: Eff es a # mplus :: Eff es a -> Eff es a -> Eff es a #
MonadCatch (Eff es)
Instance details Defined in Effectful.Internal.Monad Methods catch :: (HasCallStack, Exception e) => Eff es a -> (e -> Eff es a) -> Eff es a #
MonadMask (Eff es)
Instance details 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)
Instance details Defined in Effectful.Internal.Monad Methods throwM :: (HasCallStack, Exception e) => e -> Eff es a #
Prim :> es => PrimMonad (Eff es)
Instance details 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`).
Instance details 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)
Instance details 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)
Instance details 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)
Instance details Defined in Effectful.Internal.Monad type PrimState (Eff es) = PrimStateEff
type StM (Eff es) a
Instance details 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

Instances details

Generic All
Instance details Defined in Data.Semigroup.Internal Associated Types type Rep All :: Type -> Type # Methods from :: All -> Rep All x # to :: Rep All x -> All #
Generic Any
Instance details Defined in Data.Semigroup.Internal Associated Types type Rep Any :: Type -> Type # Methods from :: Any -> Rep Any x # to :: Rep Any x -> Any #
Generic Version
Instance details Defined in Data.Version Associated Types type Rep Version :: Type -> Type # Methods from :: Version -> Rep Version x # to :: Rep Version x -> Version #
Generic Void
Instance details Defined in GHC.Generics Associated Types type Rep Void :: Type -> Type # Methods from :: Void -> Rep Void x # to :: Rep Void x -> Void #
Generic Fingerprint
Instance details Defined in GHC.Generics Associated Types type Rep Fingerprint :: Type -> Type # Methods from :: Fingerprint -> Rep Fingerprint x # to :: Rep Fingerprint x -> Fingerprint #
Generic Associativity
Instance details Defined in GHC.Generics Associated Types type Rep Associativity :: Type -> Type # Methods from :: Associativity -> Rep Associativity x # to :: Rep Associativity x -> Associativity #
Generic DecidedStrictness
Instance details Defined in GHC.Generics Associated Types type Rep DecidedStrictness :: Type -> Type # Methods from :: DecidedStrictness -> Rep DecidedStrictness x # to :: Rep DecidedStrictness x -> DecidedStrictness #
Generic Fixity
Instance details Defined in GHC.Generics Associated Types type Rep Fixity :: Type -> Type # Methods from :: Fixity -> Rep Fixity x # to :: Rep Fixity x -> Fixity #
Generic SourceStrictness
Instance details Defined in GHC.Generics Associated Types type Rep SourceStrictness :: Type -> Type # Methods from :: SourceStrictness -> Rep SourceStrictness x # to :: Rep SourceStrictness x -> SourceStrictness #
Generic SourceUnpackedness
Instance details Defined in GHC.Generics Associated Types type Rep SourceUnpackedness :: Type -> Type # Methods from :: SourceUnpackedness -> Rep SourceUnpackedness x # to :: Rep SourceUnpackedness x -> SourceUnpackedness #
Generic ExitCode
Instance details Defined in GHC.IO.Exception Associated Types type Rep ExitCode :: Type -> Type # Methods from :: ExitCode -> Rep ExitCode x # to :: Rep ExitCode x -> ExitCode #
Generic CCFlags
Instance details Defined in GHC.RTS.Flags Associated Types type Rep CCFlags :: Type -> Type # Methods from :: CCFlags -> Rep CCFlags x # to :: Rep CCFlags x -> CCFlags #
Generic ConcFlags
Instance details Defined in GHC.RTS.Flags Associated Types type Rep ConcFlags :: Type -> Type # Methods from :: ConcFlags -> Rep ConcFlags x # to :: Rep ConcFlags x -> ConcFlags #
Generic DebugFlags
Instance details Defined in GHC.RTS.Flags Associated Types type Rep DebugFlags :: Type -> Type # Methods from :: DebugFlags -> Rep DebugFlags x # to :: Rep DebugFlags x -> DebugFlags #
Generic DoCostCentres
Instance details Defined in GHC.RTS.Flags Associated Types type Rep DoCostCentres :: Type -> Type # Methods from :: DoCostCentres -> Rep DoCostCentres x # to :: Rep DoCostCentres x -> DoCostCentres #
Generic DoHeapProfile
Instance details Defined in GHC.RTS.Flags Associated Types type Rep DoHeapProfile :: Type -> Type # Methods from :: DoHeapProfile -> Rep DoHeapProfile x # to :: Rep DoHeapProfile x -> DoHeapProfile #
Generic DoTrace
Instance details Defined in GHC.RTS.Flags Associated Types type Rep DoTrace :: Type -> Type # Methods from :: DoTrace -> Rep DoTrace x # to :: Rep DoTrace x -> DoTrace #
Generic GCFlags
Instance details Defined in GHC.RTS.Flags Associated Types type Rep GCFlags :: Type -> Type # Methods from :: GCFlags -> Rep GCFlags x # to :: Rep GCFlags x -> GCFlags #
Generic GiveGCStats
Instance details Defined in GHC.RTS.Flags Associated Types type Rep GiveGCStats :: Type -> Type # Methods from :: GiveGCStats -> Rep GiveGCStats x # to :: Rep GiveGCStats x -> GiveGCStats #
Generic MiscFlags
Instance details Defined in GHC.RTS.Flags Associated Types type Rep MiscFlags :: Type -> Type # Methods from :: MiscFlags -> Rep MiscFlags x # to :: Rep MiscFlags x -> MiscFlags #
Generic ParFlags
Instance details Defined in GHC.RTS.Flags Associated Types type Rep ParFlags :: Type -> Type # Methods from :: ParFlags -> Rep ParFlags x # to :: Rep ParFlags x -> ParFlags #
Generic ProfFlags
Instance details Defined in GHC.RTS.Flags Associated Types type Rep ProfFlags :: Type -> Type # Methods from :: ProfFlags -> Rep ProfFlags x # to :: Rep ProfFlags x -> ProfFlags #
Generic RTSFlags
Instance details Defined in GHC.RTS.Flags Associated Types type Rep RTSFlags :: Type -> Type # Methods from :: RTSFlags -> Rep RTSFlags x # to :: Rep RTSFlags x -> RTSFlags #
Generic TickyFlags
Instance details Defined in GHC.RTS.Flags Associated Types type Rep TickyFlags :: Type -> Type # Methods from :: TickyFlags -> Rep TickyFlags x # to :: Rep TickyFlags x -> TickyFlags #
Generic TraceFlags
Instance details Defined in GHC.RTS.Flags Associated Types type Rep TraceFlags :: Type -> Type # Methods from :: TraceFlags -> Rep TraceFlags x # to :: Rep TraceFlags x -> TraceFlags #
Generic SrcLoc
Instance details Defined in GHC.Generics Associated Types type Rep SrcLoc :: Type -> Type # Methods from :: SrcLoc -> Rep SrcLoc x # to :: Rep SrcLoc x -> SrcLoc #
Generic GCDetails
Instance details Defined in GHC.Stats Associated Types type Rep GCDetails :: Type -> Type # Methods from :: GCDetails -> Rep GCDetails x # to :: Rep GCDetails x -> GCDetails #
Generic RTSStats
Instance details Defined in GHC.Stats Associated Types type Rep RTSStats :: Type -> Type # Methods from :: RTSStats -> Rep RTSStats x # to :: Rep RTSStats x -> RTSStats #
Generic GeneralCategory
Instance details Defined in GHC.Generics Associated Types type Rep GeneralCategory :: Type -> Type # Methods from :: GeneralCategory -> Rep GeneralCategory x # to :: Rep GeneralCategory x -> GeneralCategory #
Generic Limit
Instance details 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
Instance details 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
Instance details 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
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 SrcLoc
Instance details 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
Instance details 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
Instance details 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
Instance details 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
Instance details 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
Instance details 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
Instance details 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
Instance details 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
Instance details 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
Instance details 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
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 OsChar
Instance details Defined in System.OsString.Internal.Types Associated Types type Rep OsChar :: Type -> Type # Methods from :: OsChar -> Rep OsChar x # to :: Rep OsChar x -> OsChar #
Generic OsString
Instance details Defined in System.OsString.Internal.Types Associated Types type Rep OsString :: Type -> Type # Methods from :: OsString -> Rep OsString x # to :: Rep OsString x -> OsString #
Generic PosixChar
Instance details Defined in System.OsString.Internal.Types Associated Types type Rep PosixChar :: Type -> Type # Methods from :: PosixChar -> Rep PosixChar x # to :: Rep PosixChar x -> PosixChar #
Generic PosixString
Instance details Defined in System.OsString.Internal.Types Associated Types type Rep PosixString :: Type -> Type # Methods from :: PosixString -> Rep PosixString x # to :: Rep PosixString x -> PosixString #
Generic WindowsChar
Instance details Defined in System.OsString.Internal.Types Associated Types type Rep WindowsChar :: Type -> Type # Methods from :: WindowsChar -> Rep WindowsChar x # to :: Rep WindowsChar x -> WindowsChar #
Generic WindowsString
Instance details Defined in System.OsString.Internal.Types Associated Types type Rep WindowsString :: Type -> Type # Methods from :: WindowsString -> Rep WindowsString x # to :: Rep WindowsString x -> WindowsString #
Generic 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 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 ConstructorInfo
Instance details 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
Instance details 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
Instance details 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
Instance details 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
Instance details 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
Instance details 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
Instance details 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
Instance details 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
Instance details 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
Instance details 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
Instance details 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
Instance details 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
Instance details 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
Instance details Defined in Codec.Compression.Zlib.Stream Associated Types type Rep CompressionLevel :: Type -> Type # Methods from :: CompressionLevel -> Rep CompressionLevel x # to :: Rep CompressionLevel x -> CompressionLevel #
Generic CompressionStrategy
Instance details Defined in Codec.Compression.Zlib.Stream Associated Types type Rep CompressionStrategy :: Type -> Type # Methods from :: CompressionStrategy -> Rep CompressionStrategy x # to :: Rep CompressionStrategy x -> CompressionStrategy #
Generic Format
Instance details Defined in Codec.Compression.Zlib.Stream Associated Types type Rep Format :: Type -> Type # Methods from :: Format -> Rep Format x # to :: Rep Format x -> Format #
Generic MemoryLevel
Instance details Defined in Codec.Compression.Zlib.Stream Associated Types type Rep MemoryLevel :: Type -> Type # Methods from :: MemoryLevel -> Rep MemoryLevel x # to :: Rep MemoryLevel x -> MemoryLevel #
Generic Method
Instance details Defined in Codec.Compression.Zlib.Stream Associated Types type Rep Method :: Type -> Type # Methods from :: Method -> Rep Method x # to :: Rep Method x -> Method #
Generic WindowBits
Instance details Defined in Codec.Compression.Zlib.Stream Associated Types type Rep WindowBits :: Type -> Type # Methods from :: WindowBits -> Rep WindowBits x # to :: Rep WindowBits x -> WindowBits #
Generic ()
Instance details Defined in GHC.Generics Associated Types type Rep () :: Type -> Type # Methods from :: () -> Rep () x # to :: Rep () x -> () #
Generic Bool
Instance details Defined in GHC.Generics Associated Types type Rep Bool :: Type -> Type # Methods from :: Bool -> Rep Bool x # to :: Rep Bool x -> Bool #
Generic (ZipList a)
Instance details Defined in Control.Applicative Associated Types type Rep (ZipList a) :: Type -> Type # Methods from :: ZipList a -> Rep (ZipList a) x # to :: Rep (ZipList a) x -> ZipList a #
Generic (Complex a)
Instance details Defined in Data.Complex Associated Types type Rep (Complex a) :: Type -> Type # Methods from :: Complex a -> Rep (Complex a) x # to :: Rep (Complex a) x -> Complex a #
Generic (Identity a)
Instance details Defined in Data.Functor.Identity Associated Types type Rep (Identity a) :: Type -> Type # Methods from :: Identity a -> Rep (Identity a) x # to :: Rep (Identity a) x -> Identity a #
Generic (First a)
Instance details Defined in Data.Monoid Associated Types type Rep (First a) :: Type -> Type # Methods from :: First a -> Rep (First a) x # to :: Rep (First a) x -> First a #
Generic (Last a)
Instance details Defined in Data.Monoid Associated Types type Rep (Last a) :: Type -> Type # Methods from :: Last a -> Rep (Last a) x # to :: Rep (Last a) x -> Last a #
Generic (Down a)
Instance details Defined in GHC.Generics Associated Types type Rep (Down a) :: Type -> Type # Methods from :: Down a -> Rep (Down a) x # to :: Rep (Down a) x -> Down a #
Generic (First a)
Instance details Defined in Data.Semigroup Associated Types type Rep (First a) :: Type -> Type # Methods from :: First a -> Rep (First a) x # to :: Rep (First a) x -> First a #
Generic (Last a)
Instance details Defined in Data.Semigroup Associated Types type Rep (Last a) :: Type -> Type # Methods from :: Last a -> Rep (Last a) x # to :: Rep (Last a) x -> Last a #
Generic (Max a)
Instance details Defined in Data.Semigroup Associated Types type Rep (Max a) :: Type -> Type # Methods from :: Max a -> Rep (Max a) x # to :: Rep (Max a) x -> Max a #
Generic (Min a)
Instance details Defined in Data.Semigroup Associated Types type Rep (Min a) :: Type -> Type # Methods from :: Min a -> Rep (Min a) x # to :: Rep (Min a) x -> Min a #
Generic (WrappedMonoid m)
Instance details Defined in Data.Semigroup Associated Types type Rep (WrappedMonoid m) :: Type -> Type # Methods from :: WrappedMonoid m -> Rep (WrappedMonoid m) x # to :: Rep (WrappedMonoid m) x -> WrappedMonoid m #
Generic (Dual a)
Instance details Defined in Data.Semigroup.Internal Associated Types type Rep (Dual a) :: Type -> Type # Methods from :: Dual a -> Rep (Dual a) x # to :: Rep (Dual a) x -> Dual a #
Generic (Endo a)
Instance details Defined in Data.Semigroup.Internal Associated Types type Rep (Endo a) :: Type -> Type # Methods from :: Endo a -> Rep (Endo a) x # to :: Rep (Endo a) x -> Endo a #
Generic (Product a)
Instance details Defined in Data.Semigroup.Internal Associated Types type Rep (Product a) :: Type -> Type # Methods from :: Product a -> Rep (Product a) x # to :: Rep (Product a) x -> Product a #
Generic (Sum a)
Instance details Defined in Data.Semigroup.Internal Associated Types type Rep (Sum a) :: Type -> Type # Methods from :: Sum a -> Rep (Sum a) x # to :: Rep (Sum a) x -> Sum a #
Generic (NonEmpty a)
Instance details Defined in GHC.Generics Associated Types type Rep (NonEmpty a) :: Type -> Type # Methods from :: NonEmpty a -> Rep (NonEmpty a) x # to :: Rep (NonEmpty a) x -> NonEmpty a #
Generic (Par1 p)
Instance details Defined in GHC.Generics Associated Types type Rep (Par1 p) :: Type -> Type # Methods from :: Par1 p -> Rep (Par1 p) x # to :: Rep (Par1 p) x -> Par1 p #
Generic (Digit a)
Instance details Defined in Data.Sequence.Internal Associated Types type Rep (Digit a) :: Type -> Type # Methods from :: Digit a -> Rep (Digit a) x # to :: Rep (Digit a) x -> Digit a #
Generic (Elem a)
Instance details Defined in Data.Sequence.Internal Associated Types type Rep (Elem a) :: Type -> Type # Methods from :: Elem a -> Rep (Elem a) x # to :: Rep (Elem a) x -> Elem a #
Generic (FingerTree a)
Instance details Defined in Data.Sequence.Internal Associated Types type Rep (FingerTree a) :: Type -> Type # Methods from :: FingerTree a -> Rep (FingerTree a) x # to :: Rep (FingerTree a) x -> FingerTree a #
Generic (Node a)
Instance details Defined in Data.Sequence.Internal Associated Types type Rep (Node a) :: Type -> Type # Methods from :: Node a -> Rep (Node a) x # to :: Rep (Node a) x -> Node a #
Generic (ViewL a)
Instance details Defined in Data.Sequence.Internal Associated Types type Rep (ViewL a) :: Type -> Type # Methods from :: ViewL a -> Rep (ViewL a) x # to :: Rep (ViewL a) x -> ViewL a #
Generic (ViewR a)
Instance details Defined in Data.Sequence.Internal Associated Types type Rep (ViewR a) :: Type -> Type # Methods from :: ViewR a -> Rep (ViewR a) x # to :: Rep (ViewR a) x -> ViewR a #
Generic (Tree a)
Instance details Defined in Data.Tree Associated Types type Rep (Tree a) :: Type -> Type # Methods from :: Tree a -> Rep (Tree a) x # to :: Rep (Tree a) x -> Tree a #
Generic (Loc a)
Instance details 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)
Instance details 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)
Instance details 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)
Instance details 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)
Instance details 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)
Instance details 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)
Instance details 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)
Instance details 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)
Instance details 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)
Instance details 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)
Instance details 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)
Instance details 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)
Instance details 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)
Instance details 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)
Instance details 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)
Instance details 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)
Instance details 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)
Instance details 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)
Instance details 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)
Instance details 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)
Instance details 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)
Instance details 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)
Instance details 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)
Instance details 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)
Instance details 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)
Instance details 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)
Instance details 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)
Instance details 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)
Instance details 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)
Instance details 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)
Instance details 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)
Instance details 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)
Instance details 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)
Instance details 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)
Instance details 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)
Instance details 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)
Instance details 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)
Instance details 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)
Instance details 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)
Instance details 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)
Instance details 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)
Instance details 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)
Instance details 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)
Instance details 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)
Instance details 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)
Instance details 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)
Instance details 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)
Instance details 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)
Instance details 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)
Instance details 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)
Instance details 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)
Instance details 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)
Instance details 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)
Instance details 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)
Instance details 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)
Instance details 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)
Instance details 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)
Instance details 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)
Instance details 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)
Instance details 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)
Instance details 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)
Instance details 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)
Instance details 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)
Instance details 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)
Instance details 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)
Instance details 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)
Instance details 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)
Instance details 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)
Instance details 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)
Instance details 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)
Instance details 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)
Instance details 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)
Instance details 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)
Instance details 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)
Instance details 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)
Instance details 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)
Instance details 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)
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 (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 (TyVarBndr flag)
Instance details Defined in Language.Haskell.TH.Syntax Associated Types type Rep (TyVarBndr flag) :: Type -> Type # Methods from :: TyVarBndr flag -> Rep (TyVarBndr flag) x # to :: Rep (TyVarBndr flag) x -> TyVarBndr flag #
Generic (Maybe a)
Instance details Defined in GHC.Generics Associated Types type Rep (Maybe a) :: Type -> Type # Methods from :: Maybe a -> Rep (Maybe a) x # to :: Rep (Maybe a) x -> Maybe a #
Generic (a)
Instance details Defined in GHC.Generics Associated Types type Rep (a) :: Type -> Type # Methods from :: (a) -> Rep (a) x # to :: Rep (a) x -> (a) #
Generic [a]
Instance details Defined in GHC.Generics Associated Types type Rep [a] :: Type -> Type # Methods from :: [a] -> Rep [a] x # to :: Rep [a] x -> [a] #
Generic (WrappedMonad m a)
Instance details Defined in Control.Applicative Associated Types type Rep (WrappedMonad m a) :: Type -> Type # Methods from :: WrappedMonad m a -> Rep (WrappedMonad m a) x # to :: Rep (WrappedMonad m a) x -> WrappedMonad m a #
Generic (Either a b)
Instance details Defined in GHC.Generics Associated Types type Rep (Either a b) :: Type -> Type # Methods from :: Either a b -> Rep (Either a b) x # to :: Rep (Either a b) x -> Either a b #
Generic (Proxy t)
Instance details Defined in GHC.Generics Associated Types type Rep (Proxy t) :: Type -> Type # Methods from :: Proxy t -> Rep (Proxy t) x # to :: Rep (Proxy t) x -> Proxy t #
Generic (Arg a b)
Instance details Defined in Data.Semigroup Associated Types type Rep (Arg a b) :: Type -> Type # Methods from :: Arg a b -> Rep (Arg a b) x # to :: Rep (Arg a b) x -> Arg a b #
Generic (U1 p)
Instance details Defined in GHC.Generics Associated Types type Rep (U1 p) :: Type -> Type # Methods from :: U1 p -> Rep (U1 p) x # to :: Rep (U1 p) x -> U1 p #
Generic (V1 p)
Instance details Defined in GHC.Generics Associated Types type Rep (V1 p) :: Type -> Type # Methods from :: V1 p -> Rep (V1 p) x # to :: Rep (V1 p) x -> V1 p #
Generic (MaybeT m a)
Instance details Defined in Control.Monad.Trans.Maybe Associated Types type Rep (MaybeT m a) :: Type -> Type # Methods from :: MaybeT m a -> Rep (MaybeT m a) x # to :: Rep (MaybeT m a) x -> MaybeT m a #
Generic (a, b)
Instance details Defined in GHC.Generics Associated Types type Rep (a, b) :: Type -> Type # Methods from :: (a, b) -> Rep (a, b) x # to :: Rep (a, b) x -> (a, b) #
Generic (WrappedArrow a b c)
Instance details Defined in Control.Applicative Associated Types type Rep (WrappedArrow a b c) :: Type -> Type # Methods from :: WrappedArrow a b c -> Rep (WrappedArrow a b c) x # to :: Rep (WrappedArrow a b c) x -> WrappedArrow a b c #
Generic (Kleisli m a b)
Instance details Defined in Control.Arrow Associated Types type Rep (Kleisli m a b) :: Type -> Type # Methods from :: Kleisli m a b -> Rep (Kleisli m a b) x # to :: Rep (Kleisli m a b) x -> Kleisli m a b #
Generic (Const a b)
Instance details Defined in Data.Functor.Const Associated Types type Rep (Const a b) :: Type -> Type # Methods from :: Const a b -> Rep (Const a b) x # to :: Rep (Const a b) x -> Const a b #
Generic (Ap f a)
Instance details Defined in Data.Monoid Associated Types type Rep (Ap f a) :: Type -> Type # Methods from :: Ap f a -> Rep (Ap f a) x # to :: Rep (Ap f a) x -> Ap f a #
Generic (Alt f a)
Instance details Defined in Data.Semigroup.Internal Associated Types type Rep (Alt f a) :: Type -> Type # Methods from :: Alt f a -> Rep (Alt f a) x # to :: Rep (Alt f a) x -> Alt f a #
Generic (Rec1 f p)
Instance details Defined in GHC.Generics Associated Types type Rep (Rec1 f p) :: Type -> Type # Methods from :: Rec1 f p -> Rep (Rec1 f p) x # to :: Rep (Rec1 f p) x -> Rec1 f p #
Generic (URec (Ptr ()) p)
Instance details Defined in GHC.Generics Associated Types type Rep (URec (Ptr ()) p) :: Type -> Type # Methods from :: URec (Ptr ()) p -> Rep (URec (Ptr ()) p) x # to :: Rep (URec (Ptr ()) p) x -> URec (Ptr ()) p #
Generic (URec Char p)
Instance details Defined in GHC.Generics Associated Types type Rep (URec Char p) :: Type -> Type # Methods from :: URec Char p -> Rep (URec Char p) x # to :: Rep (URec Char p) x -> URec Char p #
Generic (URec Double p)
Instance details Defined in GHC.Generics Associated Types type Rep (URec Double p) :: Type -> Type # Methods from :: URec Double p -> Rep (URec Double p) x # to :: Rep (URec Double p) x -> URec Double p #
Generic (URec Float p)
Instance details Defined in GHC.Generics Associated Types type Rep (URec Float p) :: Type -> Type # Methods from :: URec Float p -> Rep (URec Float p) x # to :: Rep (URec Float p) x -> URec Float p #
Generic (URec Int p)
Instance details Defined in GHC.Generics Associated Types type Rep (URec Int p) :: Type -> Type # Methods from :: URec Int p -> Rep (URec Int p) x # to :: Rep (URec Int p) x -> URec Int p #
Generic (URec Word p)
Instance details Defined in GHC.Generics Associated Types type Rep (URec Word p) :: Type -> Type # Methods from :: URec Word p -> Rep (URec Word p) x # to :: Rep (URec Word p) x -> URec Word p #
Generic (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 (AccumT w m a)
Instance details Defined in Control.Monad.Trans.Accum Associated Types type Rep (AccumT w m a) :: Type -> Type # Methods from :: AccumT w m a -> Rep (AccumT w m a) x # to :: Rep (AccumT w m a) x -> AccumT w m a #
Generic (ExceptT e m a)
Instance details Defined in Control.Monad.Trans.Except Associated Types type Rep (ExceptT e m a) :: Type -> Type # Methods from :: ExceptT e m a -> Rep (ExceptT e m a) x # to :: Rep (ExceptT e m a) x -> ExceptT e m a #
Generic (IdentityT f a)
Instance details Defined in Control.Monad.Trans.Identity Associated Types type Rep (IdentityT f a) :: Type -> Type # Methods from :: IdentityT f a -> Rep (IdentityT f a) x # to :: Rep (IdentityT f a) x -> IdentityT f a #
Generic (ReaderT r m a)
Instance details Defined in Control.Monad.Trans.Reader Associated Types type Rep (ReaderT r m a) :: Type -> Type # Methods from :: ReaderT r m a -> Rep (ReaderT r m a) x # to :: Rep (ReaderT r m a) x -> ReaderT r m a #
Generic (SelectT r m a)
Instance details Defined in Control.Monad.Trans.Select Associated Types type Rep (SelectT r m a) :: Type -> Type # Methods from :: SelectT r m a -> Rep (SelectT r m a) x # to :: Rep (SelectT r m a) x -> SelectT r m a #
Generic (StateT s m a)
Instance details Defined in Control.Monad.Trans.State.Lazy Associated Types type Rep (StateT s m a) :: Type -> Type # Methods from :: StateT s m a -> Rep (StateT s m a) x # to :: Rep (StateT s m a) x -> StateT s m a #
Generic (StateT s m a)
Instance details Defined in Control.Monad.Trans.State.Strict Associated Types type Rep (StateT s m a) :: Type -> Type # Methods from :: StateT s m a -> Rep (StateT s m a) x # to :: Rep (StateT s m a) x -> StateT s m a #
Generic (WriterT w m a)
Instance details Defined in Control.Monad.Trans.Writer.CPS Associated Types type Rep (WriterT w m a) :: Type -> Type # Methods from :: WriterT w m a -> Rep (WriterT w m a) x # to :: Rep (WriterT w m a) x -> WriterT w m a #
Generic (WriterT w m a)
Instance details Defined in Control.Monad.Trans.Writer.Lazy Associated Types type Rep (WriterT w m a) :: Type -> Type # Methods from :: WriterT w m a -> Rep (WriterT w m a) x # to :: Rep (WriterT w m a) x -> WriterT w m a #
Generic (WriterT w m a)
Instance details Defined in Control.Monad.Trans.Writer.Strict Associated Types type Rep (WriterT w m a) :: Type -> Type # Methods from :: WriterT w m a -> Rep (WriterT w m a) x # to :: Rep (WriterT w m a) x -> WriterT w m a #
Generic (Constant a b)
Instance details Defined in Data.Functor.Constant Associated Types type Rep (Constant a b) :: Type -> Type # Methods from :: Constant a b -> Rep (Constant a b) x # to :: Rep (Constant a b) x -> Constant a b #
Generic (a, b, c)
Instance details Defined in GHC.Generics Associated Types type Rep (a, b, c) :: Type -> Type # Methods from :: (a, b, c) -> Rep (a, b, c) x # to :: Rep (a, b, c) x -> (a, b, c) #
Generic (Product f g a)
Instance details Defined in Data.Functor.Product Associated Types type Rep (Product f g a) :: Type -> Type # Methods from :: Product f g a -> Rep (Product f g a) x # to :: Rep (Product f g a) x -> Product f g a #
Generic (Sum f g a)
Instance details Defined in Data.Functor.Sum Associated Types type Rep (Sum f g a) :: Type -> Type # Methods from :: Sum f g a -> Rep (Sum f g a) x # to :: Rep (Sum f g a) x -> Sum f g a #
Generic ((f :*: g) p)
Instance details Defined in GHC.Generics Associated Types type Rep ((f :: g) p) :: Type -> Type # Methods from :: (f :: g) p -> Rep ((f :: g) p) x # to :: Rep ((f :: g) p) x -> (f :*: g) p #
Generic ((f :+: g) p)
Instance details Defined in GHC.Generics Associated Types type Rep ((f :+: g) p) :: Type -> Type # Methods from :: (f :+: g) p -> Rep ((f :+: g) p) x # to :: Rep ((f :+: g) p) x -> (f :+: g) p #
Generic (K1 i c p)
Instance details Defined in GHC.Generics Associated Types type Rep (K1 i c p) :: Type -> Type # Methods from :: K1 i c p -> Rep (K1 i c p) x # to :: Rep (K1 i c p) x -> K1 i c p #
Generic (ContT r m a)
Instance details Defined in Control.Monad.Trans.Cont Associated Types type Rep (ContT r m a) :: Type -> Type # Methods from :: ContT r m a -> Rep (ContT r m a) x # to :: Rep (ContT r m a) x -> ContT r m a #
Generic (a, b, c, d)
Instance details Defined in GHC.Generics Associated Types type Rep (a, b, c, d) :: Type -> Type # Methods from :: (a, b, c, d) -> Rep (a, b, c, d) x # to :: Rep (a, b, c, d) x -> (a, b, c, d) #
Generic (Compose f g a)
Instance details Defined in Data.Functor.Compose Associated Types type Rep (Compose f g a) :: Type -> Type # Methods from :: Compose f g a -> Rep (Compose f g a) x # to :: Rep (Compose f g a) x -> Compose f g a #
Generic ((f :.: g) p)
Instance details Defined in GHC.Generics Associated Types type Rep ((f :.: g) p) :: Type -> Type # Methods from :: (f :.: g) p -> Rep ((f :.: g) p) x # to :: Rep ((f :.: g) p) x -> (f :.: g) p #
Generic (M1 i c f p)
Instance details Defined in GHC.Generics Associated Types type Rep (M1 i c f p) :: Type -> Type # Methods from :: M1 i c f p -> Rep (M1 i c f p) x # to :: Rep (M1 i c f p) x -> M1 i c f p #
Generic (RWST r w s m a)
Instance details Defined in Control.Monad.Trans.RWS.CPS Associated Types type Rep (RWST r w s m a) :: Type -> Type # Methods from :: RWST r w s m a -> Rep (RWST r w s m a) x # to :: Rep (RWST r w s m a) x -> RWST r w s m a #
Generic (RWST r w s m a)
Instance details Defined in Control.Monad.Trans.RWS.Lazy Associated Types type Rep (RWST r w s m a) :: Type -> Type # Methods from :: RWST r w s m a -> Rep (RWST r w s m a) x # to :: Rep (RWST r w s m a) x -> RWST r w s m a #
Generic (RWST r w s m a)
Instance details Defined in Control.Monad.Trans.RWS.Strict Associated Types type Rep (RWST r w s m a) :: Type -> Type # Methods from :: RWST r w s m a -> Rep (RWST r w s m a) x # to :: Rep (RWST r w s m a) x -> RWST r w s m a #
Generic (a, b, c, d, e)
Instance details Defined in GHC.Generics Associated Types type Rep (a, b, c, d, e) :: Type -> Type # Methods from :: (a, b, c, d, e) -> Rep (a, b, c, d, e) x # to :: Rep (a, b, c, d, e) x -> (a, b, c, d, e) #
Generic (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 (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 (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) #