Safe Haskell | None |
---|
IHP.Prelude
Synopsis
- seq :: forall (r :: RuntimeRep) a (b :: TYPE r). a -> b -> b
- fst :: (a, b) -> a
- snd :: (a, b) -> b
- otherwise :: Bool
- ($) :: forall (r :: RuntimeRep) a (b :: TYPE r). (a -> b) -> a -> b
- fromIntegral :: (Integral a, Num b) => a -> b
- realToFrac :: (Real a, Fractional b) => a -> b
- class Bounded a where
- class Enum a where
- succ :: a -> a
- pred :: a -> a
- toEnum :: Int -> a
- fromEnum :: a -> Int
- enumFrom :: a -> [a]
- enumFromThen :: a -> a -> [a]
- enumFromTo :: a -> a -> [a]
- enumFromThenTo :: a -> a -> a -> [a]
- class Eq a where
- class Fractional a => Floating a where
- class Num a => Fractional a where
- (/) :: a -> a -> a
- recip :: a -> a
- fromRational :: Rational -> a
- class (Real a, Enum a) => Integral a where
- class Applicative m => Monad (m :: Type -> Type) where
- class Functor (f :: Type -> Type) where
- class Num a where
- class Eq a => Ord a where
- class Read a
- class (Num a, Ord a) => Real a where
- toRational :: a -> Rational
- class (RealFrac a, Floating a) => RealFloat a where
- floatRadix :: a -> Integer
- floatDigits :: a -> Int
- floatRange :: a -> (Int, Int)
- decodeFloat :: a -> (Integer, Int)
- encodeFloat :: Integer -> Int -> a
- exponent :: a -> Int
- significand :: a -> a
- scaleFloat :: Int -> a -> a
- isNaN :: a -> Bool
- isInfinite :: a -> Bool
- isDenormalized :: a -> Bool
- isNegativeZero :: a -> Bool
- isIEEE :: a -> Bool
- atan2 :: a -> a -> a
- class (Real a, Fractional a) => RealFrac a where
- class Show a
- class Typeable (a :: k)
- class IsString a where
- fromString :: String -> a
- class Functor f => Applicative (f :: Type -> Type) where
- class Foldable (t :: Type -> Type)
- class (Functor t, Foldable t) => Traversable (t :: Type -> Type)
- (<>) :: Semigroup a => a -> a -> a
- class Semigroup a => Monoid a where
- data Bool
- data Char
- data Double
- data Float
- data Int
- data Int32
- data Int64
- data Integer
- data Maybe a
- data Ordering
- type Rational = Ratio Integer
- data IO a
- data Word
- data Word8
- data Word32
- data Word64
- data Either a b
- (>=>) :: Monad m => (a -> m b) -> (b -> m c) -> a -> m c
- bool :: a -> a -> Bool -> a
- either :: (a -> c) -> (b -> c) -> Either a b -> c
- lefts :: [Either a b] -> [a]
- partitionEithers :: [Either a b] -> ([a], [b])
- rights :: [Either a b] -> [b]
- asum :: (Foldable t, Alternative f) => t (f a) -> f a
- on :: (b -> b -> c) -> (a -> b) -> a -> a -> c
- (<$>) :: Functor f => (a -> b) -> f a -> f b
- fromMaybe :: a -> Maybe a -> a
- isJust :: Maybe a -> Bool
- isNothing :: Maybe a -> Bool
- listToMaybe :: [a] -> Maybe a
- mapMaybe :: (a -> Maybe b) -> [a] -> [b]
- maybe :: b -> (a -> b) -> Maybe a -> b
- maybeToList :: Maybe a -> [a]
- comparing :: Ord a => (b -> a) -> b -> b -> Ordering
- curry :: ((a, b) -> c) -> a -> b -> c
- swap :: (a, b) -> (b, a)
- uncurry :: (a -> b -> c) -> (a, b) -> c
- ($!) :: forall (r :: RuntimeRep) a (b :: TYPE r). (a -> b) -> a -> b
- (=<<) :: Monad m => (a -> m b) -> m a -> m b
- asTypeOf :: a -> a -> a
- const :: a -> b -> a
- flip :: (a -> b -> c) -> b -> a -> c
- until :: (a -> Bool) -> (a -> a) -> a -> a
- ioError :: IOError -> IO a
- userError :: String -> IOError
- subtract :: Num a => a -> a -> a
- (^) :: (Num a, Integral b) => a -> b -> a
- (^^) :: (Fractional a, Integral b) => a -> b -> a
- even :: Integral a => a -> Bool
- odd :: Integral a => a -> Bool
- alreadyExistsErrorType :: IOErrorType
- alreadyInUseErrorType :: IOErrorType
- annotateIOError :: IOError -> String -> Maybe Handle -> Maybe FilePath -> IOError
- doesNotExistErrorType :: IOErrorType
- eofErrorType :: IOErrorType
- fullErrorType :: IOErrorType
- illegalOperationErrorType :: IOErrorType
- ioeGetErrorString :: IOError -> String
- ioeGetErrorType :: IOError -> IOErrorType
- ioeGetFileName :: IOError -> Maybe FilePath
- ioeGetHandle :: IOError -> Maybe Handle
- ioeGetLocation :: IOError -> String
- ioeSetErrorString :: IOError -> String -> IOError
- ioeSetErrorType :: IOError -> IOErrorType -> IOError
- ioeSetFileName :: IOError -> FilePath -> IOError
- ioeSetHandle :: IOError -> Handle -> IOError
- ioeSetLocation :: IOError -> String -> IOError
- isAlreadyExistsError :: IOError -> Bool
- isAlreadyExistsErrorType :: IOErrorType -> Bool
- isAlreadyInUseError :: IOError -> Bool
- isAlreadyInUseErrorType :: IOErrorType -> Bool
- isDoesNotExistError :: IOError -> Bool
- isDoesNotExistErrorType :: IOErrorType -> Bool
- isEOFError :: IOError -> Bool
- isEOFErrorType :: IOErrorType -> Bool
- isFullError :: IOError -> Bool
- isFullErrorType :: IOErrorType -> Bool
- isIllegalOperation :: IOError -> Bool
- isIllegalOperationErrorType :: IOErrorType -> Bool
- isPermissionError :: IOError -> Bool
- isPermissionErrorType :: IOErrorType -> Bool
- isResourceVanishedError :: IOError -> Bool
- isResourceVanishedErrorType :: IOErrorType -> Bool
- isUserError :: IOError -> Bool
- isUserErrorType :: IOErrorType -> Bool
- mkIOError :: IOErrorType -> String -> Maybe Handle -> Maybe FilePath -> IOError
- modifyIOError :: (IOError -> IOError) -> IO a -> IO a
- permissionErrorType :: IOErrorType
- resourceVanishedErrorType :: IOErrorType
- tryIOError :: IO a -> IO (Either IOError a)
- userErrorType :: IOErrorType
- equating :: Eq a => (b -> a) -> b -> b -> Bool
- getArgs :: MonadIO m => m [Text]
- terror :: HasCallStack => Text -> a
- (<.>) :: FilePath -> String -> FilePath
- (</>) :: FilePath -> FilePath -> FilePath
- (&&) :: Bool -> Bool -> Bool
- not :: Bool -> Bool
- (||) :: Bool -> Bool -> Bool
- second :: Arrow a => a b c -> a (d, b) (d, c)
- first :: Arrow a => a b c -> a (b, d) (c, d)
- (&&&) :: Arrow a => a b c -> a b c' -> a b (c, c')
- (***) :: Arrow a => a b c -> a b' c' -> a (b, b') (c, c')
- (.) :: forall (b :: k) (c :: k) (a :: k). Category cat => cat b c -> cat a b -> cat a c
- id :: forall (a :: k). Category cat => cat a a
- class Monad m => MonadIO (m :: Type -> Type) where
- newtype Down a = Down {
- getDown :: a
- class Storable a
- (<|>) :: Alternative f => f a -> f a -> f a
- type String = [Char]
- class (Typeable e, Show e) => Exception e where
- toException :: e -> SomeException
- fromException :: SomeException -> Maybe e
- displayException :: e -> String
- data SomeException
- type FilePath = String
- type IOError = IOException
- data IOErrorType
- data IOException
- type LByteString = ByteString
- type LText = Text
- type SVector = Vector
- type UVector = Vector
- data ByteString
- data IntMap a
- data IntSet
- data Map k a
- data Seq a
- data Set a
- class Hashable a where
- hashWithSalt :: Int -> a -> Int
- hash :: a -> Int
- data Text
- lift :: (MonadTrans t, Monad m) => m a -> t m a
- data HashMap k v
- data HashSet a
- data Vector a
- class (Vector Vector a, MVector MVector a) => Unbox a
- catMaybes :: [Maybe a] -> [a]
- undefined :: forall (r :: RuntimeRep) (a :: TYPE r). HasCallStack => a
- catchIOError :: IO a -> (IOError -> IO a) -> IO a
- putStr :: Text -> IO ()
- putStrLn :: Text -> IO ()
- module IHP.HaskellSupport
- data UUID
- class Default a where
- def :: a
- tshow :: Show a => a -> Text
- data Proxy (t :: k) = Proxy
- join :: Monad m => m (m a) -> m a
- mapM :: (Traversable t, Monad m) => (a -> m b) -> t a -> m (t b)
- sequence :: (Traversable t, Monad m) => t (m a) -> m (t a)
- forever :: Applicative f => f a -> f b
- unless :: Applicative f => Bool -> f () -> f ()
- forM :: (Traversable t, Monad m) => t a -> (a -> m b) -> m (t b)
- when :: Applicative f => Bool -> f () -> f ()
- forM_ :: (Foldable t, Monad m) => t a -> (a -> m b) -> m ()
- mapM_ :: (Foldable t, Monad m) => (a -> m b) -> t a -> m ()
- sequence_ :: (Foldable t, Monad m) => t (m a) -> m ()
- filter :: (a -> Bool) -> [a] -> [a]
- zip :: [a] -> [b] -> [(a, b)]
- map :: (a -> b) -> [a] -> [b]
- foldr1 :: Foldable t => (a -> a -> a) -> t a -> a
- foldl1 :: Foldable t => (a -> a -> a) -> t a -> a
- foldl :: Foldable t => (b -> a -> b) -> b -> t a -> b
- minimum :: (Foldable t, Ord a) => t a -> a
- maximum :: (Foldable t, Ord a) => t a -> a
- sum :: (Foldable t, Num a) => t a -> a
- product :: (Foldable t, Num a) => t a -> a
- length :: Foldable t => t a -> Int
- foldr :: Foldable t => (a -> b -> b) -> b -> t a -> b
- elem :: (Foldable t, Eq a) => a -> t a -> Bool
- foldl' :: Foldable t => (b -> a -> b) -> b -> t a -> b
- repeat :: a -> [a]
- transpose :: [[a]] -> [[a]]
- break :: (a -> Bool) -> [a] -> ([a], [a])
- genericSplitAt :: Integral i => i -> [a] -> ([a], [a])
- dropWhile :: (a -> Bool) -> [a] -> [a]
- groupBy :: (a -> a -> Bool) -> [a] -> [[a]]
- span :: (a -> Bool) -> [a] -> ([a], [a])
- takeWhile :: (a -> Bool) -> [a] -> [a]
- sortBy :: (a -> a -> Ordering) -> [a] -> [a]
- (!!) :: [a] -> Int -> a
- zipWith :: (a -> b -> c) -> [a] -> [b] -> [c]
- lookup :: Eq a => a -> [(a, b)] -> Maybe b
- intersectBy :: (a -> a -> Bool) -> [a] -> [a] -> [a]
- unionBy :: (a -> a -> Bool) -> [a] -> [a] -> [a]
- genericReplicate :: Integral i => i -> a -> [a]
- take :: Int -> [a] -> [a]
- drop :: Int -> [a] -> [a]
- partition :: (a -> Bool) -> [a] -> ([a], [a])
- replicate :: Int -> a -> [a]
- reverse :: [a] -> [a]
- find :: Foldable t => (a -> Bool) -> t a -> Maybe a
- stripPrefix :: Eq a => [a] -> [a] -> Maybe [a]
- deleteBy :: (a -> a -> Bool) -> a -> [a] -> [a]
- delete :: Eq a => a -> [a] -> [a]
- zipWith3 :: (a -> b -> c -> d) -> [a] -> [b] -> [c] -> [d]
- zip3 :: [a] -> [b] -> [c] -> [(a, b, c)]
- zipWith4 :: (a -> b -> c -> d -> e) -> [a] -> [b] -> [c] -> [d] -> [e]
- zipWith5 :: (a -> b -> c -> d -> e -> f) -> [a] -> [b] -> [c] -> [d] -> [e] -> [f]
- zipWith6 :: (a -> b -> c -> d -> e -> f -> g) -> [a] -> [b] -> [c] -> [d] -> [e] -> [f] -> [g]
- zipWith7 :: (a -> b -> c -> d -> e -> f -> g -> h) -> [a] -> [b] -> [c] -> [d] -> [e] -> [f] -> [g] -> [h]
- all :: Foldable t => (a -> Bool) -> t a -> Bool
- and :: Foldable t => t Bool -> Bool
- any :: Foldable t => (a -> Bool) -> t a -> Bool
- concat :: Foldable t => t [a] -> [a]
- concatMap :: Foldable t => (a -> [b]) -> t a -> [b]
- maximumBy :: Foldable t => (a -> a -> Ordering) -> t a -> a
- minimumBy :: Foldable t => (a -> a -> Ordering) -> t a -> a
- notElem :: (Foldable t, Eq a) => a -> t a -> Bool
- or :: Foldable t => t Bool -> Bool
- isSubsequenceOf :: Eq a => [a] -> [a] -> Bool
- (\\) :: Eq a => [a] -> [a] -> [a]
- deleteFirstsBy :: (a -> a -> Bool) -> [a] -> [a] -> [a]
- dropWhileEnd :: (a -> Bool) -> [a] -> [a]
- elemIndex :: Eq a => a -> [a] -> Maybe Int
- elemIndices :: Eq a => a -> [a] -> [Int]
- findIndex :: (a -> Bool) -> [a] -> Maybe Int
- findIndices :: (a -> Bool) -> [a] -> [Int]
- genericDrop :: Integral i => i -> [a] -> [a]
- genericIndex :: Integral i => [a] -> i -> a
- genericLength :: Num i => [a] -> i
- genericTake :: Integral i => i -> [a] -> [a]
- group :: Eq a => [a] -> [[a]]
- inits :: [a] -> [[a]]
- insert :: Ord a => a -> [a] -> [a]
- insertBy :: (a -> a -> Ordering) -> a -> [a] -> [a]
- intersect :: Eq a => [a] -> [a] -> [a]
- nub :: Eq a => [a] -> [a]
- nubBy :: (a -> a -> Bool) -> [a] -> [a]
- permutations :: [a] -> [[a]]
- sort :: Ord a => [a] -> [a]
- sortOn :: Ord b => (a -> b) -> [a] -> [a]
- subsequences :: [a] -> [[a]]
- tails :: [a] -> [[a]]
- unfoldr :: (b -> Maybe (a, b)) -> b -> [a]
- union :: Eq a => [a] -> [a] -> [a]
- unzip4 :: [(a, b, c, d)] -> ([a], [b], [c], [d])
- unzip5 :: [(a, b, c, d, e)] -> ([a], [b], [c], [d], [e])
- unzip6 :: [(a, b, c, d, e, f)] -> ([a], [b], [c], [d], [e], [f])
- unzip7 :: [(a, b, c, d, e, f, g)] -> ([a], [b], [c], [d], [e], [f], [g])
- zip4 :: [a] -> [b] -> [c] -> [d] -> [(a, b, c, d)]
- zip5 :: [a] -> [b] -> [c] -> [d] -> [e] -> [(a, b, c, d, e)]
- zip6 :: [a] -> [b] -> [c] -> [d] -> [e] -> [f] -> [(a, b, c, d, e, f)]
- zip7 :: [a] -> [b] -> [c] -> [d] -> [e] -> [f] -> [g] -> [(a, b, c, d, e, f, g)]
- mapAccumL :: Traversable t => (a -> b -> (a, c)) -> a -> t b -> (a, t c)
- mapAccumR :: Traversable t => (a -> b -> (a, c)) -> a -> t b -> (a, t c)
- cycle :: [a] -> [a]
- foldl1' :: (a -> a -> a) -> [a] -> a
- iterate :: (a -> a) -> a -> [a]
- iterate' :: (a -> a) -> a -> [a]
- scanl :: (b -> a -> b) -> b -> [a] -> [b]
- scanl' :: (b -> a -> b) -> b -> [a] -> [b]
- scanl1 :: (a -> a -> a) -> [a] -> [a]
- scanr :: (a -> b -> b) -> b -> [a] -> [b]
- scanr1 :: (a -> a -> a) -> [a] -> [a]
- uncons :: [a] -> Maybe (a, [a])
- unzip :: [(a, b)] -> ([a], [b])
- unzip3 :: [(a, b, c)] -> ([a], [b], [c])
- head :: [a] -> Maybe a
- headMay :: [a] -> Maybe a
- last :: [a] -> Maybe a
- lastMay :: [a] -> Maybe a
- tail :: [a] -> Maybe [a]
- tailMay :: [a] -> Maybe [a]
- init :: [a] -> Maybe [a]
- initMay :: [a] -> Maybe [a]
- show :: Show a => a -> Text
- cs :: ConvertibleStrings a b => a -> b
- class ConvertibleStrings a b where
- convertString :: a -> b
- intercalate :: Text -> [Text] -> Text
- intersperse :: Char -> Text -> Text
- isInfixOf :: Text -> Text -> Bool
- isPrefixOf :: Text -> Text -> Bool
- isSuffixOf :: Text -> Text -> Bool
- lines :: Text -> [Text]
- splitAt :: Int -> Text -> (Text, Text)
- toLower :: Text -> Text
- toUpper :: Text -> Text
- unlines :: [Text] -> Text
- unwords :: [Text] -> Text
- words :: Text -> [Text]
- plain :: QuasiQuoter
- (++) :: Semigroup a => a -> a -> a
- error :: Text -> a
- class Typeable a => Data a
- class KnownSymbol (n :: Symbol)
- data Symbol
- symbolVal :: forall (n :: Symbol) proxy. KnownSymbol n => proxy n -> String
- module IHP.NameSupport
- data MetaBag = MetaBag {
- annotations :: [(Text, Text)]
- touchedFields :: [Text]
- type NormalizeModel model = GetModelByTableName (GetTableName model)
- type Id model = Id' (GetTableName model)
- type family GetModelName model :: Symbol
- class CanUpdate a where
- updateRecord :: (?modelContext :: ModelContext) => a -> IO a
- type family GetTableName model :: Symbol
- data ModelContext = ModelContext {
- connectionPool :: Pool Connection
- queryDebuggingEnabled :: Bool
- trackTableReadCallback :: Maybe (ByteString -> IO ())
- createRecord :: (?modelContext :: ModelContext, CanCreate model) => model -> IO model
- deleteRecord :: forall model id. (?modelContext :: ModelContext, Show id, KnownSymbol (GetTableName model), HasField "id" model id, ToField id) => model -> IO ()
- type TMap = TypeRepMap Identity
- class FromRow a
- null :: MonoFoldable mono => mono -> Bool
- throw :: forall (r :: RuntimeRep) (a :: TYPE r) e. Exception e => e -> a
- catch :: Exception e => IO a -> (e -> IO a) -> IO a
- throwIO :: Exception e => e -> IO a
Documentation
fromIntegral :: (Integral a, Num b) => a -> b #
realToFrac :: (Real a, Fractional b) => a -> b #
Instances
Methods
enumFromThen :: a -> a -> [a] #
enumFromTo :: a -> a -> [a] #
enumFromThenTo :: a -> a -> a -> [a] #
Instances
Enum Bool | |
Enum Char | |
Enum Int | |
Enum Int8 | |
Enum Int16 | |
Enum Int32 | |
Enum Int64 | |
Enum Integer | |
Enum Natural | |
Defined in GHC.Enum Methods enumFrom :: Natural -> [Natural] # enumFromThen :: Natural -> Natural -> [Natural] # enumFromTo :: Natural -> Natural -> [Natural] # enumFromThenTo :: Natural -> Natural -> Natural -> [Natural] # | |
Enum Ordering | |
Enum Word | |
Enum Word8 | |
Enum Word16 | |
Defined in GHC.Word | |
Enum Word32 | |
Defined in GHC.Word | |
Enum Word64 | |
Defined in GHC.Word | |
Enum VecCount | |
Defined in GHC.Enum Methods succ :: VecCount -> VecCount # pred :: VecCount -> VecCount # enumFrom :: VecCount -> [VecCount] # enumFromThen :: VecCount -> VecCount -> [VecCount] # enumFromTo :: VecCount -> VecCount -> [VecCount] # enumFromThenTo :: VecCount -> VecCount -> VecCount -> [VecCount] # | |
Enum VecElem | |
Defined in GHC.Enum Methods enumFrom :: VecElem -> [VecElem] # enumFromThen :: VecElem -> VecElem -> [VecElem] # enumFromTo :: VecElem -> VecElem -> [VecElem] # enumFromThenTo :: VecElem -> VecElem -> VecElem -> [VecElem] # | |
Enum () | |
Enum SeekMode | |
Enum IOMode | |
Defined in GHC.IO.IOMode | |
Enum Day | |
Enum DayOfWeek | |
Defined in Data.Time.Calendar.Week Methods succ :: DayOfWeek -> DayOfWeek # pred :: DayOfWeek -> DayOfWeek # fromEnum :: DayOfWeek -> Int # enumFrom :: DayOfWeek -> [DayOfWeek] # enumFromThen :: DayOfWeek -> DayOfWeek -> [DayOfWeek] # enumFromTo :: DayOfWeek -> DayOfWeek -> [DayOfWeek] # enumFromThenTo :: DayOfWeek -> DayOfWeek -> DayOfWeek -> [DayOfWeek] # | |
Enum DiffTime | |
Defined in Data.Time.Clock.Internal.DiffTime | |
Enum NominalDiffTime | |
Defined in Data.Time.Clock.Internal.NominalDiffTime Methods succ :: NominalDiffTime -> NominalDiffTime # pred :: NominalDiffTime -> NominalDiffTime # toEnum :: Int -> NominalDiffTime # fromEnum :: NominalDiffTime -> Int # enumFrom :: NominalDiffTime -> [NominalDiffTime] # enumFromThen :: NominalDiffTime -> NominalDiffTime -> [NominalDiffTime] # enumFromTo :: NominalDiffTime -> NominalDiffTime -> [NominalDiffTime] # enumFromThenTo :: NominalDiffTime -> NominalDiffTime -> NominalDiffTime -> [NominalDiffTime] # | |
Enum CChar | |
Defined in Foreign.C.Types | |
Enum CInt | |
Defined in Foreign.C.Types | |
Enum Associativity | |
Defined in GHC.Generics Methods succ :: Associativity -> Associativity # pred :: Associativity -> Associativity # toEnum :: Int -> Associativity # fromEnum :: Associativity -> Int # enumFrom :: Associativity -> [Associativity] # enumFromThen :: Associativity -> Associativity -> [Associativity] # enumFromTo :: Associativity -> Associativity -> [Associativity] # enumFromThenTo :: Associativity -> Associativity -> Associativity -> [Associativity] # | |
Enum DecidedStrictness | |
Defined in GHC.Generics Methods succ :: DecidedStrictness -> DecidedStrictness # pred :: DecidedStrictness -> DecidedStrictness # toEnum :: Int -> DecidedStrictness # fromEnum :: DecidedStrictness -> Int # enumFrom :: DecidedStrictness -> [DecidedStrictness] # enumFromThen :: DecidedStrictness -> DecidedStrictness -> [DecidedStrictness] # enumFromTo :: DecidedStrictness -> DecidedStrictness -> [DecidedStrictness] # enumFromThenTo :: DecidedStrictness -> DecidedStrictness -> DecidedStrictness -> [DecidedStrictness] # | |
Enum SourceStrictness | |
Defined in GHC.Generics Methods succ :: SourceStrictness -> SourceStrictness # pred :: SourceStrictness -> SourceStrictness # toEnum :: Int -> SourceStrictness # fromEnum :: SourceStrictness -> Int # enumFrom :: SourceStrictness -> [SourceStrictness] # enumFromThen :: SourceStrictness -> SourceStrictness -> [SourceStrictness] # enumFromTo :: SourceStrictness -> SourceStrictness -> [SourceStrictness] # enumFromThenTo :: SourceStrictness -> SourceStrictness -> SourceStrictness -> [SourceStrictness] # | |
Enum SourceUnpackedness | |
Defined in GHC.Generics Methods succ :: SourceUnpackedness -> SourceUnpackedness # pred :: SourceUnpackedness -> SourceUnpackedness # toEnum :: Int -> SourceUnpackedness # fromEnum :: SourceUnpackedness -> Int # enumFrom :: SourceUnpackedness -> [SourceUnpackedness] # enumFromThen :: SourceUnpackedness -> SourceUnpackedness -> [SourceUnpackedness] # enumFromTo :: SourceUnpackedness -> SourceUnpackedness -> [SourceUnpackedness] # enumFromThenTo :: SourceUnpackedness -> SourceUnpackedness -> SourceUnpackedness -> [SourceUnpackedness] # | |
Enum CClock | |
Defined in Foreign.C.Types | |
Enum CDouble | |
Defined in Foreign.C.Types Methods enumFrom :: CDouble -> [CDouble] # enumFromThen :: CDouble -> CDouble -> [CDouble] # enumFromTo :: CDouble -> CDouble -> [CDouble] # enumFromThenTo :: CDouble -> CDouble -> CDouble -> [CDouble] # | |
Enum CFloat | |
Defined in Foreign.C.Types | |
Enum CIntMax | |
Defined in Foreign.C.Types Methods enumFrom :: CIntMax -> [CIntMax] # enumFromThen :: CIntMax -> CIntMax -> [CIntMax] # enumFromTo :: CIntMax -> CIntMax -> [CIntMax] # enumFromThenTo :: CIntMax -> CIntMax -> CIntMax -> [CIntMax] # | |
Enum CIntPtr | |
Defined in Foreign.C.Types Methods enumFrom :: CIntPtr -> [CIntPtr] # enumFromThen :: CIntPtr -> CIntPtr -> [CIntPtr] # enumFromTo :: CIntPtr -> CIntPtr -> [CIntPtr] # enumFromThenTo :: CIntPtr -> CIntPtr -> CIntPtr -> [CIntPtr] # | |
Enum CLLong | |
Defined in Foreign.C.Types | |
Enum CLong | |
Defined in Foreign.C.Types | |
Enum CPtrdiff | |
Defined in Foreign.C.Types Methods succ :: CPtrdiff -> CPtrdiff # pred :: CPtrdiff -> CPtrdiff # enumFrom :: CPtrdiff -> [CPtrdiff] # enumFromThen :: CPtrdiff -> CPtrdiff -> [CPtrdiff] # enumFromTo :: CPtrdiff -> CPtrdiff -> [CPtrdiff] # enumFromThenTo :: CPtrdiff -> CPtrdiff -> CPtrdiff -> [CPtrdiff] # | |
Enum CSUSeconds | |
Defined in Foreign.C.Types Methods succ :: CSUSeconds -> CSUSeconds # pred :: CSUSeconds -> CSUSeconds # fromEnum :: CSUSeconds -> Int # enumFrom :: CSUSeconds -> [CSUSeconds] # enumFromThen :: CSUSeconds -> CSUSeconds -> [CSUSeconds] # enumFromTo :: CSUSeconds -> CSUSeconds -> [CSUSeconds] # enumFromThenTo :: CSUSeconds -> CSUSeconds -> CSUSeconds -> [CSUSeconds] # | |
Enum CShort | |
Defined in Foreign.C.Types | |
Enum CSigAtomic | |
Defined in Foreign.C.Types Methods succ :: CSigAtomic -> CSigAtomic # pred :: CSigAtomic -> CSigAtomic # fromEnum :: CSigAtomic -> Int # enumFrom :: CSigAtomic -> [CSigAtomic] # enumFromThen :: CSigAtomic -> CSigAtomic -> [CSigAtomic] # enumFromTo :: CSigAtomic -> CSigAtomic -> [CSigAtomic] # enumFromThenTo :: CSigAtomic -> CSigAtomic -> CSigAtomic -> [CSigAtomic] # | |
Enum CSize | |
Defined in Foreign.C.Types | |
Enum CTime | |
Defined in Foreign.C.Types | |
Enum CUInt | |
Defined in Foreign.C.Types | |
Enum CUIntMax | |
Defined in Foreign.C.Types Methods succ :: CUIntMax -> CUIntMax # pred :: CUIntMax -> CUIntMax # enumFrom :: CUIntMax -> [CUIntMax] # enumFromThen :: CUIntMax -> CUIntMax -> [CUIntMax] # enumFromTo :: CUIntMax -> CUIntMax -> [CUIntMax] # enumFromThenTo :: CUIntMax -> CUIntMax -> CUIntMax -> [CUIntMax] # | |
Enum CUIntPtr | |
Defined in Foreign.C.Types Methods succ :: CUIntPtr -> CUIntPtr # pred :: CUIntPtr -> CUIntPtr # enumFrom :: CUIntPtr -> [CUIntPtr] # enumFromThen :: CUIntPtr -> CUIntPtr -> [CUIntPtr] # enumFromTo :: CUIntPtr -> CUIntPtr -> [CUIntPtr] # enumFromThenTo :: CUIntPtr -> CUIntPtr -> CUIntPtr -> [CUIntPtr] # | |
Enum CULLong | |
Defined in Foreign.C.Types Methods enumFrom :: CULLong -> [CULLong] # enumFromThen :: CULLong -> CULLong -> [CULLong] # enumFromTo :: CULLong -> CULLong -> [CULLong] # enumFromThenTo :: CULLong -> CULLong -> CULLong -> [CULLong] # | |
Enum CULong | |
Defined in Foreign.C.Types | |
Enum CUSeconds | |
Defined in Foreign.C.Types Methods succ :: CUSeconds -> CUSeconds # pred :: CUSeconds -> CUSeconds # fromEnum :: CUSeconds -> Int # enumFrom :: CUSeconds -> [CUSeconds] # enumFromThen :: CUSeconds -> CUSeconds -> [CUSeconds] # enumFromTo :: CUSeconds -> CUSeconds -> [CUSeconds] # enumFromThenTo :: CUSeconds -> CUSeconds -> CUSeconds -> [CUSeconds] # | |
Enum CUShort | |
Defined in Foreign.C.Types Methods enumFrom :: CUShort -> [CUShort] # enumFromThen :: CUShort -> CUShort -> [CUShort] # enumFromTo :: CUShort -> CUShort -> [CUShort] # enumFromThenTo :: CUShort -> CUShort -> CUShort -> [CUShort] # | |
Enum GeneralCategory | |
Defined in GHC.Unicode Methods succ :: GeneralCategory -> GeneralCategory # pred :: GeneralCategory -> GeneralCategory # toEnum :: Int -> GeneralCategory # fromEnum :: GeneralCategory -> Int # enumFrom :: GeneralCategory -> [GeneralCategory] # enumFromThen :: GeneralCategory -> GeneralCategory -> [GeneralCategory] # enumFromTo :: GeneralCategory -> GeneralCategory -> [GeneralCategory] # enumFromThenTo :: GeneralCategory -> GeneralCategory -> GeneralCategory -> [GeneralCategory] # | |
Enum Extension | |
Defined in GHC.LanguageExtensions.Type Methods succ :: Extension -> Extension # pred :: Extension -> Extension # fromEnum :: Extension -> Int # enumFrom :: Extension -> [Extension] # enumFromThen :: Extension -> Extension -> [Extension] # enumFromTo :: Extension -> Extension -> [Extension] # enumFromThenTo :: Extension -> Extension -> Extension -> [Extension] # | |
Enum CBool | |
Defined in Foreign.C.Types | |
Enum CSChar | |
Defined in Foreign.C.Types | |
Enum CUChar | |
Defined in Foreign.C.Types | |
Enum CWchar | |
Defined in Foreign.C.Types | |
Enum ExecStatus | |
Defined in Database.PostgreSQL.LibPQ Methods succ :: ExecStatus -> ExecStatus # pred :: ExecStatus -> ExecStatus # fromEnum :: ExecStatus -> Int # enumFrom :: ExecStatus -> [ExecStatus] # enumFromThen :: ExecStatus -> ExecStatus -> [ExecStatus] # enumFromTo :: ExecStatus -> ExecStatus -> [ExecStatus] # enumFromThenTo :: ExecStatus -> ExecStatus -> ExecStatus -> [ExecStatus] # | |
Enum Format | |
Defined in Database.PostgreSQL.LibPQ | |
Enum Column | |
Defined in Database.PostgreSQL.LibPQ | |
Enum IPv6 | |
Enum IPv4 | |
Enum Row | |
Defined in Database.PostgreSQL.LibPQ | |
Enum FieldCode | |
Defined in Database.PostgreSQL.LibPQ Methods succ :: FieldCode -> FieldCode # pred :: FieldCode -> FieldCode # fromEnum :: FieldCode -> Int # enumFrom :: FieldCode -> [FieldCode] # enumFromThen :: FieldCode -> FieldCode -> [FieldCode] # enumFromTo :: FieldCode -> FieldCode -> [FieldCode] # enumFromThenTo :: FieldCode -> FieldCode -> FieldCode -> [FieldCode] # | |
Enum Verbosity | |
Defined in Database.PostgreSQL.LibPQ Methods succ :: Verbosity -> Verbosity # pred :: Verbosity -> Verbosity # fromEnum :: Verbosity -> Int # enumFrom :: Verbosity -> [Verbosity] # enumFromThen :: Verbosity -> Verbosity -> [Verbosity] # enumFromTo :: Verbosity -> Verbosity -> [Verbosity] # enumFromThenTo :: Verbosity -> Verbosity -> Verbosity -> [Verbosity] # | |
Enum PortNumber | |
Defined in Network.Socket.Types Methods succ :: PortNumber -> PortNumber # pred :: PortNumber -> PortNumber # fromEnum :: PortNumber -> Int # enumFrom :: PortNumber -> [PortNumber] # enumFromThen :: PortNumber -> PortNumber -> [PortNumber] # enumFromTo :: PortNumber -> PortNumber -> [PortNumber] # enumFromThenTo :: PortNumber -> PortNumber -> PortNumber -> [PortNumber] # | |
Enum Encoding | |
Defined in Basement.String Methods succ :: Encoding -> Encoding # pred :: Encoding -> Encoding # enumFrom :: Encoding -> [Encoding] # enumFromThen :: Encoding -> Encoding -> [Encoding] # enumFromTo :: Encoding -> Encoding -> [Encoding] # enumFromThenTo :: Encoding -> Encoding -> Encoding -> [Encoding] # | |
Enum UTF32_Invalid | |
Defined in Basement.String.Encoding.UTF32 Methods succ :: UTF32_Invalid -> UTF32_Invalid # pred :: UTF32_Invalid -> UTF32_Invalid # toEnum :: Int -> UTF32_Invalid # fromEnum :: UTF32_Invalid -> Int # enumFrom :: UTF32_Invalid -> [UTF32_Invalid] # enumFromThen :: UTF32_Invalid -> UTF32_Invalid -> [UTF32_Invalid] # enumFromTo :: UTF32_Invalid -> UTF32_Invalid -> [UTF32_Invalid] # enumFromThenTo :: UTF32_Invalid -> UTF32_Invalid -> UTF32_Invalid -> [UTF32_Invalid] # | |
Enum DoPa | |
Defined in Text.Regex.TDFA.Common | |
Enum WhichTest | |
Defined in Text.Regex.TDFA.Common Methods succ :: WhichTest -> WhichTest # pred :: WhichTest -> WhichTest # fromEnum :: WhichTest -> Int # enumFrom :: WhichTest -> [WhichTest] # enumFromThen :: WhichTest -> WhichTest -> [WhichTest] # enumFromTo :: WhichTest -> WhichTest -> [WhichTest] # enumFromThenTo :: WhichTest -> WhichTest -> WhichTest -> [WhichTest] # | |
Enum Status | |
Defined in Network.HTTP.Types.Status | |
Enum JobStatus Source # | |
Defined in IHP.Job.Types Methods succ :: JobStatus -> JobStatus # pred :: JobStatus -> JobStatus # fromEnum :: JobStatus -> Int # enumFrom :: JobStatus -> [JobStatus] # enumFromThen :: JobStatus -> JobStatus -> [JobStatus] # enumFromTo :: JobStatus -> JobStatus -> [JobStatus] # enumFromThenTo :: JobStatus -> JobStatus -> JobStatus -> [JobStatus] # | |
Enum StdMethod | |
Defined in Network.HTTP.Types.Method Methods succ :: StdMethod -> StdMethod # pred :: StdMethod -> StdMethod # fromEnum :: StdMethod -> Int # enumFrom :: StdMethod -> [StdMethod] # enumFromThen :: StdMethod -> StdMethod -> [StdMethod] # enumFromTo :: StdMethod -> StdMethod -> [StdMethod] # enumFromThenTo :: StdMethod -> StdMethod -> StdMethod -> [StdMethod] # | |
Enum CryptoError | |
Defined in Crypto.Error.Types Methods succ :: CryptoError -> CryptoError # pred :: CryptoError -> CryptoError # toEnum :: Int -> CryptoError # fromEnum :: CryptoError -> Int # enumFrom :: CryptoError -> [CryptoError] # enumFromThen :: CryptoError -> CryptoError -> [CryptoError] # enumFromTo :: CryptoError -> CryptoError -> [CryptoError] # enumFromThenTo :: CryptoError -> CryptoError -> CryptoError -> [CryptoError] # | |
Enum CompressionStrategy | |
Defined in Codec.Compression.Zlib.Stream Methods succ :: CompressionStrategy -> CompressionStrategy # pred :: CompressionStrategy -> CompressionStrategy # toEnum :: Int -> CompressionStrategy # fromEnum :: CompressionStrategy -> Int # enumFrom :: CompressionStrategy -> [CompressionStrategy] # enumFromThen :: CompressionStrategy -> CompressionStrategy -> [CompressionStrategy] # enumFromTo :: CompressionStrategy -> CompressionStrategy -> [CompressionStrategy] # enumFromThenTo :: CompressionStrategy -> CompressionStrategy -> CompressionStrategy -> [CompressionStrategy] # | |
Enum Format | |
Defined in Codec.Compression.Zlib.Stream | |
Enum Method | |
Defined in Codec.Compression.Zlib.Stream | |
Enum Clock | |
Defined in System.Clock | |
Enum IP | |
Defined in Data.IP.Addr | |
Enum IPv4 | |
Defined in Data.IP.Addr | |
Enum IPv6 | |
Defined in Data.IP.Addr | |
Integral a => Enum (Ratio a) | |
Defined in GHC.Real Methods enumFrom :: Ratio a -> [Ratio a] # enumFromThen :: Ratio a -> Ratio a -> [Ratio a] # enumFromTo :: Ratio a -> Ratio a -> [Ratio a] # enumFromThenTo :: Ratio a -> Ratio a -> Ratio a -> [Ratio a] # | |
Enum a => Enum (Identity a) | |
Defined in Data.Functor.Identity Methods succ :: Identity a -> Identity a # pred :: Identity a -> Identity a # fromEnum :: Identity a -> Int # enumFrom :: Identity a -> [Identity a] # enumFromThen :: Identity a -> Identity a -> [Identity a] # enumFromTo :: Identity a -> Identity a -> [Identity a] # enumFromThenTo :: Identity a -> Identity a -> Identity a -> [Identity a] # | |
Enum a => Enum (Down a) | |
Defined in Data.Ord | |
Enum a => Enum (WrappedMonoid a) | |
Defined in Data.Semigroup Methods succ :: WrappedMonoid a -> WrappedMonoid a # pred :: WrappedMonoid a -> WrappedMonoid a # toEnum :: Int -> WrappedMonoid a # fromEnum :: WrappedMonoid a -> Int # enumFrom :: WrappedMonoid a -> [WrappedMonoid a] # enumFromThen :: WrappedMonoid a -> WrappedMonoid a -> [WrappedMonoid a] # enumFromTo :: WrappedMonoid a -> WrappedMonoid a -> [WrappedMonoid a] # enumFromThenTo :: WrappedMonoid a -> WrappedMonoid a -> WrappedMonoid a -> [WrappedMonoid a] # | |
Enum a => Enum (First a) | |
Defined in Data.Semigroup Methods enumFrom :: First a -> [First a] # enumFromThen :: First a -> First a -> [First a] # enumFromTo :: First a -> First a -> [First a] # enumFromThenTo :: First a -> First a -> First a -> [First a] # | |
Enum a => Enum (Last a) | |
Defined in Data.Semigroup | |
Enum a => Enum (Max a) | |
Defined in Data.Semigroup | |
Enum a => Enum (Min a) | |
Defined in Data.Semigroup | |
Enum (Offset ty) | |
Defined in Basement.Types.OffsetSize Methods succ :: Offset ty -> Offset ty # pred :: Offset ty -> Offset ty # fromEnum :: Offset ty -> Int # enumFrom :: Offset ty -> [Offset ty] # enumFromThen :: Offset ty -> Offset ty -> [Offset ty] # enumFromTo :: Offset ty -> Offset ty -> [Offset ty] # enumFromThenTo :: Offset ty -> Offset ty -> Offset ty -> [Offset ty] # | |
Enum (CountOf ty) | |
Defined in Basement.Types.OffsetSize Methods succ :: CountOf ty -> CountOf ty # pred :: CountOf ty -> CountOf ty # fromEnum :: CountOf ty -> Int # enumFrom :: CountOf ty -> [CountOf ty] # enumFromThen :: CountOf ty -> CountOf ty -> [CountOf ty] # enumFromTo :: CountOf ty -> CountOf ty -> [CountOf ty] # enumFromThenTo :: CountOf ty -> CountOf ty -> CountOf ty -> [CountOf ty] # | |
Enum (Proxy s) | |
Enum (Fixed a) | |
Defined in Data.Fixed Methods enumFrom :: Fixed a -> [Fixed a] # enumFromThen :: Fixed a -> Fixed a -> [Fixed a] # enumFromTo :: Fixed a -> Fixed a -> [Fixed a] # enumFromThenTo :: Fixed a -> Fixed a -> Fixed a -> [Fixed a] # | |
a ~ b => Enum (a :~: b) | |
Defined in Data.Type.Equality Methods succ :: (a :~: b) -> a :~: b # pred :: (a :~: b) -> a :~: b # fromEnum :: (a :~: b) -> Int # enumFrom :: (a :~: b) -> [a :~: b] # enumFromThen :: (a :~: b) -> (a :~: b) -> [a :~: b] # enumFromTo :: (a :~: b) -> (a :~: b) -> [a :~: b] # enumFromThenTo :: (a :~: b) -> (a :~: b) -> (a :~: b) -> [a :~: b] # | |
Enum a => Enum (Const a b) | |
Defined in Data.Functor.Const Methods succ :: Const a b -> Const a b # pred :: Const a b -> Const a b # fromEnum :: Const a b -> Int # enumFrom :: Const a b -> [Const a b] # enumFromThen :: Const a b -> Const a b -> [Const a b] # enumFromTo :: Const a b -> Const a b -> [Const a b] # enumFromThenTo :: Const a b -> Const a b -> Const a b -> [Const a b] # | |
Enum a => Enum (Tagged s a) | |
Defined in Data.Tagged Methods succ :: Tagged s a -> Tagged s a # pred :: Tagged s a -> Tagged s a # fromEnum :: Tagged s a -> Int # enumFrom :: Tagged s a -> [Tagged s a] # enumFromThen :: Tagged s a -> Tagged s a -> [Tagged s a] # enumFromTo :: Tagged s a -> Tagged s a -> [Tagged s a] # enumFromThenTo :: Tagged s a -> Tagged s a -> Tagged s a -> [Tagged s a] # | |
Enum (f a) => Enum (Alt f a) | |
Defined in Data.Semigroup.Internal Methods enumFrom :: Alt f a -> [Alt f a] # enumFromThen :: Alt f a -> Alt f a -> [Alt f a] # enumFromTo :: Alt f a -> Alt f a -> [Alt f a] # enumFromThenTo :: Alt f a -> Alt f a -> Alt f a -> [Alt f a] # | |
Enum (f a) => Enum (Ap f a) | |
Defined in Data.Monoid | |
a ~~ b => Enum (a :~~: b) | |
Defined in Data.Type.Equality Methods succ :: (a :~~: b) -> a :~~: b # pred :: (a :~~: b) -> a :~~: b # fromEnum :: (a :~~: b) -> Int # enumFrom :: (a :~~: b) -> [a :~~: b] # enumFromThen :: (a :~~: b) -> (a :~~: b) -> [a :~~: b] # enumFromTo :: (a :~~: b) -> (a :~~: b) -> [a :~~: b] # enumFromThenTo :: (a :~~: b) -> (a :~~: b) -> (a :~~: b) -> [a :~~: b] # |
Instances
Eq Bool | |
Eq Char | |
Eq Double | |
Eq Float | |
Eq Int | |
Eq Int8 | |
Eq Int16 | |
Eq Int32 | |
Eq Int64 | |
Eq Integer | |
Eq Natural | |
Eq Ordering | |
Eq Word | |
Eq Word8 | |
Eq Word16 | |
Eq Word32 | |
Eq Word64 | |
Eq SomeTypeRep | |
Eq Exp | |
Eq Match | |
Eq Clause | |
Eq Pat | |
Eq Type | |
Eq Dec | |
Eq Name | |
Eq FunDep | |
Eq InjectivityAnn | |
Eq Overlap | |
Eq () | |
Eq TyCon | |
Eq Module | |
Eq TrName | |
Eq SeekMode | |
Eq IOErrorType | |
Defined in GHC.IO.Exception | |
Eq IOException | |
Defined in GHC.IO.Exception | |
Eq BufferMode | |
Defined in GHC.IO.Handle.Types | |
Eq Handle | |
Eq IOMode | |
Eq ByteString | |
Defined in Data.ByteString.Internal | |
Eq IntSet | |
Eq Day | |
Eq UTCTime | |
Eq ConcException | |
Defined in UnliftIO.Internals.Async Methods (==) :: ConcException -> ConcException -> Bool # (/=) :: ConcException -> ConcException -> Bool # | |
Eq ByteString | |
Eq UUID | |
Eq CalendarDiffDays | |
Defined in Data.Time.Calendar.CalendarDiffDays Methods (==) :: CalendarDiffDays -> CalendarDiffDays -> Bool # (/=) :: CalendarDiffDays -> CalendarDiffDays -> Bool # | |
Eq DayOfWeek | |
Eq DiffTime | |
Eq NominalDiffTime | |
Defined in Data.Time.Clock.Internal.NominalDiffTime Methods (==) :: NominalDiffTime -> NominalDiffTime -> Bool # (/=) :: NominalDiffTime -> NominalDiffTime -> Bool # | |
Eq UniversalTime | |
Defined in Data.Time.Clock.Internal.UniversalTime Methods (==) :: UniversalTime -> UniversalTime -> Bool # (/=) :: UniversalTime -> UniversalTime -> Bool # | |
Eq TimeLocale | |
Defined in Data.Time.Format.Locale | |
Eq CalendarDiffTime | |
Defined in Data.Time.LocalTime.Internal.CalendarDiffTime Methods (==) :: CalendarDiffTime -> CalendarDiffTime -> Bool # (/=) :: CalendarDiffTime -> CalendarDiffTime -> Bool # | |
Eq LocalTime | |
Eq TimeOfDay | |
Eq TimeZone | |
Eq SomeSymbol | |
Eq SomeNat | |
Eq Number | |
Eq More | |
Eq Scientific | |
Eq Pos | |
Eq CChar | |
Eq DataRep | |
Eq Constr | |
Eq Lit | |
Eq NameFlavour | |
Eq ConstrRep | |
Eq SrcLoc | |
Eq All | |
Eq Any | |
Eq TimeLocale | |
Eq CInt | |
Eq Builder Source # | Need for the 'Eq QueryBuilder' instance You likely wonder: Why do we need the 'Eq SQLQuery' instance if this causes so much trouble? This has to do with how has-many and belongs-to relations are models by the SchemaCompiler E.g. given a table users and a table posts. Each Post belongs to a user. The schema compiler will
add a field 'posts :: QueryBuilder "posts"' with the default value This is needed to support syntax like this: user |> get #posts |> fetch |
Eq Void | |
Eq Associativity | |
Eq DecidedStrictness | |
Eq Fixity | |
Eq SourceStrictness | |
Eq SourceUnpackedness | |
Eq SpecConstrAnnotation | |
Eq Version | |
Eq Mode | |
Eq Style | |
Eq TextDetails | |
Eq Doc | |
Eq ByteArray | |
Eq ThreadId | |
Eq UnpackedUUID | |
Eq Fixity | |
Eq CClock | |
Eq CDouble | |
Eq CFloat | |
Eq CIntMax | |
Eq CIntPtr | |
Eq CLLong | |
Eq CLong | |
Eq CPtrdiff | |
Eq CSUSeconds | |
Eq CShort | |
Eq CSigAtomic | |
Eq CSize | |
Eq CTime | |
Eq CUInt | |
Eq CUIntMax | |
Eq CUIntPtr | |
Eq CULLong | |
Eq CULong | |
Eq CUSeconds | |
Eq CUShort | |
Eq BigNat | |
Eq SystemTime | |
Eq InvalidPosException | |
Eq Pos | |
Eq SourcePos | |
Eq GeneralCategory | |
Eq ForeignSrcLang | |
Eq Extension | |
Eq AnnLookup | |
Eq AnnTarget | |
Eq Bang | |
Eq Body | |
Eq Bytes | |
Eq Callconv | |
Eq Con | |
Eq DecidedStrictness | |
Eq DerivClause | |
Eq DerivStrategy | |
Eq FamilyResultSig | |
Eq Fixity | |
Eq FixityDirection | |
Eq Foreign | |
Eq Guard | |
Eq Info | |
Eq Inline | |
Eq Loc | |
Eq ModName | |
Eq Module | |
Eq ModuleInfo | |
Eq NameSpace | |
Eq OccName | |
Eq PatSynArgs | |
Eq PatSynDir | |
Eq Phases | |
Eq PkgName | |
Eq Pragma | |
Eq Range | |
Eq Role | |
Eq RuleBndr | |
Eq RuleMatch | |
Eq Safety | |
Eq SourceStrictness | |
Eq SourceUnpackedness | |
Eq Stmt | |
Eq TyLit | |
Eq TySynEqn | |
Eq TyVarBndr | |
Eq TypeFamilyHead | |
Eq SrcSpanInfo | |
Eq SrcLoc | |
Eq SrcSpan | |
Eq ConstructorInfo | |
Eq DatatypeInfo | |
Eq ShortByteString | |
Eq Fingerprint | |
Eq Unique | |
Eq Boxed | |
Eq Tool | |
Eq ConstructorVariant | |
Eq DatatypeVariant | |
Eq FieldStrictness | |
Eq Strictness | |
Eq Unpackedness | |
Eq Specificity | |
Eq MaskingState | |
Eq Node Source # | |
Eq Attribute Source # | |
Eq AttributeValue Source # | |
Defined in IHP.HtmlSupport.Parser Methods (==) :: AttributeValue -> AttributeValue -> Bool # (/=) :: AttributeValue -> AttributeValue -> Bool # | |
Eq CBool | |
Eq CSChar | |
Eq CUChar | |
Eq CWchar | |
Eq InflectionException | |
Eq SomeWord | |
Eq ExecStatus | |
Eq ResultError | |
Eq ConnectInfo | |
Eq Connection | |
Eq FormatError | |
Eq QueryError | |
Eq SqlError | |
Eq Query | |
Eq Action Source # | Needed for the 'Eq QueryBuilder' instance |
Eq Identifier | |
Eq Null | |
Eq Oid | |
Eq QualifiedIdentifier | |
Eq Value | |
Eq Format | |
Eq JSONPathElement | |
Eq Column | |
Eq Savepoint | |
Eq IP | |
Eq IPv6 | |
Eq IPv4 | |
Eq ShortText | |
Eq AbsoluteTime | |
Eq IPv6Range | |
Eq Bytes | |
Eq IPv4Range | |
Eq B | |
Eq Result | |
Eq ConnStatus | |
Eq Row | |
Eq DotNetTime | |
Defined in Data.Aeson.Types.Internal | |
Eq SumEncoding | |
Defined in Data.Aeson.Types.Internal | |
Eq Cancel | |
Eq CopyInResult | |
Eq FieldCode | |
Eq FlushStatus | |
Eq LoFd | |
Eq PollingStatus | |
Eq TransactionStatus | |
Eq Verbosity | |
Eq ArithException | |
Eq ErrorCall | |
Eq Point Source # | |
Eq BlockReason | |
Eq ThreadStatus | |
Eq MetaBag Source # | |
Eq ExitCode | |
Eq ArrayException | |
Eq AsyncException | |
Eq Newline | |
Eq NewlineMode | |
Eq Notification | |
Eq AsyncCancelled | |
Eq AddrInfo | |
Eq AddrInfoFlag | |
Eq NameInfoFlag | |
Eq Family | |
Eq PortNumber | |
Eq SockAddr | |
Eq Socket | |
Eq SocketType | |
Eq CmdSpec | |
Eq CreateProcess | |
Eq StdStream | |
Eq IODeviceType | |
Eq Environment Source # | |
Defined in IHP.Environment | |
Eq Salt | |
Eq Encoding | |
Eq String | |
Eq ASCII7_Invalid | |
Eq ISO_8859_1_Invalid | |
Eq UTF16_Invalid | |
Eq UTF32_Invalid | |
Eq FileSize | |
Eq InvalidActionArgumentException Source # | |
Defined in IHP.Router.Types | |
Eq Migration Source # | |
Eq ValidatorResult Source # | |
Defined in IHP.ValidationSupport.Types Methods (==) :: ValidatorResult -> ValidatorResult -> Bool # (/=) :: ValidatorResult -> ValidatorResult -> Bool # | |
Eq DoPa | |
Eq Action | |
Eq OP | |
Eq QT | |
Eq TagTask | |
Eq TagUpdate | |
Eq WhichTest | |
Eq CodePoint | |
Eq DecoderState | |
Eq Status | |
Eq Unique | |
Eq SameSiteOption | |
Eq SetCookie | |
Eq UnixDiffTime | |
Eq UnixTime | |
Eq RootApplication Source # | |
Defined in IHP.FrameworkConfig Methods (==) :: RootApplication -> RootApplication -> Bool # (/=) :: RootApplication -> RootApplication -> Bool # | |
Eq HttpVersion | |
Eq JobStatus Source # | |
Eq Bound | |
Eq ParamException Source # | |
Defined in IHP.Controller.Param Methods (==) :: ParamException -> ParamException -> Bool # (/=) :: ParamException -> ParamException -> Bool # | |
Eq EscapeItem | |
Eq ByteRange | |
Eq StdMethod | |
Eq URI | |
Eq URIAuth | |
Eq CondensePolicy | |
Eq DelimPolicy | |
Eq EndPolicy | |
Eq Address | |
Eq Boundary | |
Eq Disposition | |
Eq Encoding | |
Eq Part | |
Eq PartContent | |
Eq QPC | |
Eq Event | |
Eq SMTPConnection | |
Eq AuthType | |
Eq Cookie | |
Eq CookieJar | |
Eq Proxy | |
Eq ResponseTimeout | |
Eq StreamFileStatus | |
Eq DigestAuthExceptionDetails | |
Eq ResponseClose | |
Eq SharedSecret | |
Eq CryptoError | |
Eq ConnHost | |
Eq ConnKey | |
Eq StatusHeaders | |
Eq CompressionLevel | |
Eq CompressionStrategy | |
Eq DictionaryHash | |
Eq Format | |
Eq MemoryLevel | |
Eq Method | |
Eq WindowBits | |
Eq Content | |
Eq Doctype | |
Eq Document | |
Eq Element | |
Eq ExternalID | |
Eq Instruction | |
Eq Miscellaneous | |
Eq Name | |
Eq Node | |
Eq Prologue | |
Eq MediaType | |
Eq CompressionOptions | |
Eq PermessageDeflate | |
Eq SizeLimit | |
Eq ConnectionException | |
Eq ControlMessage | |
Eq DataMessage | |
Eq Message | |
Eq Clock | |
Eq TimeSpec | |
Eq ConnectionType | |
Eq InvalidRequest | |
Eq FileMeta | |
Eq Key | |
Eq IV | |
Eq IP | |
Eq IPv4 | |
Eq IPv6 | |
Eq IPRange | |
Eq WelcomeController Source # | |
Defined in IHP.Welcome.Controller Methods (==) :: WelcomeController -> WelcomeController -> Bool # (/=) :: WelcomeController -> WelcomeController -> Bool # | |
Eq AWSAuthVersion | |
Eq Auth | |
Eq Link | |
Eq RSAError | |
Eq TelemetryInfo Source # | |
Defined in IHP.Telemetry Methods (==) :: TelemetryInfo -> TelemetryInfo -> Bool # (/=) :: TelemetryInfo -> TelemetryInfo -> Bool # | |
Eq a => Eq [a] | |
Eq a => Eq (Maybe a) | |
Eq a => Eq (Ratio a) | |
Eq (Ptr a) | |
Eq (FunPtr a) | |
Eq p => Eq (Par1 p) | |
Eq (Async a) | |
Eq (Chan a) | |
Eq a => Eq (Identity a) | |
Eq a => Eq (Down a) | |
Eq m => Eq (WrappedMonoid m) | |
Defined in Data.Semigroup Methods (==) :: WrappedMonoid m -> WrappedMonoid m -> Bool # (/=) :: WrappedMonoid m -> WrappedMonoid m -> Bool # | |
Eq (TVar a) | |
Eq (IORef a) | |
Eq (MVar a) | |
Eq a => Eq (IntMap a) | |
Eq a => Eq (Seq a) | |
Eq a => Eq (Set a) | |
Eq a => Eq (DList a) | |
Eq mono => Eq (NonNull mono) | |
Eq (TBQueue a) | |
Eq (TChan a) | |
Eq (TMVar a) | |
Eq (TQueue a) | |
Eq a => Eq (HashSet a) | |
Eq a => Eq (Vector a) | |
(Storable a, Eq a) => Eq (Vector a) | |
Eq a => Eq (NonEmpty a) | |
Eq (ForeignPtr a) | |
Eq a => Eq (Tree a) | |
Eq a => Eq (Option a) | |
(Prim a, Eq a) => Eq (Vector a) | |
Eq a => Eq (Complex a) | |
Eq a => Eq (Dual a) | |
Eq a => Eq (Product a) | |
Eq a => Eq (Sum a) | |
Eq a => Eq (ZipList a) | |
Eq a => Eq (First a) | |
Eq a => Eq (ViewL a) | |
Eq a => Eq (ViewR a) | |
Eq (MutableByteArray s) | |
Eq a => Eq (AnnotDetails a) | |
Eq (Doc a) | |
Eq a => Eq (Span a) | |
(Eq a, Prim a) => Eq (PrimArray a) | |
Eq a => Eq (SmallArray a) | |
Eq a => Eq (Array a) | |
Eq a => Eq (First a) | |
Eq a => Eq (Last a) | |
Eq a => Eq (Max a) | |
Eq a => Eq (Min a) | |
Eq a => Eq (Last a) | |
Eq e => Eq (ErrorFancy e) | |
Eq t => Eq (ErrorItem t) | |
Eq s => Eq (PosState s) | |
Eq a => Eq (ListOf a) | |
Eq l => Eq (ModuleHeadAndImports l) | |
Eq a => Eq (NonGreedy a) | |
Eq l => Eq (PragmasAndModuleHead l) | |
Eq l => Eq (PragmasAndModuleName l) | |
Eq l => Eq (ModulePragma l) | |
Eq l => Eq (ModuleHead l) | |
Eq l => Eq (ImportDecl l) | |
Eq l => Eq (ModuleName l) | |
Eq l => Eq (Decl l) | |
Eq l => Eq (Exp l) | |
Eq l => Eq (Module l) | |
Eq l => Eq (Pat l) | |
Eq l => Eq (Stmt l) | |
Eq l => Eq (Type l) | |
Eq a => Eq (Loc a) | |
Eq a => Eq (Hashed a) | |
Eq (StableName a) | |
Eq l => Eq (Activation l) | |
Eq l => Eq (Alt l) | |
Eq l => Eq (Annotation l) | |
Eq l => Eq (Assoc l) | |
Eq l => Eq (Asst l) | |
Eq l => Eq (BangType l) | |
Eq l => Eq (Binds l) | |
Eq l => Eq (BooleanFormula l) | |
Eq l => Eq (Bracket l) | |
Eq l => Eq (CName l) | |
Eq l => Eq (CallConv l) | |
Eq l => Eq (ClassDecl l) | |
Eq l => Eq (ConDecl l) | |
Eq l => Eq (Context l) | |
Eq l => Eq (DataOrNew l) | |
Eq l => Eq (DeclHead l) | |
Eq l => Eq (DerivStrategy l) | |
Eq l => Eq (Deriving l) | |
Eq l => Eq (EWildcard l) | |
Eq l => Eq (ExportSpec l) | |
Eq l => Eq (ExportSpecList l) | |
Eq l => Eq (FieldDecl l) | |
Eq l => Eq (FieldUpdate l) | |
Eq l => Eq (FunDep l) | |
Eq l => Eq (GadtDecl l) | |
Eq l => Eq (GuardedRhs l) | |
Eq l => Eq (IPBind l) | |
Eq l => Eq (IPName l) | |
Eq l => Eq (ImportSpec l) | |
Eq l => Eq (ImportSpecList l) | |
Eq l => Eq (InjectivityInfo l) | |
Eq l => Eq (InstDecl l) | |
Eq l => Eq (InstHead l) | |
Eq l => Eq (InstRule l) | |
Eq l => Eq (Literal l) | |
Eq l => Eq (Match l) | |
Eq l => Eq (MaybePromotedName l) | |
Eq l => Eq (Name l) | |
Eq l => Eq (Namespace l) | |
Eq l => Eq (Op l) | |
Eq l => Eq (Overlap l) | |
Eq l => Eq (PXAttr l) | |
Eq l => Eq (PatField l) | |
Eq l => Eq (PatternSynDirection l) | |
Eq l => Eq (Promoted l) | |
Eq l => Eq (QName l) | |
Eq l => Eq (QOp l) | |
Eq l => Eq (QualConDecl l) | |
Eq l => Eq (QualStmt l) | |
Eq l => Eq (RPat l) | |
Eq l => Eq (RPatOp l) | |
Eq l => Eq (ResultSig l) | |
Eq l => Eq (Rhs l) | |
Eq l => Eq (Role l) | |
Eq l => Eq (Rule l) | |
Eq l => Eq (RuleVar l) | |
Eq l => Eq (Safety l) | |
Eq l => Eq (Sign l) | |
Eq l => Eq (SpecialCon l) | |
Eq l => Eq (Splice l) | |
Eq l => Eq (TyVarBind l) | |
Eq l => Eq (TypeEqn l) | |
Eq l => Eq (Unpackedness l) | |
Eq l => Eq (WarningText l) | |
Eq l => Eq (XAttr l) | |
Eq l => Eq (XName l) | |
Eq (Word t) | |
Eq a => Eq (Only a) | |
Eq a => Eq (Binary a) | |
Eq a => Eq (In a) | |
Eq s => Eq (CI s) | |
Eq a => Eq (PGArray a) | |
Eq a => Eq (Values a) | |
Eq a => Eq (Unbounded a) | |
Eq a => Eq (Ok a) | |
Eq a => Eq (IResult a) | |
(Eq a, PrimUnlifted a) => Eq (UnliftedArray a) | |
Eq a => Eq (Result a) | |
Eq1 f => Eq (Fix f) | |
(Functor f, Eq1 f) => Eq (Mu f) | |
(Functor f, Eq1 f) => Eq (Nu f) | |
Eq a => Eq (Maybe a) | |
Eq (Encoding' a) | |
Eq valueType => Eq (FieldWithDefault valueType) Source # | |
Defined in IHP.ModelSupport Methods (==) :: FieldWithDefault valueType -> FieldWithDefault valueType -> Bool # (/=) :: FieldWithDefault valueType -> FieldWithDefault valueType -> Bool # | |
Eq (PrimaryKey table) => Eq (Id' table) Source # | |
Eq (Digest a) | |
(PrimType ty, Eq ty) => Eq (UArray ty) | |
Eq (Offset ty) | |
Eq (CountOf ty) | |
(PrimType ty, Eq ty) => Eq (Block ty) | |
Eq a => Eq (NonEmpty a) | |
Eq (Zn n) | |
Eq (Zn64 n) | |
Eq (QueryBuilder table) Source # | |
Defined in IHP.QueryBuilder Methods (==) :: QueryBuilder table -> QueryBuilder table -> Bool # (/=) :: QueryBuilder table -> QueryBuilder table -> Bool # | |
Eq a => Eq (AlphaColour a) | |
Eq a => Eq (Colour a) | |
Eq c => Eq (FileInfo c) | |
Eq a => Eq (Chunk a) | |
Eq body => Eq (Response body) | |
Eq a => Eq (CryptoFailable a) | |
Eq a => Eq (Flush a) | |
Eq a => Eq (AddrRange a) | |
(TypeError (('Text "Looks like you forgot to pass a " :<>: 'ShowType (GetModelByTableName record)) :<>: 'Text " id to this data constructor.") :: Constraint) => Eq (Id' record -> controller) Source # | |
(Eq a, Eq b) => Eq (Either a b) | |
Eq (V1 p) | |
Eq (U1 p) | |
Eq (TypeRep a) | |
(Eq a, Eq b) => Eq (a, b) | |
Eq (STRef s a) | |
(Eq k, Eq a) => Eq (Map k a) | |
Eq (MutVar s a) | |
(Eq k, Eq v) => Eq (HashMap k v) | |
Eq (Proxy s) | |
Eq a => Eq (Arg a b) | |
(Eq1 f, Eq a) => Eq (Cofree f a) | |
(Eq1 f, Eq a) => Eq (Free f a) | |
(Eq k, Eq v) => Eq (Leaf k v) | |
(Eq1 m, Eq a) => Eq (ListT m a) | |
(Eq1 m, Eq a) => Eq (MaybeT m a) | |
Eq (MutableArray s a) | |
Eq (MutablePrimArray s a) | |
Eq (SmallMutableArray s a) | |
(Eq (Token s), Eq e) => Eq (ParseError s e) | |
(Eq s, Eq (Token s), Eq e) => Eq (ParseErrorBundle s e) | |
(Eq (ParseError s e), Eq s) => Eq (State s e) | |
Eq (Fixed a) | |
(Eq h, Eq t) => Eq (h :. t) | |
Eq (MutableUnliftedArray s a) | |
(Eq a, Eq b) => Eq (Either a b) | |
(Eq a, Eq b) => Eq (These a b) | |
(Eq a, Eq b) => Eq (These a b) | |
(Eq a, Eq b) => Eq (Pair a b) | |
(forall (a :: k). Typeable a => Eq (f a)) => Eq (TypeRepMap f) | |
(Eq1 f, Eq a) => Eq (Yoneda f a) | |
Eq (f p) => Eq (Rec1 f p) | |
Eq (URec (Ptr ()) p) | |
Eq (URec Char p) | |
Eq (URec Double p) | |
Eq (URec Float p) | |
Eq (URec Int p) | |
Eq (URec Word p) | |
(Eq a, Eq b, Eq c) => Eq (a, b, c) | |
Eq (a :~: b) | |
(Eq1 f, Eq a) => Eq (IdentityT f a) | |
Eq a => Eq (Const a b) | |
(Eq e, Eq1 m, Eq a) => Eq (ErrorT e m a) | |
Eq b => Eq (Tagged s b) | |
Eq (p a a) => Eq (Join p a) | |
(Eq1 f, Eq1 m, Eq a) => Eq (FreeT f m a) | |
(Eq a, Eq (f b)) => Eq (FreeF f a b) | |
(Eq w, Eq1 m, Eq a) => Eq (WriterT w m a) | |
(Eq w, Eq1 m, Eq a) => Eq (WriterT w m a) | |
Eq (f a) => Eq (Alt f a) | |
Eq (f a) => Eq (Ap f a) | |
(Eq1 f, Eq1 g, Eq a) => Eq (These1 f g a) | |
Eq value => Eq (FieldWithUpdate name value) Source # | |
Defined in IHP.ModelSupport Methods (==) :: FieldWithUpdate name value -> FieldWithUpdate name value -> Bool # (/=) :: FieldWithUpdate name value -> FieldWithUpdate name value -> Bool # | |
Eq (p (Fix p a) a) => Eq (Fix p a) | |
(Eq a, Eq (f b)) => Eq (CofreeF f a b) | |
Eq (w (CofreeF f a (CofreeT f w a))) => Eq (CofreeT f w a) | |
Eq c => Eq (K1 i c p) | |
(Eq (f p), Eq (g p)) => Eq ((f :+: g) p) | |
(Eq (f p), Eq (g p)) => Eq ((f :*: g) p) | |
(Eq a, Eq b, Eq c, Eq d) => Eq (a, b, c, d) | |
(Eq1 f, Eq1 g, Eq a) => Eq (Product f g a) | |
(Eq1 f, Eq1 g, Eq a) => Eq (Sum f g a) | |
Eq (a :~~: b) | |
Eq (f p) => Eq (M1 i c f p) | |
Eq (f (g p)) => Eq ((f :.: g) p) | |
(Eq a, Eq b, Eq c, Eq d, Eq e) => Eq (a, b, c, d, e) | |
(Eq1 f, Eq1 g, Eq a) => Eq (Compose f g a) | |
Eq (f a) => Eq (Clown f a b) | |
Eq (p b a) => Eq (Flip p a b) | |
Eq (g b) => Eq (Joker g a b) | |
Eq (p a b) => Eq (WrappedBifunctor p a b) | |
(Eq a, Eq b, Eq c, Eq d, Eq e, Eq f) => Eq (a, b, c, d, e, f) | |
(Eq (f a b), Eq (g a b)) => Eq (Product f g a b) | |
(Eq (p a b), Eq (q a b)) => Eq (Sum p q a b) | |
(Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g) => Eq (a, b, c, d, e, f, g) | |
Eq (f (p a b)) => Eq (Tannen f p a b) | |
(Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g, Eq h) => Eq (a, b, c, d, e, f, g, h) | |
(Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g, Eq h, Eq i) => Eq (a, b, c, d, e, f, g, h, i) | |
Eq (p (f a) (g b)) => Eq (Biff p f g a b) | |
(Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g, Eq h, Eq i, Eq j) => Eq (a, b, c, d, e, f, g, h, i, j) | |
(Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g, Eq h, Eq i, Eq j, Eq k) => Eq (a, b, c, d, e, f, g, h, i, j, k) | |
(Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g, Eq h, Eq i, Eq j, Eq k, Eq l) => Eq (a, b, c, d, e, f, g, h, i, j, k, l) | |
(Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g, Eq h, Eq i, Eq j, Eq k, Eq l, Eq m) => Eq (a, b, c, d, e, f, g, h, i, j, k, l, m) | |
(Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g, Eq h, Eq i, Eq j, Eq k, Eq l, Eq m, Eq n) => Eq (a, b, c, d, e, f, g, h, i, j, k, l, m, n) | |
(Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g, Eq h, Eq i, Eq j, Eq k, Eq l, Eq m, Eq n, Eq o) => Eq (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) | |
class Fractional a => Floating a where #
Minimal complete definition
pi, exp, log, sin, cos, asin, acos, atan, sinh, cosh, asinh, acosh, atanh
Methods
Instances
Floating Double | |
Floating Float | |
Floating CDouble | |
Floating CFloat | |
Floating a => Floating (Identity a) | |
Defined in Data.Functor.Identity Methods exp :: Identity a -> Identity a # log :: Identity a -> Identity a # sqrt :: Identity a -> Identity a # (**) :: Identity a -> Identity a -> Identity a # logBase :: Identity a -> Identity a -> Identity a # sin :: Identity a -> Identity a # cos :: Identity a -> Identity a # tan :: Identity a -> Identity a # asin :: Identity a -> Identity a # acos :: Identity a -> Identity a # atan :: Identity a -> Identity a # sinh :: Identity a -> Identity a # cosh :: Identity a -> Identity a # tanh :: Identity a -> Identity a # asinh :: Identity a -> Identity a # acosh :: Identity a -> Identity a # atanh :: Identity a -> Identity a # log1p :: Identity a -> Identity a expm1 :: Identity a -> Identity a | |
Floating a => Floating (Down a) | |
RealFloat a => Floating (Complex a) | |
Defined in Data.Complex Methods exp :: Complex a -> Complex a # log :: Complex a -> Complex a # sqrt :: Complex a -> Complex a # (**) :: Complex a -> Complex a -> Complex a # logBase :: Complex a -> Complex a -> Complex a # sin :: Complex a -> Complex a # cos :: Complex a -> Complex a # tan :: Complex a -> Complex a # asin :: Complex a -> Complex a # acos :: Complex a -> Complex a # atan :: Complex a -> Complex a # sinh :: Complex a -> Complex a # cosh :: Complex a -> Complex a # tanh :: Complex a -> Complex a # asinh :: Complex a -> Complex a # acosh :: Complex a -> Complex a # atanh :: Complex a -> Complex a # log1p :: Complex a -> Complex a expm1 :: Complex a -> Complex a log1pexp :: Complex a -> Complex a log1mexp :: Complex a -> Complex a | |
Floating a => Floating (Const a b) | |
Defined in Data.Functor.Const Methods exp :: Const a b -> Const a b # log :: Const a b -> Const a b # sqrt :: Const a b -> Const a b # (**) :: Const a b -> Const a b -> Const a b # logBase :: Const a b -> Const a b -> Const a b # sin :: Const a b -> Const a b # cos :: Const a b -> Const a b # tan :: Const a b -> Const a b # asin :: Const a b -> Const a b # acos :: Const a b -> Const a b # atan :: Const a b -> Const a b # sinh :: Const a b -> Const a b # cosh :: Const a b -> Const a b # tanh :: Const a b -> Const a b # asinh :: Const a b -> Const a b # acosh :: Const a b -> Const a b # atanh :: Const a b -> Const a b # log1p :: Const a b -> Const a b expm1 :: Const a b -> Const a b log1pexp :: Const a b -> Const a b log1mexp :: Const a b -> Const a b | |
Floating a => Floating (Tagged s a) | |
Defined in Data.Tagged Methods exp :: Tagged s a -> Tagged s a # log :: Tagged s a -> Tagged s a # sqrt :: Tagged s a -> Tagged s a # (**) :: Tagged s a -> Tagged s a -> Tagged s a # logBase :: Tagged s a -> Tagged s a -> Tagged s a # sin :: Tagged s a -> Tagged s a # cos :: Tagged s a -> Tagged s a # tan :: Tagged s a -> Tagged s a # asin :: Tagged s a -> Tagged s a # acos :: Tagged s a -> Tagged s a # atan :: Tagged s a -> Tagged s a # sinh :: Tagged s a -> Tagged s a # cosh :: Tagged s a -> Tagged s a # tanh :: Tagged s a -> Tagged s a # asinh :: Tagged s a -> Tagged s a # acosh :: Tagged s a -> Tagged s a # atanh :: Tagged s a -> Tagged s a # log1p :: Tagged s a -> Tagged s a expm1 :: Tagged s a -> Tagged s a log1pexp :: Tagged s a -> Tagged s a log1mexp :: Tagged s a -> Tagged s a |
class Num a => Fractional a where #
Minimal complete definition
fromRational, (recip | (/))
Instances
Fractional DiffTime | |
Fractional NominalDiffTime | |
Defined in Data.Time.Clock.Internal.NominalDiffTime Methods (/) :: NominalDiffTime -> NominalDiffTime -> NominalDiffTime # recip :: NominalDiffTime -> NominalDiffTime # fromRational :: Rational -> NominalDiffTime # | |
Fractional Number | |
Defined in Data.Attoparsec.Number | |
Fractional Scientific | |
Defined in Data.Scientific | |
Fractional CDouble | |
Defined in Foreign.C.Types | |
Fractional CFloat | |
Defined in Foreign.C.Types | |
Integral a => Fractional (Ratio a) | |
Fractional a => Fractional (Identity a) | |
Fractional a => Fractional (Down a) | |
RealFloat a => Fractional (Complex a) | |
Defined in Data.Complex | |
HasResolution a => Fractional (Fixed a) | |
Defined in Data.Fixed | |
Fractional a => Fractional (Const a b) | |
Defined in Data.Functor.Const |