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

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

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

(Ord a, Monoid a) => Semiring (Set a)

The Set Semiring is union for <+>, and a Cartesian product for <.>.

Methods

zero :: Set a

one :: Set a

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

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

(Semiring a, Ord 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) => 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

(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 (Free a)

Methods

zero :: Free a

one :: Free a

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

(<+>) :: Free a -> Free a -> Free 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 a, Semiring b) => Semiring (a, b)

Methods

zero :: (a, b)

one :: (a, b)

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

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

(Semiring a, Semiring b, Semiring c) => Semiring (a, b, c)

Methods

zero :: (a, b, c)

one :: (a, b, c)

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

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

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 a, Semiring b, Semiring c, Semiring d) => Semiring (a, b, c, d)

Methods

zero :: (a, b, c, d)

one :: (a, b, c, d)

(<.>) :: (a, b, c, d) -> (a, b, c, d) -> (a, b, c, d)

(<+>) :: (a, b, c, d) -> (a, b, c, d) -> (a, b, c, d)

(Semiring a, Semiring b, Semiring c, Semiring d, Semiring e) => Semiring (a, b, c, d, e)

Methods

zero :: (a, b, c, d, e)

one :: (a, b, c, d, e)

(<.>) :: (a, b, c, d, e) -> (a, b, c, d, e) -> (a, b, c, d, e)

(<+>) :: (a, b, c, d, e) -> (a, b, c, d, e) -> (a, b, c, d, e)

newtype Add a

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

Constructors

Add

Fields

• getAdd :: a

Instances

Monad Add

Methods

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

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

return :: a -> Add a

fail :: String -> Add a

Functor Add

Methods

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

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

Applicative Add

Methods

pure :: a -> Add a

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

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

(<*) :: Add 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

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

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]

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 => Monoid (Add a)

Methods

mempty :: Add a

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

mconcat :: [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.3.0.0-E53seAEysQ85CFp81usfTw" 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.3.0.0-E53seAEysQ85CFp81usfTw" 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

Monad Mul

Methods

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

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

return :: a -> Mul a

fail :: String -> Mul a

Functor Mul

Methods

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

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

Applicative Mul

Methods

pure :: a -> Mul a

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

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

(<*) :: Mul 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

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

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]

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 => Monoid (Mul a)

Methods

mempty :: Mul a

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

mconcat :: [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.3.0.0-E53seAEysQ85CFp81usfTw" 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.3.0.0-E53seAEysQ85CFp81usfTw" True) (C1 (MetaCons "Mul" PrefixI True) (S1 (MetaSel (Just Symbol "getMul") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a)))

newtype Max a

The "Arctic" or max-plus semiring. It is a semiring where: <+> = max zero = ∞ (represented by Nothing) <.> = <+> (over the inner value) one = zero (over the inner value)

Constructors

Max

Fields

• getMax :: Maybe a

Instances

Monad Max

Methods

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

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

return :: a -> Max a

fail :: String -> Max a

Functor Max

Methods

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

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

Applicative Max

Methods

pure :: a -> Max a

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

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

(<*) :: Max 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

Generic1 Max

Associated Types

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

Methods

from1 :: Max a -> Rep1 Max a

to1 :: Rep1 Max a -> Max a

Eq a => Eq (Max a)

Methods

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

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

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]

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 => Monoid (Max a)

Methods

mempty :: Max a

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

mconcat :: [Max a] -> Max a

(Semiring a, Ord 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.3.0.0-E53seAEysQ85CFp81usfTw" True) (C1 (MetaCons "Max" PrefixI True) (S1 (MetaSel (Just Symbol "getMax") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec1 Maybe)))

type Rep (Max a)

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

newtype Min a

The "Tropical" or min-plus semiring. It is a semiring where: <+> = min zero = -∞ (represented by Nothing) <.> = <+> (over the inner value) one = zero (over the inner value)

Constructors

Min

Fields

• getMin :: Maybe a

Instances

Monad Min

Methods

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

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

return :: a -> Min a

fail :: String -> Min a

Functor Min

Methods

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

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

Applicative Min

Methods

pure :: a -> Min a

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

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

(<*) :: Min 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

Generic1 Min

Associated Types

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

Methods

from1 :: Min a -> Rep1 Min a

to1 :: Rep1 Min a -> Min a

Eq a => Eq (Min a)

Methods

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

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

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]

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 => Monoid (Min a)

Methods

mempty :: Min a

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

mconcat :: [Min a] -> Min a

(Semiring a, Ord 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.3.0.0-E53seAEysQ85CFp81usfTw" True) (C1 (MetaCons "Min" PrefixI True) (S1 (MetaSel (Just Symbol "getMin") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec1 Maybe)))

type Rep (Min a)

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