| Copyright | (C) 2013-2016 University of Twente 2017 Myrtle Software Ltd Google Inc. |
|---|---|
| License | BSD2 (see the file LICENSE) |
| Maintainer | Christiaan Baaij <christiaan.baaij@gmail.com> |
| Safe Haskell | Safe |
| Language | Haskell2010 |
| Extensions |
|
Clash.Prelude.Safe
Contents
Description
This is the Safe API only of Clash.Prelude
CλaSH (pronounced ‘clash’) is a functional hardware description language that borrows both its syntax and semantics from the functional programming language Haskell. The merits of using a functional language to describe hardware comes from the fact that combinational circuits can be directly modeled as mathematical functions and that functional languages lend themselves very well at describing and (de-)composing mathematical functions.
This package provides:
- Prelude library containing datatypes and functions for circuit design
To use the library:
- Import Clash.Prelude
- Additionally import Clash.Explicit.Prelude if you want to design explicitly clocked circuits in a multi-clock setting
For now, Clash.Prelude is also the best starting point for exploring the library. A preliminary version of a tutorial can be found in Clash.Tutorial. Some circuit examples can be found in Clash.Examples.
Synopsis
- mealy :: HiddenClockReset domain gated synchronous => (s -> i -> (s, o)) -> s -> Signal domain i -> Signal domain o
- mealyB :: (Bundle i, Bundle o, HiddenClockReset domain gated synchronous) => (s -> i -> (s, o)) -> s -> Unbundled domain i -> Unbundled domain o
- (<^>) :: (Bundle i, Bundle o, HiddenClockReset domain gated synchronous) => (s -> i -> (s, o)) -> s -> Unbundled domain i -> Unbundled domain o
- moore :: HiddenClockReset domain gated synchronous => (s -> i -> s) -> (s -> o) -> s -> Signal domain i -> Signal domain o
- mooreB :: (Bundle i, Bundle o, HiddenClockReset domain gated synchronous) => (s -> i -> s) -> (s -> o) -> s -> Unbundled domain i -> Unbundled domain o
- registerB :: (HiddenClockReset domain gated synchronous, Bundle a) => a -> Unbundled domain a -> Unbundled domain a
- asyncRom :: (KnownNat n, Enum addr) => Vec n a -> addr -> a
- asyncRomPow2 :: KnownNat n => Vec (2 ^ n) a -> Unsigned n -> a
- rom :: (KnownNat n, KnownNat m, HiddenClock domain gated) => Vec n a -> Signal domain (Unsigned m) -> Signal domain a
- romPow2 :: (KnownNat n, HiddenClock domain gated) => Vec (2 ^ n) a -> Signal domain (Unsigned n) -> Signal domain a
- asyncRam :: (Enum addr, HiddenClock domain gated, HasCallStack) => SNat n -> Signal domain addr -> Signal domain (Maybe (addr, a)) -> Signal domain a
- asyncRamPow2 :: (KnownNat n, HiddenClock domain gated, HasCallStack) => Signal domain (Unsigned n) -> Signal domain (Maybe (Unsigned n, a)) -> Signal domain a
- blockRam :: (Enum addr, HiddenClock domain gated, HasCallStack) => Vec n a -> Signal domain addr -> Signal domain (Maybe (addr, a)) -> Signal domain a
- blockRamPow2 :: (KnownNat n, HiddenClock domain gated, HasCallStack) => Vec (2 ^ n) a -> Signal domain (Unsigned n) -> Signal domain (Maybe (Unsigned n, a)) -> Signal domain a
- readNew :: (Eq addr, HiddenClockReset domain gated synchronous) => (Signal domain addr -> Signal domain (Maybe (addr, a)) -> Signal domain a) -> Signal domain addr -> Signal domain (Maybe (addr, a)) -> Signal domain a
- isRising :: (HiddenClockReset domain gated synchronous, Bounded a, Eq a) => a -> Signal domain a -> Signal domain Bool
- isFalling :: (HiddenClockReset domain gated synchronous, Bounded a, Eq a) => a -> Signal domain a -> Signal domain Bool
- riseEvery :: HiddenClockReset domain gated synchronous => SNat n -> Signal domain Bool
- oscillate :: HiddenClockReset domain gated synchronous => Bool -> SNat n -> Signal domain Bool
- module Clash.Signal
- module Clash.Signal.Delayed
- module Clash.Prelude.DataFlow
- module Clash.Sized.BitVector
- module Clash.Prelude.BitIndex
- module Clash.Prelude.BitReduction
- module Clash.Sized.Signed
- module Clash.Sized.Unsigned
- module Clash.Sized.Index
- module Clash.Sized.Fixed
- module Clash.Sized.Vector
- module Clash.Sized.RTree
- module Clash.Annotations.TopEntity
- module GHC.TypeLits
- module Clash.Promoted.Nat
- module Clash.Promoted.Nat.Literals
- module Clash.Promoted.Nat.TH
- module Clash.Promoted.Symbol
- module Clash.Class.BitPack
- module Clash.Class.Num
- module Clash.Class.Resize
- module Control.Applicative
- module Data.Bits
- module Clash.XException
- undefined :: HasCallStack => a
- module Clash.NamedTypes
- module Clash.Hidden
- seq :: a -> b -> b
- filter :: (a -> Bool) -> [a] -> [a]
- print :: Show a => a -> IO ()
- fst :: (a, b) -> a
- snd :: (a, b) -> b
- otherwise :: Bool
- ($) :: (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
- class Eq a where
- class Fractional a => Floating a where
- class Num a => Fractional a where
- class (Real a, Enum a) => Integral a where
- class Applicative m => Monad (m :: * -> *) where
- class Functor (f :: * -> *) where
- class Num a where
- class Eq a => Ord a where
- class Read a where
- class (Num a, Ord a) => Real a where
- class (RealFrac a, Floating a) => RealFloat a where
- class (Real a, Fractional a) => RealFrac a where
- class Show a where
- class Functor f => Applicative (f :: * -> *) where
- class Foldable (t :: * -> *) where
- class (Functor t, Foldable t) => Traversable (t :: * -> *) where
- class Semigroup a where
- class Semigroup a => Monoid a where
- data Bool
- data Char
- data Double
- data Float
- data Int
- data Integer
- data Maybe a
- data Ordering
- type Rational = Ratio Integer
- data IO a
- data Word
- data Either a b
- readIO :: Read a => String -> IO a
- readLn :: Read a => IO a
- appendFile :: FilePath -> String -> IO ()
- writeFile :: FilePath -> String -> IO ()
- readFile :: FilePath -> IO String
- interact :: (String -> String) -> IO ()
- getContents :: IO String
- getLine :: IO String
- getChar :: IO Char
- putStrLn :: String -> IO ()
- putStr :: String -> IO ()
- putChar :: Char -> IO ()
- ioError :: IOError -> IO a
- type FilePath = String
- userError :: String -> IOError
- type IOError = IOException
- notElem :: (Foldable t, Eq a) => a -> t a -> Bool
- all :: Foldable t => (a -> Bool) -> t a -> Bool
- any :: Foldable t => (a -> Bool) -> t a -> Bool
- or :: Foldable t => t Bool -> Bool
- and :: Foldable t => t Bool -> Bool
- concatMap :: Foldable t => (a -> [b]) -> t a -> [b]
- sequence_ :: (Foldable t, Monad m) => t (m a) -> m ()
- mapM_ :: (Foldable t, Monad m) => (a -> m b) -> t a -> m ()
- unwords :: [String] -> String
- words :: String -> [String]
- unlines :: [String] -> String
- lines :: String -> [String]
- read :: Read a => String -> a
- reads :: Read a => ReadS a
- either :: (a -> c) -> (b -> c) -> Either a b -> c
- lex :: ReadS String
- readParen :: Bool -> ReadS a -> ReadS a
- type ReadS a = String -> [(a, String)]
- (<$>) :: Functor f => (a -> b) -> f a -> f b
- lcm :: Integral a => a -> a -> a
- gcd :: Integral a => a -> a -> a
- (^^) :: (Fractional a, Integral b) => a -> b -> a
- (^) :: (Num a, Integral b) => a -> b -> a
- odd :: Integral a => a -> Bool
- even :: Integral a => a -> Bool
- showParen :: Bool -> ShowS -> ShowS
- showString :: String -> ShowS
- showChar :: Char -> ShowS
- shows :: Show a => a -> ShowS
- type ShowS = String -> String
- lookup :: Eq a => a -> [(a, b)] -> Maybe b
- break :: (a -> Bool) -> [a] -> ([a], [a])
- span :: (a -> Bool) -> [a] -> ([a], [a])
- dropWhile :: (a -> Bool) -> [a] -> [a]
- takeWhile :: (a -> Bool) -> [a] -> [a]
- cycle :: [a] -> [a]
- scanr1 :: (a -> a -> a) -> [a] -> [a]
- scanl1 :: (a -> a -> a) -> [a] -> [a]
- maybe :: b -> (a -> b) -> Maybe a -> b
- uncurry :: (a -> b -> c) -> (a, b) -> c
- curry :: ((a, b) -> c) -> a -> b -> c
- subtract :: Num a => a -> a -> a
- asTypeOf :: a -> a -> a
- until :: (a -> Bool) -> (a -> a) -> a -> a
- ($!) :: (a -> b) -> a -> b
- flip :: (a -> b -> c) -> b -> a -> c
- (.) :: (b -> c) -> (a -> b) -> a -> c
- const :: a -> b -> a
- id :: a -> a
- (=<<) :: Monad m => (a -> m b) -> m a -> m b
- type String = [Char]
- errorWithoutStackTrace :: [Char] -> a
- error :: HasCallStack => [Char] -> a
- (&&) :: Bool -> Bool -> Bool
- (||) :: Bool -> Bool -> Bool
- not :: Bool -> Bool
Creating synchronous sequential circuits
Arguments
| :: HiddenClockReset domain gated synchronous | |
| => (s -> i -> (s, o)) | Transfer function in mealy machine form:
|
| -> s | Initial state |
| -> Signal domain i -> Signal domain o | Synchronous sequential function with input and output matching that of the mealy machine |
Create a synchronous function from a combinational function describing a mealy machine
macT
:: Int -- Current state
-> (Int,Int) -- Input
-> (Int,Int) -- (Updated state, output)
macT s (x,y) = (s',s)
where
s' = x * y + s
mac :: HiddenClockReset domain gated synchronous => Signal domain (Int, Int) -> Signal domain Int
mac = mealy macT 0
>>>simulate mac [(1,1),(2,2),(3,3),(4,4)][0,1,5,14... ...
Synchronous sequential functions can be composed just like their combinational counterpart:
dualMac :: HiddenClockReset domain gated synchronous => (Signaldomain Int,Signaldomain Int) -> (Signaldomain Int,Signaldomain Int) ->Signaldomain Int dualMac (a,b) (x,y) = s1 + s2 where s1 =mealymac 0 (bundle(a,x)) s2 =mealymac 0 (bundle(b,y))
Arguments
| :: (Bundle i, Bundle o, HiddenClockReset domain gated synchronous) | |
| => (s -> i -> (s, o)) | Transfer function in mealy machine form:
|
| -> s | Initial state |
| -> Unbundled domain i -> Unbundled domain o | Synchronous sequential function with input and output matching that of the mealy machine |
A version of mealy that does automatic Bundleing
Given a function f of type:
f :: Int -> (Bool, Int) -> (Int, (Int, Bool))
When we want to make compositions of f in g using mealy, we have to
write:
g a b c = (b1,b2,i2)
where
(i1,b1) = unbundle (mealy f 0 (bundle (a,b)))
(i2,b2) = unbundle (mealy f 3 (bundle (i1,c)))
Using mealyB however we can write:
g a b c = (b1,b2,i2)
where
(i1,b1) = mealyB f 0 (a,b)
(i2,b2) = mealyB f 3 (i1,c)
Arguments
| :: (Bundle i, Bundle o, HiddenClockReset domain gated synchronous) | |
| => (s -> i -> (s, o)) | Transfer function in mealy machine form:
|
| -> s | Initial state |
| -> Unbundled domain i -> Unbundled domain o | Synchronous sequential function with input and output matching that of the mealy machine |
Infix version of mealyB
Arguments
| :: HiddenClockReset domain gated synchronous | |
| => (s -> i -> s) | Transfer function in moore machine form:
|
| -> (s -> o) | Output function in moore machine form:
|
| -> s | Initial state |
| -> Signal domain i -> Signal domain o | Synchronous sequential function with input and output matching that of the moore machine |
Create a synchronous function from a combinational function describing a moore machine
macT :: Int -- Current state
-> (Int,Int) -- Input
-> Int -- Updated state
macT s (x,y) = x * y + s
mac :: HiddenClockReset domain gated synchronous => Signal domain (Int, Int) -> Signal domain Int
mac = moore mac id 0
>>>simulate mac [(1,1),(2,2),(3,3),(4,4)][0,1,5,14... ...
Synchronous sequential functions can be composed just like their combinational counterpart:
dualMac :: HiddenClockReset domain gated synchronous => (Signaldomain Int,Signaldomain Int) -> (Signaldomain Int,Signaldomain Int) ->Signaldomain Int dualMac (a,b) (x,y) = s1 + s2 where s1 =mooremac id 0 (bundle(a,x)) s2 =mooremac id 0 (bundle(b,y))
Arguments
| :: (Bundle i, Bundle o, HiddenClockReset domain gated synchronous) | |
| => (s -> i -> s) | Transfer function in moore machine form:
|
| -> (s -> o) | Output function in moore machine form:
|
| -> s | Initial state |
| -> Unbundled domain i -> Unbundled domain o | Synchronous sequential function with input and output matching that of the moore machine |
A version of moore that does automatic Bundleing
Given a functions t and o of types:
t :: Int -> (Bool, Int) -> Int o :: Int -> (Int, Bool)
When we want to make compositions of t and o in g using moore, we have to
write:
g a b c = (b1,b2,i2)
where
(i1,b1) = unbundle (moore t o 0 (bundle (a,b)))
(i2,b2) = unbundle (moore t o 3 (bundle (i1,c)))
Using mooreB however we can write:
g a b c = (b1,b2,i2)
where
(i1,b1) = mooreB t o 0 (a,b)
(i2,b2) = mooreB t o 3 (i1,c)
registerB :: (HiddenClockReset domain gated synchronous, Bundle a) => a -> Unbundled domain a -> Unbundled domain a infixr 3 Source #
Create a register function for product-type like signals (e.g. '(Signal a, Signal b)')
rP :: HiddenClockReset domain gated synchronous => (Signal domain Int, Signal domain Int) -> (Signal domain Int, Signal domain Int) rP = registerB (8,8)
>>>simulateB rP [(1,1),(2,2),(3,3)] :: [(Int,Int)][(8,8),(1,1),(2,2),(3,3)... ...
ROMs
Arguments
| :: (KnownNat n, Enum addr) | |
| => Vec n a | ROM content NB: must be a constant |
| -> addr | Read address |
| -> a | The value of the ROM at address |
An asynchronous/combinational ROM with space for n elements
Additional helpful information:
- See Clash.Sized.Fixed and Clash.Prelude.BlockRam for ideas on how to use ROMs and RAMs
Arguments
| :: KnownNat n | |
| => Vec (2 ^ n) a | ROM content NB: must be a constant |
| -> Unsigned n | Read address |
| -> a | The value of the ROM at address |
An asynchronous/combinational ROM with space for 2^n elements
Additional helpful information:
- See Clash.Sized.Fixed and Clash.Prelude.BlockRam for ideas on how to use ROMs and RAMs
Arguments
| :: (KnownNat n, KnownNat m, HiddenClock domain gated) | |
| => Vec n a | ROM content NB: must be a constant |
| -> Signal domain (Unsigned m) | Read address |
| -> Signal domain a | The value of the ROM at address |
A ROM with a synchronous read port, with space for n elements
- NB: Read value is delayed by 1 cycle
- NB: Initial output value is
undefined
Additional helpful information:
- See Clash.Sized.Fixed and Clash.Prelude.BlockRam for ideas on how to use ROMs and RAMs
Arguments
| :: (KnownNat n, HiddenClock domain gated) | |
| => Vec (2 ^ n) a | ROM content NB: must be a constant |
| -> Signal domain (Unsigned n) | Read address |
| -> Signal domain a | The value of the ROM at address |
A ROM with a synchronous read port, with space for 2^n elements
- NB: Read value is delayed by 1 cycle
- NB: Initial output value is
undefined
Additional helpful information:
- See Clash.Sized.Fixed and Clash.Prelude.BlockRam for ideas on how to use ROMs and RAMs
RAM primitives with a combinational read port
Arguments
| :: (Enum addr, HiddenClock domain gated, HasCallStack) | |
| => SNat n | Size |
| -> Signal domain addr | Read address |
| -> Signal domain (Maybe (addr, a)) | (write address |
| -> Signal domain a | Value of the |
Create a RAM with space for n elements.
- NB: Initial content of the RAM is
undefined
Additional helpful information:
- See Clash.Prelude.BlockRam for more information on how to use a RAM.
Arguments
| :: (KnownNat n, HiddenClock domain gated, HasCallStack) | |
| => Signal domain (Unsigned n) | Read address |
| -> Signal domain (Maybe (Unsigned n, a)) | (write address |
| -> Signal domain a | Value of the |
Create a RAM with space for 2^n elements
- NB: Initial content of the RAM is
undefined
Additional helpful information:
- See Clash.Prelude.BlockRam for more information on how to use a RAM.
BlockRAM primitives
Arguments
| :: (Enum addr, HiddenClock domain gated, HasCallStack) | |
| => Vec n a | Initial content of the BRAM, also
determines the size, NB: MUST be a constant. |
| -> Signal domain addr | Read address |
| -> Signal domain (Maybe (addr, a)) | (write address |
| -> Signal domain a | Value of the |
Create a blockRAM with space for n elements.
- NB: Read value is delayed by 1 cycle
- NB: Initial output value is
undefined
bram40 ::HiddenClockdomain =>Signaldomain (Unsigned6) ->Signaldomain (Maybe (Unsigned6,Bit)) ->SignaldomainBitbram40 =blockRam(replicated40 1)
Additional helpful information:
- See Clash.Prelude.BlockRam for more information on how to use a Block RAM.
- Use the adapter
readNewfor obtaining write-before-read semantics like this:readNew (blockRam inits) rd wrM.
Arguments
| :: (KnownNat n, HiddenClock domain gated, HasCallStack) | |
| => Vec (2 ^ n) a | Initial content of the BRAM, also
determines the size, NB: MUST be a constant. |
| -> Signal domain (Unsigned n) | Read address |
| -> Signal domain (Maybe (Unsigned n, a)) | (write address |
| -> Signal domain a | Value of the |
Create a blockRAM with space for 2^n elements
- NB: Read value is delayed by 1 cycle
- NB: Initial output value is
undefined
bram32 ::HiddenClockdomain =>Signaldomain (Unsigned5) ->Signaldomain (Maybe (Unsigned5,Bit)) ->SignaldomainBitbram32 =blockRamPow2(replicated32 1)
Additional helpful information:
- See Clash.Prelude.BlockRam for more information on how to use a Block RAM.
- Use the adapter
readNewfor obtaining write-before-read semantics like this:readNew (blockRamPow2 inits) rd wrM.
BlockRAM read/write conflict resolution
Arguments
| :: (Eq addr, HiddenClockReset domain gated synchronous) | |
| => (Signal domain addr -> Signal domain (Maybe (addr, a)) -> Signal domain a) | The |
| -> Signal domain addr | Read address |
| -> Signal domain (Maybe (addr, a)) | (Write address |
| -> Signal domain a | Value of the |
Create read-after-write blockRAM from a read-before-write one (synchronised to system clock)
>>>import Clash.Prelude>>>:t readNew (blockRam (0 :> 1 :> Nil))readNew (blockRam (0 :> 1 :> Nil)) :: ... ... => Signal domain addr -> Signal domain (Maybe (addr, a)) -> Signal domain a
Utility functions
riseEvery :: HiddenClockReset domain gated synchronous => SNat n -> Signal domain Bool Source #
Give a pulse every n clock cycles. This is a useful helper function when
combined with functions like regEnmux
To be precise: the given signal will be Falsen-1 cycles,
followed by a single True
>>>Prelude.last (sampleN 1024 (riseEvery d1024)) == TrueTrue>>>Prelude.or (sampleN 1023 (riseEvery d1024)) == FalseTrue
For example, to update a counter once every 10 million cycles:
counter =regEn0 (riseEvery(SNat::SNat10000000)) (counter + 1)
oscillate :: HiddenClockReset domain gated synchronous => Bool -> SNat n -> Signal domain Bool Source #
Oscillate a BoolregEnBool
To oscillate on an interval of 5 cycles:
>>>sampleN 10 (oscillate False d5)[False,False,False,False,False,True,True,True,True,True]
To oscillate between TrueFalse
>>>sampleN 10 (oscillate False d1)[False,True,False,True,False,True,False,True,False,True]
An alternative definition for the above could be:
>>>let osc' = register False (not <$> osc')>>>let sample' = sampleN 200>>>sample' (oscillate False d1) == sample' osc'True
Exported modules
Synchronous signals
module Clash.Signal
module Clash.Signal.Delayed
DataFlow interface
module Clash.Prelude.DataFlow
Datatypes
Bit vectors
module Clash.Sized.BitVector
module Clash.Prelude.BitIndex
module Clash.Prelude.BitReduction
Arbitrary-width numbers
module Clash.Sized.Signed
module Clash.Sized.Unsigned
module Clash.Sized.Index
Fixed point numbers
module Clash.Sized.Fixed
Fixed size vectors
module Clash.Sized.Vector
Perfect depth trees
module Clash.Sized.RTree
Annotations
module Clash.Annotations.TopEntity
Type-level natural numbers
module GHC.TypeLits
module Clash.Promoted.Nat
module Clash.Promoted.Nat.Literals
module Clash.Promoted.Nat.TH
Type-level strings
module Clash.Promoted.Symbol
Type classes
Clash
module Clash.Class.BitPack
module Clash.Class.Num
module Clash.Class.Resize
Other
module Control.Applicative
module Data.Bits
Exceptions
module Clash.XException
undefined :: HasCallStack => a Source #
Named types
module Clash.NamedTypes
Hidden arguments
module Clash.Hidden
Haskell Prelude
Clash.Prelude re-exports most of the Haskell Prelude with the exception of the following: (++), (!!), concat, drop, foldl, foldl1, foldr, foldr1, head, init, iterate, last, length, map, repeat, replicate, reverse, scanl, scanr, splitAt, tail, take, unzip, unzip3, zip, zip3, zipWith, zipWith3.
It instead exports the identically named functions defined in terms of
Vec at Clash.Sized.Vector.
The value of seq a b is bottom if a is bottom, and
otherwise equal to b. In other words, it evaluates the first
argument a to weak head normal form (WHNF). seq is usually
introduced to improve performance by avoiding unneeded laziness.
A note on evaluation order: the expression seq a b does
not guarantee that a will be evaluated before b.
The only guarantee given by seq is that the both a
and b will be evaluated before seq returns a value.
In particular, this means that b may be evaluated before
a. If you need to guarantee a specific order of evaluation,
you must use the function pseq from the "parallel" package.
filter :: (a -> Bool) -> [a] -> [a] #
filter, applied to a predicate and a list, returns the list of
those elements that satisfy the predicate; i.e.,
filter p xs = [ x | x <- xs, p x]
print :: Show a => a -> IO () #
The print function outputs a value of any printable type to the
standard output device.
Printable types are those that are instances of class Show; print
converts values to strings for output using the show operation and
adds a newline.
For example, a program to print the first 20 integers and their powers of 2 could be written as:
main = print ([(n, 2^n) | n <- [0..19]])
($) :: (a -> b) -> a -> b infixr 0 #
Application operator. This operator is redundant, since ordinary
application (f x) means the same as (f . However, $ x)$ has
low, right-associative binding precedence, so it sometimes allows
parentheses to be omitted; for example:
f $ g $ h x = f (g (h x))
It is also useful in higher-order situations, such as map ($ 0) xszipWith ($) fs xs
fromIntegral :: (Integral a, Num b) => a -> b #
general coercion from integral types
realToFrac :: (Real a, Fractional b) => a -> b #
general coercion to fractional types
The Bounded class is used to name the upper and lower limits of a
type. Ord is not a superclass of Bounded since types that are not
totally ordered may also have upper and lower bounds.
The Bounded class may be derived for any enumeration type;
minBound is the first constructor listed in the data declaration
and maxBound is the last.
Bounded may also be derived for single-constructor datatypes whose
constituent types are in Bounded.
Instances
Class Enum defines operations on sequentially ordered types.
The enumFrom... methods are used in Haskell's translation of
arithmetic sequences.
Instances of Enum may be derived for any enumeration type (types
whose constructors have no fields). The nullary constructors are
assumed to be numbered left-to-right by fromEnum from 0 through n-1.
See Chapter 10 of the Haskell Report for more details.
For any type that is an instance of class Bounded as well as Enum,
the following should hold:
- The calls
succmaxBoundpredminBound fromEnumandtoEnumshould give a runtime error if the result value is not representable in the result type. For example,toEnum7 ::BoolenumFromandenumFromThenshould be defined with an implicit bound, thus:
enumFrom x = enumFromTo x maxBound
enumFromThen x y = enumFromThenTo x y bound
where
bound | fromEnum y >= fromEnum x = maxBound
| otherwise = minBoundMethods
the successor of a value. For numeric types, succ adds 1.
the predecessor of a value. For numeric types, pred subtracts 1.
Convert from an Int.
Convert to an Int.
It is implementation-dependent what fromEnum returns when
applied to a value that is too large to fit in an Int.
Used in Haskell's translation of [n..].
enumFromThen :: a -> a -> [a] #
Used in Haskell's translation of [n,n'..].
enumFromTo :: a -> a -> [a] #
Used in Haskell's translation of [n..m].
enumFromThenTo :: a -> a -> a -> [a] #
Used in Haskell's translation of [n,n'..m].
Instances
The Eq class defines equality (==) and inequality (/=).
All the basic datatypes exported by the Prelude are instances of Eq,
and Eq may be derived for any datatype whose constituents are also
instances of Eq.
Instances
| Eq Bool | |
| Eq Char | |
| Eq Double | |
| Eq Float | |
| Eq Int | |
| Eq Int8 | Since: 2.1 |
| Eq Int16 | Since: 2.1 |
| Eq Int32 | Since: 2.1 |
| Eq Int64 | Since: 2.1 |
| Eq Integer | |
| Eq Natural | |
| Eq Ordering | |
| Eq Word | |
| Eq Word8 | Since: 2.1 |
| Eq Word16 | Since: 2.1 |
| Eq Word32 | Since: 2.1 |
| Eq Word64 | Since: 2.1 |
| Eq SomeTypeRep | |
| Eq Exp | |
| Eq Match | |
| Eq Clause | |
| Eq Pat | |
| Eq Type | |
| Eq Dec | |
| Eq Name | |
| Eq FunDep | |
| Eq InjectivityAnn | |
Methods (==) :: InjectivityAnn -> InjectivityAnn -> Bool # (/=) :: InjectivityAnn -> InjectivityAnn -> Bool # | |
| Eq Overlap | |
| Eq DerivStrategy | |
Methods (==) :: DerivStrategy -> DerivStrategy -> Bool # (/=) :: DerivStrategy -> DerivStrategy -> Bool # | |
| Eq () | |
| Eq TyCon | |
| Eq Module | |
| Eq TrName | |
| Eq BigNat | |
| Eq Void | Since: 4.8.0.0 |
| Eq SpecConstrAnnotation | |
Methods (==) :: SpecConstrAnnotation -> SpecConstrAnnotation -> Bool # (/=) :: SpecConstrAnnotation -> SpecConstrAnnotation -> Bool # | |
| Eq Constr | Equality of constructors Since: 4.0.0.0 |
| Eq DataRep | |
| Eq ConstrRep | |
| Eq Fixity | |
| Eq Unique | |
| Eq Version | Since: 2.1 |
| Eq ThreadId | Since: 4.2.0.0 |
| Eq BlockReason | |
| Eq ThreadStatus | |
| Eq AsyncException | |
Methods (==) :: AsyncException -> AsyncException -> Bool # (/=) :: AsyncException -> AsyncException -> Bool # | |
| Eq ArrayException | |
Methods (==) :: ArrayException -> ArrayException -> Bool # (/=) :: ArrayException -> ArrayException -> Bool # | |
| Eq ExitCode | |
| Eq IOErrorType | Since: 4.1.0.0 |
| Eq MaskingState | |
| Eq IOException | Since: 4.1.0.0 |
| Eq ErrorCall | |
| Eq ArithException | |
Methods (==) :: ArithException -> ArithException -> Bool # (/=) :: ArithException -> ArithException -> Bool # | |
| Eq All | |
| Eq Any | |
| Eq Fixity | |
| Eq Associativity | |
Methods (==) :: Associativity -> Associativity -> Bool # (/=) :: Associativity -> Associativity -> Bool # | |
| Eq SourceUnpackedness | |
Methods (==) :: SourceUnpackedness -> SourceUnpackedness -> Bool # (/=) :: SourceUnpackedness -> SourceUnpackedness -> Bool # | |
| Eq SourceStrictness | |
Methods (==) :: SourceStrictness -> SourceStrictness -> Bool # (/=) :: SourceStrictness -> SourceStrictness -> Bool # | |
| Eq DecidedStrictness | |
Methods (==) :: DecidedStrictness -> DecidedStrictness -> Bool # (/=) :: DecidedStrictness -> DecidedStrictness -> Bool # | |
| Eq SomeSymbol | Since: 4.7.0.0 |
| Eq SomeNat | Since: 4.7.0.0 |
| Eq CChar | |
| Eq CSChar | |
| Eq CUChar | |
| Eq CShort | |
| Eq CUShort | |
| Eq CInt | |
| Eq CUInt | |
| Eq CLong | |
| Eq CULong | |
| Eq CLLong | |
| Eq CULLong | |
| Eq CBool | |
| Eq CFloat | |
| Eq CDouble | |
| Eq CPtrdiff | |
| Eq CSize | |
| Eq CWchar | |
| Eq CSigAtomic | |
| Eq CClock | |
| Eq CTime | |
| Eq CUSeconds | |
| Eq CSUSeconds | |
| Eq CIntPtr | |
| Eq CUIntPtr | |
| Eq CIntMax | |
| Eq CUIntMax | |
| Eq Fingerprint | |
| Eq Lexeme | |
| Eq Number | |
| Eq GeneralCategory | |
Methods (==) :: GeneralCategory -> GeneralCategory -> Bool # (/=) :: GeneralCategory -> GeneralCategory -> Bool # | |
| Eq SrcLoc | |
| Eq ByteString | |
| Eq ByteString | |
| Eq IntSet | |
| Eq TyVarBndr | |
| Eq Extension | |
| Eq ForeignSrcLang | |
Methods (==) :: ForeignSrcLang -> ForeignSrcLang -> Bool # (/=) :: ForeignSrcLang -> ForeignSrcLang -> Bool # | |
| Eq Doc | |
| Eq TextDetails | |
| Eq Style | |
| Eq Mode | |
| Eq ModName | |
| Eq PkgName | |
| Eq Module | |
| Eq OccName | |
| Eq NameFlavour | |
| Eq NameSpace | |
| Eq Loc | |
| Eq Info | |
| Eq ModuleInfo | |
| Eq Fixity | |
| Eq FixityDirection | |
Methods (==) :: FixityDirection -> FixityDirection -> Bool # (/=) :: FixityDirection -> FixityDirection -> Bool # | |
| Eq Lit | |
| Eq Body | |
| Eq Guard | |
| Eq Stmt | |
| Eq Range | |
| Eq DerivClause | |
| Eq TypeFamilyHead | |
Methods (==) :: TypeFamilyHead -> TypeFamilyHead -> Bool # (/=) :: TypeFamilyHead -> TypeFamilyHead -> Bool # | |
| Eq TySynEqn | |
| Eq Foreign | |
| Eq Callconv | |
| Eq Safety | |
| Eq Pragma | |
| Eq Inline | |
| Eq RuleMatch | |
| Eq Phases | |
| Eq RuleBndr | |
| Eq AnnTarget | |
| Eq SourceUnpackedness | |
Methods (==) :: SourceUnpackedness -> SourceUnpackedness -> Bool # (/=) :: SourceUnpackedness -> SourceUnpackedness -> Bool # | |
| Eq SourceStrictness | |
Methods (==) :: SourceStrictness -> SourceStrictness -> Bool # (/=) :: SourceStrictness -> SourceStrictness -> Bool # | |
| Eq DecidedStrictness | |
Methods (==) :: DecidedStrictness -> DecidedStrictness -> Bool # (/=) :: DecidedStrictness -> DecidedStrictness -> Bool # | |
| Eq Con | |
| Eq Bang | |
| Eq PatSynDir | |
| Eq PatSynArgs | |
| Eq FamilyResultSig | |
Methods (==) :: FamilyResultSig -> FamilyResultSig -> Bool # (/=) :: FamilyResultSig -> FamilyResultSig -> Bool # | |
| Eq TyLit | |
| Eq Role | |
| Eq AnnLookup | |
| Eq LocalTime | |
| Eq UniversalTime | |
Methods (==) :: UniversalTime -> UniversalTime -> Bool # (/=) :: UniversalTime -> UniversalTime -> Bool # | |
| Eq UTCTime | |
| Eq Day | |
| Eq HDL # | |
| Eq SaturationMode # | |
Methods (==) :: SaturationMode -> SaturationMode -> Bool # (/=) :: SaturationMode -> SaturationMode -> Bool # | |
| Eq Bit # | |
| Eq DefName | |
| Eq TimeLocale | |
| Eq ByteArray | |
| Eq Addr | |
| Eq ConstructorInfo | |
| Eq ConstructorVariant | |
| Eq DatatypeInfo | |
| Eq DatatypeVariant | |
| Eq FieldStrictness | |
| Eq Strictness | |
| Eq Unpackedness | |
| Eq Half | |
| Eq ResetKind # | |
| Eq ClockKind # | |
| Eq NewOrData | |
| () :=> (Eq Bool) | |
| () :=> (Eq Double) | |
| () :=> (Eq Float) | |
| () :=> (Eq Int) | |
| () :=> (Eq Integer) | |
| () :=> (Eq Natural) | |
| () :=> (Eq Word) | |
| () :=> (Eq ()) | |
| () :=> (Eq (a :- b)) | |
| () :=> (Eq (Dict a)) | |
| Class () (Eq a) | |
| 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 a => Eq (Complex a) | |
| Eq (Fixed a) | |
| Eq a => Eq (Min a) | |
| Eq a => Eq (Max a) | |
| Eq a => Eq (First a) | |
| Eq a => Eq (Last a) | |
| Eq m => Eq (WrappedMonoid m) | |
Methods (==) :: WrappedMonoid m -> WrappedMonoid m -> Bool # (/=) :: WrappedMonoid m -> WrappedMonoid m -> Bool # | |
| Eq a => Eq (Option a) | |
| Eq (StableName a) | Since: 2.1 |
| Eq a => Eq (ZipList a) | |
| Eq a => Eq (Identity a) | |
| Eq (TVar a) | Since: 4.8.0.0 |
| Eq (IORef a) | Pointer equality. Since: 4.1.0.0 |
| Eq a => Eq (First a) | |
| Eq a => Eq (Last a) | |
| Eq a => Eq (Dual a) | |
| Eq a => Eq (Sum a) | |
| Eq a => Eq (Product a) | |
| Eq a => Eq (Down a) | |
| Eq (MVar a) | Since: 4.1.0.0 |
| Eq a => Eq (NonEmpty a) | |
| Eq a => Eq (IntMap a) | |
| Eq a => Eq (Tree a) | |
| Eq a => Eq (Seq a) | |
| Eq a => Eq (ViewL a) | |
| Eq a => Eq (ViewR a) | |
| Eq a => Eq (Set a) | |
| Eq (Doc a) | |
| Eq a => Eq (AnnotDetails a) | |
Methods (==) :: AnnotDetails a -> AnnotDetails a -> Bool # (/=) :: AnnotDetails a -> AnnotDetails a -> Bool # | |
| Eq a => Eq (Span a) | |
| Eq (BitVector n) # | |
| Eq (Index n) # | |
| Eq a => Eq (Bounds a) | |
| Eq a => Eq (DList a) | |
| Eq a => Eq (HashSet a) | |
| (Storable a, Eq a) => Eq (Vector a) | |
| (Prim a, Eq a) => Eq (Vector a) | |
| Eq a => Eq (Vector a) | |
| Eq a => Eq (Array a) | |
| Eq (Unsigned n) # | |
| Eq (Signed n) # | |
| Eq (Dict a) | |
| (Eq a) :=> (Eq [a]) | |
| (Eq a) :=> (Eq (Maybe a)) | |
| (Eq a) :=> (Eq (Complex a)) | |
| (Eq a) :=> (Eq (Ratio a)) | |
| (Eq a) :=> (Eq (Identity a)) | |
| (Eq a) :=> (Eq (Const a b)) | |
| Class (Eq a) (Ord a) | |
| Class (Eq a) (Bits a) | |
| (Eq a, Eq b) => Eq (Either a b) | |
| Eq (V1 p) | Since: 4.9.0.0 |
| Eq (U1 p) | Since: 4.9.0.0 |
| Eq (TypeRep a) | Since: 2.1 |
| (Eq a, Eq b) => Eq (a, b) | |
| (Ix i, Eq e) => Eq (Array i e) | Since: 2.1 |
| Eq a => Eq (Arg a b) | Since: 4.9.0.0 |
| Eq (Proxy s) | Since: 4.7.0.0 |
| Eq (STRef s a) | Pointer equality. Since: 2.1 |
| (Eq k, Eq a) => Eq (Map k a) | |
| (KnownNat n, Eq a) => Eq (Vec n a) # | |
| (Eq i, Eq a) => Eq (Level i a) | |
| (Eq1 f, Eq a) => Eq (Cofree f a) | |
| (Eq1 f, Eq a) => Eq (Free f a) | |
| (Eq1 f, Eq a) => Eq (Yoneda f a) | |
| (Eq k, Eq v) => Eq (HashMap k v) | |
| Eq (MutableArray s a) | |
| (Eq k, Eq v) => Eq (Leaf k v) | |
| (KnownNat d, Eq a) => Eq (RTree d a) # | |
| Eq (a :- b) | |
| (Eq a, Eq b) :=> (Eq (a, b)) | |
| (Eq a, Eq b) :=> (Eq (Either a b)) | |
| 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 (STArray s i e) | Since: 2.1 |
| Eq a => Eq (Const a b) | |
| Eq (f a) => Eq (Alt f a) | |
| Eq (a :~: b) | |
| (Eq e, Eq1 m, Eq a) => Eq (ErrorT e m a) | |
| Eq a => Eq (Constant a b) | |
| Eq b => Eq (Tagged s b) | |
| Eq (p (Fix p a) a) => Eq (Fix p a) | |
| Eq (p a a) => Eq (Join 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) | |
| (Eq1 f, Eq1 m, Eq a) => Eq (FreeT f m a) | |
| (Eq a, Eq (f b)) => Eq (FreeF f a b) | |
| Eq (rep (int + frac)) => Eq (Fixed rep int frac) # | |
| 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) | Since: 4.9.0.0 |
| (Eq1 f, Eq1 g, Eq a) => Eq (Sum f g a) | Since: 4.9.0.0 |
| Eq (a :~~: b) | Since: 4.10.0.0 |
| 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) | Since: 4.9.0.0 |
| 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 #
Trigonometric and hyperbolic functions and related functions.
Minimal complete definition
pi, exp, log, sin, cos, asin, acos, atan, sinh, cosh, asinh, acosh, atanh
Instances
| Floating Double | Since: 2.1 |
| Floating Float | Since: 2.1 |
| Floating CFloat | |
| Floating CDouble | |
| Floating Half | |
| () :=> (Floating Double) | |
| () :=> (Floating Float) | |
| RealFloat a => Floating (Complex a) | Since: 2.1 |
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 # | |
| Floating a => Floating (Identity a) | |
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 (Identity a)) | |
| (Floating a) :=> (Floating (Const a b)) | |
| (RealFloat a) :=> (Floating (Complex a)) | |
| Class (Fractional a) (Floating a) | |
Methods cls :: Floating a :- Fractional a | |
| Floating a => Floating (Op a b) | |
| Class (RealFrac a, Floating a) (RealFloat a) | |
| Floating a => Floating (Const a b) | |
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 # | |
| Floating a => Floating (Tagged s a) | |
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 # | |
class Num a => Fractional a where #
Fractional numbers, supporting real division.
Minimal complete definition
fromRational, (recip | (/))
Methods
fractional division
reciprocal fraction
fromRational :: Rational -> a #
Conversion from a Rational (that is Ratio IntegerfromRational
to a value of type Rational, so such literals have type
(.Fractional a) => a
Instances
| Fractional CFloat | |
| Fractional CDouble | |
| Fractional Half | |
| () :=> (Fractional Double) | |
Methods ins :: () :- Fractional Double | |
| () :=> (Fractional Float) | |
Methods ins :: () :- Fractional Float | |
| Integral a => Fractional (Ratio a) | Since: 2.0.1 |
| RealFloat a => Fractional (Complex a) | Since: 2.1 |
| HasResolution a => Fractional (Fixed a) | Since: 2.1 |
| Fractional a => Fractional (Identity a) | |
| (Fractional a) :=> (Fractional (Identity a)) | |
Methods ins :: Fractional a :- Fractional (Identity a) | |
| (Fractional a) :=> (Fractional (Const a b)) | |
Methods ins :: Fractional a :- Fractional (Const a b) | |
| (Integral a) :=> (Fractional (Ratio a)) | |
Methods ins :: Integral a :- Fractional (Ratio a) | |
| (RealFloat a) :=> (Fractional (Complex a)) | |
Methods ins :: RealFloat a :- Fractional (Complex a) | |
| Class (Fractional a) (Floating a) | |
Methods cls :: Floating a :- Fractional a | |
| Class (Num a) (Fractional a) | |
Methods cls :: Fractional a :- Num a | |
| Fractional a => Fractional (Op a b) | |
| Fractional a => Fractional (Signal domain a) # | |
| Class (Real a, Fractional a) (RealFrac a) | |
Methods cls :: RealFrac a :- (Real a, Fractional a) | |
| Fractional a => Fractional (Const a b) | |
| Fractional a => Fractional (Tagged s a) | |
| FracFixedC rep int frac => Fractional (Fixed rep int frac) # | The operators of this instance saturate on overflow, and use truncation as the rounding method. When used in a polymorphic setting, use the following Constraint synonyms for less verbose type signatures:
|
| Fractional a => Fractional (DSignal domain delay a) # | |
class (Real a, Enum a) => Integral a where #
Integral numbers, supporting integer division.
Methods
quot :: a -> a -> a infixl 7 #
integer division truncated toward zero
integer remainder, satisfying
(x `quot` y)*y + (x `rem` y) == x
integer division truncated toward negative infinity
integer modulus, satisfying
(x `div` y)*y + (x `mod` y) == x
conversion to Integer
Instances
| Integral Int | Since: 2.0.1 |
| Integral Int8 | Since: 2.1 |
| Integral Int16 | Since: 2.1 |
| Integral Int32 | Since: 2.1 |
| Integral Int64 | Since: 2.1 |
| Integral Integer | Since: 2.0.1 |
| Integral Natural | Since: 4.8.0.0 |
| Integral Word | Since: 2.1 |
| Integral Word8 | Since: 2.1 |
| Integral Word16 | Since: 2.1 |
| Integral Word32 | Since: 2.1 |
| Integral Word64 | Since: 2.1 |
| Integral CChar | |
| Integral CSChar | |
| Integral CUChar | |
| Integral CShort | |
| Integral CUShort | |
| Integral CInt | |
| Integral CUInt | |
| Integral CLong | |
| Integral CULong | |
| Integral CLLong | |