Safe Haskell	None
Language	Haskell2010

NumHask.Prelude

Contents

Backend
Algebraic Heirarchy

Description

A prelude for NumHask

Synopsis

Backend

NumHask imports Protolude as the prelude and replaces much of the Num heirarchy in base. Usage of Semigroup and Monoid has been avoided to retain basic compatability.

module Protolude

(<>) :: Semigroup a => a -> a -> a infixr 6 #

An associative operation.

(a <> b) <> c = a <> (b <> c)

If a is also a Monoid we further require

(<>) = mappend

class Semigroup a where #

The class of semigroups (types with an associative binary operation).

Since: 4.9.0.0

Methods

(<>) :: a -> a -> a infixr 6 #

An associative operation.

(a <> b) <> c = a <> (b <> c)

If a is also a Monoid we further require

(<>) = mappend

sconcat :: NonEmpty a -> a #

Reduce a non-empty list with <>

The default definition should be sufficient, but this can be overridden for efficiency.

stimes :: Integral b => b -> a -> a #

Repeat a value n times.

Given that this works on a Semigroup it is allowed to fail if you request 0 or fewer repetitions, and the default definition will do so.

By making this a member of the class, idempotent semigroups and monoids can upgrade this to execute in O(1) by picking stimes = stimesIdempotent or stimes = stimesIdempotentMonoid respectively.

Instances

Semigroup Ordering	Since: 4.9.0.0
Methods (<>) :: Ordering -> Ordering -> Ordering # sconcat :: NonEmpty Ordering -> Ordering # stimes :: Integral b => b -> Ordering -> Ordering #
Semigroup ()	Since: 4.9.0.0
Methods (<>) :: () -> () -> () # sconcat :: NonEmpty () -> () # stimes :: Integral b => b -> () -> () #
Semigroup Void	Since: 4.9.0.0
Methods (<>) :: Void -> Void -> Void # sconcat :: NonEmpty Void -> Void # stimes :: Integral b => b -> Void -> Void #
Semigroup Event	Since: 4.10.0.0
Methods (<>) :: Event -> Event -> Event # sconcat :: NonEmpty Event -> Event # stimes :: Integral b => b -> Event -> Event #
Semigroup Lifetime	Since: 4.10.0.0
Methods (<>) :: Lifetime -> Lifetime -> Lifetime # sconcat :: NonEmpty Lifetime -> Lifetime # stimes :: Integral b => b -> Lifetime -> Lifetime #
Semigroup All	Since: 4.9.0.0
Methods (<>) :: All -> All -> All # sconcat :: NonEmpty All -> All # stimes :: Integral b => b -> All -> All #
Semigroup Any	Since: 4.9.0.0
Methods (<>) :: Any -> Any -> Any # sconcat :: NonEmpty Any -> Any # stimes :: Integral b => b -> Any -> Any #
Semigroup IntSet
Methods (<>) :: IntSet -> IntSet -> IntSet # sconcat :: NonEmpty IntSet -> IntSet # stimes :: Integral b => b -> IntSet -> IntSet #
Semigroup Doc
Methods (<>) :: Doc -> Doc -> Doc # sconcat :: NonEmpty Doc -> Doc # stimes :: Integral b => b -> Doc -> Doc #
Semigroup [a]	Since: 4.9.0.0
Methods (<>) :: [a] -> [a] -> [a] # sconcat :: NonEmpty [a] -> [a] # stimes :: Integral b => b -> [a] -> [a] #
Semigroup a => Semigroup (Maybe a)	Since: 4.9.0.0
Methods (<>) :: Maybe a -> Maybe a -> Maybe a # sconcat :: NonEmpty (Maybe a) -> Maybe a # stimes :: Integral b => b -> Maybe a -> Maybe a #
Semigroup a => Semigroup (IO a)	Since: 4.10.0.0
Methods (<>) :: IO a -> IO a -> IO a # sconcat :: NonEmpty (IO a) -> IO a # stimes :: Integral b => b -> IO a -> IO a #
Ord a => Semigroup (Min a)	Since: 4.9.0.0
Methods (<>) :: Min a -> Min a -> Min a # sconcat :: NonEmpty (Min a) -> Min a # stimes :: Integral b => b -> Min a -> Min a #
Ord a => Semigroup (Max a)	Since: 4.9.0.0
Methods (<>) :: Max a -> Max a -> Max a # sconcat :: NonEmpty (Max a) -> Max a # stimes :: Integral b => b -> Max a -> Max a #
Semigroup (First a)	Since: 4.9.0.0
Methods (<>) :: First a -> First a -> First a # sconcat :: NonEmpty (First a) -> First a # stimes :: Integral b => b -> First a -> First a #
Semigroup (Last a)	Since: 4.9.0.0
Methods (<>) :: Last a -> Last a -> Last a # sconcat :: NonEmpty (Last a) -> Last a # stimes :: Integral b => b -> Last a -> Last a #
Monoid m => Semigroup (WrappedMonoid m)	Since: 4.9.0.0
Methods (<>) :: WrappedMonoid m -> WrappedMonoid m -> WrappedMonoid m # sconcat :: NonEmpty (WrappedMonoid m) -> WrappedMonoid m # stimes :: Integral b => b -> WrappedMonoid m -> WrappedMonoid m #
Semigroup a => Semigroup (Option a)	Since: 4.9.0.0
Methods (<>) :: Option a -> Option a -> Option a # sconcat :: NonEmpty (Option a) -> Option a # stimes :: Integral b => b -> Option a -> Option a #
Semigroup (NonEmpty a)	Since: 4.9.0.0
Methods (<>) :: NonEmpty a -> NonEmpty a -> NonEmpty a # sconcat :: NonEmpty (NonEmpty a) -> NonEmpty a # stimes :: Integral b => b -> NonEmpty a -> NonEmpty a #
Semigroup a => Semigroup (Identity a)	Since: 4.9.0.0
Methods (<>) :: Identity a -> Identity a -> Identity a # sconcat :: NonEmpty (Identity a) -> Identity a # stimes :: Integral b => b -> Identity a -> Identity a #
Semigroup a => Semigroup (Dual a)	Since: 4.9.0.0
Methods (<>) :: Dual a -> Dual a -> Dual a # sconcat :: NonEmpty (Dual a) -> Dual a # stimes :: Integral b => b -> Dual a -> Dual a #
Semigroup (Endo a)	Since: 4.9.0.0
Methods (<>) :: Endo a -> Endo a -> Endo a # sconcat :: NonEmpty (Endo a) -> Endo a # stimes :: Integral b => b -> Endo a -> Endo a #
Num a => Semigroup (Sum a)	Since: 4.9.0.0
Methods (<>) :: Sum a -> Sum a -> Sum a # sconcat :: NonEmpty (Sum a) -> Sum a # stimes :: Integral b => b -> Sum a -> Sum a #
Num a => Semigroup (Product a)	Since: 4.9.0.0
Methods (<>) :: Product a -> Product a -> Product a # sconcat :: NonEmpty (Product a) -> Product a # stimes :: Integral b => b -> Product a -> Product a #
Semigroup (First a)	Since: 4.9.0.0
Methods (<>) :: First a -> First a -> First a # sconcat :: NonEmpty (First a) -> First a # stimes :: Integral b => b -> First a -> First a #
Semigroup (Last a)	Since: 4.9.0.0
Methods (<>) :: Last a -> Last a -> Last a # sconcat :: NonEmpty (Last a) -> Last a # stimes :: Integral b => b -> Last a -> Last a #
Num a => Semigroup (Colour a)
Methods (<>) :: Colour a -> Colour a -> Colour a # sconcat :: NonEmpty (Colour a) -> Colour a # stimes :: Integral b => b -> Colour a -> Colour a #
Num a => Semigroup (AlphaColour a)	`AlphaColour` forms a monoid with `over` and `transparent`.
Methods (<>) :: AlphaColour a -> AlphaColour a -> AlphaColour a # sconcat :: NonEmpty (AlphaColour a) -> AlphaColour a # stimes :: Integral b => b -> AlphaColour a -> AlphaColour a #
Semigroup (IntMap a)
Methods (<>) :: IntMap a -> IntMap a -> IntMap a # sconcat :: NonEmpty (IntMap a) -> IntMap a # stimes :: Integral b => b -> IntMap a -> IntMap a #
Semigroup (Seq a)
Methods (<>) :: Seq a -> Seq a -> Seq a # sconcat :: NonEmpty (Seq a) -> Seq a # stimes :: Integral b => b -> Seq a -> Seq a #
Ord a => Semigroup (Set a)
Methods (<>) :: Set a -> Set a -> Set a # sconcat :: NonEmpty (Set a) -> Set a # stimes :: Integral b => b -> Set a -> Set a #
Semigroup (Doc a)
Methods (<>) :: Doc a -> Doc a -> Doc a # sconcat :: NonEmpty (Doc a) -> Doc a # stimes :: Integral b => b -> Doc a -> Doc a #
Semigroup b => Semigroup (a -> b)	Since: 4.9.0.0
Methods (<>) :: (a -> b) -> (a -> b) -> a -> b # sconcat :: NonEmpty (a -> b) -> a -> b # stimes :: Integral b => b -> (a -> b) -> a -> b #
Semigroup (Either a b)	Since: 4.9.0.0
Methods (<>) :: Either a b -> Either a b -> Either a b # sconcat :: NonEmpty (Either a b) -> Either a b # stimes :: Integral b => b -> Either a b -> Either a b #
(Semigroup a, Semigroup b) => Semigroup (a, b)	Since: 4.9.0.0
Methods (<>) :: (a, b) -> (a, b) -> (a, b) # sconcat :: NonEmpty (a, b) -> (a, b) # stimes :: Integral b => b -> (a, b) -> (a, b) #
Semigroup (Proxy k s)	Since: 4.9.0.0
Methods (<>) :: Proxy k s -> Proxy k s -> Proxy k s # sconcat :: NonEmpty (Proxy k s) -> Proxy k s # stimes :: Integral b => b -> Proxy k s -> Proxy k s #
Ord k => Semigroup (Map k v)
Methods (<>) :: Map k v -> Map k v -> Map k v # sconcat :: NonEmpty (Map k v) -> Map k v # stimes :: Integral b => b -> Map k v -> Map k v #
(Semigroup a, Semigroup b, Semigroup c) => Semigroup (a, b, c)	Since: 4.9.0.0
Methods (<>) :: (a, b, c) -> (a, b, c) -> (a, b, c) # sconcat :: NonEmpty (a, b, c) -> (a, b, c) # stimes :: Integral b => b -> (a, b, c) -> (a, b, c) #
Semigroup a => Semigroup (Const k a b)	Since: 4.9.0.0
Methods (<>) :: Const k a b -> Const k a b -> Const k a b # sconcat :: NonEmpty (Const k a b) -> Const k a b # stimes :: Integral b => b -> Const k a b -> Const k a b #
Alternative f => Semigroup (Alt * f a)	Since: 4.9.0.0
Methods (<>) :: Alt * f a -> Alt * f a -> Alt * f a # sconcat :: NonEmpty (Alt * f a) -> Alt * f a # stimes :: Integral b => b -> Alt * f a -> Alt * f a #
Semigroup a => Semigroup (Tagged k s a)
Methods (<>) :: Tagged k s a -> Tagged k s a -> Tagged k s a # sconcat :: NonEmpty (Tagged k s a) -> Tagged k s a # stimes :: Integral b => b -> Tagged k s a -> Tagged k s a #
(Semigroup a, Semigroup b, Semigroup c, Semigroup d) => Semigroup (a, b, c, d)	Since: 4.9.0.0
Methods (<>) :: (a, b, c, d) -> (a, b, c, d) -> (a, b, c, d) # sconcat :: NonEmpty (a, b, c, d) -> (a, b, c, d) # stimes :: Integral b => b -> (a, b, c, d) -> (a, b, c, d) #
(Semigroup a, Semigroup b, Semigroup c, Semigroup d, Semigroup e) => Semigroup (a, b, c, d, e)	Since: 4.9.0.0
Methods (<>) :: (a, b, c, d, e) -> (a, b, c, d, e) -> (a, b, c, d, e) # sconcat :: NonEmpty (a, b, c, d, e) -> (a, b, c, d, e) # stimes :: Integral b => b -> (a, b, c, d, e) -> (a, b, c, d, e) #

fromString :: IsString a => String -> a #

fail :: Monad m => forall a. String -> m a #

Fail with a message. This operation is not part of the mathematical definition of a monad, but is invoked on pattern-match failure in a do expression.

As part of the MonadFail proposal (MFP), this function is moved to its own class MonadFail (see Control.Monad.Fail for more details). The definition here will be removed in a future release.

data Complex a :: * -> * #

Complex numbers are an algebraic type.

For a complex number z, abs z is a number with the magnitude of z, but oriented in the positive real direction, whereas signum z has the phase of z, but unit magnitude.

The Foldable and Traversable instances traverse the real part first.

Constructors

!a :+ !a infix 6

forms a complex number from its real and imaginary rectangular components.

Instances

Monad Complex	Since: 4.9.0.0
Methods (>>=) :: Complex a -> (a -> Complex b) -> Complex b # (>>) :: Complex a -> Complex b -> Complex b # return :: a -> Complex a # fail :: String -> Complex a #
Functor Complex
Methods fmap :: (a -> b) -> Complex a -> Complex b # (<$) :: a -> Complex b -> Complex a #
Applicative Complex	Since: 4.9.0.0
Methods pure :: a -> Complex a # (<>) :: Complex (a -> b) -> Complex a -> Complex b # liftA2 :: (a -> b -> c) -> Complex a -> Complex b -> Complex c # (>) :: Complex a -> Complex b -> Complex b # (<*) :: Complex a -> Complex b -> Complex a #
Foldable Complex
Methods fold :: Monoid m => Complex m -> m # foldMap :: Monoid m => (a -> m) -> Complex a -> m # foldr :: (a -> b -> b) -> b -> Complex a -> b # foldr' :: (a -> b -> b) -> b -> Complex a -> b # foldl :: (b -> a -> b) -> b -> Complex a -> b # foldl' :: (b -> a -> b) -> b -> Complex a -> b # foldr1 :: (a -> a -> a) -> Complex a -> a # foldl1 :: (a -> a -> a) -> Complex a -> a # toList :: Complex a -> [a] # null :: Complex a -> Bool # length :: Complex a -> Int # elem :: Eq a => a -> Complex a -> Bool # maximum :: Ord a => Complex a -> a # minimum :: Ord a => Complex a -> a # sum :: Num a => Complex a -> a # product :: Num a => Complex a -> a #
Traversable Complex
Methods traverse :: Applicative f => (a -> f b) -> Complex a -> f (Complex b) # sequenceA :: Applicative f => Complex (f a) -> f (Complex a) # mapM :: Monad m => (a -> m b) -> Complex a -> m (Complex b) # sequence :: Monad m => Complex (m a) -> m (Complex a) #
Eq a => Eq (Complex a)
Methods (==) :: Complex a -> Complex a -> Bool # (/=) :: Complex a -> Complex a -> Bool #
RealFloat a => Floating (Complex a)	Since: 2.1
Methods pi :: Complex a # 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 #
RealFloat a => Fractional (Complex a)	Since: 2.1
Methods (/) :: Complex a -> Complex a -> Complex a # recip :: Complex a -> Complex a # fromRational :: Rational -> Complex a #
Data a => Data (Complex a)
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Complex a -> c (Complex a) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Complex a) # toConstr :: Complex a -> Constr # dataTypeOf :: Complex a -> DataType # dataCast1 :: Typeable (* -> ) t => (forall d. Data d => c (t d)) -> Maybe (c (Complex a)) # dataCast2 :: Typeable ( -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Complex a)) # gmapT :: (forall b. Data b => b -> b) -> Complex a -> Complex a # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Complex a -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Complex a -> r # gmapQ :: (forall d. Data d => d -> u) -> Complex a -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Complex a -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Complex a -> m (Complex a) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Complex a -> m (Complex a) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Complex a -> m (Complex a) #
RealFloat a => Num (Complex a)	Since: 2.1
Methods (+) :: Complex a -> Complex a -> Complex a # (-) :: Complex a -> Complex a -> Complex a # (*) :: Complex a -> Complex a -> Complex a # negate :: Complex a -> Complex a # abs :: Complex a -> Complex a # signum :: Complex a -> Complex a # fromInteger :: Integer -> Complex a #
Read a => Read (Complex a)
Methods readsPrec :: Int -> ReadS (Complex a) # readList :: ReadS [Complex a] # readPrec :: ReadPrec (Complex a) # readListPrec :: ReadPrec [Complex a] #
Show a => Show (Complex a)
Methods showsPrec :: Int -> Complex a -> ShowS # show :: Complex a -> String # showList :: [Complex a] -> ShowS #
Generic (Complex a)
Associated Types type Rep (Complex a) :: * -> * # Methods from :: Complex a -> Rep (Complex a) x # to :: Rep (Complex a) x -> Complex a #
(RealFloat a, Arbitrary a) => Arbitrary (Complex a)
Methods arbitrary :: Gen (Complex a) # shrink :: Complex a -> [Complex a] #
(RealFloat a, CoArbitrary a) => CoArbitrary (Complex a)
Methods coarbitrary :: Complex a -> Gen b -> Gen b #
Storable a => Storable (Complex a)	Since: 4.8.0.0
Methods sizeOf :: Complex a -> Int # alignment :: Complex a -> Int # peekElemOff :: Ptr (Complex a) -> Int -> IO (Complex a) # pokeElemOff :: Ptr (Complex a) -> Int -> Complex a -> IO () # peekByteOff :: Ptr b -> Int -> IO (Complex a) # pokeByteOff :: Ptr b -> Int -> Complex a -> IO () # peek :: Ptr (Complex a) -> IO (Complex a) # poke :: Ptr (Complex a) -> Complex a -> IO () #
Epsilon a => Epsilon (Complex a)
Methods nearZero :: Complex a -> Bool # aboutEqual :: Complex a -> Complex a -> Bool # positive :: Complex a -> Bool # veryPositive :: Complex a -> Bool # veryNegative :: Complex a -> Bool #
(Semifield a, AdditiveGroup a) => Semifield (Complex a)

Field a => Field (Complex a)

(Ord a, TrigField a, ExpField a) => ExpField (Complex a)	todo: bottom is here somewhere???
Methods exp :: Complex a -> Complex a # log :: Complex a -> Complex a # logBase :: Complex a -> Complex a -> Complex a # (**) :: Complex a -> Complex a -> Complex a # sqrt :: Complex a -> Complex a #
(AdditiveGroup a, UpperBoundedField a) => UpperBoundedField (Complex a)	todo: work out boundings for complex as it stands now, complex is different eg one / (zero :: Complex Float) == nan
Methods infinity :: Complex a # nan :: Complex a #
(AdditiveGroup a, Semiring a) => Semiring (Complex a)

Ring a => Ring (Complex a)

CRing a => CRing (Complex a)

Ring a => InvolutiveRing (Complex a)
Methods adj :: Complex a -> Complex a #
(AdditiveGroup a, Distribution a) => Distribution (Complex a)

(MultiplicativeMagma a, AdditiveGroup a) => MultiplicativeMagma (Complex a)
Methods times :: Complex a -> Complex a -> Complex a #
(AdditiveUnital a, AdditiveGroup a, MultiplicativeUnital a) => MultiplicativeUnital (Complex a)
Methods one :: Complex a #
(AdditiveGroup a, MultiplicativeAssociative a) => MultiplicativeAssociative (Complex a)

(AdditiveGroup a, MultiplicativeCommutative a) => MultiplicativeCommutative (Complex a)

(AdditiveGroup a, MultiplicativeInvertible a) => MultiplicativeInvertible (Complex a)
Methods recip :: Complex a -> Complex a #
(AdditiveGroup a, Multiplicative a) => Multiplicative (Complex a)
Methods (*) :: Complex a -> Complex a -> Complex a #
(AdditiveGroup a, MultiplicativeGroup a) => MultiplicativeGroup (Complex a)
Methods (/) :: Complex a -> Complex a -> Complex a #
AdditiveMagma a => AdditiveMagma (Complex a)
Methods plus :: Complex a -> Complex a -> Complex a #
AdditiveUnital a => AdditiveUnital (Complex a)
Methods zero :: Complex a #
AdditiveAssociative a => AdditiveAssociative (Complex a)

AdditiveCommutative a => AdditiveCommutative (Complex a)

AdditiveInvertible a => AdditiveInvertible (Complex a)
Methods negate :: Complex a -> Complex a #
Additive a => Additive (Complex a)
Methods (+) :: Complex a -> Complex a -> Complex a #
AdditiveGroup a => AdditiveGroup (Complex a)
Methods (-) :: Complex a -> Complex a -> Complex a #
Generic1 * Complex
Associated Types type Rep1 Complex (f :: Complex -> ) :: k -> # Methods from1 :: f a -> Rep1 Complex f a # to1 :: Rep1 Complex f a -> f a #
(Multiplicative a, ExpField a, Normed a a) => Normed (Complex a) a
Methods normL1 :: Complex a -> a # normL2 :: Complex a -> a # normLp :: a -> Complex a -> a #
(Multiplicative a, ExpField a, Normed a a) => Metric (Complex a) a
Methods distanceL1 :: Complex a -> Complex a -> a # distanceL2 :: Complex a -> Complex a -> a # distanceLp :: a -> Complex a -> Complex a -> a #
type Rep (Complex a)
type Rep (Complex a) = D1 * (MetaData "Complex" "Data.Complex" "base" False) (C1 * (MetaCons ":+" (InfixI NotAssociative 6) False) ((::) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 * a)) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 * a))))
type Rep1 * Complex
type Rep1 * Complex = D1 * (MetaData "Complex" "Data.Complex" "base" False) (C1 * (MetaCons ":+" (InfixI NotAssociative 6) False) ((::) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness SourceStrict DecidedStrict) Par1) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness SourceStrict DecidedStrict) Par1)))

data Natural :: * #

Type representing arbitrary-precision non-negative integers.

Operations whose result would be negative throw (Underflow :: ArithException).

Since: 4.8.0.0

Constructors

NatS# GmpLimb#

in [0, maxBound::Word]

NatJ# !BigNat

in ]maxBound::Word, +inf[

Invariant: NatJ# is used iff value doesn't fit in NatS# constructor.

Instances

Enum Natural	Since: 4.8.0.0
Methods succ :: Natural -> Natural # pred :: Natural -> Natural # toEnum :: Int -> Natural # fromEnum :: Natural -> Int # enumFrom :: Natural -> [Natural] # enumFromThen :: Natural -> Natural -> [Natural] # enumFromTo :: Natural -> Natural -> [Natural] # enumFromThenTo :: Natural -> Natural -> Natural -> [Natural] #
Eq Natural
Methods (==) :: Natural -> Natural -> Bool # (/=) :: Natural -> Natural -> Bool #
Integral Natural	Since: 4.8.0.0
Methods quot :: Natural -> Natural -> Natural # rem :: Natural -> Natural -> Natural # div :: Natural -> Natural -> Natural # mod :: Natural -> Natural -> Natural # quotRem :: Natural -> Natural -> (Natural, Natural) # divMod :: Natural -> Natural -> (Natural, Natural) # toInteger :: Natural -> Integer #
Num Natural	Since: 4.8.0.0
Methods (+) :: Natural -> Natural -> Natural # (-) :: Natural -> Natural -> Natural # (*) :: Natural -> Natural -> Natural # negate :: Natural -> Natural # abs :: Natural -> Natural # signum :: Natural -> Natural # fromInteger :: Integer -> Natural #
Ord Natural
Methods compare :: Natural -> Natural -> Ordering # (<) :: Natural -> Natural -> Bool # (<=) :: Natural -> Natural -> Bool # (>) :: Natural -> Natural -> Bool # (>=) :: Natural -> Natural -> Bool # max :: Natural -> Natural -> Natural # min :: Natural -> Natural -> Natural #
Read Natural	Since: 4.8.0.0
Methods readsPrec :: Int -> ReadS Natural # readList :: ReadS [Natural] # readPrec :: ReadPrec Natural # readListPrec :: ReadPrec [Natural] #
Real Natural	Since: 4.8.0.0
Methods toRational :: Natural -> Rational #
Show Natural	Since: 4.8.0.0
Methods showsPrec :: Int -> Natural -> ShowS # show :: Natural -> String # showList :: [Natural] -> ShowS #
Ix Natural	Since: 4.8.0.0
Methods range :: (Natural, Natural) -> [Natural] # index :: (Natural, Natural) -> Natural -> Int # unsafeIndex :: (Natural, Natural) -> Natural -> Int inRange :: (Natural, Natural) -> Natural -> Bool # rangeSize :: (Natural, Natural) -> Int # unsafeRangeSize :: (Natural, Natural) -> Int
Lift Natural
Methods lift :: Natural -> Q Exp #
Bits Natural	Since: 4.8.0.0
Methods (.&.) :: Natural -> Natural -> Natural # (.\|.) :: Natural -> Natural -> Natural # xor :: Natural -> Natural -> Natural # complement :: Natural -> Natural # shift :: Natural -> Int -> Natural # rotate :: Natural -> Int -> Natural # zeroBits :: Natural # bit :: Int -> Natural # setBit :: Natural -> Int -> Natural # clearBit :: Natural -> Int -> Natural # complementBit :: Natural -> Int -> Natural # testBit :: Natural -> Int -> Bool # bitSizeMaybe :: Natural -> Maybe Int # bitSize :: Natural -> Int # isSigned :: Natural -> Bool # shiftL :: Natural -> Int -> Natural # unsafeShiftL :: Natural -> Int -> Natural # shiftR :: Natural -> Int -> Natural # unsafeShiftR :: Natural -> Int -> Natural # rotateL :: Natural -> Int -> Natural # rotateR :: Natural -> Int -> Natural # popCount :: Natural -> Int #
ToRatio Natural
Methods toRatio :: Natural -> Ratio Integer #
Signed Natural
Methods sign :: Natural -> Natural # abs :: Natural -> Natural #
Integral Natural
Methods div :: Natural -> Natural -> Natural # mod :: Natural -> Natural -> Natural # divMod :: Natural -> Natural -> (Natural, Natural) # quot :: Natural -> Natural -> Natural # rem :: Natural -> Natural -> Natural # quotRem :: Natural -> Natural -> (Natural, Natural) #
ToInteger Natural
Methods toInteger :: Natural -> Integer #
FromInteger Natural
Methods fromInteger :: Integer -> Natural #
Semiring Natural

InvolutiveRing Natural
Methods adj :: Natural -> Natural #
Distribution Natural

MultiplicativeMagma Natural
Methods times :: Natural -> Natural -> Natural #
MultiplicativeUnital Natural
Methods one :: Natural #
MultiplicativeAssociative Natural

MultiplicativeCommutative Natural

Multiplicative Natural
Methods (*) :: Natural -> Natural -> Natural #
AdditiveMagma Natural
Methods plus :: Natural -> Natural -> Natural #
AdditiveUnital Natural
Methods zero :: Natural #
AdditiveAssociative Natural

AdditiveCommutative Natural

Additive Natural
Methods (+) :: Natural -> Natural -> Natural #
Normed Natural Natural
Methods normL1 :: Natural -> Natural # normL2 :: Natural -> Natural # normLp :: Natural -> Natural -> Natural #
Metric Natural Natural
Methods distanceL1 :: Natural -> Natural -> Natural # distanceL2 :: Natural -> Natural -> Natural # distanceLp :: Natural -> Natural -> Natural -> Natural #
type (><) * * Natural Natural
type (><) * * Natural Natural = Natural

Algebraic Heirarchy

Re-defines the numeric tower.

Instances for Int, Integer, Float, Double, Bool, Complex and Naturalare supplied.

module NumHask.Algebra.Additive

module NumHask.Algebra.Basis

module NumHask.Algebra.Distribution

module NumHask.Algebra.Field

module NumHask.Algebra.Integral

module NumHask.Algebra.Magma

module NumHask.Algebra.Metric

module NumHask.Algebra.Module

module NumHask.Algebra.Multiplicative

module NumHask.Algebra.Rational

module NumHask.Algebra.Ring

module NumHask.Algebra.Singleton