{-# LANGUAGE Trustworthy #-}{-# LANGUAGE NoImplicitPrelude #-}{-# LANGUAGE PolyKinds #-}------------------------------------------------------------------------------- |-- Module : Data.Proxy-- License : BSD-style (see the LICENSE file in the distribution)---- Maintainer : libraries@haskell.org-- Stability : experimental-- Portability : portable---- Definition of a Proxy type (poly-kinded in GHC)---- @since 4.7.0.0-----------------------------------------------------------------------------moduleData.Proxy(Proxy (..),asProxyTypeOf ,KProxy (..))whereimportGHC.Base importGHC.Show importGHC.Read importGHC.Enum importGHC.Arr -- $setup-- >>> import Data.Void-- >>> import Prelude-- | '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-- ProxydataProxy t =Proxy deriving(Bounded -- ^ @since 4.7.0.0,Read -- ^ @since 4.7.0.0)-- | A concrete, promotable proxy type, for use at the kind level.-- There are no instances for this because it is intended at the kind level onlydataKProxy (t ::Type)=KProxy -- It's common to use (undefined :: Proxy t) and (Proxy :: Proxy t)-- interchangeably, so all of these instances are hand-written to be-- lazy in Proxy arguments.-- | @since 4.7.0.0instanceEq(Proxy s )where_== :: Proxy s -> Proxy s -> Bool
==_=Bool
True-- | @since 4.7.0.0instanceOrd(Proxy s )wherecompare :: Proxy s -> Proxy s -> Ordering
compare__=Ordering
EQ-- | @since 4.7.0.0instanceShow (Proxy s )whereshowsPrec :: Int -> Proxy s -> ShowS
showsPrec __=String -> ShowS
showString "Proxy"-- | @since 4.7.0.0instanceEnum (Proxy s )wheresucc :: Proxy s -> Proxy s
succ _=String -> Proxy s
forall a. String -> a
errorWithoutStackTrace "Proxy.succ"pred :: Proxy s -> Proxy s
pred _=String -> Proxy s
forall a. String -> a
errorWithoutStackTrace "Proxy.pred"fromEnum :: Proxy s -> Int
fromEnum _=0toEnum :: Int -> Proxy s
toEnum 0=Proxy s
forall k (t :: k). Proxy t
Proxy toEnum _=String -> Proxy s
forall a. String -> a
errorWithoutStackTrace "Proxy.toEnum: 0 expected"enumFrom :: Proxy s -> [Proxy s]
enumFrom _=[Proxy s
forall k (t :: k). Proxy t
Proxy ]enumFromThen :: Proxy s -> Proxy s -> [Proxy s]
enumFromThen __=[Proxy s
forall k (t :: k). Proxy t
Proxy ]enumFromThenTo :: Proxy s -> Proxy s -> Proxy s -> [Proxy s]
enumFromThenTo ___=[Proxy s
forall k (t :: k). Proxy t
Proxy ]enumFromTo :: Proxy s -> Proxy s -> [Proxy s]
enumFromTo __=[Proxy s
forall k (t :: k). Proxy t
Proxy ]-- | @since 4.7.0.0instanceIx (Proxy s )whererange :: (Proxy s, Proxy s) -> [Proxy s]
range _=[Proxy s
forall k (t :: k). Proxy t
Proxy ]index :: (Proxy s, Proxy s) -> Proxy s -> Int
index __=0inRange :: (Proxy s, Proxy s) -> Proxy s -> Bool
inRange __=Bool
TruerangeSize :: (Proxy s, Proxy s) -> Int
rangeSize _=1unsafeIndex :: (Proxy s, Proxy s) -> Proxy s -> Int
unsafeIndex __=0unsafeRangeSize :: (Proxy s, Proxy s) -> Int
unsafeRangeSize _=1-- | @since 4.9.0.0instanceSemigroup (Proxy s )where_<> :: Proxy s -> Proxy s -> Proxy s
<> _=Proxy s
forall k (t :: k). Proxy t
Proxy sconcat :: NonEmpty (Proxy s) -> Proxy s
sconcat _=Proxy s
forall k (t :: k). Proxy t
Proxy stimes :: b -> Proxy s -> Proxy s
stimes __=Proxy s
forall k (t :: k). Proxy t
Proxy -- | @since 4.7.0.0instanceMonoid (Proxy s )wheremempty :: Proxy s
mempty =Proxy s
forall k (t :: k). Proxy t
Proxy mconcat :: [Proxy s] -> Proxy s
mconcat _=Proxy s
forall k (t :: k). Proxy t
Proxy -- | @since 4.7.0.0instanceFunctor Proxy wherefmap :: (a -> b) -> Proxy a -> Proxy b
fmap __=Proxy b
forall k (t :: k). Proxy t
Proxy {-# INLINEfmap #-}-- | @since 4.7.0.0instanceApplicative Proxy wherepure :: a -> Proxy a
pure _=Proxy a
forall k (t :: k). Proxy t
Proxy {-# INLINEpure #-}_<*> :: Proxy (a -> b) -> Proxy a -> Proxy b
<*> _=Proxy b
forall k (t :: k). Proxy t
Proxy {-# INLINE(<*>)#-}-- | @since 4.9.0.0instanceAlternative Proxy whereempty :: Proxy a
empty =Proxy a
forall k (t :: k). Proxy t
Proxy {-# INLINEempty #-}_<|> :: Proxy a -> Proxy a -> Proxy a
<|> _=Proxy a
forall k (t :: k). Proxy t
Proxy {-# INLINE(<|>)#-}-- | @since 4.7.0.0instanceMonad Proxy where_>>= :: Proxy a -> (a -> Proxy b) -> Proxy b
>>= _=Proxy b
forall k (t :: k). Proxy t
Proxy {-# INLINE(>>=)#-}-- | @since 4.9.0.0instanceMonadPlus Proxy -- | 'asProxyTypeOf' is a type-restricted version of 'const'.-- It is usually used as an infix operator, and its typing forces its first-- argument (which is usually overloaded) to have the same type as the tag-- of the second.---- >>> import Data.Word-- >>> :type asProxyTypeOf 123 (Proxy :: Proxy Word8)-- asProxyTypeOf 123 (Proxy :: Proxy Word8) :: Word8---- Note the lower-case @proxy@ in the definition. This allows any type-- constructor with just one argument to be passed to the function, for example-- we could also write---- >>> import Data.Word-- >>> :type asProxyTypeOf 123 (Just (undefined :: Word8))-- asProxyTypeOf 123 (Just (undefined :: Word8)) :: Word8asProxyTypeOf ::a ->proxy a ->a asProxyTypeOf :: a -> proxy a -> a
asProxyTypeOf =a -> proxy a -> a
forall a b. a -> b -> a
const {-# INLINEasProxyTypeOf #-}