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