Data.Semiring

Documentation

class Semiring a where

A Semiring is like the the combination of two Monoids. The first is called <+>; it has the identity element zero, and it is commutative. The second is called <.>; it has identity element one, and it must distribute over <+>.

Laws

Normal Monoid laws

(a <+> b) <+> c = a <+> (b <+> c)
zero <+> a = a <+> zero = a
(a <.> b) <.> c = a <.> (b <.> c)
one <.> a = a <.> one = a

Commutativity of <+>

a <+> b = b <+> a

Distribution of <.> over <+>

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

Annihilation

zero <.> a = a <.> zero = zero

An ordered semiring follows the laws: x <= y => x <+> z <= y <+> z x <= y => x <+> z <= y <+> z zero <= z && x <= y => x <.> z <= y <.> z && z <.> x <= z <.> y

Methods

zero :: a

The identity of <+>.

one :: a

The identity of <.>.

(<.>) :: a -> a -> a infixl 7

An associative binary operation, which distributes over <+>.

(<+>) :: a -> a -> a infixl 6

An associative, commutative binary operation.

zero :: Num a => a

The identity of <+>.

one :: Num a => a

The identity of <.>.

(<+>) :: Num a => a -> a -> a infixl 6

An associative, commutative binary operation.

(<.>) :: Num a => a -> a -> a infixl 7

An associative binary operation, which distributes over <+>.

Instances

Semiring Bool

Methods

zero :: Bool

one :: Bool

(<.>) :: Bool -> Bool -> Bool

(<+>) :: Bool -> Bool -> Bool

Semiring Double

Methods

zero :: Double

one :: Double

(<.>) :: Double -> Double -> Double

(<+>) :: Double -> Double -> Double

Semiring Float

Methods

zero :: Float

one :: Float

(<.>) :: Float -> Float -> Float

(<+>) :: Float -> Float -> Float

Semiring Int

Methods

zero :: Int

one :: Int

(<.>) :: Int -> Int -> Int

(<+>) :: Int -> Int -> Int

Semiring Int8

Methods

zero :: Int8

one :: Int8

(<.>) :: Int8 -> Int8 -> Int8

(<+>) :: Int8 -> Int8 -> Int8

Semiring Int16

Methods

zero :: Int16

one :: Int16

(<.>) :: Int16 -> Int16 -> Int16

(<+>) :: Int16 -> Int16 -> Int16

Semiring Int32

Methods

zero :: Int32

one :: Int32

(<.>) :: Int32 -> Int32 -> Int32

(<+>) :: Int32 -> Int32 -> Int32

Semiring Int64

Methods

zero :: Int64

one :: Int64

(<.>) :: Int64 -> Int64 -> Int64

(<+>) :: Int64 -> Int64 -> Int64

Semiring Integer

Methods

zero :: Integer

one :: Integer

(<.>) :: Integer -> Integer -> Integer

(<+>) :: Integer -> Integer -> Integer

Semiring Word

Methods

zero :: Word

one :: Word

(<.>) :: Word -> Word -> Word

(<+>) :: Word -> Word -> Word

Semiring Word8

Methods

zero :: Word8

one :: Word8

(<.>) :: Word8 -> Word8 -> Word8

(<+>) :: Word8 -> Word8 -> Word8

Semiring Word16

Methods

zero :: Word16

one :: Word16

(<.>) :: Word16 -> Word16 -> Word16

(<+>) :: Word16 -> Word16 -> Word16

Semiring Word32

Methods

zero :: Word32

one :: Word32

(<.>) :: Word32 -> Word32 -> Word32

(<+>) :: Word32 -> Word32 -> Word32

Semiring Word64

Methods

zero :: Word64

one :: Word64

(<.>) :: Word64 -> Word64 -> Word64

(<+>) :: Word64 -> Word64 -> Word64

Semiring ()

Methods

zero :: ()

one :: ()

(<.>) :: () -> () -> ()

(<+>) :: () -> () -> ()

Semiring Natural

Methods

zero :: Natural

one :: Natural

(<.>) :: Natural -> Natural -> Natural

(<+>) :: Natural -> Natural -> Natural

Semiring CDev

Methods

zero :: CDev

one :: CDev

(<.>) :: CDev -> CDev -> CDev

(<+>) :: CDev -> CDev -> CDev

Semiring CIno

Methods

zero :: CIno

one :: CIno

(<.>) :: CIno -> CIno -> CIno

(<+>) :: CIno -> CIno -> CIno

Semiring CMode

Methods

zero :: CMode

one :: CMode

(<.>) :: CMode -> CMode -> CMode

(<+>) :: CMode -> CMode -> CMode

Semiring COff

Methods

zero :: COff

one :: COff

(<.>) :: COff -> COff -> COff

(<+>) :: COff -> COff -> COff

Semiring CPid

Methods

zero :: CPid

one :: CPid

(<.>) :: CPid -> CPid -> CPid

(<+>) :: CPid -> CPid -> CPid

Semiring CSsize

Methods

zero :: CSsize

one :: CSsize

(<.>) :: CSsize -> CSsize -> CSsize

(<+>) :: CSsize -> CSsize -> CSsize

Semiring CGid

Methods

zero :: CGid

one :: CGid

(<.>) :: CGid -> CGid -> CGid

(<+>) :: CGid -> CGid -> CGid

Semiring CNlink

Methods

zero :: CNlink

one :: CNlink

(<.>) :: CNlink -> CNlink -> CNlink

(<+>) :: CNlink -> CNlink -> CNlink

Semiring CUid

Methods

zero :: CUid

one :: CUid

(<.>) :: CUid -> CUid -> CUid

(<+>) :: CUid -> CUid -> CUid

Semiring CCc

Methods

zero :: CCc

one :: CCc

(<.>) :: CCc -> CCc -> CCc

(<+>) :: CCc -> CCc -> CCc

Semiring CSpeed

Methods

zero :: CSpeed

one :: CSpeed

(<.>) :: CSpeed -> CSpeed -> CSpeed

(<+>) :: CSpeed -> CSpeed -> CSpeed

Semiring CTcflag

Methods

zero :: CTcflag

one :: CTcflag

(<.>) :: CTcflag -> CTcflag -> CTcflag

(<+>) :: CTcflag -> CTcflag -> CTcflag

Semiring CRLim

Methods

zero :: CRLim

one :: CRLim

(<.>) :: CRLim -> CRLim -> CRLim

(<+>) :: CRLim -> CRLim -> CRLim

Semiring Fd

Methods

zero :: Fd

one :: Fd

(<.>) :: Fd -> Fd -> Fd

(<+>) :: Fd -> Fd -> Fd

Semiring WordPtr

Methods

zero :: WordPtr

one :: WordPtr

(<.>) :: WordPtr -> WordPtr -> WordPtr

(<+>) :: WordPtr -> WordPtr -> WordPtr

Semiring IntPtr

Methods

zero :: IntPtr

one :: IntPtr

(<.>) :: IntPtr -> IntPtr -> IntPtr

(<+>) :: IntPtr -> IntPtr -> IntPtr

Semiring CChar

Methods

zero :: CChar

one :: CChar

(<.>) :: CChar -> CChar -> CChar

(<+>) :: CChar -> CChar -> CChar

Semiring CSChar

Methods

zero :: CSChar

one :: CSChar

(<.>) :: CSChar -> CSChar -> CSChar

(<+>) :: CSChar -> CSChar -> CSChar

Semiring CUChar

Methods

zero :: CUChar

one :: CUChar

(<.>) :: CUChar -> CUChar -> CUChar

(<+>) :: CUChar -> CUChar -> CUChar

Semiring CShort

Methods

zero :: CShort

one :: CShort

(<.>) :: CShort -> CShort -> CShort

(<+>) :: CShort -> CShort -> CShort

Semiring CUShort

Methods

zero :: CUShort

one :: CUShort

(<.>) :: CUShort -> CUShort -> CUShort

(<+>) :: CUShort -> CUShort -> CUShort

Semiring CInt

Methods

zero :: CInt

one :: CInt

(<.>) :: CInt -> CInt -> CInt

(<+>) :: CInt -> CInt -> CInt

Semiring CUInt

Methods

zero :: CUInt

one :: CUInt

(<.>) :: CUInt -> CUInt -> CUInt

(<+>) :: CUInt -> CUInt -> CUInt

Semiring CLong

Methods

zero :: CLong

one :: CLong

(<.>) :: CLong -> CLong -> CLong

(<+>) :: CLong -> CLong -> CLong

Semiring CULong

Methods

zero :: CULong

one :: CULong

(<.>) :: CULong -> CULong -> CULong

(<+>) :: CULong -> CULong -> CULong

Semiring CLLong

Methods

zero :: CLLong

one :: CLLong

(<.>) :: CLLong -> CLLong -> CLLong

(<+>) :: CLLong -> CLLong -> CLLong

Semiring CULLong

Methods

zero :: CULLong

one :: CULLong

(<.>) :: CULLong -> CULLong -> CULLong

(<+>) :: CULLong -> CULLong -> CULLong

Semiring CFloat

Methods

zero :: CFloat

one :: CFloat

(<.>) :: CFloat -> CFloat -> CFloat

(<+>) :: CFloat -> CFloat -> CFloat

Semiring CDouble

Methods

zero :: CDouble

one :: CDouble

(<.>) :: CDouble -> CDouble -> CDouble

(<+>) :: CDouble -> CDouble -> CDouble

Semiring CPtrdiff

Methods

zero :: CPtrdiff

one :: CPtrdiff

(<.>) :: CPtrdiff -> CPtrdiff -> CPtrdiff

(<+>) :: CPtrdiff -> CPtrdiff -> CPtrdiff

Semiring CSize

Methods

zero :: CSize

one :: CSize

(<.>) :: CSize -> CSize -> CSize

(<+>) :: CSize -> CSize -> CSize

Semiring CWchar

Methods

zero :: CWchar

one :: CWchar

(<.>) :: CWchar -> CWchar -> CWchar

(<+>) :: CWchar -> CWchar -> CWchar

Semiring CSigAtomic

Methods

zero :: CSigAtomic

one :: CSigAtomic

(<.>) :: CSigAtomic -> CSigAtomic -> CSigAtomic

(<+>) :: CSigAtomic -> CSigAtomic -> CSigAtomic

Semiring CClock

Methods

zero :: CClock

one :: CClock

(<.>) :: CClock -> CClock -> CClock

(<+>) :: CClock -> CClock -> CClock

Semiring CTime

Methods

zero :: CTime

one :: CTime

(<.>) :: CTime -> CTime -> CTime

(<+>) :: CTime -> CTime -> CTime

Semiring CUSeconds

Methods

zero :: CUSeconds

one :: CUSeconds

(<.>) :: CUSeconds -> CUSeconds -> CUSeconds

(<+>) :: CUSeconds -> CUSeconds -> CUSeconds

Semiring CSUSeconds

Methods

zero :: CSUSeconds

one :: CSUSeconds

(<.>) :: CSUSeconds -> CSUSeconds -> CSUSeconds

(<+>) :: CSUSeconds -> CSUSeconds -> CSUSeconds

Semiring CIntPtr

Methods

zero :: CIntPtr

one :: CIntPtr

(<.>) :: CIntPtr -> CIntPtr -> CIntPtr

(<+>) :: CIntPtr -> CIntPtr -> CIntPtr

Semiring CUIntPtr

Methods

zero :: CUIntPtr

one :: CUIntPtr

(<.>) :: CUIntPtr -> CUIntPtr -> CUIntPtr

(<+>) :: CUIntPtr -> CUIntPtr -> CUIntPtr

Semiring CIntMax

Methods

zero :: CIntMax

one :: CIntMax

(<.>) :: CIntMax -> CIntMax -> CIntMax

(<+>) :: CIntMax -> CIntMax -> CIntMax

Semiring CUIntMax

Methods

zero :: CUIntMax

one :: CUIntMax

(<.>) :: CUIntMax -> CUIntMax -> CUIntMax

(<+>) :: CUIntMax -> CUIntMax -> CUIntMax

Semiring All

Methods

zero :: All

one :: All

(<.>) :: All -> All -> All

(<+>) :: All -> All -> All

Semiring Any

Methods

zero :: Any

one :: Any

(<.>) :: Any -> Any -> Any

(<+>) :: Any -> Any -> Any

Semiring a => Semiring [a]

A polynomial in x can be defined as a list of its coefficients, where the ith element is the coefficient of x^i. This is the semiring for such a list. Adapted from here.

Methods

zero :: [a]

one :: [a]

(<.>) :: [a] -> [a] -> [a]

(<+>) :: [a] -> [a] -> [a]

Integral a => Semiring (Ratio a)

Methods

zero :: Ratio a

one :: Ratio a

(<.>) :: Ratio a -> Ratio a -> Ratio a

(<+>) :: Ratio a -> Ratio a -> Ratio a

Semiring a => Semiring (Identity a)

Methods

zero :: Identity a

one :: Identity a

(<.>) :: Identity a -> Identity a -> Identity a

(<+>) :: Identity a -> Identity a -> Identity a

HasResolution a => Semiring (Fixed a)

Methods

zero :: Fixed a

one :: Fixed a

(<.>) :: Fixed a -> Fixed a -> Fixed a

(<+>) :: Fixed a -> Fixed a -> Fixed a

RealFloat a => Semiring (Complex a)

Methods

zero :: Complex a

one :: Complex a

(<.>) :: Complex a -> Complex a -> Complex a

(<+>) :: Complex a -> Complex a -> Complex a

Monoid a => Semiring (Endo a)

This is not a true semiring. In particular, it requires the underlying monoid to be commutative, and even then, it is only a near semiring. It is, however, extremely useful. For instance, this type:

forall a. Endo (Endo a)

Is a valid encoding of church numerals, with addition and multiplication being their semiring variants.

Methods

zero :: Endo a

one :: Endo a

(<.>) :: Endo a -> Endo a -> Endo a

(<+>) :: Endo a -> Endo a -> Endo a

Semiring a => Semiring (Sum a)

Methods

zero :: Sum a

one :: Sum a

(<.>) :: Sum a -> Sum a -> Sum a

(<+>) :: Sum a -> Sum a -> Sum a

Semiring a => Semiring (Product a)

Methods

zero :: Product a

one :: Product a

(<.>) :: Product a -> Product a -> Product a

(<+>) :: Product a -> Product a -> Product a

Semiring a => Semiring (Infinite a)

Not lawful. Only for convenience.

Methods

zero :: Infinite a

one :: Infinite a

(<.>) :: Infinite a -> Infinite a -> Infinite a

(<+>) :: Infinite a -> Infinite a -> Infinite a

Semiring a => Semiring (PositiveInfinite a)

Not lawful. Only for convenience.

Methods

zero :: PositiveInfinite a

one :: PositiveInfinite a

(<.>) :: PositiveInfinite a -> PositiveInfinite a -> PositiveInfinite a

(<+>) :: PositiveInfinite a -> PositiveInfinite a -> PositiveInfinite a

Semiring a => Semiring (NegativeInfinite a)

Not lawful. Only for convenience.

Methods

zero :: NegativeInfinite a

one :: NegativeInfinite a

(<.>) :: NegativeInfinite a -> NegativeInfinite a -> NegativeInfinite a

(<+>) :: NegativeInfinite a -> NegativeInfinite a -> NegativeInfinite a

(Semiring a, Ord a, HasNegativeInfinity a) => Semiring (Max a)

Methods

zero :: Max a

one :: Max a

(<.>) :: Max a -> Max a -> Max a

(<+>) :: Max a -> Max a -> Max a

(Semiring a, Ord a, HasPositiveInfinity a) => Semiring (Min a)

Methods

zero :: Min a

one :: Min a

(<.>) :: Min a -> Min a -> Min a

(<+>) :: Min a -> Min a -> Min a

Semiring a => Semiring (Mul a)

Methods

zero :: Mul a

one :: Mul a

(<.>) :: Mul a -> Mul a -> Mul a

(<+>) :: Mul a -> Mul a -> Mul a

Semiring a => Semiring (Add a)

Methods

zero :: Add a

one :: Add a

(<.>) :: Add a -> Add a -> Add a

(<+>) :: Add a -> Add a -> Add a

Semiring (Free a)

Methods

zero :: Free a

one :: Free a

(<.>) :: Free a -> Free a -> Free a

(<+>) :: Free a -> Free a -> Free a

(Floating a, HasPositiveInfinity a) => Semiring (Log a)

Methods

zero :: Log a

one :: Log a

(<.>) :: Log a -> Log a -> Log a

(<+>) :: Log a -> Log a -> Log a

(Ord a, Semiring a) => Semiring (Viterbi a)

Methods

zero :: Viterbi a

one :: Viterbi a

(<.>) :: Viterbi a -> Viterbi a -> Viterbi a

(<+>) :: Viterbi a -> Viterbi a -> Viterbi a

(Ord a, Num a) => Semiring (Łukasiewicz a)

Methods

zero :: Łukasiewicz a

one :: Łukasiewicz a

(<.>) :: Łukasiewicz a -> Łukasiewicz a -> Łukasiewicz a

(<+>) :: Łukasiewicz a -> Łukasiewicz a -> Łukasiewicz a

(Integral a, Semiring a) => Semiring (Division a)

Only expects positive numbers

Methods

zero :: Division a

one :: Division a

(<.>) :: Division a -> Division a -> Division a

(<+>) :: Division a -> Division a -> Division a

(Bounded a, Ord a) => Semiring (Bottleneck a)

Methods

zero :: Bottleneck a

one :: Bottleneck a

(<.>) :: Bottleneck a -> Bottleneck a -> Bottleneck a

(<+>) :: Bottleneck a -> Bottleneck a -> Bottleneck a

Semiring b => Semiring (a -> b)

The (->) instance is analogous to the one for Monoid.

Methods

zero :: a -> b

one :: a -> b

(<.>) :: (a -> b) -> (a -> b) -> a -> b

(<+>) :: (a -> b) -> (a -> b) -> a -> b

(Semiring a0, Semiring a1) => Semiring (a0, a1)

Methods

zero :: (a0, a1)

one :: (a0, a1)

(<.>) :: (a0, a1) -> (a0, a1) -> (a0, a1)

(<+>) :: (a0, a1) -> (a0, a1) -> (a0, a1)

(Semiring a0, Semiring a1, Semiring a2) => Semiring (a0, a1, a2)

Methods

zero :: (a0, a1, a2)

one :: (a0, a1, a2)

(<.>) :: (a0, a1, a2) -> (a0, a1, a2) -> (a0, a1, a2)

(<+>) :: (a0, a1, a2) -> (a0, a1, a2) -> (a0, a1, a2)

Semiring a => Semiring (Const * a b)

Methods

zero :: Const * a b

one :: Const * a b

(<.>) :: Const * a b -> Const * a b -> Const * a b

(<+>) :: Const * a b -> Const * a b -> Const * a b

(Semiring a0, Semiring a1, Semiring a2, Semiring a3) => Semiring (a0, a1, a2, a3)

Methods

zero :: (a0, a1, a2, a3)

one :: (a0, a1, a2, a3)

(<.>) :: (a0, a1, a2, a3) -> (a0, a1, a2, a3) -> (a0, a1, a2, a3)

(<+>) :: (a0, a1, a2, a3) -> (a0, a1, a2, a3) -> (a0, a1, a2, a3)

(Semiring a0, Semiring a1, Semiring a2, Semiring a3, Semiring a4) => Semiring (a0, a1, a2, a3, a4)

Methods

zero :: (a0, a1, a2, a3, a4)

one :: (a0, a1, a2, a3, a4)

(<.>) :: (a0, a1, a2, a3, a4) -> (a0, a1, a2, a3, a4) -> (a0, a1, a2, a3, a4)

(<+>) :: (a0, a1, a2, a3, a4) -> (a0, a1, a2, a3, a4) -> (a0, a1, a2, a3, a4)

(Semiring a0, Semiring a1, Semiring a2, Semiring a3, Semiring a4, Semiring a5) => Semiring (a0, a1, a2, a3, a4, a5)

Methods

zero :: (a0, a1, a2, a3, a4, a5)

one :: (a0, a1, a2, a3, a4, a5)

(<.>) :: (a0, a1, a2, a3, a4, a5) -> (a0, a1, a2, a3, a4, a5) -> (a0, a1, a2, a3, a4, a5)

(<+>) :: (a0, a1, a2, a3, a4, a5) -> (a0, a1, a2, a3, a4, a5) -> (a0, a1, a2, a3, a4, a5)

(Semiring a0, Semiring a1, Semiring a2, Semiring a3, Semiring a4, Semiring a5, Semiring a6) => Semiring (a0, a1, a2, a3, a4, a5, a6)

Methods

zero :: (a0, a1, a2, a3, a4, a5, a6)

one :: (a0, a1, a2, a3, a4, a5, a6)

(<.>) :: (a0, a1, a2, a3, a4, a5, a6) -> (a0, a1, a2, a3, a4, a5, a6) -> (a0, a1, a2, a3, a4, a5, a6)

(<+>) :: (a0, a1, a2, a3, a4, a5, a6) -> (a0, a1, a2, a3, a4, a5, a6) -> (a0, a1, a2, a3, a4, a5, a6)

(Semiring a0, Semiring a1, Semiring a2, Semiring a3, Semiring a4, Semiring a5, Semiring a6, Semiring a7) => Semiring (a0, a1, a2, a3, a4, a5, a6, a7)

Methods

zero :: (a0, a1, a2, a3, a4, a5, a6, a7)

one :: (a0, a1, a2, a3, a4, a5, a6, a7)

(<.>) :: (a0, a1, a2, a3, a4, a5, a6, a7) -> (a0, a1, a2, a3, a4, a5, a6, a7) -> (a0, a1, a2, a3, a4, a5, a6, a7)

(<+>) :: (a0, a1, a2, a3, a4, a5, a6, a7) -> (a0, a1, a2, a3, a4, a5, a6, a7) -> (a0, a1, a2, a3, a4, a5, a6, a7)

(Semiring a0, Semiring a1, Semiring a2, Semiring a3, Semiring a4, Semiring a5, Semiring a6, Semiring a7, Semiring a8) => Semiring (a0, a1, a2, a3, a4, a5, a6, a7, a8)

Methods

zero :: (a0, a1, a2, a3, a4, a5, a6, a7, a8)

one :: (a0, a1, a2, a3, a4, a5, a6, a7, a8)

(<.>) :: (a0, a1, a2, a3, a4, a5, a6, a7, a8) -> (a0, a1, a2, a3, a4, a5, a6, a7, a8) -> (a0, a1, a2, a3, a4, a5, a6, a7, a8)

(<+>) :: (a0, a1, a2, a3, a4, a5, a6, a7, a8) -> (a0, a1, a2, a3, a4, a5, a6, a7, a8) -> (a0, a1, a2, a3, a4, a5, a6, a7, a8)

class Semiring a => StarSemiring a where

A Star semiring adds one operation, star to a Semiring, such that it follows the law:

star x = one <+> x <.> star x = one <+> star x <.> x

For the semiring of types, this is equivalent to a list. When looking at the Applicative and Alternative classes as (near-) semirings, this is equivalent to the many operation.

Another operation, plus, can be defined in relation to star:

plus x = x <.> star x

This should be recognizable as a non-empty list on types, or the some operation in Alternative.

Minimal complete definition

star | plus

Methods

star :: a -> a

plus :: a -> a

Instances

StarSemiring Bool

Methods

star :: Bool -> Bool

plus :: Bool -> Bool

StarSemiring ()

Methods

star :: () -> ()

plus :: () -> ()

StarSemiring All

Methods

star :: All -> All

plus :: All -> All

StarSemiring Any

Methods

star :: Any -> Any

plus :: Any -> Any

(Monoid a, Eq a) => StarSemiring (Endo a)

Methods

star :: Endo a -> Endo a

plus :: Endo a -> Endo a

(Eq a, Semiring a) => StarSemiring (PositiveInfinite a)

Methods

star :: PositiveInfinite a -> PositiveInfinite a

plus :: PositiveInfinite a -> PositiveInfinite a

(Semiring a, Ord a, HasPositiveInfinity a, HasNegativeInfinity a) => StarSemiring (Max a)

Methods

star :: Max a -> Max a

plus :: Max a -> Max a

(Semiring a, Ord a, HasPositiveInfinity a, HasNegativeInfinity a) => StarSemiring (Min a)

Methods

star :: Min a -> Min a

plus :: Min a -> Min a

StarSemiring a => StarSemiring (Mul a)

Methods

star :: Mul a -> Mul a

plus :: Mul a -> Mul a

StarSemiring a => StarSemiring (Add a)

Methods

star :: Add a -> Add a

plus :: Add a -> Add a

StarSemiring b => StarSemiring (a -> b)

Methods

star :: (a -> b) -> a -> b

plus :: (a -> b) -> a -> b

(StarSemiring a0, StarSemiring a1) => StarSemiring (a0, a1)

Methods

star :: (a0, a1) -> (a0, a1)

plus :: (a0, a1) -> (a0, a1)

(StarSemiring a0, StarSemiring a1, StarSemiring a2) => StarSemiring (a0, a1, a2)

Methods

star :: (a0, a1, a2) -> (a0, a1, a2)

plus :: (a0, a1, a2) -> (a0, a1, a2)

(StarSemiring a0, StarSemiring a1, StarSemiring a2, StarSemiring a3) => StarSemiring (a0, a1, a2, a3)

Methods

star :: (a0, a1, a2, a3) -> (a0, a1, a2, a3)

plus :: (a0, a1, a2, a3) -> (a0, a1, a2, a3)

(StarSemiring a0, StarSemiring a1, StarSemiring a2, StarSemiring a3, StarSemiring a4) => StarSemiring (a0, a1, a2, a3, a4)

Methods

star :: (a0, a1, a2, a3, a4) -> (a0, a1, a2, a3, a4)

plus :: (a0, a1, a2, a3, a4) -> (a0, a1, a2, a3, a4)

(StarSemiring a0, StarSemiring a1, StarSemiring a2, StarSemiring a3, StarSemiring a4, StarSemiring a5) => StarSemiring (a0, a1, a2, a3, a4, a5)

Methods

star :: (a0, a1, a2, a3, a4, a5) -> (a0, a1, a2, a3, a4, a5)

plus :: (a0, a1, a2, a3, a4, a5) -> (a0, a1, a2, a3, a4, a5)

(StarSemiring a0, StarSemiring a1, StarSemiring a2, StarSemiring a3, StarSemiring a4, StarSemiring a5, StarSemiring a6) => StarSemiring (a0, a1, a2, a3, a4, a5, a6)

Methods

star :: (a0, a1, a2, a3, a4, a5, a6) -> (a0, a1, a2, a3, a4, a5, a6)

plus :: (a0, a1, a2, a3, a4, a5, a6) -> (a0, a1, a2, a3, a4, a5, a6)

(StarSemiring a0, StarSemiring a1, StarSemiring a2, StarSemiring a3, StarSemiring a4, StarSemiring a5, StarSemiring a6, StarSemiring a7) => StarSemiring (a0, a1, a2, a3, a4, a5, a6, a7)

Methods

star :: (a0, a1, a2, a3, a4, a5, a6, a7) -> (a0, a1, a2, a3, a4, a5, a6, a7)

plus :: (a0, a1, a2, a3, a4, a5, a6, a7) -> (a0, a1, a2, a3, a4, a5, a6, a7)

(StarSemiring a0, StarSemiring a1, StarSemiring a2, StarSemiring a3, StarSemiring a4, StarSemiring a5, StarSemiring a6, StarSemiring a7, StarSemiring a8) => StarSemiring (a0, a1, a2, a3, a4, a5, a6, a7, a8)

Methods

star :: (a0, a1, a2, a3, a4, a5, a6, a7, a8) -> (a0, a1, a2, a3, a4, a5, a6, a7, a8)

plus :: (a0, a1, a2, a3, a4, a5, a6, a7, a8) -> (a0, a1, a2, a3, a4, a5, a6, a7, a8)

class HasPositiveInfinity a where

Methods

positiveInfinity :: a

positiveInfinity :: RealFloat a => a

Instances

HasPositiveInfinity Double

Methods

positiveInfinity :: Double

HasPositiveInfinity Float

Methods

positiveInfinity :: Float

HasPositiveInfinity CFloat

Methods

positiveInfinity :: CFloat

HasPositiveInfinity CDouble

Methods

positiveInfinity :: CDouble

HasPositiveInfinity (Infinite a)

Methods

positiveInfinity :: Infinite a

HasPositiveInfinity (PositiveInfinite a)

Methods

positiveInfinity :: PositiveInfinite a

class HasNegativeInfinity a where

Methods

negativeInfinity :: a

negativeInfinity :: RealFloat a => a

Instances

HasNegativeInfinity Double

Methods

negativeInfinity :: Double

HasNegativeInfinity Float

Methods

negativeInfinity :: Float

HasNegativeInfinity CFloat

Methods

negativeInfinity :: CFloat

HasNegativeInfinity CDouble

Methods

negativeInfinity :: CDouble

HasNegativeInfinity (Infinite a)

Methods

negativeInfinity :: Infinite a

HasNegativeInfinity (NegativeInfinite a)

Methods

negativeInfinity :: NegativeInfinite a

data PositiveInfinite a

Constructors

PosFinite !a

PositiveInfinity

Instances

Functor PositiveInfinite

Methods

fmap :: (a -> b) -> PositiveInfinite a -> PositiveInfinite b

(<$) :: a -> PositiveInfinite b -> PositiveInfinite a

Applicative PositiveInfinite

Methods

pure :: a -> PositiveInfinite a

(<*>) :: PositiveInfinite (a -> b) -> PositiveInfinite a -> PositiveInfinite b

(*>) :: PositiveInfinite a -> PositiveInfinite b -> PositiveInfinite b

(<*) :: PositiveInfinite a -> PositiveInfinite b -> PositiveInfinite a

Foldable PositiveInfinite

Methods

fold :: Monoid m => PositiveInfinite m -> m

foldMap :: Monoid m => (a -> m) -> PositiveInfinite a -> m

foldr :: (a -> b -> b) -> b -> PositiveInfinite a -> b

foldr' :: (a -> b -> b) -> b -> PositiveInfinite a -> b

foldl :: (b -> a -> b) -> b -> PositiveInfinite a -> b

foldl' :: (b -> a -> b) -> b -> PositiveInfinite a -> b

foldr1 :: (a -> a -> a) -> PositiveInfinite a -> a

foldl1 :: (a -> a -> a) -> PositiveInfinite a -> a

toList :: PositiveInfinite a -> [a]

null :: PositiveInfinite a -> Bool

length :: PositiveInfinite a -> Int

elem :: Eq a => a -> PositiveInfinite a -> Bool

maximum :: Ord a => PositiveInfinite a -> a

minimum :: Ord a => PositiveInfinite a -> a

sum :: Num a => PositiveInfinite a -> a

product :: Num a => PositiveInfinite a -> a

Traversable PositiveInfinite

Methods

traverse :: Applicative f => (a -> f b) -> PositiveInfinite a -> f (PositiveInfinite b)

sequenceA :: Applicative f => PositiveInfinite (f a) -> f (PositiveInfinite a)

mapM :: Monad m => (a -> m b) -> PositiveInfinite a -> m (PositiveInfinite b)

sequence :: Monad m => PositiveInfinite (m a) -> m (PositiveInfinite a)

Generic1 PositiveInfinite

Associated Types

type Rep1 (PositiveInfinite :: * -> *) :: * -> *

Methods

from1 :: PositiveInfinite a -> Rep1 PositiveInfinite a

to1 :: Rep1 PositiveInfinite a -> PositiveInfinite a

Bounded a => Bounded (PositiveInfinite a)

Methods

minBound :: PositiveInfinite a

maxBound :: PositiveInfinite a

(Enum a, Bounded a, Eq a) => Enum (PositiveInfinite a)

Methods

succ :: PositiveInfinite a -> PositiveInfinite a

pred :: PositiveInfinite a -> PositiveInfinite a

toEnum :: Int -> PositiveInfinite a

fromEnum :: PositiveInfinite a -> Int

enumFrom :: PositiveInfinite a -> [PositiveInfinite a]

enumFromThen :: PositiveInfinite a -> PositiveInfinite a -> [PositiveInfinite a]

enumFromTo :: PositiveInfinite a -> PositiveInfinite a -> [PositiveInfinite a]

enumFromThenTo :: PositiveInfinite a -> PositiveInfinite a -> PositiveInfinite a -> [PositiveInfinite a]

Eq a => Eq (PositiveInfinite a)

Methods

(==) :: PositiveInfinite a -> PositiveInfinite a -> Bool

(/=) :: PositiveInfinite a -> PositiveInfinite a -> Bool

Num a => Num (PositiveInfinite a)

Methods

(+) :: PositiveInfinite a -> PositiveInfinite a -> PositiveInfinite a

(-) :: PositiveInfinite a -> PositiveInfinite a -> PositiveInfinite a

(*) :: PositiveInfinite a -> PositiveInfinite a -> PositiveInfinite a

negate :: PositiveInfinite a -> PositiveInfinite a

abs :: PositiveInfinite a -> PositiveInfinite a

signum :: PositiveInfinite a -> PositiveInfinite a

fromInteger :: Integer -> PositiveInfinite a

Ord a => Ord (PositiveInfinite a)

Methods

compare :: PositiveInfinite a -> PositiveInfinite a -> Ordering

(<) :: PositiveInfinite a -> PositiveInfinite a -> Bool

(<=) :: PositiveInfinite a -> PositiveInfinite a -> Bool

(>) :: PositiveInfinite a -> PositiveInfinite a -> Bool

(>=) :: PositiveInfinite a -> PositiveInfinite a -> Bool

max :: PositiveInfinite a -> PositiveInfinite a -> PositiveInfinite a

min :: PositiveInfinite a -> PositiveInfinite a -> PositiveInfinite a

Read a => Read (PositiveInfinite a)

Methods

readsPrec :: Int -> ReadS (PositiveInfinite a)

readList :: ReadS [PositiveInfinite a]

readPrec :: ReadPrec (PositiveInfinite a)

readListPrec :: ReadPrec [PositiveInfinite a]

Show a => Show (PositiveInfinite a)

Methods

showsPrec :: Int -> PositiveInfinite a -> ShowS

show :: PositiveInfinite a -> String

showList :: [PositiveInfinite a] -> ShowS

Generic (PositiveInfinite a)

Associated Types

type Rep (PositiveInfinite a) :: * -> *

Methods

from :: PositiveInfinite a -> Rep (PositiveInfinite a) x

to :: Rep (PositiveInfinite a) x -> PositiveInfinite a

Monoid a => Monoid (PositiveInfinite a)

Methods

mempty :: PositiveInfinite a

mappend :: PositiveInfinite a -> PositiveInfinite a -> PositiveInfinite a

mconcat :: [PositiveInfinite a] -> PositiveInfinite a

Storable a => Storable (PositiveInfinite a)

Methods

sizeOf :: PositiveInfinite a -> Int

alignment :: PositiveInfinite a -> Int

peekElemOff :: Ptr (PositiveInfinite a) -> Int -> IO (PositiveInfinite a)

pokeElemOff :: Ptr (PositiveInfinite a) -> Int -> PositiveInfinite a -> IO ()

peekByteOff :: Ptr b -> Int -> IO (PositiveInfinite a)

pokeByteOff :: Ptr b -> Int -> PositiveInfinite a -> IO ()

peek :: Ptr (PositiveInfinite a) -> IO (PositiveInfinite a)

poke :: Ptr (PositiveInfinite a) -> PositiveInfinite a -> IO ()

HasPositiveInfinity (PositiveInfinite a)

Methods

positiveInfinity :: PositiveInfinite a

(Eq a, Semiring a) => StarSemiring (PositiveInfinite a)

Methods

star :: PositiveInfinite a -> PositiveInfinite a

plus :: PositiveInfinite a -> PositiveInfinite a

Semiring a => Semiring (PositiveInfinite a)

Not lawful. Only for convenience.

Methods

zero :: PositiveInfinite a

one :: PositiveInfinite a

(<.>) :: PositiveInfinite a -> PositiveInfinite a -> PositiveInfinite a

(<+>) :: PositiveInfinite a -> PositiveInfinite a -> PositiveInfinite a

type Rep1 PositiveInfinite

type Rep1 PositiveInfinite = D1 (MetaData "PositiveInfinite" "Data.Semiring.Infinite" "semiring-num-0.7.0.0-LZTdLH4bZPrFoYJgqNzb7N" False) ((:+:) (C1 (MetaCons "PosFinite" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness SourceStrict DecidedStrict) Par1)) (C1 (MetaCons "PositiveInfinity" PrefixI False) U1))

type Rep (PositiveInfinite a)

type Rep (PositiveInfinite a) = D1 (MetaData "PositiveInfinite" "Data.Semiring.Infinite" "semiring-num-0.7.0.0-LZTdLH4bZPrFoYJgqNzb7N" False) ((:+:) (C1 (MetaCons "PosFinite" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 a))) (C1 (MetaCons "PositiveInfinity" PrefixI False) U1))

data NegativeInfinite a

Constructors

NegativeInfinity

NegFinite !a

Instances

Functor NegativeInfinite

Methods

fmap :: (a -> b) -> NegativeInfinite a -> NegativeInfinite b

(<$) :: a -> NegativeInfinite b -> NegativeInfinite a

Applicative NegativeInfinite

Methods

pure :: a -> NegativeInfinite a

(<*>) :: NegativeInfinite (a -> b) -> NegativeInfinite a -> NegativeInfinite b

(*>) :: NegativeInfinite a -> NegativeInfinite b -> NegativeInfinite b

(<*) :: NegativeInfinite a -> NegativeInfinite b -> NegativeInfinite a

Foldable NegativeInfinite

Methods

fold :: Monoid m => NegativeInfinite m -> m

foldMap :: Monoid m => (a -> m) -> NegativeInfinite a -> m

foldr :: (a -> b -> b) -> b -> NegativeInfinite a -> b

foldr' :: (a -> b -> b) -> b -> NegativeInfinite a -> b

foldl :: (b -> a -> b) -> b -> NegativeInfinite a -> b

foldl' :: (b -> a -> b) -> b -> NegativeInfinite a -> b

foldr1 :: (a -> a -> a) -> NegativeInfinite a -> a

foldl1 :: (a -> a -> a) -> NegativeInfinite a -> a

toList :: NegativeInfinite a -> [a]

null :: NegativeInfinite a -> Bool

length :: NegativeInfinite a -> Int

elem :: Eq a => a -> NegativeInfinite a -> Bool

maximum :: Ord a => NegativeInfinite a -> a

minimum :: Ord a => NegativeInfinite a -> a

sum :: Num a => NegativeInfinite a -> a

product :: Num a => NegativeInfinite a -> a

Traversable NegativeInfinite

Methods

traverse :: Applicative f => (a -> f b) -> NegativeInfinite a -> f (NegativeInfinite b)

sequenceA :: Applicative f => NegativeInfinite (f a) -> f (NegativeInfinite a)

mapM :: Monad m => (a -> m b) -> NegativeInfinite a -> m (NegativeInfinite b)

sequence :: Monad m => NegativeInfinite (m a) -> m (NegativeInfinite a)

Generic1 NegativeInfinite

Associated Types

type Rep1 (NegativeInfinite :: * -> *) :: * -> *

Methods

from1 :: NegativeInfinite a -> Rep1 NegativeInfinite a

to1 :: Rep1 NegativeInfinite a -> NegativeInfinite a

Bounded a => Bounded (NegativeInfinite a)

Methods

minBound :: NegativeInfinite a

maxBound :: NegativeInfinite a

(Enum a, Bounded a, Eq a) => Enum (NegativeInfinite a)

Methods

succ :: NegativeInfinite a -> NegativeInfinite a

pred :: NegativeInfinite a -> NegativeInfinite a

toEnum :: Int -> NegativeInfinite a

fromEnum :: NegativeInfinite a -> Int

enumFrom :: NegativeInfinite a -> [NegativeInfinite a]

enumFromThen :: NegativeInfinite a -> NegativeInfinite a -> [NegativeInfinite a]

enumFromTo :: NegativeInfinite a -> NegativeInfinite a -> [NegativeInfinite a]

enumFromThenTo :: NegativeInfinite a -> NegativeInfinite a -> NegativeInfinite a -> [NegativeInfinite a]

Eq a => Eq (NegativeInfinite a)

Methods

(==) :: NegativeInfinite a -> NegativeInfinite a -> Bool

(/=) :: NegativeInfinite a -> NegativeInfinite a -> Bool

Num a => Num (NegativeInfinite a)

Methods

(+) :: NegativeInfinite a -> NegativeInfinite a -> NegativeInfinite a

(-) :: NegativeInfinite a -> NegativeInfinite a -> NegativeInfinite a

(*) :: NegativeInfinite a -> NegativeInfinite a -> NegativeInfinite a

negate :: NegativeInfinite a -> NegativeInfinite a

abs :: NegativeInfinite a -> NegativeInfinite a

signum :: NegativeInfinite a -> NegativeInfinite a

fromInteger :: Integer -> NegativeInfinite a

Ord a => Ord (NegativeInfinite a)

Methods

compare :: NegativeInfinite a -> NegativeInfinite a -> Ordering

(<) :: NegativeInfinite a -> NegativeInfinite a -> Bool

(<=) :: NegativeInfinite a -> NegativeInfinite a -> Bool

(>) :: NegativeInfinite a -> NegativeInfinite a -> Bool

(>=) :: NegativeInfinite a -> NegativeInfinite a -> Bool

max :: NegativeInfinite a -> NegativeInfinite a -> NegativeInfinite a

min :: NegativeInfinite a -> NegativeInfinite a -> NegativeInfinite a

Read a => Read (NegativeInfinite a)

Methods

readsPrec :: Int -> ReadS (NegativeInfinite a)

readList :: ReadS [NegativeInfinite a]

readPrec :: ReadPrec (NegativeInfinite a)

readListPrec :: ReadPrec [NegativeInfinite a]

Show a => Show (NegativeInfinite a)

Methods

showsPrec :: Int -> NegativeInfinite a -> ShowS

show :: NegativeInfinite a -> String

showList :: [NegativeInfinite a] -> ShowS

Generic (NegativeInfinite a)

Associated Types

type Rep (NegativeInfinite a) :: * -> *

Methods

from :: NegativeInfinite a -> Rep (NegativeInfinite a) x

to :: Rep (NegativeInfinite a) x -> NegativeInfinite a

Monoid a => Monoid (NegativeInfinite a)

Methods

mempty :: NegativeInfinite a

mappend :: NegativeInfinite a -> NegativeInfinite a -> NegativeInfinite a

mconcat :: [NegativeInfinite a] -> NegativeInfinite a

Storable a => Storable (NegativeInfinite a)

Methods

sizeOf :: NegativeInfinite a -> Int

alignment :: NegativeInfinite a -> Int

peekElemOff :: Ptr (NegativeInfinite a) -> Int -> IO (NegativeInfinite a)

pokeElemOff :: Ptr (NegativeInfinite a) -> Int -> NegativeInfinite a -> IO ()

peekByteOff :: Ptr b -> Int -> IO (NegativeInfinite a)

pokeByteOff :: Ptr b -> Int -> NegativeInfinite a -> IO ()

peek :: Ptr (NegativeInfinite a) -> IO (NegativeInfinite a)

poke :: Ptr (NegativeInfinite a) -> NegativeInfinite a -> IO ()

HasNegativeInfinity (NegativeInfinite a)

Methods

negativeInfinity :: NegativeInfinite a

Semiring a => Semiring (NegativeInfinite a)

Not lawful. Only for convenience.

Methods

zero :: NegativeInfinite a

one :: NegativeInfinite a

(<.>) :: NegativeInfinite a -> NegativeInfinite a -> NegativeInfinite a

(<+>) :: NegativeInfinite a -> NegativeInfinite a -> NegativeInfinite a

type Rep1 NegativeInfinite

type Rep1 NegativeInfinite = D1 (MetaData "NegativeInfinite" "Data.Semiring.Infinite" "semiring-num-0.7.0.0-LZTdLH4bZPrFoYJgqNzb7N" False) ((:+:) (C1 (MetaCons "NegativeInfinity" PrefixI False) U1) (C1 (MetaCons "NegFinite" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness SourceStrict DecidedStrict) Par1)))

type Rep (NegativeInfinite a)

type Rep (NegativeInfinite a) = D1 (MetaData "NegativeInfinite" "Data.Semiring.Infinite" "semiring-num-0.7.0.0-LZTdLH4bZPrFoYJgqNzb7N" False) ((:+:) (C1 (MetaCons "NegativeInfinity" PrefixI False) U1) (C1 (MetaCons "NegFinite" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 a))))

data Infinite a

Constructors

Negative

Finite !a

Positive

Instances

Functor Infinite

Methods

fmap :: (a -> b) -> Infinite a -> Infinite b

(<$) :: a -> Infinite b -> Infinite a

Applicative Infinite

Methods

pure :: a -> Infinite a

(<*>) :: Infinite (a -> b) -> Infinite a -> Infinite b

(*>) :: Infinite a -> Infinite b -> Infinite b

(<*) :: Infinite a -> Infinite b -> Infinite a

Foldable Infinite

Methods

fold :: Monoid m => Infinite m -> m

foldMap :: Monoid m => (a -> m) -> Infinite a -> m

foldr :: (a -> b -> b) -> b -> Infinite a -> b

foldr' :: (a -> b -> b) -> b -> Infinite a -> b

foldl :: (b -> a -> b) -> b -> Infinite a -> b

foldl' :: (b -> a -> b) -> b -> Infinite a -> b

foldr1 :: (a -> a -> a) -> Infinite a -> a

foldl1 :: (a -> a -> a) -> Infinite a -> a

toList :: Infinite a -> [a]

null :: Infinite a -> Bool

length :: Infinite a -> Int

elem :: Eq a => a -> Infinite a -> Bool

maximum :: Ord a => Infinite a -> a

minimum :: Ord a => Infinite a -> a

sum :: Num a => Infinite a -> a

product :: Num a => Infinite a -> a

Traversable Infinite

Methods

traverse :: Applicative f => (a -> f b) -> Infinite a -> f (Infinite b)

sequenceA :: Applicative f => Infinite (f a) -> f (Infinite a)

mapM :: Monad m => (a -> m b) -> Infinite a -> m (Infinite b)

sequence :: Monad m => Infinite (m a) -> m (Infinite a)

Generic1 Infinite

Associated Types

type Rep1 (Infinite :: * -> *) :: * -> *

Methods

from1 :: Infinite a -> Rep1 Infinite a

to1 :: Rep1 Infinite a -> Infinite a

Bounded (Infinite a)

Methods

minBound :: Infinite a

maxBound :: Infinite a

(Enum a, Bounded a, Eq a) => Enum (Infinite a)

Methods

succ :: Infinite a -> Infinite a

pred :: Infinite a -> Infinite a

toEnum :: Int -> Infinite a

fromEnum :: Infinite a -> Int

enumFrom :: Infinite a -> [Infinite a]

enumFromThen :: Infinite a -> Infinite a -> [Infinite a]

enumFromTo :: Infinite a -> Infinite a -> [Infinite a]

enumFromThenTo :: Infinite a -> Infinite a -> Infinite a -> [Infinite a]

Eq a => Eq (Infinite a)

Methods

(==) :: Infinite a -> Infinite a -> Bool

(/=) :: Infinite a -> Infinite a -> Bool

Num a => Num (Infinite a)

Methods

(+) :: Infinite a -> Infinite a -> Infinite a

(-) :: Infinite a -> Infinite a -> Infinite a

(*) :: Infinite a -> Infinite a -> Infinite a

negate :: Infinite a -> Infinite a

abs :: Infinite a -> Infinite a

signum :: Infinite a -> Infinite a

fromInteger :: Integer -> Infinite a

Ord a => Ord (Infinite a)

Methods

compare :: Infinite a -> Infinite a -> Ordering

(<) :: Infinite a -> Infinite a -> Bool

(<=) :: Infinite a -> Infinite a -> Bool

(>) :: Infinite a -> Infinite a -> Bool

(>=) :: Infinite a -> Infinite a -> Bool

max :: Infinite a -> Infinite a -> Infinite a

min :: Infinite a -> Infinite a -> Infinite a

Read a => Read (Infinite a)

Methods

readsPrec :: Int -> ReadS (Infinite a)

readList :: ReadS [Infinite a]

readPrec :: ReadPrec (Infinite a)

readListPrec :: ReadPrec [Infinite a]

Show a => Show (Infinite a)

Methods

showsPrec :: Int -> Infinite a -> ShowS

show :: Infinite a -> String

showList :: [Infinite a] -> ShowS

Generic (Infinite a)

Associated Types

type Rep (Infinite a) :: * -> *

Methods

from :: Infinite a -> Rep (Infinite a) x

to :: Rep (Infinite a) x -> Infinite a

Monoid a => Monoid (Infinite a)

Methods

mempty :: Infinite a

mappend :: Infinite a -> Infinite a -> Infinite a

mconcat :: [Infinite a] -> Infinite a

Storable a => Storable (Infinite a)

Methods

sizeOf :: Infinite a -> Int

alignment :: Infinite a -> Int

peekElemOff :: Ptr (Infinite a) -> Int -> IO (Infinite a)

pokeElemOff :: Ptr (Infinite a) -> Int -> Infinite a -> IO ()

peekByteOff :: Ptr b -> Int -> IO (Infinite a)

pokeByteOff :: Ptr b -> Int -> Infinite a -> IO ()

peek :: Ptr (Infinite a) -> IO (Infinite a)

poke :: Ptr (Infinite a) -> Infinite a -> IO ()

HasNegativeInfinity (Infinite a)

Methods

negativeInfinity :: Infinite a

HasPositiveInfinity (Infinite a)

Methods

positiveInfinity :: Infinite a

Semiring a => Semiring (Infinite a)

Not lawful. Only for convenience.

Methods

zero :: Infinite a

one :: Infinite a

(<.>) :: Infinite a -> Infinite a -> Infinite a

(<+>) :: Infinite a -> Infinite a -> Infinite a

type Rep1 Infinite

type Rep1 Infinite = D1 (MetaData "Infinite" "Data.Semiring.Infinite" "semiring-num-0.7.0.0-LZTdLH4bZPrFoYJgqNzb7N" False) ((:+:) (C1 (MetaCons "Negative" PrefixI False) U1) ((:+:) (C1 (MetaCons "Finite" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness SourceStrict DecidedStrict) Par1)) (C1 (MetaCons "Positive" PrefixI False) U1)))

type Rep (Infinite a)

type Rep (Infinite a) = D1 (MetaData "Infinite" "Data.Semiring.Infinite" "semiring-num-0.7.0.0-LZTdLH4bZPrFoYJgqNzb7N" False) ((:+:) (C1 (MetaCons "Negative" PrefixI False) U1) ((:+:) (C1 (MetaCons "Finite" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 a))) (C1 (MetaCons "Positive" PrefixI False) U1)))

newtype Add a

Monoid under <+>. Analogous to Sum, but uses the Semiring constraint, rather than Num.

Constructors

Add

Fields

• getAdd :: a

Instances

Functor Add

Methods

fmap :: (a -> b) -> Add a -> Add b

(<$) :: a -> Add b -> Add a

Foldable Add

Methods

fold :: Monoid m => Add m -> m

foldMap :: Monoid m => (a -> m) -> Add a -> m

foldr :: (a -> b -> b) -> b -> Add a -> b

foldr' :: (a -> b -> b) -> b -> Add a -> b

foldl :: (b -> a -> b) -> b -> Add a -> b

foldl' :: (b -> a -> b) -> b -> Add a -> b

foldr1 :: (a -> a -> a) -> Add a -> a

foldl1 :: (a -> a -> a) -> Add a -> a

toList :: Add a -> [a]

null :: Add a -> Bool

length :: Add a -> Int

elem :: Eq a => a -> Add a -> Bool

maximum :: Ord a => Add a -> a

minimum :: Ord a => Add a -> a

sum :: Num a => Add a -> a

product :: Num a => Add a -> a

Traversable Add

Methods

traverse :: Applicative f => (a -> f b) -> Add a -> f (Add b)

sequenceA :: Applicative f => Add (f a) -> f (Add a)

mapM :: Monad m => (a -> m b) -> Add a -> m (Add b)

sequence :: Monad m => Add (m a) -> m (Add a)

Generic1 Add

Associated Types

type Rep1 (Add :: * -> *) :: * -> *

Methods

from1 :: Add a -> Rep1 Add a

to1 :: Rep1 Add a -> Add a

Bounded a => Bounded (Add a)

Methods

minBound :: Add a

maxBound :: Add a

Enum a => Enum (Add a)

Methods

succ :: Add a -> Add a

pred :: Add a -> Add a

toEnum :: Int -> Add a

fromEnum :: Add a -> Int

enumFrom :: Add a -> [Add a]

enumFromThen :: Add a -> Add a -> [Add a]

enumFromTo :: Add a -> Add a -> [Add a]

enumFromThenTo :: Add a -> Add a -> Add a -> [Add a]

Eq a => Eq (Add a)

Methods

(==) :: Add a -> Add a -> Bool

(/=) :: Add a -> Add a -> Bool

Fractional a => Fractional (Add a)

Methods

(/) :: Add a -> Add a -> Add a

recip :: Add a -> Add a

fromRational :: Rational -> Add a

Num a => Num (Add a)

Methods

(+) :: Add a -> Add a -> Add a

(-) :: Add a -> Add a -> Add a

(*) :: Add a -> Add a -> Add a

negate :: Add a -> Add a

abs :: Add a -> Add a

signum :: Add a -> Add a

fromInteger :: Integer -> Add a

Ord a => Ord (Add a)

Methods

compare :: Add a -> Add a -> Ordering

(<) :: Add a -> Add a -> Bool

(<=) :: Add a -> Add a -> Bool

(>) :: Add a -> Add a -> Bool

(>=) :: Add a -> Add a -> Bool

max :: Add a -> Add a -> Add a

min :: Add a -> Add a -> Add a

Read a => Read (Add a)

Methods

readsPrec :: Int -> ReadS (Add a)

readList :: ReadS [Add a]

readPrec :: ReadPrec (Add a)

readListPrec :: ReadPrec [Add a]

Real a => Real (Add a)

Methods

toRational :: Add a -> Rational

RealFrac a => RealFrac (Add a)

Methods

properFraction :: Integral b => Add a -> (b, Add a)

truncate :: Integral b => Add a -> b

round :: Integral b => Add a -> b

ceiling :: Integral b => Add a -> b

floor :: Integral b => Add a -> b

Show a => Show (Add a)

Methods

showsPrec :: Int -> Add a -> ShowS

show :: Add a -> String

showList :: [Add a] -> ShowS

Generic (Add a)

Associated Types

type Rep (Add a) :: * -> *

Methods

from :: Add a -> Rep (Add a) x

to :: Rep (Add a) x -> Add a

Semiring a => Semigroup (Add a)

Methods

(<>) :: Add a -> Add a -> Add a

sconcat :: NonEmpty (Add a) -> Add a

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

Semiring a => Monoid (Add a)

Methods

mempty :: Add a

mappend :: Add a -> Add a -> Add a

mconcat :: [Add a] -> Add a

Storable a => Storable (Add a)

Methods

sizeOf :: Add a -> Int

alignment :: Add a -> Int

peekElemOff :: Ptr (Add a) -> Int -> IO (Add a)

pokeElemOff :: Ptr (Add a) -> Int -> Add a -> IO ()

peekByteOff :: Ptr b -> Int -> IO (Add a)

pokeByteOff :: Ptr b -> Int -> Add a -> IO ()

peek :: Ptr (Add a) -> IO (Add a)

poke :: Ptr (Add a) -> Add a -> IO ()

StarSemiring a => StarSemiring (Add a)

Methods

star :: Add a -> Add a

plus :: Add a -> Add a

Semiring a => Semiring (Add a)

Methods

zero :: Add a

one :: Add a

(<.>) :: Add a -> Add a -> Add a

(<+>) :: Add a -> Add a -> Add a

type Rep1 Add

type Rep1 Add = D1 (MetaData "Add" "Data.Semiring" "semiring-num-0.7.0.0-LZTdLH4bZPrFoYJgqNzb7N" True) (C1 (MetaCons "Add" PrefixI True) (S1 (MetaSel (Just Symbol "getAdd") NoSourceUnpackedness NoSourceStrictness DecidedLazy) Par1))

type Rep (Add a)

type Rep (Add a) = D1 (MetaData "Add" "Data.Semiring" "semiring-num-0.7.0.0-LZTdLH4bZPrFoYJgqNzb7N" True) (C1 (MetaCons "Add" PrefixI True) (S1 (MetaSel (Just Symbol "getAdd") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a)))

newtype Mul a

Monoid under <.>. Analogous to Product, but uses the Semiring constraint, rather than Num.

Constructors

Mul

Fields

• getMul :: a

Instances

Functor Mul

Methods

fmap :: (a -> b) -> Mul a -> Mul b

(<$) :: a -> Mul b -> Mul a

Foldable Mul

Methods

fold :: Monoid m => Mul m -> m

foldMap :: Monoid m => (a -> m) -> Mul a -> m

foldr :: (a -> b -> b) -> b -> Mul a -> b

foldr' :: (a -> b -> b) -> b -> Mul a -> b

foldl :: (b -> a -> b) -> b -> Mul a -> b

foldl' :: (b -> a -> b) -> b -> Mul a -> b

foldr1 :: (a -> a -> a) -> Mul a -> a

foldl1 :: (a -> a -> a) -> Mul a -> a

toList :: Mul a -> [a]

null :: Mul a -> Bool

length :: Mul a -> Int

elem :: Eq a => a -> Mul a -> Bool

maximum :: Ord a => Mul a -> a

minimum :: Ord a => Mul a -> a

sum :: Num a => Mul a -> a

product :: Num a => Mul a -> a

Traversable Mul

Methods

traverse :: Applicative f => (a -> f b) -> Mul a -> f (Mul b)

sequenceA :: Applicative f => Mul (f a) -> f (Mul a)

mapM :: Monad m => (a -> m b) -> Mul a -> m (Mul b)

sequence :: Monad m => Mul (m a) -> m (Mul a)

Generic1 Mul

Associated Types

type Rep1 (Mul :: * -> *) :: * -> *

Methods

from1 :: Mul a -> Rep1 Mul a

to1 :: Rep1 Mul a -> Mul a

Bounded a => Bounded (Mul a)

Methods

minBound :: Mul a

maxBound :: Mul a

Enum a => Enum (Mul a)

Methods

succ :: Mul a -> Mul a

pred :: Mul a -> Mul a

toEnum :: Int -> Mul a

fromEnum :: Mul a -> Int

enumFrom :: Mul a -> [Mul a]

enumFromThen :: Mul a -> Mul a -> [Mul a]

enumFromTo :: Mul a -> Mul a -> [Mul a]

enumFromThenTo :: Mul a -> Mul a -> Mul a -> [Mul a]

Eq a => Eq (Mul a)

Methods

(==) :: Mul a -> Mul a -> Bool

(/=) :: Mul a -> Mul a -> Bool

Fractional a => Fractional (Mul a)

Methods

(/) :: Mul a -> Mul a -> Mul a

recip :: Mul a -> Mul a

fromRational :: Rational -> Mul a

Num a => Num (Mul a)

Methods

(+) :: Mul a -> Mul a -> Mul a

(-) :: Mul a -> Mul a -> Mul a

(*) :: Mul a -> Mul a -> Mul a

negate :: Mul a -> Mul a

abs :: Mul a -> Mul a

signum :: Mul a -> Mul a

fromInteger :: Integer -> Mul a

Ord a => Ord (Mul a)

Methods

compare :: Mul a -> Mul a -> Ordering

(<) :: Mul a -> Mul a -> Bool

(<=) :: Mul a -> Mul a -> Bool

(>) :: Mul a -> Mul a -> Bool

(>=) :: Mul a -> Mul a -> Bool

max :: Mul a -> Mul a -> Mul a

min :: Mul a -> Mul a -> Mul a

Read a => Read (Mul a)

Methods

readsPrec :: Int -> ReadS (Mul a)

readList :: ReadS [Mul a]

readPrec :: ReadPrec (Mul a)

readListPrec :: ReadPrec [Mul a]

Real a => Real (Mul a)

Methods

toRational :: Mul a -> Rational

RealFrac a => RealFrac (Mul a)

Methods

properFraction :: Integral b => Mul a -> (b, Mul a)

truncate :: Integral b => Mul a -> b

round :: Integral b => Mul a -> b

ceiling :: Integral b => Mul a -> b

floor :: Integral b => Mul a -> b

Show a => Show (Mul a)

Methods

showsPrec :: Int -> Mul a -> ShowS

show :: Mul a -> String

showList :: [Mul a] -> ShowS

Generic (Mul a)

Associated Types

type Rep (Mul a) :: * -> *

Methods

from :: Mul a -> Rep (Mul a) x

to :: Rep (Mul a) x -> Mul a

Semiring a => Semigroup (Mul a)

Methods

(<>) :: Mul a -> Mul a -> Mul a

sconcat :: NonEmpty (Mul a) -> Mul a

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

Semiring a => Monoid (Mul a)

Methods

mempty :: Mul a

mappend :: Mul a -> Mul a -> Mul a

mconcat :: [Mul a] -> Mul a

Storable a => Storable (Mul a)

Methods

sizeOf :: Mul a -> Int

alignment :: Mul a -> Int

peekElemOff :: Ptr (Mul a) -> Int -> IO (Mul a)

pokeElemOff :: Ptr (Mul a) -> Int -> Mul a -> IO ()

peekByteOff :: Ptr b -> Int -> IO (Mul a)

pokeByteOff :: Ptr b -> Int -> Mul a -> IO ()

peek :: Ptr (Mul a) -> IO (Mul a)

poke :: Ptr (Mul a) -> Mul a -> IO ()

StarSemiring a => StarSemiring (Mul a)

Methods

star :: Mul a -> Mul a

plus :: Mul a -> Mul a

Semiring a => Semiring (Mul a)

Methods

zero :: Mul a

one :: Mul a

(<.>) :: Mul a -> Mul a -> Mul a

(<+>) :: Mul a -> Mul a -> Mul a

type Rep1 Mul

type Rep1 Mul = D1 (MetaData "Mul" "Data.Semiring" "semiring-num-0.7.0.0-LZTdLH4bZPrFoYJgqNzb7N" True) (C1 (MetaCons "Mul" PrefixI True) (S1 (MetaSel (Just Symbol "getMul") NoSourceUnpackedness NoSourceStrictness DecidedLazy) Par1))

type Rep (Mul a)

type Rep (Mul a) = D1 (MetaData "Mul" "Data.Semiring" "semiring-num-0.7.0.0-LZTdLH4bZPrFoYJgqNzb7N" True) (C1 (MetaCons "Mul" PrefixI True) (S1 (MetaSel (Just Symbol "getMul") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a)))

add :: (Foldable f, Semiring a) => f a -> a

Takes the sum of the elements of a Foldable. Analogous to sum on numbers, or or on Bools.

>>> add [1..5]
15
>>> add [False, False]
False
>>> add [False, True]
True
>>> add [True, undefined]
True

mul :: (Foldable f, Semiring a) => f a -> a

Takes the product of the elements of a Foldable. Analogous to product on numbers, or and on Bools.

>>> mul [1..5]
120
>>> mul [True, True]
True
>>> mul [True, False]
False
>>> mul [False, undefined]
False

newtype Max a

The "Arctic" or max-plus semiring. It is a semiring where:

<+>  = max
zero = -∞ -- represented by Nothing
<.>  = <+>
one  = zero

Note that we can't use Max from Semigroup because annihilation needs to hold:

-∞ <+> x = x <+> -∞ = -∞

Taking -∞ to be minBound would break the above law. Using Nothing to represent it follows the law.

Constructors

Max

Fields

• getMax :: a

Instances

Functor Max

Methods

fmap :: (a -> b) -> Max a -> Max b

(<$) :: a -> Max b -> Max a

Foldable Max

Methods

fold :: Monoid m => Max m -> m

foldMap :: Monoid m => (a -> m) -> Max a -> m

foldr :: (a -> b -> b) -> b -> Max a -> b

foldr' :: (a -> b -> b) -> b -> Max a -> b

foldl :: (b -> a -> b) -> b -> Max a -> b

foldl' :: (b -> a -> b) -> b -> Max a -> b

foldr1 :: (a -> a -> a) -> Max a -> a

foldl1 :: (a -> a -> a) -> Max a -> a

toList :: Max a -> [a]

null :: Max a -> Bool

length :: Max a -> Int

elem :: Eq a => a -> Max a -> Bool

maximum :: Ord a => Max a -> a

minimum :: Ord a => Max a -> a

sum :: Num a => Max a -> a

product :: Num a => Max a -> a

Traversable Max

Methods

traverse :: Applicative f => (a -> f b) -> Max a -> f (Max b)

sequenceA :: Applicative f => Max (f a) -> f (Max a)

mapM :: Monad m => (a -> m b) -> Max a -> m (Max b)

sequence :: Monad m => Max (m a) -> m (Max a)

Generic1 Max

Associated Types

type Rep1 (Max :: * -> *) :: * -> *

Methods

from1 :: Max a -> Rep1 Max a

to1 :: Rep1 Max a -> Max a

Bounded a => Bounded (Max a)

Methods

minBound :: Max a

maxBound :: Max a

Enum a => Enum (Max a)

Methods

succ :: Max a -> Max a

pred :: Max a -> Max a

toEnum :: Int -> Max a

fromEnum :: Max a -> Int

enumFrom :: Max a -> [Max a]

enumFromThen :: Max a -> Max a -> [Max a]

enumFromTo :: Max a -> Max a -> [Max a]

enumFromThenTo :: Max a -> Max a -> Max a -> [Max a]

Eq a => Eq (Max a)

Methods

(==) :: Max a -> Max a -> Bool

(/=) :: Max a -> Max a -> Bool

Fractional a => Fractional (Max a)

Methods

(/) :: Max a -> Max a -> Max a

recip :: Max a -> Max a

fromRational :: Rational -> Max a

Num a => Num (Max a)

Methods

(+) :: Max a -> Max a -> Max a

(-) :: Max a -> Max a -> Max a

(*) :: Max a -> Max a -> Max a

negate :: Max a -> Max a

abs :: Max a -> Max a

signum :: Max a -> Max a

fromInteger :: Integer -> Max a

Ord a => Ord (Max a)

Methods

compare :: Max a -> Max a -> Ordering

(<) :: Max a -> Max a -> Bool

(<=) :: Max a -> Max a -> Bool

(>) :: Max a -> Max a -> Bool

(>=) :: Max a -> Max a -> Bool

max :: Max a -> Max a -> Max a

min :: Max a -> Max a -> Max a

Read a => Read (Max a)

Methods

readsPrec :: Int -> ReadS (Max a)

readList :: ReadS [Max a]

readPrec :: ReadPrec (Max a)

readListPrec :: ReadPrec [Max a]

Real a => Real (Max a)

Methods

toRational :: Max a -> Rational

RealFrac a => RealFrac (Max a)

Methods

properFraction :: Integral b => Max a -> (b, Max a)

truncate :: Integral b => Max a -> b

round :: Integral b => Max a -> b

ceiling :: Integral b => Max a -> b

floor :: Integral b => Max a -> b

Show a => Show (Max a)

Methods

showsPrec :: Int -> Max a -> ShowS

show :: Max a -> String

showList :: [Max a] -> ShowS

Generic (Max a)

Associated Types

type Rep (Max a) :: * -> *

Methods

from :: Max a -> Rep (Max a) x

to :: Rep (Max a) x -> Max a

Ord a => Semigroup (Max a)

Methods

(<>) :: Max a -> Max a -> Max a

sconcat :: NonEmpty (Max a) -> Max a

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

(Ord a, HasNegativeInfinity a) => Monoid (Max a)

>>> (getMax . foldMap Max) [1..10]
10.0

Methods

mempty :: Max a

mappend :: Max a -> Max a -> Max a

mconcat :: [Max a] -> Max a

Storable a => Storable (Max a)

Methods

sizeOf :: Max a -> Int

alignment :: Max a -> Int

peekElemOff :: Ptr (Max a) -> Int -> IO (Max a)

pokeElemOff :: Ptr (Max a) -> Int -> Max a -> IO ()

peekByteOff :: Ptr b -> Int -> IO (Max a)

pokeByteOff :: Ptr b -> Int -> Max a -> IO ()

peek :: Ptr (Max a) -> IO (Max a)

poke :: Ptr (Max a) -> Max a -> IO ()

(Semiring a, Ord a, HasPositiveInfinity a, HasNegativeInfinity a) => StarSemiring (Max a)

Methods

star :: Max a -> Max a

plus :: Max a -> Max a

(Semiring a, Ord a, HasNegativeInfinity a) => Semiring (Max a)

Methods

zero :: Max a

one :: Max a

(<.>) :: Max a -> Max a -> Max a

(<+>) :: Max a -> Max a -> Max a

type Rep1 Max

type Rep1 Max = D1 (MetaData "Max" "Data.Semiring" "semiring-num-0.7.0.0-LZTdLH4bZPrFoYJgqNzb7N" True) (C1 (MetaCons "Max" PrefixI True) (S1 (MetaSel (Just Symbol "getMax") NoSourceUnpackedness NoSourceStrictness DecidedLazy) Par1))

type Rep (Max a)

type Rep (Max a) = D1 (MetaData "Max" "Data.Semiring" "semiring-num-0.7.0.0-LZTdLH4bZPrFoYJgqNzb7N" True) (C1 (MetaCons "Max" PrefixI True) (S1 (MetaSel (Just Symbol "getMax") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a)))

newtype Min a

The "Tropical" or min-plus semiring. It is a semiring where:

<+>  = min
zero = ∞ -- represented by Nothing
<.>  = <+>
one  = zero

Note that we can't use Min from Semigroup because annihilation needs to hold:

∞ <+> x = x <+> ∞ = ∞

Taking ∞ to be maxBound would break the above law. Using Nothing to represent it follows the law.

Constructors

Min

Fields

• getMin :: a

Instances

Functor Min

Methods

fmap :: (a -> b) -> Min a -> Min b

(<$) :: a -> Min b -> Min a

Foldable Min

Methods

fold :: Monoid m => Min m -> m

foldMap :: Monoid m => (a -> m) -> Min a -> m

foldr :: (a -> b -> b) -> b -> Min a -> b

foldr' :: (a -> b -> b) -> b -> Min a -> b

foldl :: (b -> a -> b) -> b -> Min a -> b

foldl' :: (b -> a -> b) -> b -> Min a -> b

foldr1 :: (a -> a -> a) -> Min a -> a

foldl1 :: (a -> a -> a) -> Min a -> a

toList :: Min a -> [a]

null :: Min a -> Bool

length :: Min a -> Int

elem :: Eq a => a -> Min a -> Bool

maximum :: Ord a => Min a -> a

minimum :: Ord a => Min a -> a

sum :: Num a => Min a -> a

product :: Num a => Min a -> a

Traversable Min

Methods

traverse :: Applicative f => (a -> f b) -> Min a -> f (Min b)

sequenceA :: Applicative f => Min (f a) -> f (Min a)

mapM :: Monad m => (a -> m b) -> Min a -> m (Min b)

sequence :: Monad m => Min (m a) -> m (Min a)

Generic1 Min

Associated Types

type Rep1 (Min :: * -> *) :: * -> *

Methods

from1 :: Min a -> Rep1 Min a

to1 :: Rep1 Min a -> Min a

Bounded a => Bounded (Min a)

Methods

minBound :: Min a

maxBound :: Min a

Enum a => Enum (Min a)

Methods

succ :: Min a -> Min a

pred :: Min a -> Min a

toEnum :: Int -> Min a

fromEnum :: Min a -> Int

enumFrom :: Min a -> [Min a]

enumFromThen :: Min a -> Min a -> [Min a]

enumFromTo :: Min a -> Min a -> [Min a]

enumFromThenTo :: Min a -> Min a -> Min a -> [Min a]

Eq a => Eq (Min a)

Methods

(==) :: Min a -> Min a -> Bool

(/=) :: Min a -> Min a -> Bool

Fractional a => Fractional (Min a)

Methods

(/) :: Min a -> Min a -> Min a

recip :: Min a -> Min a

fromRational :: Rational -> Min a

Num a => Num (Min a)

Methods

(+) :: Min a -> Min a -> Min a

(-) :: Min a -> Min a -> Min a

(*) :: Min a -> Min a -> Min a

negate :: Min a -> Min a

abs :: Min a -> Min a

signum :: Min a -> Min a

fromInteger :: Integer -> Min a

Ord a => Ord (Min a)

Methods

compare :: Min a -> Min a -> Ordering

(<) :: Min a -> Min a -> Bool

(<=) :: Min a -> Min a -> Bool

(>) :: Min a -> Min a -> Bool

(>=) :: Min a -> Min a -> Bool

max :: Min a -> Min a -> Min a

min :: Min a -> Min a -> Min a

Read a => Read (Min a)

Methods

readsPrec :: Int -> ReadS (Min a)

readList :: ReadS [Min a]

readPrec :: ReadPrec (Min a)

readListPrec :: ReadPrec [Min a]

Real a => Real (Min a)

Methods

toRational :: Min a -> Rational

RealFrac a => RealFrac (Min a)

Methods

properFraction :: Integral b => Min a -> (b, Min a)

truncate :: Integral b => Min a -> b

round :: Integral b => Min a -> b

ceiling :: Integral b => Min a -> b

floor :: Integral b => Min a -> b

Show a => Show (Min a)

Methods

showsPrec :: Int -> Min a -> ShowS

show :: Min a -> String

showList :: [Min a] -> ShowS

Generic (Min a)

Associated Types

type Rep (Min a) :: * -> *

Methods

from :: Min a -> Rep (Min a) x

to :: Rep (Min a) x -> Min a

Ord a => Semigroup (Min a)

Methods

(<>) :: Min a -> Min a -> Min a

sconcat :: NonEmpty (Min a) -> Min a

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

(Ord a, HasPositiveInfinity a) => Monoid (Min a)

>>> (getMin . foldMap Min) [1..10]
1.0

Methods

mempty :: Min a

mappend :: Min a -> Min a -> Min a

mconcat :: [Min a] -> Min a

Storable a => Storable (Min a)

Methods

sizeOf :: Min a -> Int

alignment :: Min a -> Int

peekElemOff :: Ptr (Min a) -> Int -> IO (Min a)

pokeElemOff :: Ptr (Min a) -> Int -> Min a -> IO ()

peekByteOff :: Ptr b -> Int -> IO (Min a)

pokeByteOff :: Ptr b -> Int -> Min a -> IO ()

peek :: Ptr (Min a) -> IO (Min a)

poke :: Ptr (Min a) -> Min a -> IO ()

(Semiring a, Ord a, HasPositiveInfinity a, HasNegativeInfinity a) => StarSemiring (Min a)

Methods

star :: Min a -> Min a

plus :: Min a -> Min a

(Semiring a, Ord a, HasPositiveInfinity a) => Semiring (Min a)

Methods

zero :: Min a

one :: Min a

(<.>) :: Min a -> Min a -> Min a

(<+>) :: Min a -> Min a -> Min a

type Rep1 Min

type Rep1 Min = D1 (MetaData "Min" "Data.Semiring" "semiring-num-0.7.0.0-LZTdLH4bZPrFoYJgqNzb7N" True) (C1 (MetaCons "Min" PrefixI True) (S1 (MetaSel (Just Symbol "getMin") NoSourceUnpackedness NoSourceStrictness DecidedLazy) Par1))

type Rep (Min a)

type Rep (Min a) = D1 (MetaData "Min" "Data.Semiring" "semiring-num-0.7.0.0-LZTdLH4bZPrFoYJgqNzb7N" True) (C1 (MetaCons "Min" PrefixI True) (S1 (MetaSel (Just Symbol "getMin") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a)))