Servant.QuickCheck

Servant.QuickCheck provides utilities related to using QuickCheck over an API. Rather than specifying properties that individual handlers must satisfy, you can state properties that ought to hold true of the entire API.

While the API must be described with servant types, the server being tested itself need not be implemented with servant-server (or indeed, written in Haskell).

The documentation of the Useful predicates sections is meant to serve as a set of helpful pointers for learning more about best practices concerning REST APIs.

Property testing

serverSatisfies :: HasGenRequest a => Proxy a -> BaseUrl -> Args -> Predicates -> Expectation

Check that a server satisfies the set of properties specified.

Note that, rather than having separate tests for each property you'd like to test, you should generally prefer to combine all properties into a single test. This enables a more parsimonious generation of requests and responses with the same testing depth.

Example usage:

goodAPISpec = describe "my server" $ do

  it "follows best practices" $ do
    withServantServer api server $ \burl ->
      serverSatisfies api burl stdArgs (not500
                                    <%> onlyJsonObjects
                                    <%> notAllowedContainsAllowHeader
                                    <%> mempty)

Since 0.0.0.0

Predicates

Useful predicates

The predicates below are often useful. Some check RFC compliance; some are best practice, and some are useful to check that APIs follow in-house best-practices. Included in the documentation for each is a list of references to any relevant RFCs and other links, as well as what type of predicate it is (RFC Compliance, Best Practice, Optional).

RFCs distinguish between the force of requirements (e.g. MUST vs. SHOULD). RFC Compliance includes any absolute requirements present in RFCs. The Best Practices includes, in addition to RFC recommendations, recommendations found elsewhere or generally accepted.

not500 :: ResponsePredicate

Best Practice

500 Internal Server Error should be avoided - it may represent some issue with the application code, and it moreover gives the client little indication of how to proceed or what went wrong.

This function checks that the response code is not 500.

Since 0.0.0.0

notLongerThan :: Integer -> RequestPredicate

Optional

This function checks that the response from the server does not take longer than the specified number of nanoseconds.

Since 0.0.2.1

onlyJsonObjects :: ResponsePredicate

Best Practice

Returning anything other than an object when returning JSON is considered bad practice, as:

1. it is hard to modify the returned value while maintaining backwards compatibility
2. many older tools do not support top-level arrays
3. whether top-level numbers, booleans, or strings are valid JSON depends on what RFC you're going by
4. there are security issues with top-level arrays

This function checks that any application/json responses only return JSON objects (and not arrays, strings, numbers, or booleans) at the top level.

References:

• JSON Grammar: RFC 7159 Section 2
• JSON Grammar: RFC 4627 Section 2

Since 0.0.0.0

honoursAcceptHeader :: RequestPredicate

RFC Compliance

When a request contains an Accept header, the server must either return content in one of the requested representations, or respond with 406 Not Acceptable.

This function checks that every *successful* response has a Content-Type header that matches the Accept header. It does *not* check that the server matches the quality descriptions of the Accept header correctly.

References:

• Accept header: RFC 2616 Section 14.1

Since 0.0.0.0

notAllowedContainsAllowHeader :: RequestPredicate

RFC Compliance

When an HTTP request has a method that is not allowed, a 405 response should be returned. Additionally, it is good practice to return an Allow header with the list of allowed methods.

This function checks that every 405 Method Not Allowed response contains an Allow header with a list of standard HTTP methods.

Note that servant itself does not currently set the Allow headers.

References:

• Allow header: RFC 2616 Section 14.7
• Status 405: RFC 2616 Section 10.4.6
• Servant Allow header issue: Issue #489

Since 0.0.0.0

unauthorizedContainsWWWAuthenticate :: ResponsePredicate

RFC Compliance

Any 401 Unauthorized response must include a WWW-Authenticate header.

This function checks that, if a response has status code 401, it contains a WWW-Authenticate header.

References:

• WWW-Authenticate header: RFC 7235 Section 4.1

Since 0.0.0.0

getsHaveLastModifiedHeader :: RequestPredicate

Optional

The Last-Modified header represents the time a resource was last modified. It is used to drive caching and conditional requests.

When using this mechanism, the server adds the Last-Modified header to responses. Clients may then make requests with the If-Modified-Since header to conditionally request resources. If the resource has not changed since that date, the server responds with a status code of 304 (Not Modified) without a response body.

The Last-Modified header can also be used in conjunction with the If-Unmodified-Since header to drive optimistic concurrency.

The Last-Modified date must be in RFC 822 format.

References:

• 304 Not Modified: RFC 7232 Section 4.1
• Last-Modified header: RFC 7232 Section 2.2
• If-Modified-Since header: RFC 7232 Section 3.3
• If-Unmodified-Since header: RFC 7232 Section 3.4
• Date format: RFC 2616 Section 3.3

Since 0.0.2.1

getsHaveCacheControlHeader :: RequestPredicate

Best Practice

Whether or not a representation should be cached, it is good practice to have a Cache-Control header for GET requests. If the representation should not be cached, used Cache-Control: no-cache.

This function checks that GET responses have Cache-Control header. It does NOT currently check that the header is valid.

References:

• Cache-Control header: RFC 7234 Section 5.2

Since 0.0.0.0

headsHaveCacheControlHeader :: RequestPredicate

Best Practice

Like getsHaveCacheControlHeader, but for HEAD requests.

Since 0.0.0.0

createContainsValidLocation :: RequestPredicate

Optional

When creating a new resource, it is good practice to provide a Location header with a link to the created resource.

This function checks that every 201 Created response contains a Location header, and that the link in it responds with a 2XX response code to GET requests.

This is considered optional because other means of linking to the resource (e.g. via the response body) are also acceptable; linking to the resource in some way is considered best practice.

References:

• 201 Created: RFC 7231 Section 6.3.2
• Location header: RFC 7231 Section 7.1.2

Since 0.0.0.0

Html Predicates

htmlIncludesDoctype :: ResponsePredicate

RFC Compliance

An HTML

document will start with exactly this string: html

This function checks that HTML documents (those with `Content-Type: text/html...`) include a DOCTYPE declaration at the top. We do not enforce capital case for the string DOCTYPE.

References:

• HTML5 Doctype: RFC 7992 Section 6.1 Since 0.3.0.0

Predicate utilities and types

(<%>) :: JoinPreds a => a -> Predicates -> Predicates infixr 6

Adds a new predicate (either ResponsePredicate or RequestPredicate) to the existing predicates.

not500 <%> onlyJsonObjects <%> empty

Since 0.0.0.0

data Predicates

A set of predicates. Construct one with mempty and <%>.

Instances

Generic Predicates

Defined in Servant.QuickCheck.Internal.Predicates

Associated Types

type Rep Predicates :: Type -> Type

Methods

from :: Predicates -> Rep Predicates x

to :: Rep Predicates x -> Predicates

Semigroup Predicates

Defined in Servant.QuickCheck.Internal.Predicates

Methods

(<>) :: Predicates -> Predicates -> Predicates

sconcat :: NonEmpty Predicates -> Predicates

stimes :: Integral b => b -> Predicates -> Predicates

Monoid Predicates

Defined in Servant.QuickCheck.Internal.Predicates

Methods

mempty :: Predicates

mappend :: Predicates -> Predicates -> Predicates

mconcat :: [Predicates] -> Predicates

type Rep Predicates

Defined in Servant.QuickCheck.Internal.Predicates

type Rep Predicates = D1 (MetaData "Predicates" "Servant.QuickCheck.Internal.Predicates" "servant-quickcheck-0.0.7.4-FRgMEjtLfGiGjtYQ2ImRmW" False) (C1 (MetaCons "Predicates" PrefixI True) (S1 (MetaSel (Just "requestPredicates") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 RequestPredicate) :*: S1 (MetaSel (Just "responsePredicates") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 ResponsePredicate)))

newtype ResponsePredicate

A predicate that depends only on the response.

Since 0.0.0.0

Constructors

ResponsePredicate

Fields

• getResponsePredicate :: Response ByteString -> IO ()

Instances

Generic ResponsePredicate

Defined in Servant.QuickCheck.Internal.Predicates

Associated Types

type Rep ResponsePredicate :: Type -> Type

Methods

from :: ResponsePredicate -> Rep ResponsePredicate x

to :: Rep ResponsePredicate x -> ResponsePredicate

Semigroup ResponsePredicate

Defined in Servant.QuickCheck.Internal.Predicates

Methods

(<>) :: ResponsePredicate -> ResponsePredicate -> ResponsePredicate

sconcat :: NonEmpty ResponsePredicate -> ResponsePredicate

stimes :: Integral b => b -> ResponsePredicate -> ResponsePredicate

Monoid ResponsePredicate

Defined in Servant.QuickCheck.Internal.Predicates

Methods

mempty :: ResponsePredicate

mappend :: ResponsePredicate -> ResponsePredicate -> ResponsePredicate

mconcat :: [ResponsePredicate] -> ResponsePredicate

JoinPreds ResponsePredicate

Defined in Servant.QuickCheck.Internal.Predicates

Methods

joinPreds :: ResponsePredicate -> Predicates -> Predicates

type Rep ResponsePredicate

Defined in Servant.QuickCheck.Internal.Predicates

type Rep ResponsePredicate = D1 (MetaData "ResponsePredicate" "Servant.QuickCheck.Internal.Predicates" "servant-quickcheck-0.0.7.4-FRgMEjtLfGiGjtYQ2ImRmW" True) (C1 (MetaCons "ResponsePredicate" PrefixI True) (S1 (MetaSel (Just "getResponsePredicate") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Response ByteString -> IO ()))))

newtype RequestPredicate

A predicate that depends on both the request and the response.

Since 0.0.0.0

Constructors

RequestPredicate

Fields

• getRequestPredicate :: Request -> Manager -> IO [Response ByteString]

Instances

Generic RequestPredicate

Defined in Servant.QuickCheck.Internal.Predicates

Associated Types

type Rep RequestPredicate :: Type -> Type

Methods

from :: RequestPredicate -> Rep RequestPredicate x

to :: Rep RequestPredicate x -> RequestPredicate

Semigroup RequestPredicate

Defined in Servant.QuickCheck.Internal.Predicates

Methods

(<>) :: RequestPredicate -> RequestPredicate -> RequestPredicate

sconcat :: NonEmpty RequestPredicate -> RequestPredicate

stimes :: Integral b => b -> RequestPredicate -> RequestPredicate

Monoid RequestPredicate

Defined in Servant.QuickCheck.Internal.Predicates

Methods

mempty :: RequestPredicate

mappend :: RequestPredicate -> RequestPredicate -> RequestPredicate

mconcat :: [RequestPredicate] -> RequestPredicate

JoinPreds RequestPredicate

Defined in Servant.QuickCheck.Internal.Predicates

Methods

joinPreds :: RequestPredicate -> Predicates -> Predicates

type Rep RequestPredicate

Defined in Servant.QuickCheck.Internal.Predicates

type Rep RequestPredicate = D1 (MetaData "RequestPredicate" "Servant.QuickCheck.Internal.Predicates" "servant-quickcheck-0.0.7.4-FRgMEjtLfGiGjtYQ2ImRmW" True) (C1 (MetaCons "RequestPredicate" PrefixI True) (S1 (MetaSel (Just "getRequestPredicate") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Request -> Manager -> IO [Response ByteString]))))

Equality testing

serversEqual :: HasGenRequest a => Proxy a -> BaseUrl -> BaseUrl -> Args -> ResponseEquality ByteString -> Expectation

Check that the two servers running under the provided BaseUrls behave identically by randomly generating arguments (captures, query params, request bodies, headers, etc.) expected by the server. If, given the same request, the response is not the same (according to the definition of == for the return datatype), the Expectation fails, printing the counterexample.

The Int argument specifies maximum number of test cases to generate and run.

Evidently, if the behaviour of the server is expected to be non-deterministic, this function may produce spurious failures

Note that only valid requests are generated and tested. As an example of why this matters, let's say your API specifies that a particular endpoint can only generate JSON. serversEqual will then not generate any requests with an Accept header _other_ than application/json. It may therefore fail to notice that one application, when the request has Accept: text/html, returns a 406 Not Acceptable HTTP response, and another returns a 200 Success, but with application/json as the content-type.

The fact that only valid requests are tested also means that no endpoints not listed in the API type are tested.

Since 0.0.0.0

Response equality

Often the normal equality of responses is not what we want. For example, if responses contain a Date header with the time of the response, responses will fail to be equal even though they morally are. This datatype represents other means of checking equality *** Useful ResponseEqualitys

bodyEquality :: Eq b => ResponseEquality b

ByteString Eq instance over the response body.

Since 0.0.0.0

jsonEquality :: JsonEq b => ResponseEquality b

Equality as Value. This means that if two bodies are equal as JSON (e.g., insignificant whitespace difference) they are considered equal.

Since 0.0.3.0

allEquality :: Eq b => ResponseEquality b

Use Eq instance for Response

Since 0.0.0.0

Response equality type

newtype ResponseEquality b

Constructors

ResponseEquality

Fields

• getResponseEquality :: Response b -> Response b -> Bool

Instances

Semigroup (ResponseEquality b)

Defined in Servant.QuickCheck.Internal.Equality

Methods

(<>) :: ResponseEquality b -> ResponseEquality b -> ResponseEquality b

sconcat :: NonEmpty (ResponseEquality b) -> ResponseEquality b

stimes :: Integral b0 => b0 -> ResponseEquality b -> ResponseEquality b

Monoid (ResponseEquality b)

Defined in Servant.QuickCheck.Internal.Equality

Methods

mempty :: ResponseEquality b

mappend :: ResponseEquality b -> ResponseEquality b -> ResponseEquality b

mconcat :: [ResponseEquality b] -> ResponseEquality b

Test setup helpers

Helpers to setup and teardown servant servers during tests.

withServantServer :: HasServer a '[] => Proxy a -> IO (Server a) -> (BaseUrl -> IO r) -> IO r

Start a servant application on an open port, run the provided function, then stop the application.

Since 0.0.0.0

withServantServerAndContext :: HasServer a ctx => Proxy a -> Context ctx -> IO (Server a) -> (BaseUrl -> IO r) -> IO r

Like withServantServer, but allows passing in a Context to the application.

Since 0.0.0.0

defaultArgs :: Args

QuickCheck Args with 1000 rather than 100 test cases.

Since 0.0.0.0

Re-exports

Types and constructors from other packages that are generally needed for using servant-quickcheck.

data BaseUrl

Simple data type to represent the target of HTTP requests for servant's automatically-generated clients.

Constructors

BaseUrl

Fields

• baseUrlScheme :: Scheme

  URI scheme to use

• baseUrlHost :: String

  host (eg "haskell.org")

• baseUrlPort :: Int

  port (eg 80)

• baseUrlPath :: String

  path (eg "ab/c")

Instances

Eq BaseUrl

Defined in Servant.Client.Core.BaseUrl

Methods

(==) :: BaseUrl -> BaseUrl -> Bool

(/=) :: BaseUrl -> BaseUrl -> Bool

Data BaseUrl

Defined in Servant.Client.Core.BaseUrl

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> BaseUrl -> c BaseUrl

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c BaseUrl

toConstr :: BaseUrl -> Constr

dataTypeOf :: BaseUrl -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c BaseUrl)

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c BaseUrl)

gmapT :: (forall b. Data b => b -> b) -> BaseUrl -> BaseUrl

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> BaseUrl -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> BaseUrl -> r

gmapQ :: (forall d. Data d => d -> u) -> BaseUrl -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> BaseUrl -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> BaseUrl -> m BaseUrl

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> BaseUrl -> m BaseUrl

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> BaseUrl -> m BaseUrl

Ord BaseUrl

Defined in Servant.Client.Core.BaseUrl

Methods

compare :: BaseUrl -> BaseUrl -> Ordering

(<) :: BaseUrl -> BaseUrl -> Bool

(<=) :: BaseUrl -> BaseUrl -> Bool

(>) :: BaseUrl -> BaseUrl -> Bool

(>=) :: BaseUrl -> BaseUrl -> Bool

max :: BaseUrl -> BaseUrl -> BaseUrl

min :: BaseUrl -> BaseUrl -> BaseUrl

Show BaseUrl

Defined in Servant.Client.Core.BaseUrl

Methods

showsPrec :: Int -> BaseUrl -> ShowS

show :: BaseUrl -> String

showList :: [BaseUrl] -> ShowS

Generic BaseUrl

Defined in Servant.Client.Core.BaseUrl

Associated Types

type Rep BaseUrl :: Type -> Type

Methods

from :: BaseUrl -> Rep BaseUrl x

to :: Rep BaseUrl x -> BaseUrl

Lift BaseUrl

Defined in Servant.Client.Core.BaseUrl

Methods

lift :: BaseUrl -> Q Exp

ToJSON BaseUrl

>>> traverse_ (LBS8.putStrLn . encode) $ parseBaseUrl "api.example.com"
"http://api.example.com"

Defined in Servant.Client.Core.BaseUrl

Methods

toJSON :: BaseUrl -> Value

toEncoding :: BaseUrl -> Encoding

toJSONList :: [BaseUrl] -> Value

toEncodingList :: [BaseUrl] -> Encoding

ToJSONKey BaseUrl

>>> :{
traverse_ (LBS8.putStrLn . encode) $ do
  u1 <- parseBaseUrl "api.example.com"
  u2 <- parseBaseUrl "example.com"
  return $ Map.fromList [(u1, 'x'), (u2, 'y')]
:}
{"http://api.example.com":"x","http://example.com":"y"}

Defined in Servant.Client.Core.BaseUrl

Methods

toJSONKey :: ToJSONKeyFunction BaseUrl

toJSONKeyList :: ToJSONKeyFunction [BaseUrl]

FromJSON BaseUrl

>>> parseBaseUrl "api.example.com" >>= decode . encode :: Maybe BaseUrl
Just (BaseUrl {baseUrlScheme = Http, baseUrlHost = "api.example.com", baseUrlPort = 80, baseUrlPath = ""})

Defined in Servant.Client.Core.BaseUrl

Methods

parseJSON :: Value -> Parser BaseUrl

parseJSONList :: Value -> Parser [BaseUrl]

FromJSONKey BaseUrl

Defined in Servant.Client.Core.BaseUrl

Methods

fromJSONKey :: FromJSONKeyFunction BaseUrl

fromJSONKeyList :: FromJSONKeyFunction [BaseUrl]

NFData BaseUrl

Defined in Servant.Client.Core.BaseUrl

Methods

rnf :: BaseUrl -> ()

type Rep BaseUrl

Defined in Servant.Client.Core.BaseUrl

type Rep BaseUrl = D1 (MetaData "BaseUrl" "Servant.Client.Core.BaseUrl" "servant-client-core-0.16-6iWzPJGUuC04PVsaHw9Hep" False) (C1 (MetaCons "BaseUrl" PrefixI True) ((S1 (MetaSel (Just "baseUrlScheme") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Scheme) :*: S1 (MetaSel (Just "baseUrlHost") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 String)) :*: (S1 (MetaSel (Just "baseUrlPort") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Int) :*: S1 (MetaSel (Just "baseUrlPath") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 String))))

data Scheme

URI scheme to use

Constructors

Http

http://

Https

https://

Instances

Eq Scheme

Defined in Servant.Client.Core.BaseUrl

Methods

(==) :: Scheme -> Scheme -> Bool

(/=) :: Scheme -> Scheme -> Bool

Data Scheme

Defined in Servant.Client.Core.BaseUrl

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Scheme -> c Scheme

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Scheme

toConstr :: Scheme -> Constr

dataTypeOf :: Scheme -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Scheme)

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Scheme)

gmapT :: (forall b. Data b => b -> b) -> Scheme -> Scheme

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Scheme -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Scheme -> r

gmapQ :: (forall d. Data d => d -> u) -> Scheme -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> Scheme -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Scheme -> m Scheme

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Scheme -> m Scheme

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Scheme -> m Scheme

Ord Scheme

Defined in Servant.Client.Core.BaseUrl

Methods

compare :: Scheme -> Scheme -> Ordering

(<) :: Scheme -> Scheme -> Bool

(<=) :: Scheme -> Scheme -> Bool

(>) :: Scheme -> Scheme -> Bool

(>=) :: Scheme -> Scheme -> Bool

max :: Scheme -> Scheme -> Scheme

min :: Scheme -> Scheme -> Scheme

Show Scheme

Defined in Servant.Client.Core.BaseUrl

Methods

showsPrec :: Int -> Scheme -> ShowS

show :: Scheme -> String

showList :: [Scheme] -> ShowS

Generic Scheme

Defined in Servant.Client.Core.BaseUrl

Associated Types

type Rep Scheme :: Type -> Type

Methods

from :: Scheme -> Rep Scheme x

to :: Rep Scheme x -> Scheme

Lift Scheme

Defined in Servant.Client.Core.BaseUrl

Methods

lift :: Scheme -> Q Exp

type Rep Scheme

Defined in Servant.Client.Core.BaseUrl

type Rep Scheme = D1 (MetaData "Scheme" "Servant.Client.Core.BaseUrl" "servant-client-core-0.16-6iWzPJGUuC04PVsaHw9Hep" False) (C1 (MetaCons "Http" PrefixI False) (U1 :: Type -> Type) :+: C1 (MetaCons "Https" PrefixI False) (U1 :: Type -> Type))

data Args

Args specifies arguments to the QuickCheck driver

Constructors

Args

Fields

• replay :: Maybe (QCGen, Int)

  Should we replay a previous test? Note: saving a seed from one version of QuickCheck and replaying it in another is not supported. If you want to store a test case permanently you should save the test case itself.

• maxSuccess :: Int

  Maximum number of successful tests before succeeding. Testing stops at the first failure. If all tests are passing and you want to run more tests, increase this number.

• maxDiscardRatio :: Int

  Maximum number of discarded tests per successful test before giving up

• maxSize :: Int

  Size to use for the biggest test cases

• chatty :: Bool

  Whether to print anything

• maxShrinks :: Int

  Maximum number of shrinks to before giving up. Setting this to zero turns shrinking off.

Instances

Read Args

Defined in Test.QuickCheck.Test

Methods

readsPrec :: Int -> ReadS Args

readList :: ReadS [Args]

readPrec :: ReadPrec Args

readListPrec :: ReadPrec [Args]

Show Args

Defined in Test.QuickCheck.Test

Methods

showsPrec :: Int -> Args -> ShowS

show :: Args -> String

showList :: [Args] -> ShowS

data Proxy (t :: k) :: forall k. k -> Type

Proxy is a type that holds no data, but has a phantom parameter of arbitrary type (or even kind). Its use is to provide type information, even though there is no value available of that type (or it may be too costly to create one).

Historically, Proxy :: Proxy a is a safer alternative to the 'undefined :: a' idiom.

>>> Proxy :: Proxy (Void, Int -> Int)
Proxy

Proxy can even hold types of higher kinds,

>>> Proxy :: Proxy Either
Proxy

>>> Proxy :: Proxy Functor
Proxy

>>> Proxy :: Proxy complicatedStructure
Proxy

Constructors

Proxy

Instances

Generic1 (Proxy :: k -> Type)

Defined in GHC.Generics

Associated Types

type Rep1 Proxy :: k -> Type

Methods

from1 :: Proxy a -> Rep1 Proxy a

to1 :: Rep1 Proxy a -> Proxy a

Monad (Proxy :: Type -> Type)

Since: base-4.7.0.0

Defined in Data.Proxy

Methods

(>>=) :: Proxy a -> (a -> Proxy b) -> Proxy b

(>>) :: Proxy a -> Proxy b -> Proxy b

return :: a -> Proxy a

fail :: String -> Proxy a

Functor (Proxy :: Type -> Type)

Since: base-4.7.0.0

Defined in Data.Proxy

Methods

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

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

Applicative (Proxy :: Type -> Type)

Since: base-4.7.0.0

Defined in Data.Proxy

Methods

pure :: a -> Proxy a

(<*>) :: Proxy (a -> b) -> Proxy a -> Proxy b

liftA2 :: (a -> b -> c) -> Proxy a -> Proxy b -> Proxy c

(*>) :: Proxy a -> Proxy b -> Proxy b

(<*) :: Proxy a -> Proxy b -> Proxy a

Foldable (Proxy :: Type -> Type)

Since: base-4.7.0.0

Defined in Data.Foldable

Methods

fold :: Monoid m => Proxy m -> m

foldMap :: Monoid m => (a -> m) -> Proxy a -> m

foldr :: (a -> b -> b) -> b -> Proxy a -> b

foldr' :: (a -> b -> b) -> b -> Proxy a -> b

foldl :: (b -> a -> b) -> b -> Proxy a -> b

foldl' :: (b -> a -> b) -> b -> Proxy a -> b

foldr1 :: (a -> a -> a) -> Proxy a -> a

foldl1 :: (a -> a -> a) -> Proxy a -> a

toList :: Proxy a -> [a]

null :: Proxy a -> Bool

length :: Proxy a -> Int

elem :: Eq a => a -> Proxy a -> Bool

maximum :: Ord a => Proxy a -> a

minimum :: Ord a => Proxy a -> a

sum :: Num a => Proxy a -> a

product :: Num a => Proxy a -> a

Traversable (Proxy :: Type -> Type)

Since: base-4.7.0.0

Defined in Data.Traversable

Methods

traverse :: Applicative f => (a -> f b) -> Proxy a -> f (Proxy b)

sequenceA :: Applicative f => Proxy (f a) -> f (Proxy a)

mapM :: Monad m => (a -> m b) -> Proxy a -> m (Proxy b)

sequence :: Monad m => Proxy (m a) -> m (Proxy a)

FromJSON1 (Proxy :: Type -> Type)

Defined in Data.Aeson.Types.FromJSON

Methods

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

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

Alternative (Proxy :: Type -> Type)

Since: base-4.9.0.0

Defined in Data.Proxy

Methods

empty :: Proxy a

(<|>) :: Proxy a -> Proxy a -> Proxy a

some :: Proxy a -> Proxy [a]

many :: Proxy a -> Proxy [a]

MonadPlus (Proxy :: Type -> Type)

Since: base-4.9.0.0

Defined in Data.Proxy

Methods

mzero :: Proxy a

mplus :: Proxy a -> Proxy a -> Proxy a

Eq1 (Proxy :: Type -> Type)

Since: base-4.9.0.0

Defined in Data.Functor.Classes

Methods

liftEq :: (a -> b -> Bool) -> Proxy a -> Proxy b -> Bool

Ord1 (Proxy :: Type -> Type)

Since: base-4.9.0.0

Defined in Data.Functor.Classes

Methods

liftCompare :: (a -> b -> Ordering) -> Proxy a -> Proxy b -> Ordering

Read1 (Proxy :: Type -> Type)

Since: base-4.9.0.0

Defined in Data.Functor.Classes

Methods

liftReadsPrec :: (Int -> ReadS a) -> ReadS [a] -> Int -> ReadS (Proxy a)

liftReadList :: (Int -> ReadS a) -> ReadS [a] -> ReadS [Proxy a]

liftReadPrec :: ReadPrec a -> ReadPrec [a] -> ReadPrec (Proxy a)

liftReadListPrec :: ReadPrec a -> ReadPrec [a] -> ReadPrec [Proxy a]

Show1 (Proxy :: Type -> Type)

Since: base-4.9.0.0

Defined in Data.Functor.Classes

Methods

liftShowsPrec :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> Int -> Proxy a -> ShowS

liftShowList :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> [Proxy a] -> ShowS

Hashable1 (Proxy :: Type -> Type)

Defined in Data.Hashable.Class

Methods

liftHashWithSalt :: (Int -> a -> Int) -> Int -> Proxy a -> Int

Bounded (Proxy t)

Since: base-4.7.0.0

Defined in Data.Proxy

Methods

minBound :: Proxy t

maxBound :: Proxy t

Enum (Proxy s)

Since: base-4.7.0.0

Defined in Data.Proxy

Methods

succ :: Proxy s -> Proxy s

pred :: Proxy s -> Proxy s

toEnum :: Int -> Proxy s

fromEnum :: Proxy s -> Int

enumFrom :: Proxy s -> [Proxy s]

enumFromThen :: Proxy s -> Proxy s -> [Proxy s]

enumFromTo :: Proxy s -> Proxy s -> [Proxy s]

enumFromThenTo :: Proxy s -> Proxy s -> Proxy s -> [Proxy s]

Eq (Proxy s)

Since: base-4.7.0.0

Defined in Data.Proxy

Methods

(==) :: Proxy s -> Proxy s -> Bool

(/=) :: Proxy s -> Proxy s -> Bool

Ord (Proxy s)

Since: base-4.7.0.0

Defined in Data.Proxy

Methods

compare :: Proxy s -> Proxy s -> Ordering

(<) :: Proxy s -> Proxy s -> Bool

(<=) :: Proxy s -> Proxy s -> Bool

(>) :: Proxy s -> Proxy s -> Bool

(>=) :: Proxy s -> Proxy s -> Bool

max :: Proxy s -> Proxy s -> Proxy s

min :: Proxy s -> Proxy s -> Proxy s

Read (Proxy t)

Since: base-4.7.0.0

Defined in Data.Proxy

Methods

readsPrec :: Int -> ReadS (Proxy t)

readList :: ReadS [Proxy t]

readPrec :: ReadPrec (Proxy t)

readListPrec :: ReadPrec [Proxy t]

Show (Proxy s)

Since: base-4.7.0.0

Defined in Data.Proxy

Methods

showsPrec :: Int -> Proxy s -> ShowS

show :: Proxy s -> String

showList :: [Proxy s] -> ShowS

Ix (Proxy s)

Since: base-4.7.0.0

Defined in Data.Proxy

Methods

range :: (Proxy s, Proxy s) -> [Proxy s]

index :: (Proxy s, Proxy s) -> Proxy s -> Int

unsafeIndex :: (Proxy s, Proxy s) -> Proxy s -> Int

inRange :: (Proxy s, Proxy s) -> Proxy s -> Bool

rangeSize :: (Proxy s, Proxy s) -> Int

unsafeRangeSize :: (Proxy s, Proxy s) -> Int

Generic (Proxy t)

Defined in GHC.Generics

Associated Types

type Rep (Proxy t) :: Type -> Type

Methods

from :: Proxy t -> Rep (Proxy t) x

to :: Rep (Proxy t) x -> Proxy t

Semigroup (Proxy s)

Since: base-4.9.0.0

Defined in Data.Proxy

Methods

(<>) :: Proxy s -> Proxy s -> Proxy s

sconcat :: NonEmpty (Proxy s) -> Proxy s

stimes :: Integral b => b -> Proxy s -> Proxy s

Monoid (Proxy s)

Since: base-4.7.0.0

Defined in Data.Proxy

Methods

mempty :: Proxy s

mappend :: Proxy s -> Proxy s -> Proxy s

mconcat :: [Proxy s] -> Proxy s

Hashable (Proxy a)

Defined in Data.Hashable.Class

Methods

hashWithSalt :: Int -> Proxy a -> Int

hash :: Proxy a -> Int

FromJSON (Proxy a)

Defined in Data.Aeson.Types.FromJSON

Methods

parseJSON :: Value -> Parser (Proxy a)

parseJSONList :: Value -> Parser [Proxy a]

type Rep1 (Proxy :: k -> Type)

Since: base-4.6.0.0

Defined in GHC.Generics

type Rep1 (Proxy :: k -> Type) = D1 (MetaData "Proxy" "Data.Proxy" "base" False) (C1 (MetaCons "Proxy" PrefixI False) (U1 :: k -> Type))

type Rep (Proxy t)

Since: base-4.6.0.0

Defined in GHC.Generics

type Rep (Proxy t) = D1 (MetaData "Proxy" "Data.Proxy" "base" False) (C1 (MetaCons "Proxy" PrefixI False) (U1 :: Type -> Type))