-- Hoogle documentation, generated by Haddock
-- See Hoogle, http://www.haskell.org/hoogle/
-- | Liquid Types for Haskell
--
-- Liquid Types for Haskell.
@package liquidhaskell
@version 0.9.10.1
module Data.Bits_LHAssumptions
module Data.Tuple_LHAssumptions
module Foreign.Ptr_LHAssumptions
module GHC.Int_LHAssumptions
module Foreign.C.Types_LHAssumptions
module GHC.Internal.Float_LHAssumptions
-- | Trigonometric and hyperbolic functions and related functions.
--
-- The Haskell Report defines no laws for Floating. However,
-- (+), (*) and exp are
-- customarily expected to define an exponential field and have the
-- following properties:
--
--
-- - exp (a + b) = exp a * exp b
-- - exp (fromInteger 0) = fromInteger 1
--
class Fractional a => Floating a
pi :: Floating a => a
exp :: Floating a => a -> a
log :: Floating a => a -> a
sqrt :: Floating a => a -> a
(**) :: Floating a => a -> a -> a
logBase :: Floating a => a -> a -> a
sin :: Floating a => a -> a
cos :: Floating a => a -> a
tan :: Floating a => a -> a
asin :: Floating a => a -> a
acos :: Floating a => a -> a
atan :: Floating a => a -> a
sinh :: Floating a => a -> a
cosh :: Floating a => a -> a
tanh :: Floating a => a -> a
asinh :: Floating a => a -> a
acosh :: Floating a => a -> a
atanh :: Floating a => a -> a
infixr 8 **
module GHC.Float_LHAssumptions
module GHC.Internal.Int_LHAssumptions
module GHC.Internal.Word_LHAssumptions
module Data.Word_LHAssumptions
module GHC.Maybe_LHAssumptions
module GHC.Types_LHAssumptions
module GHC.Real_LHAssumptions
-- | Integral numbers, supporting integer division.
--
-- The Haskell Report defines no laws for Integral. However,
-- Integral instances are customarily expected to define a
-- Euclidean domain and have the following properties for the
-- div/mod and quot/rem pairs, given suitable
-- Euclidean functions f and g:
--
--
-- - x = y * quot x y + rem x y with rem x y
-- = fromInteger 0 or g (rem x y) < g
-- y
-- - x = y * div x y + mod x y with mod x y
-- = fromInteger 0 or f (mod x y) < f
-- y
--
--
-- An example of a suitable Euclidean function, for Integer's
-- instance, is abs.
--
-- In addition, toInteger should be total, and
-- fromInteger should be a left inverse for it, i.e.
-- fromInteger (toInteger i) = i.
class (Real a, Enum a) => Integral a
-- | Integer division truncated toward zero.
--
-- WARNING: This function is partial (because it throws when 0 is passed
-- as the divisor) for all the integer types in base.
quot :: Integral a => a -> a -> a
-- | Integer remainder, satisfying
--
--
-- (x `quot` y)*y + (x `rem` y) == x
--
--
-- WARNING: This function is partial (because it throws when 0 is passed
-- as the divisor) for all the integer types in base.
rem :: Integral a => a -> a -> a
-- | Integer division truncated toward negative infinity.
--
-- WARNING: This function is partial (because it throws when 0 is passed
-- as the divisor) for all the integer types in base.
div :: Integral a => a -> a -> a
-- | Integer modulus, satisfying
--
--
-- (x `div` y)*y + (x `mod` y) == x
--
--
-- WARNING: This function is partial (because it throws when 0 is passed
-- as the divisor) for all the integer types in base.
mod :: Integral a => a -> a -> a
-- | Simultaneous quot and rem.
--
-- WARNING: This function is partial (because it throws when 0 is passed
-- as the divisor) for all the integer types in base.
quotRem :: Integral a => a -> a -> (a, a)
-- | simultaneous div and mod.
--
-- WARNING: This function is partial (because it throws when 0 is passed
-- as the divisor) for all the integer types in base.
divMod :: Integral a => a -> a -> (a, a)
-- | Conversion to Integer.
toInteger :: Integral a => a -> Integer
infixl 7 `div`
infixl 7 `mod`
infixl 7 `quot`
infixl 7 `rem`
-- | Fractional numbers, supporting real division.
--
-- The Haskell Report defines no laws for Fractional. However,
-- (+) and (*) are customarily expected
-- to define a division ring and have the following properties:
--
--
--
-- Note that it isn't customarily expected that a type instance of
-- Fractional implement a field. However, all instances in
-- base do.
class Num a => Fractional a
-- | Fractional division.
(/) :: Fractional a => a -> a -> a
-- | Reciprocal fraction.
recip :: Fractional a => a -> a
-- | Conversion from a Rational (that is Ratio
-- Integer). A floating literal stands for an application of
-- fromRational to a value of type Rational, so such
-- literals have type (Fractional a) => a.
fromRational :: Fractional a => Rational -> a
infixl 7 /
module GHC.Ptr_LHAssumptions
module GHC.ForeignPtr_LHAssumptions
module Foreign.Concurrent_LHAssumptions
module Foreign.ForeignPtr_LHAssumptions
module Foreign.Storable_LHAssumptions
module GHC.Num.Integer_LHAssumptions
module GHC.Internal.Num_LHAssumptions
module GHC.Num_LHAssumptions
module GHC.Internal.List_LHAssumptions
module GHC.List_LHAssumptions
module GHC.Internal.Data.Maybe_LHAssumptions
module Data.Maybe_LHAssumptions
module GHC.Internal.Data.Foldable_LHAssumptions
module Data.Foldable_LHAssumptions
module GHC.IO.Handle_LHAssumptions
module GHC.Exts_LHAssumptions
module GHC.Classes_LHAssumptions
module GHC.CString_LHAssumptions
module GHC.Internal.Base_LHAssumptions
module GHC.Base_LHAssumptions
module Foreign.Marshal.Alloc_LHAssumptions
module Foreign.C.String_LHAssumptions
module Data.String_LHAssumptions
module Data.ByteString_LHAssumptions
module Data.ByteString.Char8_LHAssumptions
module Data.ByteString.Short_LHAssumptions
module Data.ByteString.Lazy_LHAssumptions
module Data.ByteString.Lazy.Char8_LHAssumptions
module Data.Set_LHAssumptions
module Data.Either_LHAssumptions
module Data.ByteString.Unsafe_LHAssumptions
module GHC.Word_LHAssumptions
module Liquid.Prelude.Real_LHAssumptions
module Liquid.Prelude.Totality_LHAssumptions
module LiquidHaskell
plugin :: Plugin
lq :: QuasiQuoter
module Prelude_LHAssumptions